111qqz的小窝

老年咸鱼冲锋！

Date Time

19/02/18 14:00

Author

Category

优化

Tags

Leave a Reply

【试工中】 halide学习笔记

Halide is a programming language designed to make it easier to write high-performance image and array processing code on modern machines. 

halide有两个特性比较吸引人。一个是对于各种平台架构的支持。

  • CPU architectures: X86, ARM, MIPS, Hexagon, PowerPC
  • Operating systems: Linux, Windows, macOS, Android, iOS, Qualcomm QuRT
  • GPU Compute APIs: CUDA, OpenCL, OpenGL, OpenGL Compute Shaders, Apple Metal, Microsoft Direct X 12

另一个是把计算什么和怎么计算(何时计算)分离开来。

可以直接参考tutorials 来学习

 

下面是一段将Halide Buffer转化成opencv Mat的代码，用于调试。

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
 
 
// Include some support code for loading pngs.
// #include "halide_image_io.h"
#include <iostream>
#include "para_norm.h"
#include "HalideBuffer.h"
#include "clock.h"
#include "halide_image_io.h"  // for Halide::tools to load image. just for debug
#include <opencv2/opencv.hpp> // to show image
 
// #include "Halide.h"
using namespace std;
using namespace cv;
using namespace Halide;
using namespace Halide::Runtime;
// using namespace Halide::Tools;
void convertHalide2Mat(const Buffer<uint8_t> &src, cv::Mat &dest)
{
    if (dest.empty())
        dest.create(cv::Size(src.width(), src.height()), CV_MAKETYPE(CV_8U, src.channels()));
    const int ch = dest.channels();
    if (ch == 1)
    {
        for (int j = 0; j < dest.rows; j++)
        {
            for (int i = 0; i < dest.cols; i++)
            {
                dest.at<uchar>(j, i) = src(i, j);
            }
        }
    }
    else if (ch == 3)
    {
        for (int j = 0; j < dest.rows; j++)
        {
            for (int i = 0; i < dest.cols; i++)
            {
                dest.at<uchar>(j, 3 * i + 0) = src(i, j, 2);
                dest.at<uchar>(j, 3 * i + 1) = src(i, j, 1);
                dest.at<uchar>(j, 3 * i + 2) = src(i, j, 0);
            }
        }
    }
}
int main(int argc, char **argv)
{
 
    Halide::Runtime::Buffer<uint8_t> input = Halide::Tools::load_image("/data/github/learnhalide/png.png");
    cv::Mat Img;
    convertHalide2Mat(input,Img);
    cv::imshow("debug", Img);
    cv::waitKey(0);
    return 0;
}
 
 
 
 

 

吐槽下hahide的文档…各种函数全靠试…

试了好久得到的,opencv Mat转halide::buffer的办法:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
 
 
cv::Mat image = cv::imread("/data/github/learnhalide/png.png");
    cv::imshow("input",image);
    cv::waitKey(0);
    halide_buffer_t buffer;
    // memset(&buffer, 0, sizeof(buffer));
 
    buffer.host = image.data;
    printf("image.data %d %d %d\n",image.data[0],image.data[1],image.data[2]);
    printf("buffer.host %d %d %d\n",buffer.host[0],buffer.host[1],buffer.host[2]);
    // 数据没有copy过来
    buffer.type = halide_type_t(halide_type_uint,8);
    buffer.dimensions = 3;
    buffer.dim = (halide_dimension_t *)malloc(3*4*sizeof(uint32_t));
    buffer.dim[0].extent = image.cols;
    buffer.dim[1].extent = image.rows;
    buffer.dim[2].extent = image.channels();
    buffer.dim[0].min = buffer.dim[1].min = buffer.dim[2].min = 0;
 
 
    buffer.dim[0].stride = image.step1(1);
    buffer.dim[1].stride = image.step1(0);
    buffer.dim[2].stride = 1;
 
    Halide::Runtime::Buffer<uint8_t> input(buffer);
    printf("input buffer:%d %d %d\n",input.width(),input.height(),input.channels());
    // printf("%d\n",input(2,2));
    const halide_buffer_t *         raw_buffer = input.raw_buffer();
    printf("raw buffer: %d %d %d\n",raw_buffer->host[0],raw_buffer->host[1],raw_buffer->host[2]);
 
 
    cv::Mat Img;
    convertHalide2Mat(input, Img);
    printf("Mat(%d %d)\n", Img.cols, Img.rows);
    cv::imshow("debug", Img);
    cv::waitKey(0);
 
 
 
 

 

