2

我是卤化物的新手。我一直在玩教程以了解该语言。现在，我正在编写一个小型演示应用程序以在 OSX 上从命令行运行。

我的目标是对图像执行逐像素操作，将其安排在 GPU 上并测量性能。我已经尝试了一些我想在这里分享的东西，并对接下来的步骤有一些疑问。

第一种方法

我在 GPU 上安排了算法，目标是 OpenGL，但是因为我无法访问 GPU 内存来写入文件，所以在 Halide 例程中，我通过创建Func cpu_out类似于Halide repo 中的glsl 示例应用程序将输出复制到 CPU

pixel_operation_cpu_out.cpp

#include "Halide.h"
#include <stdio.h>

using namespace Halide;

const int _number_of_channels = 4;

int main(int argc, char** argv)
{
    ImageParam input8(UInt(8), 3);

    input8
        .set_stride(0, _number_of_channels) // stride in dimension 0 (x) is three
        .set_stride(2, 1); // stride in dimension 2 (c) is one

    Var x("x"), y("y"), c("c");

    // algorithm
    Func input;
    input(x, y, c) = cast<float>(input8(clamp(x, input8.left(), input8.right()),
                                 clamp(y, input8.top(), input8.bottom()),
                                 clamp(c, 0, _number_of_channels))) / 255.0f;

    Func pixel_operation;

    // calculate the corresponding value for input(x, y, c) after doing a 
    // pixel-wise operation on each each pixel. This gives us pixel_operation(x, y, c).
    // This operation is not location dependent, eg: brighten

    Func out;
    out(x, y, c) = cast<uint8_t>(pixel_operation(x, y, c) * 255.0f + 0.5f);
    out.output_buffer()
        .set_stride(0, _number_of_channels)
        .set_stride(2, 1);
    input8.set_bounds(2, 0, _number_of_channels); // Dimension 2 (c) starts at 0 and has extent _number_of_channels.
    out.output_buffer().set_bounds(2, 0, _number_of_channels);

    // schedule

     out.compute_root();
     out.reorder(c, x, y)
         .bound(c, 0, _number_of_channels)
         .unroll(c);

    // Schedule for GLSL

    out.glsl(x, y, c);

    Target target = get_target_from_environment();
    target.set_feature(Target::OpenGL);

    // create a cpu_out Func to copy over the data in Func out from GPU to CPU
    std::vector<Argument> args = {input8};
    Func cpu_out;
    cpu_out(x, y, c) = out(x, y, c);
    cpu_out.output_buffer()
        .set_stride(0, _number_of_channels)
        .set_stride(2, 1);
    cpu_out.output_buffer().set_bounds(2, 0, _number_of_channels);
    cpu_out.compile_to_file("pixel_operation_cpu_out", args, target);

    return 0;
}

因为我编译了这个 AOT，所以我在我的函数中调用main()了它。main()驻留在另一个文件中。

主文件.cpp

注意： Image 此处使用的类与此 Halide示例应用程序中的类相同

int main()
{
    char *encodeded_jpeg_input_buffer = read_from_jpeg_file("input_image.jpg");
    unsigned char *pixelsRGBA = decompress_jpeg(encoded_jpeg_input_buffer);

    Image input(width, height, channels, sizeof(uint8_t), Image::Interleaved);
    Image output(width, height, channels, sizeof(uint8_t), Image::Interleaved);
    input.buf.host = &pixelsRGBA[0];
    unsigned char *outputPixelsRGBA = (unsigned char *)malloc(sizeof(unsigned char) * width * height * channels);
    output.buf.host = &outputPixelsRGBA[0];

    double best = benchmark(100, 10, [&]() {
         pixel_operation_cpu_out(&input.buf, &output.buf);
    });

    char* encoded_jpeg_output_buffer = compress_jpeg(output.buf.host);
    write_to_jpeg_file("output_image.jpg", encoded_jpeg_output_buffer);
}

这工作得很好，给了我我期望的输出。据我了解，cpu_out使 CPU 内存中的值out可用，这就是为什么我能够通过访问来访问这些output.buf.host值main_file.cpp

第二种方法：

我尝试的第二件事是不通过创建从设备中的设备复制到主机Func cpu_out，而是copy_to_host使用main_file.cpp.

pixel_operation_gpu_out.cpp

#include "Halide.h"
#include <stdio.h>

using namespace Halide;

const int _number_of_channels = 4;

