A computação heterogênea é uma abordagem que utiliza diferentes tipos de unidades de processamento, como CPUs, GPUs e outros aceleradores, para otimizar o desempenho de aplicações. No ambiente Linux, essa prática é altamente aplicável e pode ser implementada usando frameworks como OpenCL e CUDA. A seguir, vamos explorar como configurar e executar tarefas de computação heterogênea no Linux.

Exemplos:

1. Configurando o Ambiente OpenCL no Linux:

Primeiro, precisamos instalar os pacotes necessários para usar OpenCL. No Ubuntu, você pode fazer isso usando o seguinte comando:

   sudo apt-get install ocl-icd-opencl-dev

Em seguida, você pode verificar se o OpenCL está corretamente instalado e quais dispositivos estão disponíveis:

   clinfo

Este comando listará todas as plataformas e dispositivos OpenCL disponíveis no sistema.

2. Executando um Programa Simples em OpenCL:

Aqui está um exemplo de um programa simples em OpenCL que multiplica cada elemento de um vetor por 2:

   #include <CL/cl.h>

   #include <stdio.h>

   #include <stdlib.h>



   const char *kernelSource = 

       "__kernel void vecAdd(__global int *a) {"

       "   int id = get_global_id(0);"

       "   a[id] *= 2;"

       "}";



   int main() {

       int data[10];

       for (int i = 0; i < 10; i++) data[i] = i;



       // Setup OpenCL environment

       cl_platform_id platform;

       cl_device_id device;

       cl_context context;

       cl_command_queue queue;

       cl_program program;

       cl_kernel kernel;

       cl_mem buffer;



       clGetPlatformIDs(1, &platform, NULL);

       clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, NULL);

       context = clCreateContext(NULL, 1, &device, NULL, NULL, NULL);

       queue = clCreateCommandQueue(context, device, 0, NULL);



       buffer = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(int) * 10, NULL, NULL);

       clEnqueueWriteBuffer(queue, buffer, CL_TRUE, 0, sizeof(int) * 10, data, 0, NULL, NULL);



       program = clCreateProgramWithSource(context, 1, &kernelSource, NULL, NULL);

       clBuildProgram(program, 0, NULL, NULL, NULL, NULL);

       kernel = clCreateKernel(program, "vecAdd", NULL);



       clSetKernelArg(kernel, 0, sizeof(cl_mem), &buffer);

       size_t globalSize = 10;

       clEnqueueNDRangeKernel(queue, kernel, 1, NULL, &globalSize, NULL, 0, NULL, NULL);

       clEnqueueReadBuffer(queue, buffer, CL_TRUE, 0, sizeof(int) * 10, data, 0, NULL, NULL);



       for (int i = 0; i < 10; i++) printf("%d ", data[i]);

       printf("\n");



       clReleaseMemObject(buffer);

       clReleaseKernel(kernel);

       clReleaseProgram(program);

       clReleaseCommandQueue(queue);

       clReleaseContext(context);



       return 0;

   }

Compile o programa com:

   gcc -o vecAdd vecAdd.c -lOpenCL

Execute o programa com:

   ./vecAdd

3. Configurando o Ambiente CUDA no Linux:

Para usar CUDA, você precisa instalar o toolkit CUDA da NVIDIA. Siga as instruções no site oficial da NVIDIA para baixar e instalar o toolkit e os drivers necessários.

Após a instalação, você pode verificar a instalação do CUDA com:

   nvcc --version

4. Executando um Programa Simples em CUDA:

Aqui está um exemplo de um programa CUDA que multiplica cada elemento de um vetor por 2:

   #include <stdio.h>



   __global__ void vecAdd(int *a) {

       int id = blockIdx.x * blockDim.x + threadIdx.x;

       a[id] *= 2;

   }



   int main() {

       int data[10];

       for (int i = 0; i < 10; i++) data[i] = i;



       int *d_data;

       cudaMalloc(&d_data, sizeof(int) * 10);

       cudaMemcpy(d_data, data, sizeof(int) * 10, cudaMemcpyHostToDevice);



       vecAdd<<<1, 10>>>(d_data);



       cudaMemcpy(data, d_data, sizeof(int) * 10, cudaMemcpyDeviceToHost);

       cudaFree(d_data);



       for (int i = 0; i < 10; i++) printf("%d ", data[i]);

       printf("\n");



       return 0;

   }

Compile o programa com:

   nvcc -o vecAdd vecAdd.cu

Execute o programa com:

   ./vecAdd

Esses exemplos mostram como configurar e executar tarefas de computação heterogênea no Linux usando OpenCL e CUDA. Ambas as abordagens permitem que você aproveite o poder das GPUs para acelerar suas aplicações.