hello_opencl.cpp - master - BALABOL/SPEC_EVM

hello_opencl.cpp
215 строк6 KB
BRLivesey
Добавлен буф K
20 фев 2026, 09:41
20 фев 2026, 09:412b5d35d
#include <stdio.h>
#include <iostream> 
#include <OpenCL/opencl.h>
#include<string.h>
#include<stdlib.h>
#include <string>
#include <fstream>
using namespace std; 

int convertToString(const char *filename, string& s){

    size_t size;
    char* str;
    fstream f (filename,(fstream::in | fstream::binary));
    if(f.is_open()){
        size_t fileSize;
        f.seekg(0,fstream::end);
        size = fileSize = (size_t)f.tellg();
        f.seekg(0,fstream::beg);
        str = new char[size+1];
        if(!str){
            f.close();
            return 0;
        }

        f.read(str,fileSize);
        f.close();
        str[size] = '\0';
        s = str;
        delete[] str;
        return 0;


    }

    return -1;

}

void printInfo(cl_device_id device){

    char deviceName[1024];
    clGetDeviceInfo(device,CL_DEVICE_NAME,sizeof(deviceName),deviceName,NULL);
    printf("Имя устройства: %s\n",deviceName);

    char vendor[1024];
    clGetDeviceInfo(device,CL_DEVICE_VENDOR,sizeof(vendor),vendor,NULL);
    printf("Производитель: %s\n",vendor);

    char version[1024];
    clGetDeviceInfo(device,CL_DEVICE_VERSION,sizeof(version),version,NULL);
    printf("Версия OpenCL: %s\n",version);

   cl_uint computeUnits;
   clGetDeviceInfo(device,CL_DEVICE_MAX_COMPUTE_UNITS,sizeof(computeUnits),&computeUnits,NULL);
   printf("Вычислительные блоки: %u\n",computeUnits);

   cl_uint maxClockFreq;
   clGetDeviceInfo(device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof(maxClockFreq), &maxClockFreq, NULL);
   printf("Макс. частота: %u МГц\n", maxClockFreq);
}



void Init(){

    cl_uint numPlatforms;
    cl_platform_id platform = NULL;
    cl_int status = clGetPlatformIDs(0,NULL,&numPlatforms);
    #define CL_SUCCESS 0
    if (status != CL_SUCCESS ){
     printf("Ошибка: %d\n", status);
    }

    if(numPlatforms > 0){
        cl_platform_id* platforms = (cl_platform_id*)malloc(numPlatforms* sizeof(cl_platform_id));
        status = clGetPlatformIDs(numPlatforms,platforms,NULL);
        platform = platforms[0];
        free(platforms);
        
        cl_uint numDevices = 0;
        cl_device_id *devices;
        status = clGetDeviceIDs(platform,CL_DEVICE_TYPE_CPU,0,NULL,&numDevices);
        devices = (cl_device_id*)malloc(numDevices *sizeof(cl_device_id));
        status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_CPU, numDevices,devices,NULL);

        printInfo(devices[0]);


        cl_context context = clCreateContext(NULL,1,devices,NULL,NULL,NULL);
        cl_command_queue commandQueue = clCreateCommandQueue(context,devices[0],0,NULL);

        //create program
        string sourceStr;
        const char *filename = "HelloWorld_Kernel.cl";
        status = convertToString(filename, sourceStr);
        const char *source = sourceStr.c_str();
        size_t sourceSize = {strlen(source)};
        cl_program program = clCreateProgramWithSource(context, 1, &source, &sourceSize, NULL);

        //Build
        status = clBuildProgram(program,1,devices,NULL,NULL,NULL);

        //инициализируем входной буфер

        const char* input = "jkjkkkk";
        size_t strlenght = strlen(input);
        char *output = (char*) malloc(strlenght + 1);
        
        //буфер в памяти 

        cl_mem inputBuffer = clCreateBuffer(context,CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,(strlenght+1)*sizeof(char),(void*)input,NULL);
        cl_mem outputBuffer = clCreateBuffer(context,CL_MEM_WRITE_ONLY,(strlenght+1)*sizeof(char),NULL,NULL);


        cl_kernel kernel = clCreateKernel(program,"helloWorld",NULL);


        int K = 3;
        cl_mem bufferK = clCreateBuffer(context,CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,sizeof(int),&K,NULL);

        status = clSetKernelArg(kernel,0,sizeof(cl_mem),&inputBuffer);
        status = clSetKernelArg(kernel,1,sizeof(cl_mem),&outputBuffer);
        status = clSetKernelArg(kernel,2,sizeof(cl_mem),&bufferK);





        size_t global_work_size[1] = {strlenght};
        status = clEnqueueNDRangeKernel(commandQueue,kernel,1,NULL,global_work_size,NULL,0,NULL,NULL);

        status = clEnqueueReadBuffer(commandQueue,outputBuffer,CL_TRUE,0,strlenght*sizeof(char),output,0,NULL,NULL);
        output[strlenght] = '\0';

        printf("Результат на CPU: %s\n", output);

        //Задание с Буферами

        const int arr_size = 10;

        float A[arr_size] = {1.0f,2.0f,3.0f,4.0f,5.0f,6.0f,7.0f,8.0f,9.0f,10.0f};
        float B[arr_size] = {10.0f,9.0f,8.0f,7.0f,6.0f,5.0f,4.0f,3.0f,2.0f,1.0f};
        float C[arr_size];
        
        cl_mem bufferA = clCreateBuffer(context,CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, arr_size*sizeof(float),A,NULL);
        cl_mem bufferB = clCreateBuffer(context,CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, arr_size*sizeof(float),B,NULL);

        cl_mem bufferC = clCreateBuffer(context,CL_MEM_WRITE_ONLY,arr_size*sizeof(float),NULL,NULL);

        // Ядро

        cl_kernel kernel_multi = clCreateKernel(program,"multi_float",NULL);
        clSetKernelArg(kernel_multi,0,sizeof(cl_mem),&bufferA);
        clSetKernelArg(kernel_multi,1,sizeof(cl_mem),&bufferB);
        clSetKernelArg(kernel_multi,2,sizeof(cl_mem),&bufferC);

        //Запуск

        size_t global_size[1] = {arr_size};

        clEnqueueNDRangeKernel(commandQueue,kernel_multi,1,NULL,global_size,NULL,0,NULL,NULL);

        //Чтение

        clEnqueueReadBuffer(commandQueue,bufferC,CL_TRUE,0,arr_size*sizeof(float),C,0,NULL,NULL);

        printf("Result\n");

        for(int i = 0; i<arr_size;i++){
            printf("%.1f * %.1f = %.1f\n",A[i],B[i],C[i]);
        }


        //Очистка результата

        status = clReleaseKernel(kernel);
        status = clReleaseMemObject(inputBuffer);
        status = clReleaseMemObject(outputBuffer);
        status = clReleaseMemObject(bufferK);
        status = clReleaseProgram(program);
        status = clReleaseCommandQueue(commandQueue);
        status = clReleaseContext(context);

        clReleaseKernel(kernel_multi);
        clReleaseMemObject(bufferA);
        clReleaseMemObject(bufferB);
        clReleaseMemObject(bufferC);


        if(output != NULL){
            free(output);
            output = NULL;
        }

        if(devices != NULL){
            free(devices);
            devices = NULL;
        }
        
        cout<<output<<endl;
        

    }  
}




//CL_DEVICE_TYPE_CPU	(для устройств CPU),

int main(){
        Init();
        return 0;
    }