CUDA और रिमोट GPU

CUDA सभी के लिए अच्छा है, जब तक कि Nvidia से हाथ में एक वीडियो कार्ड है। लेकिन क्या करें जब आपके पसंदीदा लैपटॉप पर कोई एनवीडिया ग्राफिक्स कार्ड न हो? या क्या आपको वर्चुअल मशीन में विकास का संचालन करने की आवश्यकता है?

मैं इस लेख में rCUDA (रिमोट CUDA) ढांचे के रूप में इस तरह के समाधान पर विचार करने की कोशिश करूंगा, जो एनवीडिया वीडियो कार्ड होने पर मदद करेगा, लेकिन यह उस मशीन में स्थापित नहीं है जिस पर CUDA अनुप्रयोगों को लॉन्च किया जाना चाहिए। जो लोग रुचि रखते हैं, उनके लिए बिल्ली का स्वागत है।

RCUDA क्या है

rCUDA (रिमोट CUDA) एक ऐसा ढांचा है जो CUDA API को कार्यान्वित करता है, जिससे आप CUDA कंप्यूटिंग के लिए रिमोट मशीन पर स्थित वीडियो कार्ड का उपयोग अपने कोड में कोई बदलाव किए बिना कर सकते हैं। वालेंसिया के पॉलिटेक्निक विश्वविद्यालय ( आरसीयूडीए-टीम ) में विकसित ।

प्रतिबंध

वर्तमान में केवल GNU / Linux सिस्टम का समर्थन किया जाता है, हालांकि, डेवलपर्स भविष्य में विंडोज समर्थन का वादा करते हैं। RCUDA, 18.03beta का वर्तमान संस्करण, CUDA 5-8 के साथ संगत है, अर्थात CUDA 9 समर्थित नहीं है। डेवलपर्स ने CUDA एपीआई के साथ ग्राफिक्स के अपवाद के साथ पूर्ण संगतता घोषित की।

संभावित उपयोग के मामले

1. वर्चुअल मशीन में CUDA एप्लिकेशन चलाना जब वीडियो कार्ड को अग्रेषित करना असुविधाजनक या असंभव है, उदाहरण के लिए, जब वीडियो कार्ड किसी होस्ट द्वारा कब्जा कर लिया जाता है, या जब एक से अधिक वर्चुअल मशीन होती हैं।
2. असतत ग्राफिक्स कार्ड के बिना लैपटॉप।
3. कई वीडियो कार्ड (क्लस्टरिंग) का उपयोग करने की इच्छा। सैद्धांतिक रूप से, आप टीम में उपलब्ध सभी वीडियो कार्ड का उपयोग कर सकते हैं, जिसमें संयुक्त रूप से शामिल हैं।

संक्षिप्त निर्देश

परीक्षण कॉन्फ़िगरेशन

परीक्षण निम्नलिखित विन्यास पर किया गया था:

सर्वर:
Ubuntu 16.04, GeForce GTX 660

ग्राहक:
असतत ग्राफिक्स कार्ड के बिना लैपटॉप पर उबंटू 16.04 के साथ एक वर्चुअल मशीन।

RCUDA हो रही है

सबसे कठिन अवस्था। दुर्भाग्य से, इस समय, इस ढांचे की अपनी प्रतिलिपि प्राप्त करने का एकमात्र तरीका आधिकारिक वेबसाइट पर उपयुक्त अनुरोध फ़ॉर्म भरना है । हालांकि, डेवलपर्स 1-2 दिनों के भीतर जवाब देने का वादा करते हैं। मेरे मामले में, उन्होंने मुझे उसी दिन एक वितरण भेजा।

CUDA स्थापित करें

पहले आपको सर्वर और क्लाइंट पर CUDA टूलकिट स्थापित करने की आवश्यकता है (भले ही ग्राहक के पास एनवीडिया वीडियो कार्ड न हो)। ऐसा करने के लिए, आप इसे आधिकारिक साइट से डाउनलोड कर सकते हैं या रिपॉजिटरी का उपयोग कर सकते हैं। मुख्य बात यह है कि संस्करण 8 से अधिक का उपयोग न करें। इस उदाहरण में, आधिकारिक साइट से .run इंस्टॉलर का उपयोग किया जाता है ।

