Halide示例学习二

最新推荐文章于 2022-05-02 16:42:43 发布
最新推荐文章于 2022-05-02 16:42:43 发布
阅读量419 收藏 1
点赞数 1
分类专栏： 高性能计算 文章标签： 人工智能 算法 边缘计算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Pengcode/article/details/124391353
版权

Halide示例学习二

默认的维度计算顺序

#include "Halide.h"
#include <algorithm>
#include <stdio.h>
using namespace Halide;

int main(int argc, char **argv) {
    // 该示例演示了如何观察计算的维度变化顺序以及如何改变计算顺序
    Var x("x"), y("y");
    // 首先来观察一个默认的计算顺序
    Func gradient("gradient");
    gradient(x, y) = x + y;
    gradient.trace_stores();

    /* 一般地，图像中x表示列，y表示行
        那么一般是先遍历一行，也就是从左往右，从上往下的遍历顺序
        columns-列，rows-行
        行-列遍历计算顺序
    */
    printf("Evaluating gradient row-major\n");
    Buffer<int> output = gradient.realize({4, 4});
    // 等价的C代码如下所示：
    printf("Equivalent C:\n");
    for (int y = 0; y < 4; y++) {
        for (int x = 0; x < 4; x++) {
            printf("Evaluating at x = %d, y = %d: %d\n", x, y, x + y);
        }
    }
    printf("\n\n");

    // 使用print_loop_nest函数可以打印出怎样的调度信息和循环嵌套
    printf("Pseudo-code for the schedule:\n");
    gradient.print_loop_nest();
    printf("\n");
    // 上述将会打印出如下所示的调度信息
    // compute gradient:
    //   for y:
    //     for x:
    //       gradient(...) = ...
    return 0;
}

# 运行结果如下所示：
Begin pipeline gradient.0()
Tag gradient.0() tag = "func_type_and_dim: 1 0 32 1 2 0 4 0 4"
Store gradient.0(0, 0) = 0
Store gradient.0(1, 0) = 1
Store gradient.0(2, 0) = 2
Store gradient.0(3, 0) = 3
Store gradient.0(0, 1) = 1
Store gradient.0(1, 1) = 2
Store gradient.0(2, 1) = 3
Store gradient.0(3, 1) = 4
Store gradient.0(0, 2) = 2
Store gradient.0(1, 2) = 3
Store gradient.0(2, 2) = 4
Store gradient.0(3, 2) = 5
Store gradient.0(0, 3) = 3
Store gradient.0(1, 3) = 4
Store gradient.0(2, 3) = 5
Store gradient.0(3, 3) = 6
End pipeline gradient.0()
Evaluating gradient row-major
Equivalent C:
Evaluating at x = 0, y = 0: 0
Evaluating at x = 1, y = 0: 1
Evaluating at x = 2, y = 0: 2
Evaluating at x = 3, y = 0: 3
Evaluating at x = 0, y = 1: 1
Evaluating at x = 1, y = 1: 2
Evaluating at x = 2, y = 1: 3
Evaluating at x = 3, y = 1: 4
Evaluating at x = 0, y = 2: 2
Evaluating at x = 1, y = 2: 3
Evaluating at x = 2, y = 2: 4
Evaluating at x = 3, y = 2: 5
Evaluating at x = 0, y = 3: 3
Evaluating at x = 1, y = 3: 4
Evaluating at x = 2, y = 3: 5
Evaluating at x = 3, y = 3: 6


Pseudo-code for the schedule:
produce gradient:
  for y:
    for x:
      gradient(...) = ...

维度顺序重排操作

#include "Halide.h"
#include <algorithm>
#include <stdio.h>
using namespace Halide;

int main(int argc, char **argv) {
    Func gradient("gradient_col_major");
    Var x,y;
    gradient(x, y) = x + y;
    gradient.trace_stores();

    // 我们可以通过reorder类方法来进行调度的重排
    gradient.reorder(y, x);
    // 上述交换了x和y这两个轴的计算先后顺序
    // 也就是说现在是列-行的计算顺序
    printf("Evaluating gradient column-major\n");
    Buffer<int> output = gradient.realize({4, 4});
    // 以下是等效的C代码
    printf("Equivalent C:\n");
    for (int x = 0; x < 4; x++) {
        for (int y = 0; y < 4; y++) {
            printf("Evaluating at x = %d, y = %d: %d\n", x, y, x + y);
        }
    }
    printf("\n");
    printf("Pseudo-code for the schedule:\n");
    gradient.print_loop_nest();
    printf("\n");
    return 0;
}


#运行结果如下所示
Begin pipeline gradient_col_major.0()
Tag gradient_col_major.0() tag = "func_type_and_dim: 1 0 32 1 2 0 4 0 4"
Store gradient_col_major.0(0, 0) = 0
Store gradient_col_major.0(0, 1) = 1
Store gradient_col_major.0(0, 2) = 2
Store gradient_col_major.0(0, 3) = 3
Store gradient_col_major.0(1, 0) = 1
Store gradient_col_major.0(1, 1) = 2
Store gradient_col_major.0(1, 2) = 3
Store gradient_col_major.0(1, 3) = 4
Store gradient_col_major.0(2, 0) = 2
Store gradient_col_major.0(2, 1) = 3
Store gradient_col_major.0(2, 2) = 4
Store gradient_col_major.0(2, 3) = 5
Store gradient_col_major.0(3, 0) = 3
Store gradient_col_major.0(3, 1) = 4
Store gradient_col_major.0(3, 2) = 5
Store gradient_col_major.0(3, 3) = 6
End pipeline gradient_col_major.0()

Evaluating gradient column-major
Equivalent C:
Evaluating at x = 0, y = 0: 0
Evaluating at x = 0, y = 1: 1
Evaluating at x = 0, y = 2: 2
Evaluating at x = 0, y = 3: 3
Evaluating at x = 1, y = 0: 1
Evaluating at x = 1, y = 1: 2
Evaluating at x = 1, y = 2: 3
Evaluating at x = 1, y = 3: 4
Evaluating at x = 2, y = 0: 2
Evaluating at x = 2, y = 1: 3
Evaluating at x = 2, y = 2: 4
Evaluating at x = 2, y = 3: 5
Evaluating at x = 3, y = 0: 3
Evaluating at x = 3, y = 1: 4
Evaluating at x = 3, y = 2: 5
Evaluating at x = 3, y = 3: 6

Pseudo-code for the schedule:
produce gradient_col_major:
  for x:
    for y:
      gradient_col_major(...) = ...

维度拆分

#include "Halide.h"
#include <algorithm>
#include <stdio.h>
using namespace Halide;

