एक कार्यक्रम में दो दिग्गज - एनवीडिया क्यूडा और एमपीआई

हैलो खब्रोविट्स, इस लेख में मैं दो MPI प्रौद्योगिकियों (mpich2) और NVIDIA CUDA की बातचीत के बारे में बात करना चाहता हूं। मैं जो जोर देना चाहता हूं वह कार्यक्रम की संरचना और एक कार्यक्रम में काम करने के लिए उपरोक्त तकनीकों के विन्यास पर है। और इसलिए चलो ...


सुविधा के लिए, मैंने एक छोटी योजना लिखी, जिस पर हम आगे बढ़ेंगे:
1) काम के लिए सिस्टम तैयार करना।
2) mpich2 लाइब्रेरी स्थापित करें।
3) NVIDIA CUDA स्थापित करना।
4) प्रोग्राम कोड लिखना (प्रोग्राम संरचना)
5) कंपाइलर को कॉन्फ़िगर करना।
6) निष्पादन योग्य फ़ाइल का संकलन और लॉन्च।

बिंदु 1

शायद यह किसी तरह इसे अलग तरह से कॉल करने के लायक था, लेकिन फिर भी। मैं Ubuntu 12.04 ऑपरेटिंग सिस्टम का उपयोग करता हूं, और सैद्धांतिक रूप से, एक बैच मैनेजर पूरे सेटअप के लिए पर्याप्त है - सिनेप्टिक
sudo apt-get install synaptic
या, यदि आप चाहें, तो आप टर्मिनल से सीधे सब कुछ डाल सकते हैं।

बिंदु 2

और तो चलिए शुरू करते हैं। MPI क्या है? मैं विकिपीडिया को थोड़ा पीछे हटाता हूं - यह एक तरह का एपीआई है जो आपको एक कार्य करने वाली प्रक्रियाओं के बीच डेटा का आदान-प्रदान करने की अनुमति देता है। सीधे शब्दों में कहें, यह कई समानांतर प्रोग्रामिंग प्रौद्योगिकियों में से एक है। आप विकिपीडिया पर अधिक पढ़ सकते हैं। हम MPICH2 का उपयोग करेंगे - एक पुस्तकालय जो MPI मानक को लागू करता है, क्योंकि यह पुस्तकालय सबसे आम है। इसे स्थापित करने के लिए, आपको टर्मिनल में पंजीकरण करना होगा:
sudo apt-get install mpi-default-dev
sudo apt-get install mpich2
sudo apt-get install libmpich2-dev

या Alt + f2:
gksu synaptic


और खोज रजिस्टर में:
mpi-default-dev
mpich2
libmpich2-dev



पाया गया पैकेज चुनें और इसे इंस्टॉल करें। इसके अलावा, यदि आप चाहें, तो आप अपने दृष्टिकोण से mpi या mpich2 से संबंधित अन्य उपयोगी पैकेज स्थापित कर सकते हैं। प्रलेखन स्थापित करना उचित है। अगला, जांचें कि हमारे पास क्या है, एक फ़ाइल test.cpp बनाएं और उसमें निम्न कोड जोड़ें:

 #include <mpi.h> #include <iostream> int main (int argc, char* argv[]) { int rank, size; MPI_Init (&argc, &argv); MPI_Comm_rank (MPI_COMM_WORLD, &rank); MPI_Comm_size (MPI_COMM_WORLD, &size); std::cout<<"\nHello Habrahabr!!"<<std::endl; MPI_Finalize(); return 0; } 

इसे संकलित करें:
mpic++ test.cpp -o test

चलाएँ:
mpirun.mpich2 -l -n 8 ./test


परिणाम कुछ इस तरह होना चाहिए:

बिंदु 3

मैंने अपनी अंतिम पोस्ट में इस प्रक्रिया का वर्णन किया है।

बिंदु 4

मान लीजिए कि हमारे पास एक हबल फ़ोल्डर है, तो उसमें निम्न फ़ाइलें बनाएँ:
main.cu
head.h // इसमें हेडर फाइलें होंगी।
GPU.cu // कोड GPU के लिए अभिप्रेत है।
CPU.cpp // कोड प्रोसेसर के लिए अभिप्रेत है।

