Использование extern на Halide с GPU

Я нахожу решение своей проблемы.

Я публикую ответ в коде только здесь. (Поскольку я провел небольшой автономный тест, имя переменной не совпадает)

Внутри Halide: (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: (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);

}

Вы можете скомпилировать halide_func с тестом 4, чтобы использовать все функциональные возможности Extern.

Вот некоторые выводы, которые у меня есть. (Спасибо Zalman и zougloub)

• Compute_root не вызывает устройство, если вы используете его отдельно.
• Нам нужен gpu() из gpu_tile() в коде для вызова подпрограммы GPU. (Кстати, вам нужно поместить всю свою переменную внутрь)
• gpu_tile, чем ваш предмет приведет к сбою.
• BoundaryCondition хорошо работает в графическом процессоре.
• Прежде чем вызывать внешнюю функцию, Func, которая используется в качестве входных данных, должна быть: f.compute_root(); f.gpu_tile(x,y,...,...); Compute_root на промежуточном этапе не является неявным.
• Если адрес разработчика равен 0, это нормально, мы повторно отправляем измерение, и внешний вызов будет вызван снова.
• Последний этап как неявный метод calculate_root().

Знаете ли вы о протоколе вывода границ для функций внешнего массива? Это происходит, когда указатель хоста любого буфера равен NULL. (Вкратце, в этом случае вам нужно заполнить поля экстента структур buffer_t, которые имеют NULL указатели хоста, и больше ничего не делать.) Если вы уже позаботились об этом, то игнорируйте вышеизложенное.

Если вы проверили, что указатели хоста не равны NULL для всех буферов, вызов halide_copy_to_dev должен работать. Возможно, вам придется заранее явно установить для host_dirty значение true, чтобы выполнить часть копирования, в зависимости от того, откуда был взят буфер. (Я надеюсь, что Halide понимает это правильно, и он уже установлен, если буфер получен из предыдущей стадии конвейера на ЦП. Но если буфер получен из чего-то вне Halide, грязные биты, вероятно, ложны из-за инициализации. Кажется, halide_dev_malloc должен установить dev_dirty, если он выделяет память устройства, а в настоящее время это не так.)

Я ожидаю, что поле dev будет заполнено после вызова halide_copy_to_dev, так как первое, что он делает, это вызывает halide_dev_malloc. Вы можете попробовать вызвать halide_dev_malloc самостоятельно, установить host_dirty и затем вызвать halide_copy_to_dev.

Предыдущий этап находится на хосте или на графическом процессоре? Если он находится на графическом процессоре, я ожидаю, что входной буфер также будет на графическом процессоре.

Этот API нуждается в доработке. Я занимаюсь первым рефакторингом того, что может помочь, но в конечном итоге это потребует изменения структуры buffer_t. Можно заставить работать большинство вещей, но для этого потребуется изменить биты host_dirty и dev_dirty, а также правильно вызвать API-интерфейсы halide_dev*. Спасибо за терпеливость.