chmod +x cuda_8.0.61_375.26_linux.run ./cuda_8.0.61_375.26_linux.run 

महत्वपूर्ण! क्लाइंट पर, आपको एनवीडिया ड्राइवर को स्थापित करने से इनकार करना चाहिए। डिफ़ॉल्ट रूप से, CUDA टूलकिट / usr / स्थानीय / कोडा / पर उपलब्ध होगी। CUDA नमूने स्थापित करें, आपको उनकी आवश्यकता होगी।

RCUDA स्थापित करें

हम डेवलपर्स से प्राप्त संग्रह को हमारे होम डायरेक्टरी में सर्वर और क्लाइंट पर अनपैक करेंगे।

 tar -xvf rCUDA*.tgz -C ~/ mv ~/rCUDA* ~/rCUDA 

आपको सर्वर और क्लाइंट दोनों पर ये क्रिया करने की आवश्यकता है।

सर्वर पर rCUDA डेमन शुरू करना

 export PATH=$PATH/usr/local/cuda/bin export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib64:/home/<XXX>/rCUDA/lib/cudnn cd ~/rCUDA/bin ./rCUDAd 

अपने उपयोगकर्ता नाम के साथ <XXX> बदलें। यदि आप वर्बोज़ आउटपुट देखना चाहते हैं तो/rCUDAd -iv का उपयोग करें।

क्लाइंट सेटअप

ग्राहक पर टर्मिनल खोलें, जिसमें हम भविष्य में CUDA कोड चलाएंगे। क्लाइंट पक्ष पर, हमें मानक क्यूडा पुस्तकालयों को आरसीयूडीए पुस्तकालयों के साथ "प्रतिस्थापित" करने की आवश्यकता है, जिसके लिए हम पर्यावरण चर LD_LIBRARY_PATH में उपयुक्त पथ जोड़ते हैं। हमें सर्वर की संख्या और उनके पते भी निर्दिष्ट करने की आवश्यकता है (मेरे उदाहरण में, यह एक होगा)।

 export PATH=$PATH/usr/local/cuda/bin export LD_LIBRARY_PATH=/home/<XXX>/rCUDA/lib/:$LD_LIBRARY_PATH export RCUDA_DEVICE_COUNT=1 #    (),     export RCUDA_DEVICE_0=<IP  >:0 #     

असेंबली और लॉन्च

आइए कुछ उदाहरणों को बनाने और चलाने का प्रयास करें।

उदाहरण 1

आइए एक सरल डिवाइस के उदाहरण के साथ शुरू करें जो बस एक संगत डिवाइस के लिए CUDA सेटिंग्स को प्रदर्शित करता है, जो कि हमारे मामले में रिमोट GTX660 है।

 cd <YYY>/NVIDIA_CUDA-8.0_Samples/1_Utilities/deviceQuery make EXTRA_NVCCFLAGS=--cudart=shared 

महत्वपूर्ण! बिना EXTRA_NVCCFLAGS = - cudart = साझा किए चमत्कार नहीं चलेगा
CUDA स्थापित करते समय CUDA नमूने के लिए निर्दिष्ट पथ के साथ <YYY> बदलें।

इकट्ठे उदाहरण चलाएं:

 ./deviceQuery 