int main(int argc, char **argv) {
    Var x,y;
    Func gradient("gradient_split");
    gradient(x, y) = x + y;
    gradient.trace_stores();
    // 以下的split进行了单层循环到多层循环嵌套的变化
    Var x_outer, x_inner;
    gradient.split(x, x_outer, x_inner, 2);
    /* 以下的C代码展示了相应的循环嵌套转换结果
        原始的x_dim=x_outer*factor+x_inner
    */
    printf("Evaluating gradient with x split into x_outer and x_inner \n");
    Buffer<int> output = gradient.realize({4, 4});

    printf("Equivalent C:\n");
    for (int y = 0; y < 4; y++) {
        for (int x_outer = 0; x_outer < 2; x_outer++) {
            for (int x_inner = 0; x_inner < 2; x_inner++) {
                int x = x_outer * 2 + x_inner;
                printf("Evaluating at x = %d, y = %d: %d\n", x, y, x + y);
            }
        }
    }
    printf("\n");

    printf("Pseudo-code for the schedule:\n");
    /* 打印出来的结果如下所示：
    produce gradient_split:
    for y:
        for x.v0:
        for x.v1 in [0, 1]:
            gradient_split(...) = ...
    */
    gradient.print_loop_nest();
    printf("\n");
    /*
    说明：尽管进行了维度拆分，但是并没有影响那个像素点的计算顺序
    */
    return 0;
}


#运行结果如下所示
Begin pipeline gradient_split.0()
Tag gradient_split.0() tag = "func_type_and_dim: 1 0 32 1 2 0 4 0 4"
Store gradient_split.0(0, 0) = 0
Store gradient_split.0(1, 0) = 1
Store gradient_split.0(2, 0) = 2
Store gradient_split.0(3, 0) = 3
Store gradient_split.0(0, 1) = 1
Store gradient_split.0(1, 1) = 2
Store gradient_split.0(2, 1) = 3
Store gradient_split.0(3, 1) = 4
Store gradient_split.0(0, 2) = 2
Store gradient_split.0(1, 2) = 3
Store gradient_split.0(2, 2) = 4
Store gradient_split.0(3, 2) = 5
Store gradient_split.0(0, 3) = 3
Store gradient_split.0(1, 3) = 4
Store gradient_split.0(2, 3) = 5
Store gradient_split.0(3, 3) = 6
End pipeline gradient_split.0()

Evaluating gradient with x split into x_outer and x_inner 
Equivalent C:
Evaluating at x = 0, y = 0: 0
Evaluating at x = 1, y = 0: 1
Evaluating at x = 2, y = 0: 2
Evaluating at x = 3, y = 0: 3
Evaluating at x = 0, y = 1: 1
Evaluating at x = 1, y = 1: 2
Evaluating at x = 2, y = 1: 3
Evaluating at x = 3, y = 1: 4
Evaluating at x = 0, y = 2: 2
Evaluating at x = 1, y = 2: 3
Evaluating at x = 2, y = 2: 4
Evaluating at x = 3, y = 2: 5
Evaluating at x = 0, y = 3: 3
Evaluating at x = 1, y = 3: 4
Evaluating at x = 2, y = 3: 5
Evaluating at x = 3, y = 3: 6

Pseudo-code for the schedule:
produce gradient_split:
  for y:
    for x.v0:
      for x.v1 in [0, 1]:
        gradient_split(...) = ...

维度融合

#include "Halide.h"
#include <algorithm>
#include <stdio.h>
using namespace Halide;

int main(int argc, char **argv) {
    Var x,y;
    Func gradient("gradient_fused");
    gradient(x, y) = x + y;

    // 维度拆分的反例就是维度融合
    // 通过融合可以把双循环变成单循环，同时像素点的计算顺序不变
    Var fused;
    gradient.fuse(x, y, fused);
    printf("Evaluating gradient with x and y fused\n");
    Buffer<int> output = gradient.realize({4, 4});
    printf("Equivalent C:\n");
    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);
    }
    printf("\n");
    printf("Pseudo-code for the schedule:\n");
    gradient.print_loop_nest();
    printf("\n");
    return 0;
}


#运行结果如下所示
Evaluating gradient with x and y fused
Equivalent C:
Evaluating at x = 0, y = 0: 0
Evaluating at x = 1, y = 0: 1
Evaluating at x = 2, y = 0: 2
Evaluating at x = 3, y = 0: 3
Evaluating at x = 0, y = 1: 1
Evaluating at x = 1, y = 1: 2
Evaluating at x = 2, y = 1: 3
Evaluating at x = 3, y = 1: 4
Evaluating at x = 0, y = 2: 2
Evaluating at x = 1, y = 2: 3
Evaluating at x = 2, y = 2: 4
Evaluating at x = 3, y = 2: 5
Evaluating at x = 0, y = 3: 3
Evaluating at x = 1, y = 3: 4
Evaluating at x = 2, y = 3: 5
Evaluating at x = 3, y = 3: 6

Pseudo-code for the schedule:
produce gradient_fused:
  for x.v2:
    gradient_fused(...) = ...

维度平铺

#include "Halide.h"
#include <algorithm>
#include <stdio.h>
using namespace Halide;

int main(int argc, char **argv) {
    //平铺操作，类似于取一个图像中相邻的几个像素点的操作，比较像卷积操作
    Var x,y;
    Func gradient("gradient_tiled");
    gradient(x, y) = x + y;
    gradient.trace_stores();

    // 平铺可以是维度拆分+循环重排的组合技能
    Var x_outer, x_inner, y_outer, y_inner;
    gradient.split(x, x_outer, x_inner, 4);
    gradient.split(y, y_outer, y_inner, 4);
    gradient.reorder(x_inner, y_inner, x_outer, y_outer);
    // 使用tile接口就是如下所示的操作
    // gradient.tile(x, y, x_outer, y_outer, x_inner, y_inner, 4, 4);
    printf("Evaluating gradient in 4x4 tiles\n");
    Buffer<int> output = gradient.realize({8, 8});
    // 示意图可以查看lesson_05_tiled.gif
    printf("Equivalent C:\n");
    for (int y_outer = 0; y_outer < 2; y_outer++) {
        for (int x_outer = 0; x_outer < 2; x_outer++) {
            for (int y_inner = 0; y_inner < 4; y_inner++) {
                for (int x_inner = 0; x_inner < 4; x_inner++) {
                    int x = x_outer * 4 + x_inner;
                    int y = y_outer * 4 + y_inner;
                    printf("Evaluating at x = %d, y = %d: %d\n", x, y, x + y);
                }
            }
        }
    }
    printf("\n");
    printf("Pseudo-code for the schedule:\n");
    gradient.print_loop_nest();
    printf("\n");
    return 0;
}

结果的动态展示图如下所示：

在这里插入图片描述

