Правильный способ написания и вызова пользовательских функций C ArrayFire в Julia - PullRequest
Новая
       53

Правильный способ написания и вызова пользовательских функций C ArrayFire в Julia

2 голосов
/ 12 марта 2019

Я работаю в Julia, и мне нужно вызвать некоторые настраиваемые функции C, которые используют библиотеку ArraFire, когда я использую такой код: 

  void copy(const af::array &A, af::array &B,size_t length) {
      // 2.Obtain the device, context, and queue used by ArrayFire 
      // 3.Obtain cl_mem references to af::array objects
      cl_mem * d_A = A.device<cl_mem>();
      cl_mem * d_B = B.device<cl_mem>();

      // 4. Load, build, and use your kernels.

      // Set arguments and launch your kernels
      //kernel is the function build in step 4
      clSetKernelArg(kernel, 0, sizeof(cl_mem), d_A);
      clSetKernelArg(kernel, 1, sizeof(cl_mem), d_B);
      clEnqueueNDRangeKernel(af_queue, kernel, 1, NULL, &length, NULL, 0, NULL, NULL);
      // 5. Return control of af::array memory to ArrayFire
      A.unlock();
      B.unlock();
   }

Я использовал в качестве ссылки пример, приведенный в: Взаимодействие с OpenCL

Я вызываю эту функцию в Юлии следующим образом: 

ccall((:copy,"path/to/dll"),Cvoid(Ref{af_array},Ref{af_array}),Af.arr,Bf.arr)

Af и Bf - массивы ArrayFire, вызов работает, как и ожидалось, проблема заключается в том, чтокогда я использую B=A только для проверки, т. е. 

  void copy(const af::array &A, af::array &B,size_t length) {        
     B=A;//only to test
  }

, остановка вызова работает в Джулии, это заставило меня усомниться, что я использую правильный способ написания и вызова этой функции.

Некоторые из функций Arrayfire, включенных в Julia, которые я видел, вызывают функции, у которых af_array являются аргументами, отличными от аргументов af :: array.Ну, я хочу изменить аргументы, затем я делаю это: 

void copy(const af_array &dA, af_array &dB,size_t length) {

//this to be able to use A.device and B.device
array A=array(dA);
array B=array(dB);

//steps 2 to 5 in the original code 

}

Это не работает в C или в Джулии, вопрос в том, хочу ли я использовать af_array в качестве аргументов, как я получаю указатель устройства?или как правильно использовать эти функции, чтобы избежать проблем, когда я вызываю их у Джулии?

заранее спасибо.

UPD

Я изменил B=A; внутри функции: 

  void copy(const af::array &A, af::array &B,size_t length) {        
        size_t len = A.dims(0);
        seq idx(0, len - 1, 1);
        af::copy(B, A, idx);
  }

И работает!Тем не менее, я все еще сомневаюсь, что это правильный путь, так как этот код очень прост.Я буду работать с более сложным кодом, который может перестать работать аналогичным образом.

1 Ответ

0 голосов
/ 22 марта 2019

Это не окончательный ответ, но я думаю, что это значительно улучшает функциональность. Функция af_get_device_ptr является решением для получения указателя устройства от объекта af_array, и правильный способ написания функций для вызова из Julia, по-видимому, - это те, которые имеют af_array аргументы (см .: вызывающий пользовательские функции C ArrayFire в Julia # 229 ), поскольку функции, встроенные в ArrayFire.jl , делают это следующим образом. Вот простой и полный пример того, как написать и вызвать функцию от Юлии:

в C 

//function for adding ArrayFire arrays   
void AFire::sumaaf(af_array* out , af_array dA, af_array dB) {

        //to store the result
        af_array dC;
        af_copy_array(&dC, dA);

        // 2. Obtain the device, context, and queue used by ArrayFire   
        static cl_context af_context = afcl::getContext();
        static cl_device_id af_device_id = afcl::getDeviceId();
        static cl_command_queue af_queue = afcl::getQueue();

        dim_t _order[4];
        af_get_dims(&_order[0], &_order[1], &_order[2], &_order[3], dA);
        size_t order = _order[0];

        int status = CL_SUCCESS;

        // 3. Obtain cl_mem references to af_array objects
        cl_mem *d_A = (cl_mem*)clCreateBuffer(af_context,
            CL_MEM_READ_ONLY, sizeof(float) * order,
            NULL, &status);
        af_get_device_ptr((void**)d_A, dA);

        cl_mem *d_B = (cl_mem*)clCreateBuffer(af_context,
            CL_MEM_READ_ONLY, sizeof(float) * order,
            NULL, &status);
        af_get_device_ptr((void**)d_B, dB);

        cl_mem *d_C = (cl_mem*)clCreateBuffer(af_context,
            CL_MEM_WRITE_ONLY, sizeof(float) * order,
            NULL, &status);
        af_get_device_ptr((void**)d_C, dC);

        // 4. Load, build, and use your kernels.
        //    For the sake of readability, we have omitted error checking.
        // A simple sum kernel, uses C++11 syntax for multi-line strings.
        const char * kernel_name = "sum_kernel";
        const char * source = R"(
            void __kernel
            sum_kernel(__global float * gC, __global float * gA, __global float * gB)
            {
                int id = get_global_id(0);
                gC[id] = gA[id]+gB[id];
            }
        )";
        // Create the program, build the executable, and extract the entry point
        // for the kernel.
        cl_program program = clCreateProgramWithSource(af_context, 1, &source, NULL, &status);
        status = clBuildProgram(program, 1, &af_device_id, NULL, NULL, NULL);
        cl_kernel sumkernel = clCreateKernel(program, kernel_name, &status);
        // Set arguments and launch your kernels
        clSetKernelArg(sumkernel, 0, sizeof(cl_mem), d_C);
        clSetKernelArg(sumkernel, 1, sizeof(cl_mem), d_A);
        clSetKernelArg(sumkernel, 2, sizeof(cl_mem), d_B);
        clEnqueueNDRangeKernel(af_queue, sumkernel, 1, NULL, &order, NULL, 0, NULL, NULL);

        // 5. Return control of af::array memory to ArrayFire
        af_unlock_array(dA);
        af_unlock_array(dB);
        af_unlock_array(dC);

        //copy results to output argument
        af_copy_array(out, dC);

        // ... resume ArrayFire operations
        // Because the device pointers, d_x and d_y, were returned to ArrayFire's
        // control by the unlock function, there is no need to free them using
        // clReleaseMemObject()
    }

у Юлии звонок будет: 

function sumaaf(A::AFArray{Float32,1},B::AFArray{Float32,1})
    out = ArrayFire.RefValue{af_array}(0);
    ccall((:sumaaf,"path/to/dll")
            ,Cvoid,(Ptr{af_array},af_array,af_array),out,Af.arr,Bf.arr);
    AFArray{Float32,1}(out[])
end
...