R + C + CUDA = ...

कभी-कभी गणना को गति देना आवश्यक हो जाता है, और यह कई बार तुरंत वांछनीय है। उसी समय, आपको सुविधाजनक, लेकिन धीमा उपकरण छोड़ना होगा और कुछ निचले-स्तर और तेज़ का सहारा लेना होगा। C के पास C / C ++, फोरट्रान या यहां तक ​​कि जावा में लिखे गए गतिशील पुस्तकालयों के साथ काम करने के लिए काफी उन्नत क्षमताएं हैं। आदत से बाहर, मैं C / C ++ पसंद करता हूं।

आर और सी

तुरंत एक आरक्षण करें कि मैं डेबियन व्हीज़ी (विंडोज के तहत, शायद कुछ बारीकियों के तहत) काम करता हूं। R के लिए C में लाइब्रेरी लिखते समय, निम्नलिखित पर विचार करें:

• C में लिखे और R में फंक्शन्स टाइप शून्य होने चाहिए। इसका मतलब यह है कि यदि कोई फ़ंक्शन कोई परिणाम देता है, तो उन्हें फ़ंक्शन तर्क के माध्यम से लौटाया जाना चाहिए
• सभी तर्क संदर्भ द्वारा पारित किए जाते हैं (और जब संकेत के साथ काम करते हैं, तो आपको सतर्कता नहीं खोनी चाहिए!)
• C कोड में, Rh
  
  
  
  और Rmath.h
  
  
  
  को शामिल करना वांछनीय है (यदि R के गणितीय कार्यों का उपयोग किया जाता है)

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

 #include <Rh> void iprod(double *v1, double *v2, int *n, double *s) { double ret = 0; int len = *n; for (int i = 0; i < len; i++) { ret += v1[i] * v2[i]; } *s = ret; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अगला, आपको एक गतिशील पुस्तकालय प्राप्त करने की आवश्यकता है - आप सीधे जीसीसी के माध्यम से कर सकते हैं, या आप इस कमांड का उपयोग कर सकते हैं (वैसे, आपको आउटपुट याद रखना चाहिए, क्योंकि यह भविष्य में हमारे लिए उपयोगी होगा):

 R CMD SHLIB inner_prod.c
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आउटपुट पर, हमें इनर_प्रोड.सो फ़ाइल मिलती है, जिसे लोड करने के लिए हम dyn.load()



फ़ंक्शन का उपयोग करते हैं। फ़ंक्शन को C में स्वयं कॉल करने के लिए, .C()



.External()



.C()



(वहाँ भी है .External()



.Call()



और .External()



, लेकिन थोड़ी अलग कार्यक्षमता के साथ, और कभी-कभी .External()



.Call()



और .External()



के समर्थकों के बीच गर्म बहस होती है। मैं केवल यह ध्यान देता हूं कि जब .C()



माध्यम से कॉल करने के लिए सी में कोड लिखा जाता है .C()



तो यह क्लीनर और अधिक पठनीय हो जाता है। विशेष रूप से आर और सी में चर के प्रकार के पत्राचार पर ध्यान दिया जाना चाहिए .C()



लिए प्रलेखन .C()



फ़ंक्शन इस बारे में विस्तार से .C()



है)। आर पर आवरण समारोह:

 iprod <- function(a, b) { if (!is.loaded('iprod')) { dyn.load("inner_prod.so") } n <- length(a) v <- 0 return(.C("iprod", as.double(a), as.double(b), as.integer(n), as.double(v))[[4]]) }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अब आप यह जान सकते हैं कि हमने क्या हासिल किया है:

 > n <- 1e7; a <- rnorm(n); b <- rnorm(n); > iprod(a, b) [1] 3482.183
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

और थोड़ा चेक करें:

 > sum(a * b) [1] 3482.183
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

किसी भी मामले में, वह सही सोचता है।

आर और CUDA

उन सभी लाभों का लाभ उठाने के लिए जो एनवीडिया ग्राफिक्स एक्सेलेरेटर डेबियन में प्रदान करता है, आपके पास एनवीडिया मालिकाना चालक और एनवीडिया nvidia-cuda-toolkit