#运行结果如下所示
Begin pipeline gradient_tiled.0()
Tag gradient_tiled.0() tag = "func_type_and_dim: 1 0 32 1 2 0 8 0 8"
Store gradient_tiled.0(0, 0) = 0
Store gradient_tiled.0(1, 0) = 1
Store gradient_tiled.0(2, 0) = 2
Store gradient_tiled.0(3, 0) = 3
Store gradient_tiled.0(0, 1) = 1
Store gradient_tiled.0(1, 1) = 2
Store gradient_tiled.0(2, 1) = 3
Store gradient_tiled.0(3, 1) = 4
Store gradient_tiled.0(0, 2) = 2
Store gradient_tiled.0(1, 2) = 3
Store gradient_tiled.0(2, 2) = 4
Store gradient_tiled.0(3, 2) = 5
Store gradient_tiled.0(0, 3) = 3
Store gradient_tiled.0(1, 3) = 4
Store gradient_tiled.0(2, 3) = 5
Store gradient_tiled.0(3, 3) = 6
Store gradient_tiled.0(4, 0) = 4
Store gradient_tiled.0(5, 0) = 5
Store gradient_tiled.0(6, 0) = 6
Store gradient_tiled.0(7, 0) = 7
Store gradient_tiled.0(4, 1) = 5
Store gradient_tiled.0(5, 1) = 6
Store gradient_tiled.0(6, 1) = 7
Store gradient_tiled.0(7, 1) = 8
Store gradient_tiled.0(4, 2) = 6
Store gradient_tiled.0(5, 2) = 7
Store gradient_tiled.0(6, 2) = 8
Store gradient_tiled.0(7, 2) = 9
Store gradient_tiled.0(4, 3) = 7
Store gradient_tiled.0(5, 3) = 8
Store gradient_tiled.0(6, 3) = 9
Store gradient_tiled.0(7, 3) = 10
Store gradient_tiled.0(0, 4) = 4
Store gradient_tiled.0(1, 4) = 5
Store gradient_tiled.0(2, 4) = 6
Store gradient_tiled.0(3, 4) = 7
Store gradient_tiled.0(0, 5) = 5
Store gradient_tiled.0(1, 5) = 6
Store gradient_tiled.0(2, 5) = 7
Store gradient_tiled.0(3, 5) = 8
Store gradient_tiled.0(0, 6) = 6
Store gradient_tiled.0(1, 6) = 7
Store gradient_tiled.0(2, 6) = 8
Store gradient_tiled.0(3, 6) = 9
Store gradient_tiled.0(0, 7) = 7
Store gradient_tiled.0(1, 7) = 8
Store gradient_tiled.0(2, 7) = 9
Store gradient_tiled.0(3, 7) = 10
Store gradient_tiled.0(4, 4) = 8
Store gradient_tiled.0(5, 4) = 9
Store gradient_tiled.0(6, 4) = 10
Store gradient_tiled.0(7, 4) = 11
Store gradient_tiled.0(4, 5) = 9
Store gradient_tiled.0(5, 5) = 10
Store gradient_tiled.0(6, 5) = 11
Store gradient_tiled.0(7, 5) = 12
Store gradient_tiled.0(4, 6) = 10
Store gradient_tiled.0(5, 6) = 11
Store gradient_tiled.0(6, 6) = 12
Store gradient_tiled.0(7, 6) = 13
Store gradient_tiled.0(4, 7) = 11
Store gradient_tiled.0(5, 7) = 12
Store gradient_tiled.0(6, 7) = 13
Store gradient_tiled.0(7, 7) = 14
End pipeline gradient_tiled.0()

Evaluating gradient in 4x4 tiles
Equivalent C:
Evaluating at x = 0, y = 0: 0
Evaluating at x = 1, y = 0: 1
Evaluating at x = 2, y = 0: 2
Evaluating at x = 3, y = 0: 3
Evaluating at x = 0, y = 1: 1
Evaluating at x = 1, y = 1: 2
Evaluating at x = 2, y = 1: 3
Evaluating at x = 3, y = 1: 4
Evaluating at x = 0, y = 2: 2
Evaluating at x = 1, y = 2: 3
Evaluating at x = 2, y = 2: 4
Evaluating at x = 3, y = 2: 5
Evaluating at x = 0, y = 3: 3
Evaluating at x = 1, y = 3: 4
Evaluating at x = 2, y = 3: 5
Evaluating at x = 3, y = 3: 6
Evaluating at x = 4, y = 0: 4
Evaluating at x = 5, y = 0: 5
Evaluating at x = 6, y = 0: 6
Evaluating at x = 7, y = 0: 7
Evaluating at x = 4, y = 1: 5
Evaluating at x = 5, y = 1: 6
Evaluating at x = 6, y = 1: 7
Evaluating at x = 7, y = 1: 8
Evaluating at x = 4, y = 2: 6
Evaluating at x = 5, y = 2: 7
Evaluating at x = 6, y = 2: 8
Evaluating at x = 7, y = 2: 9
Evaluating at x = 4, y = 3: 7
Evaluating at x = 5, y = 3: 8
Evaluating at x = 6, y = 3: 9
Evaluating at x = 7, y = 3: 10
Evaluating at x = 0, y = 4: 4
Evaluating at x = 1, y = 4: 5
Evaluating at x = 2, y = 4: 6
Evaluating at x = 3, y = 4: 7
Evaluating at x = 0, y = 5: 5
Evaluating at x = 1, y = 5: 6
Evaluating at x = 2, y = 5: 7
Evaluating at x = 3, y = 5: 8
Evaluating at x = 0, y = 6: 6
Evaluating at x = 1, y = 6: 7
Evaluating at x = 2, y = 6: 8
Evaluating at x = 3, y = 6: 9
Evaluating at x = 0, y = 7: 7
Evaluating at x = 1, y = 7: 8
Evaluating at x = 2, y = 7: 9
Evaluating at x = 3, y = 7: 10
Evaluating at x = 4, y = 4: 8
Evaluating at x = 5, y = 4: 9
Evaluating at x = 6, y = 4: 10
Evaluating at x = 7, y = 4: 11
Evaluating at x = 4, y = 5: 9
Evaluating at x = 5, y = 5: 10
Evaluating at x = 6, y = 5: 11
Evaluating at x = 7, y = 5: 12
Evaluating at x = 4, y = 6: 10
Evaluating at x = 5, y = 6: 11
Evaluating at x = 6, y = 6: 12
Evaluating at x = 7, y = 6: 13
Evaluating at x = 4, y = 7: 11
Evaluating at x = 5, y = 7: 12
Evaluating at x = 6, y = 7: 13
Evaluating at x = 7, y = 7: 14

Pseudo-code for the schedule:
produce gradient_tiled:
  for y.v5:
    for x.v3:
      for y.v6 in [0, 3]:
        for x.v4 in [0, 3]:
          gradient_tiled(...) = ...

向量化操作

