1

我尝试在 Halide 中使用 extern 函数。在我的上下文中，我想在 GPU 上进行。

我用 opencl 语句在 AOT 编译中编译。当然opencl还是可以用cpu的，所以我用这个：

halide_set_ocl_device_type("gpu");

现在，一切都安排在 compute_root() 中。

第一个问题，如果我使用 compute_root() 和 OpenCL gpu，我的进程是否会在设备上使用 CopyHtoD 和 DtoH 进行计算？（或者它将在主机缓冲区上）

第二个问题，更多与外部函数有关。我们使用一些外部调用，因为我们的一些算法不在 Halide 中。外呼：

foo.define_extern("cool_foo", args, Float(32), 4);

外部检索：外部“C” int cool_foo(buffer_t * in, int w, int h, int z, buffer_t * out){ .. }

但是，在cool_foo 函数中，我的buffer_t 只加载到主机内存中。开发地址为 0（默认）。

如果我尝试在算法之前复制内存：

halide_copy_to_dev(NULL, &in);

它什么也不做。

如果我只提供设备内存：

in.host = NULL;

我的主机指针为空，但设备地址仍为 0。

（在我的情况下，dev_dirty 为 true，host_dirty 为 false）

任何想法？

编辑（回答 dsharlet）

这是我的代码的结构：

在 CPU 上正确解析数据。--> 在 GPU 上发送缓冲区（使用 halide_copy_to_dev...） --> 进入 Halide 结构，读取参数并添加边界条件 --> 进入我的 extern 函数 -->...

我的 extern 函数中没有有效的 buffer_t。我在 compute_root() 中安排所有内容，但使用 HL_TARGET=host-opencl 并将 ocl 设置为 gpu。在进入Halide之前，我可以读取我的设备地址，就可以了。

这是我的代码：

在 Halide 之前，一切都是 CPU 的东西（指针），我们将它转​​移到 GPU

buffer_t k = { 0, (uint8_t *) k_full, {w_k, h_k, num_patch_x * num_patch_y * 3}, {1, w_k, w_k * h_k}, {0}, sizeof(float), };
#if defined( USEGPU )
    // Transfer into GPU
    halide_copy_to_dev(NULL, &k);
    k.host_dirty = false;
    k.dev_dirty = true;
    //k.host = NULL; // It's k_full
#endif
halide_func(&k)

卤化物内部：

ImageParam ...
Func process;
process = halide_sub_func(k, width, height, k.channels());
process.compute_root();

...

Func halide_sub_func(ImageParam k, Expr width, Expr height, Expr patches)
{
    Func kBounded("kBounded"), kShifted("kShifted"), khat("khat"), khat_tuple("khat_tuple");
    kBounded = repeat_image(constant_exterior(k, 0.0f), 0, width, 0, height, 0, patches);
    kShifted(x, y, pi) = kBounded(x + k.width() / 2, y + k.height() / 2, pi);

    khat = extern_func(kShifted, width, height, patches);
    khat_tuple(x, y, pi) = Tuple(khat(0, x, y, pi), khat(1, x, y, pi));

    kShifted.compute_root();
    khat.compute_root();

    return khat_tuple;
}

外卤化物（外部功能）：

inline .... 
{
   //The buffer_t.dev and .host are 0 and null. I expect a null from the host, but the dev..
}
4

2 回答 2

3

我找到了我的问题的解决方案。

我在这里用代码发布答案。（由于我做了一点离线测试，变量名不匹配）

卤化物内部：（Halide_func.cpp）

#include <Halide.h>


 using namespace Halide;

 using namespace Halide::BoundaryConditions;

 Func thirdPartyFunction(ImageParam f);
 Func fourthPartyFunction(ImageParam f);
 Var x, y;

 int main(int argc, char **argv) {
    // Input:
    ImageParam f( Float( 32 ), 2, "f" );

    printf(" Argument: %d\n",argc);

    int test = atoi(argv[1]);

    if (test == 1) {
        Func f1;
        f1(x, y) = f(x, y) + 1.0f;
        f1.gpu_tile(x, 256);
        std::vector<Argument> args( 1 );
        args[ 0 ] = f;
        f1.compile_to_file("halide_func", args);

    } else if (test == 2) {
        Func fOutput("fOutput");
        Func fBounded("fBounded");
        fBounded = repeat_image(f, 0, f.width(), 0, f.height());
        fOutput(x, y) = fBounded(x-1, y) + 1.0f;


        fOutput.gpu_tile(x, 256);
        std::vector<Argument> args( 1 );
        args[ 0 ] = f;
        fOutput.compile_to_file("halide_func", args);

    } else if (test == 3) {
        Func h("hOut");

        h = thirdPartyFunction(f);

        h.gpu_tile(x, 256);
        std::vector<Argument> args( 1 );
        args[ 0 ] = f;
        h.compile_to_file("halide_func", args);

    } else {
        Func h("hOut");

        h = fourthPartyFunction(f);

        std::vector<Argument> args( 1 );
        args[ 0 ] = f;
        h.compile_to_file("halide_func", args);
    }
 }

 Func thirdPartyFunction(ImageParam f) {
     Func g("g");
     Func fBounded("fBounded");
     Func h("h");
     //Boundary
     fBounded = repeat_image(f, 0, f.width(), 0, f.height());
     g(x, y) = fBounded(x-1, y) + 1.0f;
     h(x, y) = g(x, y) - 1.0f;

     // Need to be comment out if you want to use GPU schedule.
     //g.compute_root(); //At least one stage schedule alone
     //h.compute_root();

     return h;
 }