यदि आपने सब कुछ सही ढंग से किया, तो परिणाम कुछ इस तरह होगा:

 ./deviceQuery Starting... CUDA Device Query (Runtime API) version (CUDART static linking) Detected 1 CUDA Capable device(s) Device 0: "GeForce GTX 660" CUDA Driver Version / Runtime Version 9.0 / 8.0 CUDA Capability Major/Minor version number: 3.0 Total amount of global memory: 1994 MBytes (2090991616 bytes) ( 5) Multiprocessors, (192) CUDA Cores/MP: 960 CUDA Cores GPU Max Clock rate: 1072 MHz (1.07 GHz) Memory Clock rate: 3004 Mhz Memory Bus Width: 192-bit L2 Cache Size: 393216 bytes Maximum Texture Dimension Size (x,y,z) 1D=(65536), 2D=(65536, 65536), 3D=(4096, 4096, 4096) Maximum Layered 1D Texture Size, (num) layers 1D=(16384), 2048 layers Maximum Layered 2D Texture Size, (num) layers 2D=(16384, 16384), 2048 layers Total amount of constant memory: 65536 bytes Total amount of shared memory per block: 49152 bytes Total number of registers available per block: 65536 Warp size: 32 Maximum number of threads per multiprocessor: 2048 Maximum number of threads per block: 1024 Max dimension size of a thread block (x,y,z): (1024, 1024, 64) Max dimension size of a grid size (x,y,z): (2147483647, 65535, 65535) Maximum memory pitch: 2147483647 bytes Texture alignment: 512 bytes Concurrent copy and kernel execution: Yes with 1 copy engine(s) Run time limit on kernels: Yes Integrated GPU sharing Host Memory: No Support host page-locked memory mapping: Yes Alignment requirement for Surfaces: Yes Device has ECC support: Disabled Device supports Unified Addressing (UVA): Yes Device PCI Domain ID / Bus ID / location ID: 0 / 1 / 0 Compute Mode: < Default (multiple host threads can use ::cudaSetDevice() with device simultaneously) > deviceQuery, CUDA Driver = CUDART, CUDA Driver Version = 9.0, CUDA Runtime Version = 8.0, NumDevs = 1, Device0 = GeForce GTX 660 Result = PASS 

सबसे महत्वपूर्ण बात जो हमें देखनी चाहिए:

Device0 = GeForce GTX 660
परिणाम = पास

बहुत बढ़िया! हम एक असतत ग्राफिक्स कार्ड के बिना एक मशीन पर CUDA एप्लिकेशन को बनाने और चलाने में कामयाब रहे, इस उद्देश्य के लिए रिमोट सर्वर पर एक वीडियो कार्ड स्थापित किया गया।

महत्वपूर्ण! यदि एप्लिकेशन आउटपुट फॉर्म की लाइनों से शुरू होता है:

 mlock error: Cannot allocate memory rCUDA warning: 1007.461 mlock error: Cannot allocate memory 

इसका अर्थ है कि सर्वर और क्लाइंट पर "/etc/security/limits.conf" फ़ाइल में निम्न पंक्तियों को जोड़ना आवश्यक है:

 * hard memlock unlimited * soft memlock unlimited 

इस प्रकार, आप सभी उपयोगकर्ताओं को (*) असीमित (असीमित) अवरुद्ध मेमोरी (मेमॉक) की अनुमति देंगे। वांछित उपयोगकर्ता के साथ * प्रतिस्थापित करना बेहतर होगा, और असीमित के बजाय कम वसा वाले अधिकारों का चयन करें।

उदाहरण 2

चलिए अब कुछ और दिलचस्प कोशिश करते हैं। हम साझा मेमोरी और सिंक्रनाइजेशन ("उदाहरणों में CUDA टेक्नोलॉजी" सैंडर्स जे। केंड्रोट ई। 5.3.1) का उपयोग करके वैक्टर के स्केलर उत्पाद के कार्यान्वयन का परीक्षण करेंगे।