#include "Halide.h"
#include <algorithm>
#include <stdio.h>
using namespace Halide;

int main(int argc, char **argv) {
    // 向量化操作
    Var x,y;
    Func gradient("gradient_in_vectors");
    gradient(x, y) = x + y;
    gradient.trace_stores();

    // 使用向量化操作，在x86平台上可以使用SSE指令集进行长度为4的向量加速
    Var x_outer, x_inner;
    gradient.split(x, x_outer, x_inner, 4);
    gradient.vectorize(x_inner);
    // 可以使用以下操作等效上述两个语句
    // gradient.vectorize(x, 4);
    printf("Evaluating gradient with x_inner vectorized \n");
    Buffer<int> output = gradient.realize({8, 4});
    // 动态图可见lesson_05_vectors.gif
    printf("Equivalent C:\n");
    for (int y = 0; y < 4; y++) {
        for (int x_outer = 0; x_outer < 2; x_outer++) {
            // 内部的循环已经被指令集加速进行替换
            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]);
        }
    }
    printf("\n");
    printf("Pseudo-code for the schedule:\n");
    gradient.print_loop_nest();
    printf("\n");
    return 0;
}

向量化的示意图如下所示：

在这里插入图片描述

#运行结果如下所示
Begin pipeline gradient_in_vectors.0()
Tag gradient_in_vectors.0() tag = "func_type_and_dim: 1 0 32 1 2 0 8 0 4"
Store gradient_in_vectors.0(<0, 1, 2, 3>, <0, 0, 0, 0>) = <0, 1, 2, 3>
Store gradient_in_vectors.0(<4, 5, 6, 7>, <0, 0, 0, 0>) = <4, 5, 6, 7>
Store gradient_in_vectors.0(<0, 1, 2, 3>, <1, 1, 1, 1>) = <1, 2, 3, 4>
Store gradient_in_vectors.0(<4, 5, 6, 7>, <1, 1, 1, 1>) = <5, 6, 7, 8>
Store gradient_in_vectors.0(<0, 1, 2, 3>, <2, 2, 2, 2>) = <2, 3, 4, 5>
Store gradient_in_vectors.0(<4, 5, 6, 7>, <2, 2, 2, 2>) = <6, 7, 8, 9>
Store gradient_in_vectors.0(<0, 1, 2, 3>, <3, 3, 3, 3>) = <3, 4, 5, 6>
Store gradient_in_vectors.0(<4, 5, 6, 7>, <3, 3, 3, 3>) = <7, 8, 9, 10>
End pipeline gradient_in_vectors.0()

Evaluating gradient with x_inner vectorized 
Equivalent C:
Evaluating at <0, 1, 2, 3>, <0, 0, 0, 0>: <0, 1, 2, 3>
Evaluating at <4, 5, 6, 7>, <0, 0, 0, 0>: <4, 5, 6, 7>
Evaluating at <0, 1, 2, 3>, <1, 1, 1, 1>: <1, 2, 3, 4>
Evaluating at <4, 5, 6, 7>, <1, 1, 1, 1>: <5, 6, 7, 8>
Evaluating at <0, 1, 2, 3>, <2, 2, 2, 2>: <2, 3, 4, 5>
Evaluating at <4, 5, 6, 7>, <2, 2, 2, 2>: <6, 7, 8, 9>
Evaluating at <0, 1, 2, 3>, <3, 3, 3, 3>: <3, 4, 5, 6>
Evaluating at <4, 5, 6, 7>, <3, 3, 3, 3>: <7, 8, 9, 10>

Pseudo-code for the schedule:
produce gradient_in_vectors:
  for y:
    for x.v7:
      vectorized x.v8 in [0, 3]:
        gradient_in_vectors(...) = ...

循环展开

#include "Halide.h"
#include <algorithm>
#include <stdio.h>
using namespace Halide;

int main(int argc, char **argv) {
    Var x,y;
    Func gradient("gradient_unroll");
    gradient(x, y) = x + y;
    gradient.trace_stores();
    // 循环展开就指被指定的那层循环用重复代码进行替换，消除掉该层
    Var x_outer, x_inner;
    gradient.split(x, x_outer, x_inner, 2);
    gradient.unroll(x_inner);
    // 上述可以用unroll一个语句代替，如下所示
    // gradient.unroll(x, 2);
    printf("Evaluating gradient unrolled by a factor of two\n");
    Buffer<int> result = gradient.realize({4, 4});
    printf("Equivalent C:\n");
    for (int y = 0; y < 4; y++) {
        for (int x_outer = 0; x_outer < 2; x_outer++) {
            // 循环展开如下所示
            {
                int x_inner = 0;
                int x = x_outer * 2 + x_inner;
                printf("Evaluating at x = %d, y = %d: %d\n", x, y, x + y);
            }
            {
                int x_inner = 1;
                int x = x_outer * 2 + x_inner;
                printf("Evaluating at x = %d, y = %d: %d\n", x, y, x + y);
            }
        }
    }
    printf("\n");
    printf("Pseudo-code for the schedule:\n");
    gradient.print_loop_nest();
    printf("\n");
    return 0;
}


#运行结果如下所示
Begin pipeline gradient_unroll.0()
Tag gradient_unroll.0() tag = "func_type_and_dim: 1 0 32 1 2 0 4 0 4"
Store gradient_unroll.0(0, 0) = 0
Store gradient_unroll.0(1, 0) = 1
Store gradient_unroll.0(2, 0) = 2
Store gradient_unroll.0(3, 0) = 3
Store gradient_unroll.0(0, 1) = 1
Store gradient_unroll.0(1, 1) = 2
Store gradient_unroll.0(2, 1) = 3
Store gradient_unroll.0(3, 1) = 4
Store gradient_unroll.0(0, 2) = 2
Store gradient_unroll.0(1, 2) = 3
Store gradient_unroll.0(2, 2) = 4
Store gradient_unroll.0(3, 2) = 5
Store gradient_unroll.0(0, 3) = 3
Store gradient_unroll.0(1, 3) = 4
Store gradient_unroll.0(2, 3) = 5
Store gradient_unroll.0(3, 3) = 6
End pipeline gradient_unroll.0()

Evaluating gradient unrolled by a factor of two
Equivalent C:
Evaluating at x = 0, y = 0: 0
Evaluating at x = 1, y = 0: 1
Evaluating at x = 2, y = 0: 2
Evaluating at x = 3, y = 0: 3
Evaluating at x = 0, y = 1: 1
Evaluating at x = 1, y = 1: 2
Evaluating at x = 2, y = 1: 3
Evaluating at x = 3, y = 1: 4
Evaluating at x = 0, y = 2: 2
Evaluating at x = 1, y = 2: 3
Evaluating at x = 2, y = 2: 4
Evaluating at x = 3, y = 2: 5
Evaluating at x = 0, y = 3: 3
Evaluating at x = 1, y = 3: 4
Evaluating at x = 2, y = 3: 5
Evaluating at x = 3, y = 3: 6