Func fourthPartyFunction(ImageParam f) {
    Func fBounded("fBounded");
    Func g("g");
    Func h("h");

    //Boundary
    fBounded = repeat_image(f, 0, f.width(), 0, f.height());

    // Preprocess
    g(x, y) = fBounded(x-1, y) + 1.0f;

    g.compute_root();
    g.gpu_tile(x, y, 256, 1);


    // Extern
    std::vector < ExternFuncArgument > args = { g, f.width(), f.height() };
    h.define_extern("extern_func", args, Int(16), 3);

    h.compute_root();
    return h;
}

外部函数：(external_func.h)

#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <cinttypes>
#include <cstring>
#include <fstream>
#include <map>
#include <vector>
#include <complex>
#include <chrono>
#include <iostream>


#include <clFFT.h> // All OpenCL I need are include.

using namespace std;
// Useful stuff.
void completeDetails2D(buffer_t buffer) {
    // Read all elements:
    std::cout << "Buffer information:" << std::endl;
    std::cout << "Extent: " << buffer.extent[0] << ", " << buffer.extent[1] << std::endl;
    std::cout << "Stride: " << buffer.stride[0] << ", " << buffer.stride[1] << std::endl;
    std::cout << "Min: " << buffer.min[0] << ", " << buffer.min[1] << std::endl;
    std::cout << "Elem size: " << buffer.elem_size << std::endl;
    std::cout << "Host dirty: " << buffer.host_dirty << ", Dev dirty: " << buffer.dev_dirty << std::endl;
    printf("Host pointer: %p, Dev pointer: %" PRIu64 "\n\n\n", buffer.host, buffer.dev);
}

extern cl_context _ZN6Halide7Runtime8Internal11weak_cl_ctxE;
extern cl_command_queue _ZN6Halide7Runtime8Internal9weak_cl_qE;


extern "C" int extern_func(buffer_t * in, int width, int height, buffer_t * out)
{
    printf("In extern\n");
    completeDetails2D(*in);
    printf("Out extern\n");
    completeDetails2D(*out);

    if(in->dev == 0) {
        // Boundary stuff
        in->min[0] = 0;
        in->min[1] = 0;
        in->extent[0] = width;
        in->extent[1] = height;
        return 0;
    }

    // Super awesome stuff on GPU
    // ...

    cl_context & ctx = _ZN6Halide7Runtime8Internal11weak_cl_ctxE; // Found by zougloub
    cl_command_queue & queue = _ZN6Halide7Runtime8Internal9weak_cl_qE; // Same

    printf("ctx: %p\n", ctx);

    printf("queue: %p\n", queue);

    cl_mem buffer_in;
    buffer_in = (cl_mem) in->dev;
    cl_mem buffer_out;
    buffer_out = (cl_mem) out->dev;

    // Just copying data from one buffer to another
    int err = clEnqueueCopyBuffer(queue, buffer_in, buffer_out, 0, 0, 256*256*4, 0, NULL, NULL);

    printf("copy: %d\n", err);

    err = clFinish(queue);

    printf("finish: %d\n\n", err);

    return 0;
}

最后，非卤化物的东西：（Halide_test.cpp）

#include <halide_func.h>
#include <iostream>
#include <cinttypes>

#include <external_func.h>

