在带有GPU的Halide上使用extern

Question

我尝试在Halide中使用extern函数。在我的背景下，我想在GPU上做。

我用OpenCL语句在AOT编译中编译。当然，opencl仍然可以使用CPU，所以我使用以下代码：

halide_set_ocl_device_type("gpu");

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

第一个问题，如果我使用compute_root()和OpenCL图形处理器，我的进程会在带有一些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仅加载到主机内存中。dev地址为0(默认值)。

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

halide_copy_to_dev(NULL, &in);

它什么也做不了。

如果我只提供设备内存：

in.host = NULL;

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

(在我的情况下，dev_dirty为真，host_dirty为假)

有什么想法吗？

编辑(回答dsharlet)

下面是我的代码结构：

在CPU上正确解析数据。-->在图形处理器上发送缓冲区(使用halide_copy_to_dev...) -->进入Halide结构，读取参数并添加边界条件-->在我的外部函数中Go -->...

我的外部函数中没有有效的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;
}

外部Halide(外部函数)：

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

Answer 1

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

我在这里用代码发布了答案。(因为我做了一些离线测试，所以变量名不匹配)

哈利德内部：(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，以使用所有的外部功能。

以下是我得出的一些结论。(感谢Zalman和zougloub)

• Compute_root如果您单独使用设备，请不要调用它。
• 我们需要在代码中使用gpu_tile()的gpu()来调用GPU例程。(顺便说一句，你需要把你所有的变量放在inside)
• gpu_tile上，这样你的项目才能让你的stuff.
• BoundaryCondition在GPU中运行得很好。
• 在调用外部函数之前，作为输入的函数需要是: f.compute_root()；f.gpu_tile(x，y，...，...)；中间阶段的compute_root不是隐式的。
• 如果开发地址是0，这是正常的，我们重新发送维度，外部项将被再次调用。
• 最后一个阶段作为compute_root()隐式。

Answer 2

你知道外部数组函数的边界推断协议吗？当任何缓冲区的主机指针为空时，就会发生这种情况。(简而言之，在本例中，您需要填充buffer_t结构的区段字段，这些结构的主机指针为空，不执行任何其他操作。)如果你已经注意到了这一点，那么忽略上面的内容。

如果您已经测试了所有缓冲区的主机指针都是非空的，那么调用halide_copy_to_dev应该是可行的。您可能需要事先显式地将host_dirty设置为true，以使复制部分发生，具体取决于缓冲区来自何处。(我希望Halide能正确处理这一点，如果缓冲区来自CPU上的前一个流水线阶段，它已经设置好了。但是，如果缓冲区来自Halide之外的某个地方，则从初始化开始，脏位可能是假的。如果halide_dev_malloc分配设备内存，它似乎应该设置dev_dirty，但目前还没有。)

我希望dev字段在调用halide_copy_to_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。感谢您的耐心。