Pseudo-code for the schedule:
produce gradient_unroll:
  for y:
    for x.v9:
      unrolled x.v10 in [0, 1]:
        gradient_unroll(...) = ...

维度拆分split的特殊情况

#include "Halide.h"
#include <algorithm>
#include <stdio.h>
using namespace Halide;

int main(int argc, char **argv) {
    Var x,y;
    Func gradient("gradient_split_7x2");
    gradient(x, y) = x + y;
    gradient.trace_stores();
    // 此时进行拆分，那么将会出现没有维度溢出的情况
    Var x_outer, x_inner;
    gradient.split(x, x_outer, x_inner, 3);

    printf("Evaluating gradient over a 7x2 box with x split by three \n");
    Buffer<int> output = gradient.realize({7, 2});
    // 示意图可以见lesson_05_split_7_by_3.gif
    printf("Equivalent C:\n");
    for (int y = 0; y < 2; y++) {
        for (int x_outer = 0; x_outer < 3; x_outer++) {  // Now runs from 0 to 2
            for (int x_inner = 0; x_inner < 3; x_inner++) {
                int x = x_outer * 3;
                // 在计算前，为了防止溢出7之外，这里使用判断进行溢出处理
                // 这样的判断导致了不会溢出，最多到6下标这个点
                if (x > 4) x = 4;
                x += x_inner;
                printf("Evaluating at x = %d, y = %d: %d\n", x, y, x + y);
            }
        }
    }
    printf("\n");
    printf("Pseudo-code for the schedule:\n");
    gradient.print_loop_nest();
    printf("\n");
    // The general rule is: If we require x from x_min to x_min + x_extent, and
    // we split by a factor 'factor', then:
    //
    // x_outer runs from 0 to (x_extent + factor - 1)/factor
    // x_inner runs from 0 to factor
    // x = min(x_outer * factor, x_extent - factor) + x_inner + x_min
    // In our example, x_min was 0, x_extent was 7, and factor was 3.
    return 0;
}

维度拆分的特殊情况的示意图如下所示：

在这里插入图片描述

#运行结果如下所示
Begin pipeline gradient_split_7x2.0()
Tag gradient_split_7x2.0() tag = "func_type_and_dim: 1 0 32 1 2 0 7 0 2"
Store gradient_split_7x2.0(0, 0) = 0
Store gradient_split_7x2.0(1, 0) = 1
Store gradient_split_7x2.0(2, 0) = 2
Store gradient_split_7x2.0(3, 0) = 3
Store gradient_split_7x2.0(4, 0) = 4
Store gradient_split_7x2.0(5, 0) = 5
Store gradient_split_7x2.0(4, 0) = 4
Store gradient_split_7x2.0(5, 0) = 5
Store gradient_split_7x2.0(6, 0) = 6
Store gradient_split_7x2.0(0, 1) = 1
Store gradient_split_7x2.0(1, 1) = 2
Store gradient_split_7x2.0(2, 1) = 3
Store gradient_split_7x2.0(3, 1) = 4
Store gradient_split_7x2.0(4, 1) = 5
Store gradient_split_7x2.0(5, 1) = 6
Store gradient_split_7x2.0(4, 1) = 5
Store gradient_split_7x2.0(5, 1) = 6
Store gradient_split_7x2.0(6, 1) = 7
End pipeline gradient_split_7x2.0()

Evaluating gradient over a 7x2 box with x split by three 
Equivalent C:
Evaluating at x = 0, y = 0: 0
Evaluating at x = 1, y = 0: 1
Evaluating at x = 2, y = 0: 2
Evaluating at x = 3, y = 0: 3
Evaluating at x = 4, y = 0: 4
Evaluating at x = 5, y = 0: 5
Evaluating at x = 4, y = 0: 4
Evaluating at x = 5, y = 0: 5
Evaluating at x = 6, y = 0: 6
Evaluating at x = 0, y = 1: 1
Evaluating at x = 1, y = 1: 2
Evaluating at x = 2, y = 1: 3
Evaluating at x = 3, y = 1: 4
Evaluating at x = 4, y = 1: 5
Evaluating at x = 5, y = 1: 6
Evaluating at x = 4, y = 1: 5
Evaluating at x = 5, y = 1: 6
Evaluating at x = 6, y = 1: 7

Pseudo-code for the schedule:
produce gradient_split_7x2:
  for y:
    for x.v11:
      for x.v12 in [0, 2]:
        gradient_split_7x2(...) = ...

融合、平铺、并行化组合技

#include "Halide.h"
#include <algorithm>
#include <stdio.h>
using namespace Halide;

int main(int argc, char **argv) {
    Var x,y;
    // 有时候为了进行并行化操作，我们需要使用融合和平铺来跨维度进行并行化操作
    Func gradient("gradient_fused_tiles");
    gradient(x, y) = x + y;
    gradient.trace_stores();
    // 平铺->外部循环融合->外部循环并行
    Var x_outer, y_outer, x_inner, y_inner, tile_index;
    gradient.tile(x, y, x_outer, y_outer, x_inner, y_inner, 4, 4);
    gradient.fuse(x_outer, y_outer, tile_index);
    gradient.parallel(tile_index);
    // 能够使用如下的链式表达式进行上述的替代
    // gradient
    //     .tile(x, y, x_outer, y_outer, x_inner, y_inner, 4, 4)
    //     .fuse(x_outer, y_outer, tile_index)
    //     .parallel(tile_index);
    printf("Evaluating gradient tiles in parallel\n");
    Buffer<int> output = gradient.realize({8, 8});
    // 如此一来，每个瓦片都是并行运行的
    printf("Equivalent (serial) C:\n");
    // 外部循环应该进行展开
    // C中使用 # omp for
    for (int tile_index = 0; tile_index < 4; tile_index++) {
        int y_outer = tile_index / 2;
        int x_outer = tile_index % 2;
        for (int y_inner = 0; y_inner < 4; y_inner++) {
            for (int x_inner = 0; x_inner < 4; x_inner++) {
                int y = y_outer * 4 + y_inner;
                int x = x_outer * 4 + x_inner;
                printf("Evaluating at x = %d, y = %d: %d\n", x, y, x + y);
            }
        }
    }
    printf("\n");
    printf("Pseudo-code for the schedule:\n");
    gradient.print_loop_nest();
    printf("\n");
    return 0;
}

三个组合技的示意图如下所示:

在这里插入图片描述