可能会报错Error: Constraint violated: input.stride.0 (3) == 1 (1),原因是:

We have a default constraint of stride==1 on the innermost dimension, so that vectorization works out well

Constraint violated: f.stride.0 (2) == 1 (1) #3109

解决办法是(对于AOT的编译方式):

ImageParam input(type_of<uint8_t>(), 3);
input.dim(0).set_stride(Expr());
一种更简便的opencv Mat得到halide buffer的办法.　一个关键的问题是opencv Mat的memory layout是Interleaved的方式，也就是如下:
// RGBRGBRGBRGBRGBRGBRGBRGB
// RGBRGBRGBRGBRGBRGBRGBRGB
// RGBRGBRGBRGBRGBRGBRGBRGB
// RGBRGBRGBRGBRGBRGBRGBRGB
但是Halide::buffer的默认memory layout是Planar的方式：
// RRRRRRRR
// RRRRRRRR
// RRRRRRRR
// RRRRRRRR
// GGGGGGGG
// GGGGGGGG
// GGGGGGGG
// GGGGGGGG
// BBBBBBBB
// BBBBBBBB
// BBBBBBBB
// BBBBBBBB
因此需要用到函数

make_interleaved()

opencv Mat 转Halide Buffer
C#
1
2
3
4
5
6
7
8
 
 
 
  cv::Mat image = cv::imread("/data/github/learnhalide/png.png");
  Halide::Runtime::Buffer<uint8_t> input = Halide::Runtime::Buffer<uint8_t>::make_interleaved(image.data,1240, 460, 3);
 
 
 

 

 

 

Date Time

19/01/23 19:51

Author

Category

优化

Tags

,
Leave a Reply

优化学习笔记(1):Loop unrolling

迫于生计，最近要学习halide

先去学习/复习一下常见的编译优化技巧。

loop unrolling，也就是循环展开，顾名思义，就是把循环展开来写。

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
 
 
normal loop:
int x;
for (x = 0; x < 100; x++)
{
     delete(x);
}
 
after loop unrolling:
int x;
for (x = 0; x < 100; x += 5 )
{
     delete(x);
     delete(x + 1);
     delete(x + 2);
     delete(x + 3);
     delete(x + 4);
}
 
 
 

循环展开是一种优化，可以手动实现也可以编译器自动实现。

为什么要将循环展开？

  • 循环每次都需要判断终止条件，展开后可以消除这部分开销。
  • 减少分支预测开销。循环里的分支是指“跳出循环”还是“进行下一次迭代”
  • vectorization
    halide tutorial lesson 05
    C++
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
     
     
     
    for (int y = 0; y < 4; y++) {
                for (int x_outer = 0; x_outer < 2; x_outer++) {
                    // The loop over x_inner has gone away, and has been
                    // replaced by a vectorized version of the
                    // expression. On x86 processors, Halide generates SSE
                    // for all of this.
                    int x_vec[] = {x_outer * 4 + 0,
                                   x_outer * 4 + 1,
                                   x_outer * 4 + 2,
                                   x_outer * 4 + 3};
                    int val[] = {x_vec[0] + y,
                                 x_vec[1] + y,
                                 x_vec[2] + y,
                                 x_vec[3] + y};
                    printf("Evaluating at <%d, %d, %d, %d>, <%d, %d, %d, %d>:"
                           " <%d, %d, %d, %d>\n",
                           x_vec[0], x_vec[1], x_vec[2], x_vec[3],
                           y, y, y, y,
                           val[0], val[1], val[2], val[3]);
                }
            }zhichi
     
     
     

    可以看到最里面一层循环被展开以实现向量化.向量化是一种优化计算的手段。该优化的实现基于SIMD 和Advanced_Vector_Extensions(AVX)指令集架构的支持。
  • 消除和loop counter(i)有关的除法计算。
    halide tutorial lesson 05
    C++
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
     
     
         for (int fused = 0; fused < 4*4; fused++) {
                int y = fused / 4;
                int x = fused % 4;
                printf("Evaluating at x = %d, y = %d: %d\n", x, y, x + y);
            }
     
     
     
  • 消除循环内部的分支。比如loop counter奇数和偶数时会进入不同的分支，那么将循环展开后，就消除了该分支。

有什么缺点？

  • 代码体积增加了。这对于嵌入式设备等往往是不可接受的。
  • 代码可读性变差了。
  • 单一指令可能会使用更多的寄存器，导致性能下降。
  • 如果循环内部包含函数调用，那么和函数的内联(inline)优化会有冲突。原因是，循环展开＋函数展开…代码的体积会爆炸。

参考资料