इस उदाहरण में, हम सीपीयू पर प्राप्त परिणाम के साथ जवाब की तुलना करते हुए, आयाम 33 * 1024 के दो वैक्टर के स्केलर उत्पाद की गणना करते हैं।

 #include <stdio.h> #define imin(a,b) (a<b?a:b) const int N = 33 * 1024; const int threadsPerBlock = 256; const int blocksPerGrid = imin(32, (N+threadsPerBlock-1) / threadsPerBlock); __global__ void dot(float* a, float* b, float* c) { __shared__ float cache[threadsPerBlock]; int tid = threadIdx.x + blockIdx.x * blockDim.x; int cacheIndex = threadIdx.x; float temp = 0; while (tid < N){ temp += a[tid] * b[tid]; tid += blockDim.x * gridDim.x; } // set the cache values cache[cacheIndex] = temp; // synchronize threads in this block __syncthreads(); // for reductions, threadsPerBlock must be a power of 2 // because of the following code int i = blockDim.x/2; while (i != 0){ if (cacheIndex < i) cache[cacheIndex] += cache[cacheIndex + i]; __syncthreads(); i /= 2; } if (cacheIndex == 0) c[blockIdx.x] = cache[0]; } int main (void) { float *a, *b, c, *partial_c; float *dev_a, *dev_b, *dev_partial_c; // allocate memory on the cpu side a = (float*)malloc(N*sizeof(float)); b = (float*)malloc(N*sizeof(float)); partial_c = (float*)malloc(blocksPerGrid*sizeof(float)); // allocate the memory on the gpu cudaMalloc((void**)&dev_a, N*sizeof(float)); cudaMalloc((void**)&dev_b, N*sizeof(float)); cudaMalloc((void**)&dev_partial_c, blocksPerGrid*sizeof(float)); // fill in the host memory with data for(int i=0; i<N; i++) { a[i] = i; b[i] = i*2; } // copy the arrays 'a' and 'b' to the gpu cudaMemcpy(dev_a, a, N*sizeof(float), cudaMemcpyHostToDevice); cudaMemcpy(dev_b, b, N*sizeof(float), cudaMemcpyHostToDevice); dot<<<blocksPerGrid, threadsPerBlock>>>(dev_a, dev_b, dev_partial_c); // copy the array 'c' back from the gpu to the cpu cudaMemcpy(partial_c,dev_partial_c, blocksPerGrid*sizeof(float), cudaMemcpyDeviceToHost); // finish up on the cpu side c = 0; for(int i=0; i<blocksPerGrid; i++) { c += partial_c[i]; } #define sum_squares(x) (x*(x+1)*(2*x+1)/6) printf("GPU - %.6g \nCPU - %.6g\n", c, 2*sum_squares((float)(N-1))); // free memory on the gpu side cudaFree(dev_a); cudaFree(dev_b); cudaFree(dev_partial_c); // free memory on the cpu side free(a); free(b); free(partial_c); } 

बनाएँ और चलाएँ:

 /usr/local/cuda/bin/nvcc --cudart=shared dotProd.cu -o dotProd ./dotProd 

यह परिणाम बताता है कि हमारे साथ सब कुछ ठीक है:

GPU - 2.57236e + 13
CPU - 2.57236e + 13

उदाहरण 3

एक और मानक CUDA- मैट्रिक्समूलक्लास परीक्षण (मैट्रिक्स गुणन) चलाएँ।

 cd < YYY>/NVIDIA_CUDA-8.0_Samples/0_Simple/matrixMulCUBLAS make EXTRA_NVCCFLAGS=--cudart=shared ./matrixMulCUBLAS 

हमारे लिए दिलचस्प:

प्रदर्शन = 436.24 GFlop / s,
CPU परिणामों के साथ CUBLAS मैट्रिक्स की तुलना करें: पास

सुरक्षा

मुझे rCUDA के लिए प्रलेखन में किसी भी प्राधिकरण पद्धति का उल्लेख नहीं मिला। मुझे लगता है कि इस समय जो सबसे सरल काम किया जा सकता है वह एक विशिष्ट पते से वांछित बंदरगाह (8308) तक पहुंच खोलना है।

Iptables का उपयोग करना, यह इस तरह दिखेगा:

 iptables -A INPUT -m state --state NEW -p tcp -s < > --dport 8308 -j ACCEPT 

बाकी के लिए, मैं इस पोस्ट के दायरे से परे सुरक्षा मुद्दे को छोड़ देता हूं।