#运行结果如下所示
Begin pipeline gradient_fused_tiles.0()
Tag gradient_fused_tiles.0() tag = "func_type_and_dim: 1 0 32 1 2 0 8 0 8"
Store gradient_fused_tiles.0(0, 0) = 0
Store gradient_fused_tiles.0(1, 0) = 1
Store gradient_fused_tiles.0(2, 0) = 2
Store gradient_fused_tiles.0(3, 0) = 3
Store gradient_fused_tiles.0(0, 1) = 1
Store gradient_fused_tiles.0(1, 1) = 2
Store gradient_fused_tiles.0(2, 1) = 3
Store gradient_fused_tiles.0(3, 1) = 4
Store gradient_fused_tiles.0(0, 2) = 2
Store gradient_fused_tiles.0(1, 2) = 3
Store gradient_fused_tiles.0(2, 2) = 4
Store gradient_fused_tiles.0(3, 2) = 5
Store gradient_fused_tiles.0(0, 3) = 3
Store gradient_fused_tiles.0(1, 3) = 4
Store gradient_fused_tiles.0(2, 3) = 5
Store gradient_fused_tiles.0(3, 3) = 6
Store gradient_fused_tiles.0(4, 0) = 4
Store gradient_fused_tiles.0(4, 4) = 8
Store gradient_fused_tiles.0(0, 4) = 4
Store gradient_fused_tiles.0(5, 0) = 5
Store gradient_fused_tiles.0(1, 4) = 5
Store gradient_fused_tiles.0(5, 4) = 9
Store gradient_fused_tiles.0(6, 0) = 6
Store gradient_fused_tiles.0(2, 4) = 6
Store gradient_fused_tiles.0(6, 4) = 10
Store gradient_fused_tiles.0(7, 0) = 7
Store gradient_fused_tiles.0(3, 4) = 7
Store gradient_fused_tiles.0(4, 1) = 5
Store gradient_fused_tiles.0(7, 4) = 11
Store gradient_fused_tiles.0(0, 5) = 5
Store gradient_fused_tiles.0(5, 1) = 6
Store gradient_fused_tiles.0(1, 5) = 6
Store gradient_fused_tiles.0(4, 5) = 9
Store gradient_fused_tiles.0(2, 5) = 7
Store gradient_fused_tiles.0(5, 5) = 10
Store gradient_fused_tiles.0(6, 1) = 7
Store gradient_fused_tiles.0(3, 5) = 8
Store gradient_fused_tiles.0(6, 5) = 11
Store gradient_fused_tiles.0(7, 1) = 8
Store gradient_fused_tiles.0(0, 6) = 6
Store gradient_fused_tiles.0(7, 5) = 12
Store gradient_fused_tiles.0(4, 2) = 6
Store gradient_fused_tiles.0(1, 6) = 7
Store gradient_fused_tiles.0(4, 6) = 10
Store gradient_fused_tiles.0(5, 2) = 7
Store gradient_fused_tiles.0(5, 6) = 11
Store gradient_fused_tiles.0(2, 6) = 8
Store gradient_fused_tiles.0(6, 2) = 8
Store gradient_fused_tiles.0(6, 6) = 12
Store gradient_fused_tiles.0(3, 6) = 9
Store gradient_fused_tiles.0(7, 2) = 9
Store gradient_fused_tiles.0(7, 6) = 13
Store gradient_fused_tiles.0(0, 7) = 7
Store gradient_fused_tiles.0(4, 3) = 7
Store gradient_fused_tiles.0(1, 7) = 8
Store gradient_fused_tiles.0(4, 7) = 11
Store gradient_fused_tiles.0(5, 3) = 8
Store gradient_fused_tiles.0(2, 7) = 9
Store gradient_fused_tiles.0(6, 3) = 9
Store gradient_fused_tiles.0(5, 7) = 12
Store gradient_fused_tiles.0(3, 7) = 10
Store gradient_fused_tiles.0(7, 3) = 10
Store gradient_fused_tiles.0(6, 7) = 13
Store gradient_fused_tiles.0(7, 7) = 14
End pipeline gradient_fused_tiles.0()

Evaluating gradient tiles in parallel
Equivalent (serial) C:
Evaluating at x = 0, y = 0: 0
Evaluating at x = 1, y = 0: 1
Evaluating at x = 2, y = 0: 2
Evaluating at x = 3, y = 0: 3
Evaluating at x = 0, y = 1: 1
Evaluating at x = 1, y = 1: 2
Evaluating at x = 2, y = 1: 3
Evaluating at x = 3, y = 1: 4
Evaluating at x = 0, y = 2: 2
Evaluating at x = 1, y = 2: 3
Evaluating at x = 2, y = 2: 4
Evaluating at x = 3, y = 2: 5
Evaluating at x = 0, y = 3: 3
Evaluating at x = 1, y = 3: 4
Evaluating at x = 2, y = 3: 5
Evaluating at x = 3, y = 3: 6
Evaluating at x = 4, y = 0: 4
Evaluating at x = 5, y = 0: 5
Evaluating at x = 6, y = 0: 6
Evaluating at x = 7, y = 0: 7
Evaluating at x = 4, y = 1: 5
Evaluating at x = 5, y = 1: 6
Evaluating at x = 6, y = 1: 7
Evaluating at x = 7, y = 1: 8
Evaluating at x = 4, y = 2: 6
Evaluating at x = 5, y = 2: 7
Evaluating at x = 6, y = 2: 8
Evaluating at x = 7, y = 2: 9
Evaluating at x = 4, y = 3: 7
Evaluating at x = 5, y = 3: 8
Evaluating at x = 6, y = 3: 9
Evaluating at x = 7, y = 3: 10
Evaluating at x = 0, y = 4: 4
Evaluating at x = 1, y = 4: 5
Evaluating at x = 2, y = 4: 6
Evaluating at x = 3, y = 4: 7
Evaluating at x = 0, y = 5: 5
Evaluating at x = 1, y = 5: 6
Evaluating at x = 2, y = 5: 7
Evaluating at x = 3, y = 5: 8
Evaluating at x = 0, y = 6: 6
Evaluating at x = 1, y = 6: 7
Evaluating at x = 2, y = 6: 8
Evaluating at x = 3, y = 6: 9
Evaluating at x = 0, y = 7: 7
Evaluating at x = 1, y = 7: 8
Evaluating at x = 2, y = 7: 9
Evaluating at x = 3, y = 7: 10
Evaluating at x = 4, y = 4: 8
Evaluating at x = 5, y = 4: 9
Evaluating at x = 6, y = 4: 10
Evaluating at x = 7, y = 4: 11
Evaluating at x = 4, y = 5: 9
Evaluating at x = 5, y = 5: 10
Evaluating at x = 6, y = 5: 11
Evaluating at x = 7, y = 5: 12
Evaluating at x = 4, y = 6: 10
Evaluating at x = 5, y = 6: 11
Evaluating at x = 6, y = 6: 12
Evaluating at x = 7, y = 6: 13
Evaluating at x = 4, y = 7: 11
Evaluating at x = 5, y = 7: 12
Evaluating at x = 6, y = 7: 13
Evaluating at x = 7, y = 7: 14

