இந்த வழிகாட்டியில், சி ++ உடன் GPU நிரலாக்கத்தின் சக்தியை ஆராய்வோம். டெவலப்பர்கள் C ++ உடன் நம்பமுடியாத செயல்திறனை எதிர்பார்க்கலாம், மேலும் குறைந்த அளவிலான மொழியுடன் GPU இன் தனித்துவமான சக்தியை அணுகுவது தற்போது கிடைக்கும் வேகமான கணக்கீட்டை அளிக்கும்.
தேவைகள்
லினக்ஸின் நவீன பதிப்பை இயக்கும் எந்த எந்திரமும் சி ++ கம்பைலரை ஆதரிக்க முடியும் என்றாலும், இந்த பயிற்சியைத் தொடர உங்களுக்கு என்விடியா அடிப்படையிலான ஜிபியு தேவை. உங்களிடம் ஜிபியூ இல்லையென்றால், அமேசான் வலை சேவைகள் அல்லது உங்களுக்கு விருப்பமான மற்றொரு கிளவுட் வழங்குநரில் ஜிபியூ-இயங்கும் நிகழ்வை நீங்கள் சுழற்றலாம்.
நீங்கள் ஒரு இயற்பியல் இயந்திரத்தைத் தேர்வுசெய்தால், என்விடியா தனியுரிம இயக்கிகள் நிறுவப்பட்டுள்ளதா என்பதை உறுதிப்படுத்தவும். இதற்கான வழிமுறைகளை இங்கே காணலாம்: https://linuxhint.com/install-nvidia-drivers-linux/
இயக்கிக்கு கூடுதலாக, உங்களுக்கு CUDA கருவித்தொகுப்பு தேவைப்படும். இந்த எடுத்துக்காட்டில், நாங்கள் உபுண்டு 16.04 LTS ஐப் பயன்படுத்துவோம், ஆனால் பின்வரும் URL இல் பெரும்பாலான முக்கிய விநியோகங்களுக்கு பதிவிறக்கங்கள் உள்ளன: https://developer.nvidia.com/cuda-downloads
உபுண்டுவிற்கு, நீங்கள் .deb அடிப்படையிலான பதிவிறக்கத்தை தேர்வு செய்வீர்கள். பதிவிறக்கம் செய்யப்பட்ட கோப்பில் இயல்பாக .deb நீட்டிப்பு இருக்காது, எனவே இறுதியில் .deb என மறுபெயரிட பரிந்துரைக்கிறேன். பின்னர், நீங்கள் இதை நிறுவலாம்:
சூடோ dpkg -நான்தொகுப்பு- name.deb
நீங்கள் ஒரு GPG விசையை நிறுவும்படி கேட்கப்படுவீர்கள், அப்படியானால், அவ்வாறு செய்ய வழங்கப்பட்ட வழிமுறைகளைப் பின்பற்றவும்.
நீங்கள் அதைச் செய்தவுடன், உங்கள் களஞ்சியங்களைப் புதுப்பிக்கவும்:
சூடோ apt-get update
சூடோ apt-get installஅற்புதங்கள்மற்றும் மற்றும்
முடிந்ததும், எல்லாம் சரியாக ஏற்றப்பட்டிருப்பதை உறுதி செய்ய மறுதொடக்கம் செய்ய பரிந்துரைக்கிறேன்.
GPU வளர்ச்சியின் நன்மைகள்
CPU கள் பல்வேறு உள்ளீடுகள் மற்றும் வெளியீடுகளைக் கையாளுகின்றன மற்றும் நிரல் தேவைகளின் பரந்த வகைப்பாட்டைக் கையாள்வதற்கு மட்டுமல்லாமல் பல்வேறு வன்பொருள் கட்டமைப்புகளை நிர்வகிப்பதற்கும் ஒரு பெரிய வகை செயல்பாடுகளைக் கொண்டிருக்கின்றன. அவர்கள் நினைவகம், கேச்சிங், சிஸ்டம் பஸ், செக்மென்டிங் மற்றும் ஐஓ செயல்பாட்டையும் கையாளுகிறார்கள், அவை அனைத்து வர்த்தகங்களிலும் ஒரு பலாவாக மாறும்.
GPU கள் இதற்கு நேர்மாறானவை - அவற்றில் பல தனிப்பட்ட செயலிகள் உள்ளன, அவை மிகவும் எளிமையான கணித செயல்பாடுகளில் கவனம் செலுத்துகின்றன. இதன் காரணமாக, அவர்கள் CPU களை விட பல மடங்கு வேகமாக பணிகளைச் செய்கிறார்கள். அளவிடுதல் செயல்பாடுகளில் நிபுணத்துவம் பெறுவதன் மூலம் (ஒன்று அல்லது அதற்கு மேற்பட்ட உள்ளீடுகளை எடுக்கும் ஒரு செயல்பாடு ஆனால் ஒரு வெளியீட்டை மட்டுமே அளிக்கிறது), அவை தீவிர நிபுணத்துவத்தின் விலையில் தீவிர செயல்திறனை அடைகின்றன.
எடுத்துக்காட்டு குறியீடு
எடுத்துக்காட்டு குறியீட்டில், நாங்கள் திசையன்களை ஒன்றாக சேர்க்கிறோம். வேகத்தை ஒப்பிடுவதற்காக நான் குறியீட்டின் CPU மற்றும் GPU பதிப்பைச் சேர்த்துள்ளேன்.
gpu-example.cpp கீழே உள்ளவை:
#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
தட்டச்சுமணி::காலவரிசை::உயர்_தீர்வு_ கடிகாரம்கடிகாரம்;
#ITER 65535 ஐ வரையறுக்கவும்
// திசையன் சேர்க்கும் செயல்பாட்டின் CPU பதிப்பு
வெற்றிடம்திசையன்_அடி_சிபியு(int *க்கு,int *b,int *c,intஎன்) {
intநான்;
// திசையன் உறுப்புகள் a மற்றும் b ஆகியவற்றை திசையன் c இல் சேர்க்கவும்
க்கான (நான்= 0;நான்<என்; ++நான்) {
c[நான்] =க்கு[நான்] +b[நான்];
}
}
// திசையன் சேர்க்கும் செயல்பாட்டின் GPU பதிப்பு
__ குளோபல்__வெற்றிடம்திசையன்_ஆட்_ஜிபி(int *gpu_a,int *gpu_b,int *gpu_c,intஎன்) {
intநான்=threadIdx.எக்ஸ்;
// CUDA இயக்க நேரம் என்பதால் லூப் தேவை இல்லை
// இதை ITER முறை திரிடுவேன்
gpu_c[நான்] =gpu_a[நான்] +gpu_b[நான்];
}
intமுக்கிய() {
int *க்கு,*b,*c;
int *gpu_a,*gpu_b,*gpu_c;
க்கு= (int *)மல்லோக்(ITER* அளவு(int));
b= (int *)மல்லோக்(ITER* அளவு(int));
c= (int *)மல்லோக்(ITER* அளவு(int));
// GPU க்கு அணுகக்கூடிய மாறிகள் தேவை,
// எனவே cudaMallocManaged இவற்றை வழங்குகிறது
cudaMallocManaged(&gpu_a, ITER* அளவு(int));
cudaMallocManaged(&gpu_b, ITER* அளவு(int));
cudaMallocManaged(&gpu_c, ITER* அளவு(int));
க்கான (intநான்= 0;நான்<ITER; ++நான்) {
க்கு[நான்] =நான்;
b[நான்] =நான்;
c[நான்] =நான்;
}
// CPU செயல்பாட்டை அழைக்கவும் மற்றும் நேரம் செய்யவும்
ஆட்டோcpu_start=கடிகாரம்::இப்போது();
திசையன்_அடி_சிபியு(a, b, c, ITER);
ஆட்டோcpu_end=கடிகாரம்::இப்போது();
மணி::செலவு << 'vector_add_cpu:'
<<மணி::காலவரிசை::காலம்_காஸ்ட்<மணி::காலவரிசை::நானோ வினாடிகள்>(cpu_end-cpu_start).எண்ண()
<< நானோ வினாடிகள். n';
// GPU செயல்பாட்டை அழைக்கவும் மற்றும் நேரம் செய்யவும்
// டிரிபிள் ஆங்கிள் ப்ராக்கெட்ஸ் என்பது CUDA இயக்க நேர நீட்டிப்பு ஆகும்
// CUDA கர்னல் அழைப்பின் அளவுருக்கள் அனுப்பப்பட வேண்டும்.
// இந்த எடுத்துக்காட்டில், ITER இழைகளுடன் ஒரு நூல் தொகுதியை நாங்கள் கடந்து செல்கிறோம்.
ஆட்டோgpu_start=கடிகாரம்::இப்போது();
திசையன்_ஆட்_ஜிபி<<<1, ITER>>> (gpu_a, gpu_b, gpu_c, ITER);
cudaDeviceSynchronize();
ஆட்டோgpu_end=கடிகாரம்::இப்போது();
மணி::செலவு << 'திசையன்_ஆட்_ஜிபி:'
<<மணி::காலவரிசை::காலம்_காஸ்ட்<மணி::காலவரிசை::நானோ வினாடிகள்>(gpu_end-gpu_start).எண்ண()
<< நானோ வினாடிகள். n';
// GPU- செயல்பாட்டு அடிப்படையிலான நினைவக ஒதுக்கீடுகளை இலவசமாக்குங்கள்
cudaFree(க்கு);
cudaFree(b);
cudaFree(c);
// CPU- செயல்பாடு அடிப்படையிலான நினைவக ஒதுக்கீடுகளை இலவசமாக்குங்கள்
இலவசம்(க்கு);
இலவசம்(b);
இலவசம்(c);
திரும்ப 0;
}
Makefile கீழே உள்ளவை:
INC= -நான்/usr/உள்ளூர்/அற்புதங்கள்/சேர்க்கிறதுஎன்விசிசி=/usr/உள்ளூர்/அற்புதங்கள்/நான்/என்விசிசி
NVCC_OPT= -std = c ++பதினொன்று
அனைத்து:
$(என்விசிசி)$(NVCC_OPT)gpu-example.cpp-அல்லதுgpu- உதாரணம்
சுத்தமான:
-ஆர்எம் -fgpu- உதாரணம்
உதாரணத்தை இயக்க, அதை தொகுக்கவும்:
செய்யபின்னர் நிரலை இயக்கவும்:
./gpu- உதாரணம்நீங்கள் பார்க்க முடியும் என, CPU பதிப்பு (vector_add_cpu) GPU பதிப்பை (vector_add_gpu) விட கணிசமாக மெதுவாக இயங்குகிறது.
இல்லையென்றால், gpu-example.cu இல் உள்ள ITER வரையறையை அதிக எண்ணிக்கையில் சரிசெய்ய வேண்டியிருக்கலாம். சில சிறிய CPU- தீவிர சுழல்களை விட GPU அமைவு நேரம் நீண்டதாக இருப்பதே இதற்குக் காரணம். எனது இயந்திரத்தில் 65535 நன்றாக வேலை செய்வதை நான் கண்டேன், ஆனால் உங்கள் மைலேஜ் மாறுபடலாம். இருப்பினும், இந்த வரம்பை நீங்கள் அழித்தவுடன், ஜிபியு சிபியுவை விட வியத்தகு வேகத்தில் இருக்கும்.
முடிவுரை
C ++ உடன் GPU நிரலாக்கத்தில் எங்கள் அறிமுகத்திலிருந்து நீங்கள் நிறைய கற்றுக்கொண்டீர்கள் என்று நம்புகிறேன். மேலே உள்ள உதாரணம் பெரிதாக சாதிக்கவில்லை, ஆனால் உங்கள் GPU இன் சக்தியை கட்டவிழ்த்துவிட உங்கள் யோசனைகளை இணைக்க நீங்கள் பயன்படுத்தக்கூடிய ஒரு கட்டமைப்பை நிரூபிக்கப்பட்ட கருத்துக்கள் வழங்குகின்றன.