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.