Pseudo-code for the schedule:
produce gradient_fused_tiles:
  parallel x.v13.v17:
    for y.v16 in [0, 3]:
      for x.v15 in [0, 3]:
        gradient_fused_tiles(...) = ...

所有循环优化的手段组合运用

#include "Halide.h"
#include <algorithm>
#include <stdio.h>
using namespace Halide;

int main(int argc, char **argv) {
    Var x,y;
    Func gradient_fast("gradient_fast");
    gradient_fast(x, y) = x + y;

    // 首先进行了大循环平铺->外循环融合->外循环并行化
    Var x_outer, y_outer, x_inner, y_inner, tile_index;
    gradient_fast
        .tile(x, y, x_outer, y_outer, x_inner, y_inner, 64, 64)
        .fuse(x_outer, y_outer, tile_index)
        .parallel(tile_index);
    // 然后对平铺的瓦片进行平铺->向量化->循环展开
    Var x_inner_outer, y_inner_outer, x_vectors, y_pairs;
    gradient_fast
        .tile(x_inner, y_inner, x_inner_outer, y_inner_outer, x_vectors, y_pairs, 4, 2)
        .vectorize(x_vectors)
        .unroll(y_pairs);
    // 这里没有用到维度分割和维度变化操作，因为使用了其他操作进行替换，但是这两种可以组合成其他操作
    Buffer<int> result = gradient_fast.realize({350, 250});

    // See figures/lesson_05_fast.mp4 for a visualization.

    printf("Checking Halide result against equivalent C...\n");
    for (int tile_index = 0; tile_index < 6 * 4; tile_index++) {
        int y_outer = tile_index / 4;
        int x_outer = tile_index % 4;
        for (int y_inner_outer = 0; y_inner_outer < 64 / 2; y_inner_outer++) {
            for (int x_inner_outer = 0; x_inner_outer < 64 / 4; x_inner_outer++) {
                // We're vectorized across x
                int x = std::min(x_outer * 64, 350 - 64) + x_inner_outer * 4;
                int x_vec[4] = {x + 0,
                                x + 1,
                                x + 2,
                                x + 3};

                // And we unrolled across y
                int y_base = std::min(y_outer * 64, 250 - 64) + y_inner_outer * 2;
                {
                    // y_pairs = 0
                    int y = y_base + 0;
                    int y_vec[4] = {y, y, y, y};
                    int val[4] = {x_vec[0] + y_vec[0],
                                    x_vec[1] + y_vec[1],
                                    x_vec[2] + y_vec[2],
                                    x_vec[3] + y_vec[3]};

                    // Check the result.
                    for (int i = 0; i < 4; i++) {
                        if (result(x_vec[i], y_vec[i]) != val[i]) {
                            printf("There was an error at %d %d!\n",
                                    x_vec[i], y_vec[i]);
                            return -1;
                        }
                    }
                }
                {
                    // y_pairs = 1
                    int y = y_base + 1;
                    int y_vec[4] = {y, y, y, y};
                    int val[4] = {x_vec[0] + y_vec[0],
                                    x_vec[1] + y_vec[1],
                                    x_vec[2] + y_vec[2],
                                    x_vec[3] + y_vec[3]};

                    // Check the result.
                    for (int i = 0; i < 4; i++) {
                        if (result(x_vec[i], y_vec[i]) != val[i]) {
                            printf("There was an error at %d %d!\n",
                                    x_vec[i], y_vec[i]);
                            return -1;
                        }
                    }
                }
            }
        }
    }
    printf("\n");
    printf("Pseudo-code for the schedule:\n");
    gradient_fast.print_loop_nest();
    printf("\n");
    return 0;
}

所有的组合技叠加的效果：

在这里插入图片描述

#运行结果如下所示
Checking Halide result against equivalent C...

Pseudo-code for the schedule:
produce gradient_fast:
  parallel x.v18.v22:
    for y.v21.v24 in [0, 31]:
      for x.v20.v23 in [0, 15]:
        unrolled y.v21.v26 in [0, 1]:
          vectorized x.v20.v25 in [0, 3]:
            gradient_fast(...) = ...
