Tabla de contenido
Partiendo de la informática heterogénea
La computación heterogénea es un método que utiliza múltiples tipos diferentes de recursos informáticos para resolver problemas informáticos de forma colaborativa. Su idea central es combinar dispositivos informáticos con diferentes características y capacidades (como CPU, GPU, FPGA, etc.) para aprovechar al máximo sus ventajas en diferentes tipos de cargas de trabajo y tareas.
Los modelos informáticos tradicionales suelen depender de un único tipo de procesador, como una unidad central de procesamiento (CPU). Sin embargo, las CPU pueden ser menos eficientes al procesar algunas tareas paralelas con un uso intensivo de computación. Por el contrario, las unidades de procesamiento de gráficos (GPU) generalmente tienen un rendimiento excelente para la computación y el procesamiento de gráficos en paralelo. Los recursos informáticos modernos existen en muchas variedades, cada una con ventajas y características únicas. Al combinar estos recursos informáticos heterogéneos, se puede lograr una informática más eficiente y flexible.
En la informática heterogénea, las tareas se pueden clasificar en función de sus características y requisitos y asignarse a los recursos informáticos más adecuados para realizar la tarea. Por ejemplo, la CPU puede ejecutar algunas tareas en serie que requieren un flujo de control intensivo, mientras que la GPU puede ejecutar algunas tareas que requieren un procesamiento paralelo masivo. Al asignar y utilizar racionalmente los recursos informáticos, se puede lograr un mayor rendimiento y eficiencia informática.
La computación heterogénea también se puede utilizar para optimizar la eficiencia energética. Debido a las diferencias en el consumo de energía y el rendimiento entre los diferentes tipos de dispositivos informáticos, la carga informática se puede asignar a los dispositivos más eficientes energéticamente de acuerdo con los requisitos de la tarea para mejorar la eficiencia en la utilización de la energía.
En la práctica, la informática heterogénea requiere herramientas y modelos de programación adecuados para gestionar y programar diferentes tipos de recursos informáticos. Por ejemplo, OpenCL y CUDA son marcos de programación informática heterogéneos ampliamente utilizados que proporcionan API y herramientas ricas para implementar computación paralela en diferentes dispositivos y recursos informáticos.
En resumen, la computación heterogénea aprovecha las características y ventajas de diferentes tipos de recursos informáticos para lograr un mayor rendimiento informático, eficiencia energética y flexibilidad mediante la asignación razonable y el uso colaborativo de estos recursos. Se ha utilizado ampliamente en muchos campos, como la informática científica, el aprendizaje automático, la representación de gráficos, etc.
Instrucciones relacionadas con la instalación de Opencl
Al usar OpenCL, tienes dos opciones:
Utilice controladores y tiempos de ejecución de OpenCL predeterminados: muchos sistemas operativos tienen controladores y tiempos de ejecución de OpenCL predeterminados integrados, y puede usar directamente estos controladores y tiempos de ejecución predeterminados para compilar y ejecutar aplicaciones OpenCL. En este caso no necesitas un SDK adicional.
Instale el SDK de OpenCL proporcionado por un fabricante de hardware específico: si su sistema no proporciona el controlador y el tiempo de ejecución predeterminados de OpenCL, o si desea utilizar la última versión del tiempo de ejecución y el controlador proporcionados por un fabricante de hardware específico, puede instalar el SDK de OpenCL proporcionada por el fabricante correspondiente. Estos SDK suelen contener bibliotecas, archivos de encabezado, código de muestra y herramientas de depuración para que los utilicen los desarrolladores.
Independientemente del método que elija utilizar, puede utilizar las bibliotecas OpenCL y los archivos de encabezado correspondientes para escribir y compilar aplicaciones OpenCL. Cuando compila y vincula una aplicación OpenCL, el compilador busca el tiempo de ejecución y el controlador de OpenCL en el sistema y los conecta con la aplicación.
OpenCL es un estándar abierto multiplataforma que tiene como objetivo proporcionar un modelo de programación unificado para ejecutar tareas informáticas paralelas en una variedad de dispositivos informáticos diferentes, incluidos CPU, GPU, DSP, FPGA, etc.
OpenCL está diseñado para que los desarrolladores puedan escribir código una vez y ejecutarlo en diferentes plataformas que admitan OpenCL sin tener que escribir código específico para cada plataforma. Esta portabilidad convierte a OpenCL en el modelo de programación paralela preferido en muchos sistemas heterogéneos, supercomputadoras y sistemas integrados.
Si bien los SDK de OpenCL proporcionados por proveedores de hardware específicos pueden contener herramientas y optimizaciones adicionales, los estándares principales y las interfaces de funciones de OpenCL son multiplataforma y se pueden desarrollar y compilar sin un SDK específico. Por lo tanto, puede utilizar el mismo código OpenCL en diferentes plataformas, simplemente utilice el tiempo de ejecución y el controlador de OpenCL adecuados.
Cómo comprobar los modelos de CPU y GPU del sistema Linux
Ver CPU:
lscpu
Verifique la gpu:
primero instale los paquetes de software relevantes:
sudo apt-get install pciutils
Luego, enumere información detallada de la tarjeta gráfica:
lspci | grep -i vga
Instalar opencl
Compruebe si opencl está instalado:
clinfo
Si no:
sudo apt-get install intel-opencl-icd
Si falla, instálelo manualmente:
Según el modelo correspondiente de CPU Intel:
https://www.intel.com/content/www/us/en/developer/tools/opencl-sdk/choose-download.html?wapkw=Intel%C2%AE%20SDK%20for%20OpenCL%E2%84%A2%20Applications
Instalar dependencias:
sudo apt-get install cpio
Instalar:
sudo tar xvf /work/intel_sdk_for_opencl_applications_2020.3.494.tar.gz
sudo /work/intel_sdk_for_opencl_applications_2020.3.494/install.sh
La instalación se completa según las instrucciones.
Puede ver el efecto de instalación mediante el siguiente comando:
find / -name libOpenCL.so
programa helloword ejecutándose
Correspondiente a cmakelist:
cmake_minimum_required(VERSION 3.5)
project(fangdou)
FIND_PACKAGE(OpenMP REQUIRED)
if(OPENMP_FOUND)
message("OPENMP FOUND")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OpenMP_EXE_LINKER_FLAGS}")
endif()
include_directories(${
BW_SUB_LIB_ROOT_DIR}/include
/opt/intel/system_studio_2020/opencl/SDK/include
)
SET(OpenCV_DIR /usr/local/lib/cmake/opencv4/)
FIND_PACKAGE(OpenCV REQUIRED)
file(GLOB_RECURSE cpp_srcs ${
CMAKE_SOURCE_DIR}/src/*.cpp ${CMAKE_SOURCE_DIR}/src/*.cc ${CMAKE_SOURCE_DIR}/src/*.h)
link_directories(
/usr/myffmpg/lib/
/usr/lib/x86_64-linux-gnu/
)
add_executable(${PROJECT_NAME} ${cpp_srcs})
target_link_libraries(${PROJECT_NAME} PRIVATE ${OpenCV_LIBS} avcodec avformat avutil swscale avfilter OpenCL)
Archivo cpp correspondiente:
#include <stdio.h>
#include <stdlib.h>
#include <CL/cl.h>
#define MAX_PLATFORMS 10
#define MAX_DEVICES 10
int main() {
cl_platform_id platforms[MAX_PLATFORMS];
cl_device_id devices[MAX_DEVICES];
cl_uint num_platforms, num_devices;
cl_context context;
cl_command_queue command_queue;
cl_program program;
cl_kernel kernel;
cl_int ret;
// 获取平台数量
ret = clGetPlatformIDs(MAX_PLATFORMS, platforms, &num_platforms);
if (ret != CL_SUCCESS) {
printf("Failed to get platform IDs\n");
return -1;
}
printf("Number of platforms: %u\n", num_platforms);
// 遍历打印平台信息
for (cl_uint i = 0; i < num_platforms; i++) {
char platform_name[128];
char platform_vendor[128];
ret = clGetPlatformInfo(platforms[i], CL_PLATFORM_NAME, sizeof(platform_name), platform_name, NULL);
if (ret != CL_SUCCESS) {
printf("Failed to get platform name for platform %u\n", i);
}
ret = clGetPlatformInfo(platforms[i], CL_PLATFORM_VENDOR, sizeof(platform_vendor), platform_vendor, NULL);
if (ret != CL_SUCCESS) {
printf("Failed to get platform vendor for platform %u\n", i);
}
printf("Platform %u:\n", i);
printf(" Name: %s\n", platform_name);
printf(" Vendor: %s\n", platform_vendor);
printf("\n");
}
// 获取设备数量
ret = clGetDeviceIDs(platforms[0], CL_DEVICE_TYPE_CPU, MAX_DEVICES, devices, &num_devices);
if (ret != CL_SUCCESS) {
printf("Failed to get device IDs\n");
return -1;
}
// 创建OpenCL上下文
context = clCreateContext(NULL, num_devices, devices, NULL, NULL, &ret);
if (ret != CL_SUCCESS) {
printf("Failed to create context\n");
return -1;
}
// 创建命令队列
command_queue = clCreateCommandQueue(context, devices[0], 0, &ret);
if (ret != CL_SUCCESS) {
printf("Failed to create command queue\n");
return -1;
}
// 定义和构建OpenCL内核
const char *kernel_source = "__kernel void hello_world() {\n"
" printf(\"Hello, World!\\n\");\n"
"}\n";
program = clCreateProgramWithSource(context, 1, &kernel_source, NULL, &ret);
if (ret != CL_SUCCESS) {
printf("Failed to create program\n");
return -1;
}
ret = clBuildProgram(program, num_devices, devices, NULL, NULL, NULL);
if (ret != CL_SUCCESS) {
printf("Failed to build program\n");
return -1;
}
// 创建OpenCL内核对象
kernel = clCreateKernel(program, "hello_world", &ret);
if (ret != CL_SUCCESS) {
printf("Failed to create kernel\n");
return -1;
}
// 执行内核函数
ret = clEnqueueTask(command_queue, kernel, 0, NULL, NULL);
if (ret != CL_SUCCESS) {
printf("Failed to enqueue task\n");
return -1;
}
// 等待执行完成
ret = clFinish(command_queue);
if (ret != CL_SUCCESS) {
printf("Failed to finish execution\n");
return -1;
}
printf("Kernel executed successfully\n");
// 清理资源
ret = clReleaseKernel(kernel);
ret = clReleaseProgram(program);
ret = clReleaseCommandQueue(command_queue);
ret = clReleaseContext(context);
return 0;
}
El contenido impreso es el siguiente:
Number of platforms: 1
Platform 0:
Name: Intel(R) CPU Runtime for OpenCL(TM) Applications
Vendor: Intel(R) Corporation
Hello, World!
Kernel executed successfully