int main(int argc, char** argv)
{
    ImageParam input8(UInt(8), 3);

    input8
        .set_stride(0, _number_of_channels) // stride in dimension 0 (x) is three
        .set_stride(2, 1); // stride in dimension 2 (c) is one

    Var x("x"), y("y"), c("c");

    // algorithm
    Func input;
    input(x, y, c) = cast<float>(input8(clamp(x, input8.left(), input8.right()),
                                 clamp(y, input8.top(), input8.bottom()),
                                 clamp(c, 0, _number_of_channels))) / 255.0f;

    Func pixel_operation;

    // calculate the corresponding value for input(x, y, c) after doing a 
    // pixel-wise operation on each each pixel. This gives us pixel_operation(x, y, c).
    // This operation is not location dependent, eg: brighten

    Func out;
    out(x, y, c) = cast<uint8_t>(pixel_operation(x, y, c) * 255.0f + 0.5f);
    out.output_buffer()
        .set_stride(0, _number_of_channels)
        .set_stride(2, 1);
    input8.set_bounds(2, 0, _number_of_channels); // Dimension 2 (c) starts at 0 and has extent _number_of_channels.
    out.output_buffer().set_bounds(2, 0, _number_of_channels);

    // schedule

     out.compute_root();
     out.reorder(c, x, y)
         .bound(c, 0, _number_of_channels)
         .unroll(c);

    // Schedule for GLSL

    out.glsl(x, y, c);

    Target target = get_target_from_environment();
    target.set_feature(Target::OpenGL);

    std::vector<Argument> args = {input8};
    out.compile_to_file("pixel_operation_gpu_out", args, target);

    return 0;
}

主文件.cpp

#include "pixel_operation_gpu_out.h"
#include "runtime/HalideRuntime.h"

int main()
{
    char *encodeded_jpeg_input_buffer = read_from_jpeg_file("input_image.jpg");
    unsigned char *pixelsRGBA = decompress_jpeg(encoded_jpeg_input_buffer);

    Image input(width, height, channels, sizeof(uint8_t), Image::Interleaved);
    Image output(width, height, channels, sizeof(uint8_t), Image::Interleaved);
    input.buf.host = &pixelsRGBA[0];
    unsigned char *outputPixelsRGBA = (unsigned char *)malloc(sizeof(unsigned char) * width * height * channels);
    output.buf.host = &outputPixelsRGBA[0];

    double best = benchmark(100, 10, [&]() {
         pixel_operation_gpu_out(&input.buf, &output.buf);
    });

    int status = halide_copy_to_host(NULL, &output.buf);

    char* encoded_jpeg_output_buffer = compress_jpeg(output.buf.host);
    write_to_jpeg_file("output_image.jpg", encoded_jpeg_output_buffer);

    return 0;
}

所以，现在，我认为正在发生的事情pixel_operation_gpu_out是保持output.buf在 GPU 上，当我这样做copy_to_host时，我将内存复制到 CPU 上。这个程序也给了我预期的输出。

问题：

第二种方法比第一种方法慢得多。不过，慢速部分不在基准测试部分。例如，对于第一种方法，我得到 17 毫秒作为 4k 图像的基准时间。对于同一张图片，在第二种方法中，我得到的基准时间为 22us，所用时间为copy_to_host10s。我不确定这种行为是否是预期的，因为方法 1 和 2 基本上都在做同样的事情。

我尝试的下一件事是使用[HalideRuntimeOpenGL.h][3]纹理并将纹理链接到输入和输出缓冲区，以便能够直接绘制到 OpenGL 上下文，main_file.cpp而不是保存到 jpeg 文件。但是，我找不到任何示例来弄清楚如何使用其中的函数，HalideRuntimeOpenGL.h而且我自己尝试的任何事情总是给我运行时错误，我无法弄清楚如何解决。如果有人有任何资源可以指点我，那就太好了。

此外，也欢迎对我上面的代码提供任何反馈。我知道它有效并且正在做我想做的事，但这可能是完全错误的做法，我不会知道更好。

4

1 回答 1

0

10s 复制内存的原因很可能是因为 GPU API 已将所有内核调用排队，然后在调用 halide_copy_to_host 时等待它们完成。您可以在运行所有计算调用后在基准计时内调用 halide_device_sync 以处理在没有复制回时间的情况下在循环内获取计算时间。

我无法从代码中得知内核从该代码运行了多少次。（我的猜测是 100，但可能是那些用于基准测试的参数设置了某种参数化，它试图根据需要多次运行它以获得重要性。如果是这样，这是一个问题，因为排队调用真的很快但计算当然是异步的。如果是这种情况，你可以做一些事情，比如排队 10 个调用，然后调用 halide_device_sync 并使用数字“10”来了解它需要多长时间。）

于 2016-06-13T21:24:51.607 回答