慷仔
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
快速入门Halide
Time_remember的专栏
08-21 881
Halide代码流程： 声明函数，变量，表达式 用变量、表达式等实现算法 使用调度策略对算法进行调度调优 调用函数的realize成员函数，对函数进行实现 写出数据 example 1: Halide::Func gradient; // Func对象表示了一个pipeline阶段。它是一个纯函数，定义了每个像素点对应的值。 Halide::Var x, y; // Var对象是Func的定义域，或者说是Func的参数。它们本身没有任何意义。Var用来索引 Halide::Expr e = x
Halide学习
u011994454的博客
06-13 586
目的：在现代机器上完成高性能的图像处理。 编译器目标：x86/SSE, ARM V7/NEON, CUDA, Native Client, OpenCL, and Metal. 大致流程：用Halide::Var, Halide::Expr, Halide::Func类型的对象完成c++程序，然后调用Halide::Func::compile_to_file来生成对象文件和头文件。或者调用Halide::Func::realize即时编译(JIT)并即刻运行整套pipeline，这有利于测试小的程序。
Halide示例学习一
Pengcode的博客
04-19 539
Halide示例学习一示例学习基本变量和概念操控图片操作debug操作1 示例学习 基本变量和概念 // 使用Halide，我们只需要包含Halide.h这个头文件就可以了 #include "Halide.h" #include <stdio.h> int main(int argc, char **argv) { // Halide::Func代表了一个计算图，代表了每一个像素值需要进行的计算操作 Halide::Func gradient; // Halide::
Halide学习笔记--04--Vectorize, parallelize, unroll and tile
weixin_45331269的博客
09-03 337
前言 接上, 本文学习Halide lesson_05_scheduling ** schedule Func in different ways ** 内容 本节主要学习几个概念: 矢量, 并行, 展开, 平铺 用来加速图像像素级计算的过程; row-major && column-major //row-major Func gradient; gradient(x, y) = x + y; ;;; //column-major gradient.reorder(y, x);
Halide学习笔记---Halide语言设计的初衷
luzhanbo207的博客
11-30 7342
Halide语言设计初衷我们正处于一个数据密集的时代，4D广场相机、图形渲染、3D打印、图像传感器、高质量医学图像等，每天生产大量的图像数据，面对这样一个图像时代，急需要针对图像处理算法设计的高性能图像处理编程语言，在这样的需求下，Halide应运而生。 应用当前存在的编程工具编写高性能的图像处理程序需要牺牲可读性、可移植性和模块性。这可能是由于算法描述、数据存储和计算顺序杂糅在一起所致。
wscad-2019:Halide 与强化学习
05-29
《Halide 与强化学习：探索深度学习优化的新路径》 在现代计算机视觉和图像处理领域，Halide语言因其高效、灵活的特性而备受青睐。Halide是一种领域特定的语言，专为编译图像处理和计算机视觉算法而设计，它允许...
SIGGRAPH2015:siggraph 2015 Halide课程中使用的示例代码
05-17
首先，请从halide-lang.org下载Halide的二进制版本，并将其解压缩/解压缩到此目录中。
halide-magnify:使用 Halide 放大视频！
06-10
通过阅读和理解这些文件，你可以深入学习如何使用 Halide 实现视频放大，并了解 UROP 项目中涉及的具体技术挑战和解决方案。此外，该项目也可以作为一个起点，为其他图像处理或计算机视觉任务提供灵感和基础。
gradient-halide
04-26
有关如何使用梯度扩展看到测试在实施例 ，在一个简单的多项式函数拟合示例 ，并且在一个更复杂的透镜优化应用 。 有关实现，请参见 ， ， ， 。 我们还实现了一个新的自动调度程序，该程序具有一组输出Halide函数并...
Halide_Film调色
03-05
强大的电影效果AE调色插件Halide_Film去水印版，插件!擦除动态水印
Halide：一种用于快速，便携式数据并行计算的语言
01-31
卤化物 Halide是一种编程语言，旨在使在现代机器上编写高性能图像和数组处理代码更加容易。 卤化物目前的目标是： CPU体系结构：X86，ARM，MIPS，Hexagon，PowerPC 操作系统：Linux，Windows，Mac OS X，Android，iOS，Qualcomm QuRT GPU计算API：CUDA，OpenCL，OpenGL计算着色器，Apple Metal，Microsoft Direct X 12 Halide并不是独立的编程语言，而是嵌入C ++中。 这意味着您编写的C ++代码使用Halide的C ++ API构建了Halide管道的内存中表示形式。 然后，您可以将该表示形式编译为目标文件，或对其进行JIT编译并在同一过程中运行。 Halide还提供了Python绑定，该绑定提供了对编写无需C ++的Python中嵌入的Halide的完全支持。 有关Halide是什么的更多详细信息，请参见 。 有关API文档，请参见 要查看一些示例代码，请查看tutorials目录。 如果您已获取完整的源代码发行版并希望构建Halide，请参阅的。 卤
Halide学习笔记----Halide tutorial源码阅读1
luzhanbo207的博客
11-28 6712
Halide入门教程01// Halide tutorial lesson 1: Getting started with Funcs, Vars, and Exprs // Halide入门教程第一课：了解Funcs（函数），Vars（变量）和Exprs（表达式）// This lesson demonstrates basic usage of Halide as a JIT compiler
Halide学习笔记----Halide tutorial源码阅读10
luzhanbo207的博客
12-22 1478
Halide入门教程10// Halide tutorial lesson 10: AOT compilation part 1 // Halide入门教程第十课：提前编译 // This lesson demonstrates how to use Halide as an more traditional // ahead-of-time (AOT) compiler. // 本课程展示了如何用
Halide学习笔记----Halide tutorial源码阅读5
luzhanbo207的博客
12-04 2142
Halide入门教程05// Halide教程第五课：向量化，并行化，平铺，数据分块 // 本课展示了如何才操作函数像素索引的计算顺序，包括向量化/并行化/平铺/分块等技术// 在linux系统中，采用如下指令编译并执行 // g++ lesson_05*.cpp -g -I ../include -L ../bin -lHalide -lpthread -ldl -o lesson_05 -std
Halide学习笔记----Halide tutorial源码阅读2
luzhanbo207的博客
11-29 2258
Halide入门教程02// Halide tutorial lesson 2: Processing images // Halide入门第二课： 处理图像// This lesson demonstrates how to pass in input images and manipulate // them. // 本课展示了如何读入图像数据，并操作像素// On linux, you can
Halide学习笔记----Halide tutorial源码阅读8
luzhanbo207的博客
12-22 1203
Halide入门教程08// Halide tutorial lesson 8: Scheduling multi-stage pipelines // Halide入门教程第八课，多阶段流水线调度// On linux, you can compile and run it like so: // 在linux上按如下方法编译执行，在仅仅测试的情况下，建议将如下两行写入shell脚本文件，避免每次
Halide示例学习四
Pengcode的博客
05-02 217
Halide示例学习四多阶段计算图多计算图组合示例compute_at使用方法store_root配合compute_at使用方法tile配合compute_at使用方法compute_at和store_at以及之前的混合技使用方法 多阶段计算图 #include "Halide.h" #include <stdio.h> using namespace Halide; int main(int argc, char **argv) { Var x("x"), y("y");
Halide学习笔记--01--配置环境
weixin_45331269的博客
09-02 410
准备 最近要做图像算法的一些性能优化, 所以就要学一下Halide, 什么是Halide? 为何选择Halide? Halide有什么优势, 有什么不足? 以上问题, 此处省略1w字… 环境 win10, vs2019, cmake… 准备Halide Download下载最新安装包 Halide-12.0.1-x86-64-windows–本人是win10_64位机器, 所以就选择了介个… 选择的是编译好的release版本, 准备source code 此处不是要从源码编译, 只想要tutoria
Halide 构建
2Know的博客
03-09 1602
hello halide 随着人工智能，VR等领域的发展，我们对于高性能图像处理程序的需求越来越大；当前编程工具开发的高性能图像处理程序牺牲了程序的可读性，模块性，可移植性等；其主要原因是，当前程序将算法描述， 数据存储以及计算糅杂在一起。同时手工编写高性能图像处理程序开发效率较低，难以快速构建大量高性能图像处理代码。 在这样的背景下，MIT的研究人员专门为图像处理设计了一种程序语言——Halid...
将 OpenCV 的 Mat 转换为 Halide 的 Buffer
最新发布
05-22
要将 OpenCV 的 Mat 转换为 Halide 的 Buffer，可以使用以下代码示例： ```c++ #include <opencv2/opencv.hpp> #include <Halide.h> int main() { // Create an OpenCV Mat object cv::Mat input_mat = cv::imread("input.jpg", cv::IMREAD_COLOR); // Create a Halide Buffer object with the same dimensions and data type as the input Mat Halide::Buffer<uint8_t> input_buf(input_mat.data, input_mat.cols, input_mat.rows, input_mat.channels()); // Now you can use the input_buf object in your Halide pipeline // ... return 0; } ``` 在这个示例中，我们首先创建了一个 OpenCV Mat 对象 `input_mat`，然后使用该对象的数据、宽度、高度和通道数创建了一个 Halide Buffer 对象 `input_buf`。现在，您可以将 `input_buf` 对象传递给 Halide 管道的输入。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值