main.cu - यहाँ हम सबसे सरल mpi कोड लिखते हैं जो कई कोर पर प्रोग्राम चलाने के लिए काम करेगा। Gpu और cpu फ़ंक्शंस में, सामान्य गुणन होता है, एकमात्र अंतर यह है कि gpu फ़ंक्शन में गुणन वीडियो कार्ड पर होता है।

 #include "head.h" int main(int argc, char* argv[]){ int rank, size; int x = 9999; int y = 9999; MPI_Init (&argc, &argv); MPI_Comm_rank (MPI_COMM_WORLD, &rank);//   MPI_Comm_size (MPI_COMM_WORLD, &size);//  int res_gpu = gpu(x, y); int res_cpu = cpu(x, y); std::cout<<"res_gpu = "<<res_gpu<<std::endl; std::cout<<"res_cpu = "<<res_cpu<<std::endl; MPI_Finalize(); return 0; } 

head.h - यहाँ हम आवश्यक निष्कर्षों का वर्णन करते हैं।

 #include <iostream> #include <mpi.h> #include <cuda.h> #include "CPU.cpp" #include "GPU.cu" 

GPU.cu - सीधे एक कोड जो एक वीडियो कार्ड पर दो संख्याओं को गुणा करता है।

 #include <cuda.h> #include <iostream> #include <stdio.h> __global__ void mult(int x, int y, int *res) { *res = x * y; } int gpu(int x, int y){ int *dev_res; int res = 0; cudaMalloc((void**)&dev_res, sizeof(int)); mult<<<1,1>>>(x, y, dev_res); cudaMemcpy(&res, dev_res, sizeof(int), cudaMemcpyDeviceToHost); cudaFree(dev_res); return res; } 

CPU.cpp - यह कोड, GPU पर क्या हो रहा है गुणन की जांच करने के लिए और, सिद्धांत रूप में, कोई और उपयोगिता नहीं ले जाता है।

 int cpu(int x, int y){ int res; res = x * y; return res; } 

बनाई गई फ़ाइलें ../src फ़ोल्डर में डाल दी जाती हैं। परिणाम कुछ इस तरह होना चाहिए:

बिंदु 5

यहाँ सबसे दिलचस्प बात यह है कि आपको न केवल CUDA कोड, बल्कि MPI कोड को संकलित करने के लिए nvcc कंपाइलर को कॉन्फ़िगर करने की आवश्यकता है, इसके लिए हम एक छोटी सी फाइल लिखते हैं:

 CXX = nvcc LD = $(CXX) LIBS_PATH = -L/usr/lib LIBS = -lmpi -lopa -lmpl -lrt -lcr -lpthread INCLUDE_PATH = -I/usr/lib/mpich2/include/ FLAGS = -g TARGET = "/home/relaps/habr/src/main.cu" OBIN = "/home/relaps/habr/bin/cuda&mpi" all: $(TARGET) $(TARGET): $(LD) $(INCLUDE_PATH) $(FLAGS) $(TARGET) -o $(OBIN) $(LIBS_PATH) $(LIBS) 

और इसलिए अब आपको केवल प्रोजेक्ट फ़ोल्डर में जाने और इसे इकट्ठा करने की आवश्यकता है।

बिंदु 6

यहां मुझे लगता है कि स्क्रीनशॉट में टिप्पणियां बहुत ही शानदार हैं, सब कुछ दिखाई दे रहा है।
हम एकत्रित करते हैं:


हम शुरू करते हैं, यह कुछ इस तरह से निकलता है:


खैर, वास्तव में इस पर काम किया जाता है, अंत में हमें एक कार्यक्रम मिला जिसमें वीडियो कार्ड और कई प्रोसेसर कोर दोनों शामिल हैं। बेशक, इस संदर्भ में प्रस्तुत दो संख्याओं के गुणन के साथ उदाहरण इन तकनीकों के लिए पूरी तरह से प्रासंगिक नहीं है, लेकिन मैं दोहराता हूं - मैंने खुद को यह दिखाने का कार्य निर्धारित किया है कि एमपीआई और क्यूडा एक ही कार्यक्रम में सह-अस्तित्व में हो सकते हैं (मुझे लगता है कि कोड प्रारंभिक है क्यूडा और एमपीआई को छोड़कर। , इसलिए, विशेष रूप से इसे स्पष्ट नहीं किया)। स्वाभाविक रूप से, यदि आप अधिक जटिल कार्यक्रम लेते हैं, तो एक साथ कई बारीकियां हैं, क्लस्टर की संरचना से शुरू होने, आदि, आप यहां लंबे समय तक जारी रख सकते हैं, ऐसे प्रत्येक कार्यक्रम के लिए व्यक्तिगत विचार की आवश्यकता होती है। लेकिन अंत में, यह इसके लायक है।

ps अगली पोस्ट में, सबसे अधिक संभावना है, मैं एनवीडिया क्यूडा की मूल बातें के बारे में बात करने की कोशिश करूंगा।