Table des matières
Partir d’une informatique hétérogène
L'informatique hétérogène est une méthode qui utilise plusieurs types différents de ressources informatiques pour résoudre de manière collaborative des problèmes informatiques. Son idée principale est de combiner des appareils informatiques présentant des caractéristiques et des capacités différentes (telles que CPU, GPU, FPGA, etc.) pour exploiter pleinement leurs avantages dans différents types de charges de travail et de tâches.
Les modèles informatiques traditionnels reposent souvent sur un seul type de processeur, tel qu'une unité centrale de traitement (CPU). Cependant, les processeurs peuvent être moins efficaces lors du traitement de certaines tâches parallèles très gourmandes en calcul. En revanche, les unités de traitement graphique (GPU) offrent généralement d'excellentes performances pour le calcul parallèle et le traitement graphique. Les ressources informatiques modernes se déclinent en de nombreuses variétés, chacune présentant des avantages et des caractéristiques uniques. En combinant ces ressources informatiques hétérogènes, une informatique plus efficace et plus flexible peut être obtenue.
En informatique hétérogène, les tâches peuvent être classées en fonction de leurs caractéristiques et exigences et attribuées aux ressources informatiques les mieux adaptées pour exécuter la tâche. Par exemple, certaines tâches série nécessitant beaucoup de flux de contrôle peuvent être exécutées par le processeur, tandis que certaines tâches nécessitant un traitement parallèle massif peuvent être exécutées par le GPU. En allouant et en utilisant rationnellement les ressources informatiques, des performances et une efficacité informatiques plus élevées peuvent être obtenues.
L’informatique hétérogène peut également être utilisée pour optimiser l’efficacité énergétique. En raison des différences de consommation d'énergie et de performances entre les différents types d'appareils informatiques, la charge de calcul peut être allouée aux appareils les plus économes en énergie en fonction des exigences de la tâche visant à améliorer l'efficacité de l'utilisation de l'énergie.
En pratique, l’informatique hétérogène nécessite des modèles et des outils de programmation appropriés pour gérer et planifier différents types de ressources informatiques. Par exemple, OpenCL et CUDA sont des cadres de programmation informatique hétérogènes largement utilisés, qui fournissent des API et des outils riches pour mettre en œuvre le calcul parallèle sur différents appareils et ressources informatiques.
En résumé, l'informatique hétérogène tire parti des caractéristiques et des avantages de différents types de ressources informatiques pour obtenir des performances informatiques, une efficacité énergétique et une flexibilité supérieures grâce à une allocation raisonnable et une utilisation collaborative de ces ressources. Il a été largement utilisé dans de nombreux domaines, tels que le calcul scientifique, l’apprentissage automatique, le rendu graphique, etc.
Instructions relatives à l'installation d'Opencl
Lorsque vous utilisez OpenCL, vous avez deux options :
Utiliser les environnements d'exécution et les pilotes OpenCL par défaut : de nombreux systèmes d'exploitation ont des environnements d'exécution et des pilotes OpenCL par défaut intégrés, et vous pouvez directement utiliser ces environnements d'exécution et pilotes par défaut pour compiler et exécuter des applications OpenCL. Dans ce cas, vous n'avez pas besoin d'un SDK supplémentaire.
Installez le SDK OpenCL fourni par un fabricant de matériel spécifique : Si votre système ne fournit pas le runtime et le pilote OpenCL par défaut, ou si vous souhaitez utiliser la dernière version du runtime et du pilote fournis par un fabricant de matériel spécifique, vous pouvez installer le SDK OpenCL. fourni par le fabricant correspondant. . Ces SDK contiennent généralement des bibliothèques, des fichiers d'en-tête, des exemples de code et des outils de débogage que les développeurs peuvent utiliser.
Quelle que soit la méthode que vous choisissez d'utiliser, vous pouvez utiliser les bibliothèques OpenCL et les fichiers d'en-tête correspondants pour écrire et compiler des applications OpenCL. Lorsque vous compilez et liez une application OpenCL, le compilateur recherche le runtime et le pilote OpenCL dans le système et les connecte à l'application.
OpenCL est une norme multiplateforme ouverte qui vise à fournir un modèle de programmation unifié pour exécuter des tâches informatiques parallèles sur une variété de dispositifs informatiques différents, notamment des CPU, des GPU, des DSP, des FPGA, etc.
OpenCL est conçu pour que les développeurs puissent écrire du code une seule fois et l'exécuter sur différentes plates-formes prenant en charge OpenCL sans avoir à écrire de code spécifique pour chaque plate-forme. Cette portabilité fait d'OpenCL le modèle de programmation parallèle préféré dans de nombreux systèmes hétérogènes, supercalculateurs et systèmes embarqués.
Bien que les SDK OpenCL fournis par des fournisseurs de matériel spécifiques puissent contenir des outils et des optimisations supplémentaires, les normes de base et les interfaces de fonctions d'OpenCL sont multiplateformes et peuvent être développées et compilées sans SDK spécifique. Par conséquent, vous pouvez utiliser le même code OpenCL sur différentes plates-formes, utilisez simplement le runtime et le pilote OpenCL appropriés.
Comment vérifier les modèles CPU et GPU du système Linux
Afficher le processeur :
lscpu
Vérifiez le GPU :
installez d'abord les packages logiciels appropriés :
sudo apt-get install pciutils
Ensuite, répertoriez les informations détaillées sur la carte graphique :
lspci | grep -i vga
Installer opencl
Vérifiez si opencl est installé :
clinfo
Sinon:
sudo apt-get install intel-opencl-icd
En cas d'échec, installez-le manuellement :
selon le modèle de processeur Intel concerné :
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
Installer les dépendances :
sudo apt-get install cpio
Installer:
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
L'installation est terminée conformément aux instructions.
Vous pouvez voir l'effet de l'installation via la commande suivante :
find / -name libOpenCL.so
programme helloword en cours d'exécution
Correspondant à 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)
Fichier cpp correspondant :
#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;
}
Le contenu imprimé est le suivant :
Number of platforms: 1
Platform 0:
Name: Intel(R) CPU Runtime for OpenCL(TM) Applications
Vendor: Intel(R) Corporation
Hello, World!
Kernel executed successfully