पैकेज nvidia-cuda-toolkit



। CUDA निश्चित रूप से एक अलग विशाल विषय का हकदार है, और चूंकि इस विषय में मेरा स्तर "नौसिखिया" है, इसलिए मैं अपने कुटिल और अपूर्ण कोड वाले लोगों को नहीं डराऊंगा, लेकिन मुझे मैनुअल से कुछ पंक्तियों की प्रतिलिपि बनाने दें।

मान लीजिए कि वेक्टर के प्रत्येक तत्व को तीसरी शक्ति तक उठाना आवश्यक है और परिणामी वेक्टर के यूक्लिडियन मान को खोजना होगा:







GPU के साथ काम करना आसान बनाने के लिए, हम Thrust



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

 #include <thrust/transform_reduce.h> #include <thrust/device_vector.h> #include <cmath> // ,     6   GPU (device) template <typename T> struct power{ __device__ T operator()(const T& x) const{ return std::pow(x, 6); } }; extern "C" void nrm(double *v, int *n, double *vnorm) { // ,    GPU,     *v thrust::device_vector<double> dv(v, v + *n); // Reduce- , ..        power //    . *vnorm = std::sqrt( thrust::transform_reduce(dv.begin(), dv.end(), power<double>(), 0.0, thrust::plus<double>()) ); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

extern "C"



करना यहां अनिवार्य है, अन्यथा आर एनआरएम () फ़ंक्शन नहीं देखेगा। अब हम कोड को संकलित करने के लिए nvcc का उपयोग करेंगे। कमांड R CMD SHLIB...



का आउटपुट याद रखें R CMD SHLIB...



? यहाँ यह थोड़ा सा है और इसे अनुकूलित करें ताकि CUDA / थ्रस्ट का उपयोग करने वाले एक पुस्तकालय को बिना किसी समस्या के R से बुलाया जा सके:

 nvcc -g -G -O2 -arch sm_30 -I/usr/share/R/include -Xcompiler "-Wall -fpic" -c thr.cu thr.o nvcc -shared -lm thr.o -o thr.so -L/usr/lib/R/lib -lR
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आउटपुट में हमें DSO thr.so मिलता है। आवरण समारोह व्यावहारिक रूप से अलग नहीं है:

 gpunrm <- function(v) { if (!is.loaded('nrm')) dyn.load("thr.so") n <- length(v) vnorm <- 0 return(.C("nrm", as.double(v), as.integer(n), as.double(vnorm))[[3]]) }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

नीचे दिया गया ग्राफ स्पष्ट रूप से दिखाता है कि वेक्टर की लंबाई के आधार पर रनटाइम कैसे बढ़ता है। यह ध्यान देने योग्य है कि यदि गणनाओं में जोड़ / घटाव जैसे सरल ऑपरेशन होते हैं, तो सीपीयू और जीपीयू पर गणना समय के बीच व्यावहारिक रूप से कोई अंतर नहीं होगा। इसके अलावा, यह बहुत संभावना है कि GPU मेमोरी के साथ काम करने के ओवरहेड के कारण खो जाएगा।

निष्कर्ष

वास्तव में, मेट्रिसेस और वैक्टर के साथ काम करने के लिए आर ऑपरेशन बहुत अच्छी तरह से अनुकूलित हैं, और रोजमर्रा की जिंदगी में एक GPU का उपयोग करने की आवश्यकता बहुत बार उत्पन्न नहीं होती है, लेकिन कभी-कभी GPU गणना समय को काफी कम कर सकता है। CRAN में पहले से तैयार पैकेज हैं (उदाहरण के लिए, gputools



) GPU के साथ काम करने के लिए अनुकूलित ( यहां आप इस बारे में और अधिक पढ़ सकते हैं)।

संदर्भ

1. .सी इंटरफ़ेस टू आर का परिचय

2. R और Matlab में C फंक्शंस को कॉल करना

3. R के लिए CUDA C एक्सटेंशन लिखना

4. जोर :: CUDA टूलकिट प्रलेखन



PS मैंने पहले कोड के टुकड़े को सही सिफारिश के अनुसार ठीक किया।