Нарисуйте Мандельброта с помощью OpenCl

Question

Я хочу написать программу для рисования набора Мандельброта для изображения. Я использую OpenCl и cl.hpp - оболочку для C++, но я не знаю, почему это не работает.

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

Мне также интересно узнать, как передать image2d_t в ядро ​​и "записать" пиксели непосредственно в изображение, но когда я запускаю свое ядро, я получаю ошибку -52, в которой я установил недопустимые аргументы.

Объявление моего ядра (с использованием image2d_t) выглядит так:

__kernel syf(__write_only image2d_t img)

и я устанавливаю аргументы так:

cl_mem image= clCreateImage2D(context, CL_MEM_WRITE_ONLY, &outputFormat, ImageWidth, ImageHeight, 0, 0, &err);
clSetKernelArg(kernel, 0, sizeof(cl_mem), (void*)&image)

Не могли бы вы взглянуть на код и помочь мне?

#define __CL_ENABLE_EXCEPTIONS
//#define __NO_STD_VECTOR

#include <ctime>
#include <fstream>
#include <iostream>
#include <exception>
#include "D:/Users/cuda/cuda/bmp.cpp"


#if defined (__APPLE__) || defined (MACOSX)
#include <OpenCl/cl.cpp>
#else
#include <CL/OpenCL.h>
#include <CL/cl.hpp>
#endif

const int N = 1024 * 1024 * 3;

const char * kernelSource =
"__kernel void prepareVector(__global char *output)"
"{"
"       size_t xDimension = get_global_id(0);                                              "
"       size_t yDimension = get_global_id(1);                                              "
"                                                                                                                          "
"       size_t currentIndex = 3 * 1024.0f*yDimension + 3 * xDimension;  "
"       float xOriginal = 3.25f*((float) xDimension / 1024.0f) - 2.0f; "
"       float yOriginal = 2.5f*((float) yDimension / 1024.0f) - 1.25f;"
"                                                                                                               "
"       int iteration = 0;                                                                      "
"       int maxIteration = 256;                                                         "
"       float temp;                                                                                     "
"       float x = 0.0f;                                                                         "
"       float y = 0.0f;                                                                         "
"       while (x*x + y*y <= 4.0f && iteration < maxIteration)"
"       {                                                                 "
"               temp = x*x - y*y + xOriginal; "
"               y = 2.0*x*y + yOriginal;          "
"               x = temp;                                         "
"               ++iteration;                              "
"       }                                                         "
"                                                                         "
"       if (iteration == maxIteration)    "
"       {                                                                 "
"               iteration = 0;                            "
"       }                                                                 "
"       output[currentIndex] = iteration;         "
"       output[currentIndex] = iteration;"
"       output[currentIndex] = iteration;"
"}";

std::vector<cl::Platform> platforms;
std::vector<cl::Device> devices;
std::vector<cl::Kernel> allKernels;
cl::Program program;

cl_int cli_err_msg;

char *host_out_c;

int main(int argc, char* argv [])
{
        try
        {
                size_t dimensionSize = 2;
                cl::NDRange *globalSize = new cl::NDRange( 6, 8 );
                cl::NDRange *localSize = new cl::NDRange( 3, 4 );
                cl::NDRange *offsetSize = new cl::NDRange( 0, 0 );

                host_out_c = new char[N];

                cl::Platform::get(&platforms);
                platforms[0].getDevices(CL_DEVICE_TYPE_ALL, &devices);

                cl_context_properties properties [] =
                {
                        CL_CONTEXT_PLATFORM, (cl_context_properties) (platforms[0])(), 0
                };

                //cl_context context = clCreateContext(0, devices.size(), devices, NULL, NULL, NULL);
                cl::Context context(CL_DEVICE_TYPE_ALL, properties);
                std::vector<cl::Device> devices = context.getInfo<CL_CONTEXT_DEVICES>();
                cl::Program::Sources source(1, std::make_pair(kernelSource, strlen(kernelSource)));
                program = cl::Program(context, source);
                program.build(devices);

                cl::Kernel kernel(program, "prepareVector", &cli_err_msg);

                cl::Buffer device_out_c(context, CL_MEM_WRITE_ONLY, N*sizeof(char));

                cl::Event event;
                cl::CommandQueue queue(context, devices[0], 0, &cli_err_msg);

                kernel.setArg(0, device_out_c);

                queue.enqueueNDRangeKernel(kernel, *offsetSize, *globalSize, *localSize, NULL, &event);
                queue.enqueueReadBuffer(device_out_c, true, 0, N*sizeof(char), (void*) host_out_c);
                //printArray("kernel output:\n", host_out_c);
                write_bmp("lel.bmp", 1024, 1024, host_out_c);
        }
        catch (cl::Error e)
        {
                std::cout << "Status: "<< program.getBuildInfo<CL_PROGRAM_BUILD_STATUS>(devices[0]) << std::endl;
                std::cout << "Options: "<< program.getBuildInfo<CL_PROGRAM_BUILD_OPTIONS>(devices[0]) << std::endl;
                std::cout << "Log: "<< program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(devices[0]) << std::endl;
                std::cout << e.what() << ": Error code: " << e.err() << std::endl;
        }
        return 0;
}