// Extern function available inside the .o generated.
#include "HalideRuntime.h"

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

    // Init the kernel in GPU
    halide_set_ocl_device_type("gpu");

    // Create a buffer
    int width = 256;
    int height = 256;
    float * bufferHostIn = (float*) malloc(sizeof(float) * width * height);
    float * bufferHostOut = (float*) malloc(sizeof(float) * width * height);

    for( int j = 0; j < height; ++j) {
        for( int i = 0; i < width; ++i) {
            bufferHostIn[i + j * width] = i+j;
        }
    }

    buffer_t bufferHalideIn = {0, (uint8_t *) bufferHostIn, {width, height}, {1, width, width * height}, {0, 0}, sizeof(float), true, false};
    buffer_t bufferHalideOut = {0, (uint8_t *) bufferHostOut, {width, height}, {1, width, width * height}, {0, 0}, sizeof(float), true, false};

    printf("IN\n");
    completeDetails2D(bufferHalideIn);
    printf("Data (host): ");
    for(int i = 0; i < 10; ++ i) {
        printf(" %f, ", bufferHostIn[i]);
    }
    printf("\n");

    printf("OUT\n");
    completeDetails2D(bufferHalideOut);

    // Send to GPU
    halide_copy_to_dev(NULL, &bufferHalideIn);
    halide_copy_to_dev(NULL, &bufferHalideOut);
    bufferHalideIn.host_dirty = false;
    bufferHalideIn.dev_dirty = true;
    bufferHalideOut.host_dirty = false;
    bufferHalideOut.dev_dirty = true;
    // TRICKS Halide to force the use of device.
    bufferHalideIn.host = NULL;
    bufferHalideOut.host = NULL;

    printf("IN After device\n");
    completeDetails2D(bufferHalideIn);

    // Halide function
    halide_func(&bufferHalideIn, &bufferHalideOut);

    // Get back to HOST
    bufferHalideIn.host = (uint8_t*)bufferHostIn;
    bufferHalideOut.host = (uint8_t*)bufferHostOut;
    halide_copy_to_host(NULL, &bufferHalideOut);
    halide_copy_to_host(NULL, &bufferHalideIn);

    // Validation
    printf("\nOUT\n");
    completeDetails2D(bufferHalideOut);
    printf("Data (host): ");
    for(int i = 0; i < 10; ++ i) {
        printf(" %f, ", bufferHostOut[i]);
    }
    printf("\n");

    // Free all
    free(bufferHostIn);
    free(bufferHostOut);

}

您可以使用测试 4 编译 halide_func 以使用所有 Extern 功能。

这是我的一些结论。（感谢 Zalman 和 zougloub）

  • 如果单独使用，Compute_root 不会调用该设备。
  • 我们需要代码中的 gpu_tile() 的 gpu() 来调用 GPU 例程。（顺便说一句，您需要将所有变量放入其中）
  • gpu_tile 小于你的项目会使你的东西崩溃。
  • BoundaryCondition 在 GPU 中运行良好。
  • 在调用 extern 函数之前，作为输入的 Func 需要是： f.compute_root(); f.gpu_tile(x,y,...,...); 中间阶段的compute_root不是隐含的。
  • 如果dev地址为0是正常的，我们重新发送维度，再次调用extern。
  • 最后阶段作为 compute_root() 隐式。
于 2014-10-16T21:06:02.753 回答
0

你知道外部数组函数的边界推断协议吗？这发生在任何缓冲区的主机指针为 NULL 时。（简而言之，在这种情况下，您需要填写具有 NULL 主机指针的 buffer_t 结构的范围字段，并且不执行任何其他操作。）如果您已经处理了这一点，则忽略上述内容。

如果您已经测试过所有缓冲区的主机指针都不是 NULL，那么调用 halide_copy_to_dev 应该可以工作。您可能需要事先将 host_dirty 显式设置为 true 以使复制部分发生，具体取决于缓冲区的来源。（我希望 Halide 做对了，如果缓冲区来自 CPU 上的前一个管道阶段，它已经设置好了。但是如果缓冲区来自 Halide 之外的东西，那么脏位可能在初始化时是错误的。似乎 halide_dev_malloc 应该设置dev_dirty 如果它分配了设备内存，目前它没有。）

我希望在调用 halide_copy_to_dev 之后填充 dev 字段，因为它所做的第一件事就是调用 halide_dev_malloc。您可以尝试自己显式调用 halide_dev_malloc，设置 host_dirty，然后调用 halide_copy_to_dev。

前一阶段是在主机上还是在 GPU 上？如果它在 GPU 上，我希望输入缓冲区也在 GPU 上。

这个 API 需要工作。我正在对一些有用的东西进行第一次重构，但最终它需要更改 buffer_t 结构。大多数事情都可以正常工作，但它需要修改 host_dirty 和 dev_dirty 位，并以正确的方式调用 halide_dev* API。感谢您的耐心等待。

于 2014-10-08T22:25:52.683 回答