Halide 配置 visual studio

Halide 配置 visual studio
Halide是一种编程语言，使得在现代机器上编写高性能图像和数组处理代码更加容易。Halide支持如下的平台：

CPU体系结构：X86，ARM，MIPS，Hexagon，PowerPC

操作系统：Linux，Windows，macOS，Android，iOS，Qualcomm QuRT

GPU计算API：CUDA，OpenCL，OpenGL，OpenGL计算着色器，Apple Metal，Microsoft Direct X 12

Halide并不是独立的编程语言，而是嵌入在C ++中。 这意味可以像编写c++代码一样编写halide代码。本文会介绍如何通过配置环境，在visual studio上可以跑Halide代码

1.一个视频介绍

https://halide-lang.org/cvpr2015.html
很好的博客介绍

2.halide下载

https://github.com/halide/Halide/releases
Windows下载x86-64的版本, 后面会在vs上进行配置

3.Test 代码，包含很多测试性能的例子

https://github.com/halide/Halide/tree/master/test

4.在windows visual studio 2022中配置 halide 14.0步骤

1）解压后的文件夹

2）配置环境变量

比如下面路径
D:\Halide-14.0.0-x86-64-windows\Halide-14.0.0-x86-64-windows\bin\Release

3）新建控制台应用，

在属性管理器中， release x64下新建halidePropertySheet属性页，后续配置完成这个属性页后，保存下来，再建立其他用到halide的时候直接复制该属性页就可以。

解决方案配置选择 release x64

复制https://halide-lang.org/docs/tutorial_2lesson_01_basics_8cpp-example.html中的代码用于验证。

// The only Halide header file you need is Halide.h. It includes all of Halide.
#include "Halide.h"

// We'll also include stdio for printf.
#include 

int main(int argc, char** argv) {

    // This program defines a single-stage imaging pipeline that
    // outputs a grayscale diagonal gradient.

    // A 'Func' object represents a pipeline stage. It's a pure
    // function that defines what value each pixel should have. You
    // can think of it as a computed image.
    Halide::Func gradient;

    // Var objects are names to use as variables in the definition of
    // a Func. They have no meaning by themselves.
    Halide::Var x, y;

    // We typically use Vars named 'x' and 'y' to correspond to the x
    // and y axes of an image, and we write them in that order. If
    // you're used to thinking of images as having rows and columns,
    // then x is the column index, and y is the row index.

    // Funcs are defined at any integer coordinate of its variables as
    // an Expr in terms of those variables and other functions.
    // Here, we'll define an Expr which has the value x + y. Vars have
    // appropriate operator overloading so that expressions like
    // 'x + y' become 'Expr' objects.
    Halide::Expr e = x + y;

    // Now we'll add a definition for the Func object. At pixel x, y,
    // the image will have the value of the Expr e. On the left hand
    // side we have the Func we're defining and some Vars. On the right
    // hand side we have some Expr object that uses those same Vars.
    gradient(x, y) = e;

    // This is the same as writing:
    //
    //   gradient(x, y) = x + y;
    //
    // which is the more common form, but we are showing the
    // intermediate Expr here for completeness.

    // That line of code defined the Func, but it didn't actually
    // compute the output image yet. At this stage it's just Funcs,
    // Exprs, and Vars in memory, representing the structure of our
    // imaging pipeline. We're meta-programming. This C++ program is
    // constructing a Halide program in memory. Actually computing
    // pixel data comes next.

    // Now we 'realize' the Func, which JIT compiles some code that
    // implements the pipeline we've defined, and then runs it.  We
    // also need to tell Halide the domain over which to evaluate the
    // Func, which determines the range of x and y above, and the
    // resolution of the output image. Halide.h also provides a basic
    // templatized image type we can use. We'll make an 800 x 600
    // image.
    Halide::Buffer<int32_t> output = gradient.realize({ 800, 600 });

    // Halide does type inference for you. Var objects represent
    // 32-bit integers, so the Expr object 'x + y' also represents a
    // 32-bit integer, and so 'gradient' defines a 32-bit image, and
    // so we got a 32-bit signed integer image out when we call
    // 'realize'. Halide types and type-casting rules are equivalent
    // to C.

    // Let's check everything worked, and we got the output we were
    // expecting:
    for (int j = 0; j < output.height(); j++) {
        for (int i = 0; i < output.width(); i++) {
            // We can access a pixel of an Buffer object using similar
            // syntax to defining and using functions.
            if (output(i, j) != i + j) {
                printf("Something went wrong!\n"
                    "Pixel %d, %d was supposed to be %d, but instead it's %d\n",
                    i, j, i + j, output(i, j));
                return -1;
            }
        }
    }

    // Everything worked! We defined a Func, then called 'realize' on
    // it to generate and run machine code that produced an Buffer.
    printf("Success!\n");

    return 0;
}
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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

4）配置 属性页

添加包含目录和库目录

修改 c++语言标准为 c++ 17

链接器-常规-附加库目录

连接器-输入-附加依赖项

5）以上完成后保存属性页，点击运行程序，程序正常运行，表示配置正确，可以正常使用halide

5. 有用的资源

CSDN上的 halide编程技术指南

官网example

很好的博客介绍