💃🏾 🖖🏿 🧡 रस्ट + CUDA C में लिखना 🥙 🙇🏼 👏🏿

सभी को नमस्कार!

इस गाइड में मैं दोस्तों को CUDA C / C ++ और Rust बनाने का तरीका बताना चाहता हूँ। और एक उदाहरण के रूप में, हम वैक्टर के स्केलर उत्पाद की गणना करने के लिए जंग में एक छोटा सा कार्यक्रम लिखेंगे, स्केलर उत्पाद की गणना CUDA C का उपयोग करके GPU पर की जाएगी।

बिल्ली की कौन परवाह करता है!

CUDA सी

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

तो nvcc और CUDA टूलकिट स्थापित करें। इस जटिलता के साथ, विस्तृत निर्देश उत्पन्न नहीं होने चाहिए: ऑफ साइट पर ।

RUST + CUDA C

इस ट्यूटोरियल के पाठ्यक्रम में, जैसा कि पहले उल्लेख किया गया है, हम दो वैक्टर के स्केलर उत्पाद को खोजने के लिए रस्ट में एक कार्यक्रम लिखेंगे, गणना प्रक्रिया स्वयं GPU पर होगी।

दो वैक्टर का अदिश उत्पाद।

मान लीजिए हमारे पास दो वैक्टर हैं:

a = [a_{1}, a_{2}, . . . a_{n}]

$a = [a_1, a_2, ... a_n]$ और

b = [b_{1}, b_{2}, . . ., b_{n}]

$b = [b_1, b_2, ..., b_n]$ इन वैक्टर के स्केलर उत्पाद:

a c d o t b = s u m_{i = 1}^{n} a_{i} b_{i}

$a \ cdot b = \ sum_ {i = 1} ^ {n} {a_ib_i}$

चलो हमारे कार्यक्रम बनाना शुरू करते हैं। इसके अलावा, मुझे लगता है कि nvcc सफलतापूर्वक स्थापित है, जंग और कार्गो भी जंग कोड संकलन के लिए खड़े हैं।

सबसे पहले, प्रोजेक्ट फ़ोल्डर बनाएँ। प्रोजेक्ट फ़ोल्डर में, कार्गो टोमल फ़ाइल बनाएं, जिसमें कार्गो कलेक्टर के लिए निर्देश हैं। फ़ाइल इस तरह दिखती है:

[package] name = "rust_cuda" #   version = "0.1.0" #   authors = ["MoonL1ght <ixav1@icloud.com>"] #    build = "build.rs" #    rust links = "cudart" #  cuda,    [dependencies] libc = "0.2" #  rust     rand = "0.5.5" #  rust      [build-dependencies] cc = "1.0" # rust

प्रोजेक्ट रूट फ़ोल्डर में भी build.rs फ़ाइल बनाएँ जिसमें जंग कार्यक्रम बनाने और CUDA C कोड को संकलित करने के निर्देश होंगे।

प्रोजेक्ट रूट में src फोल्डर जोड़ें, जिसमें हम सोर्स कोड फाइलें रखेंगे। Src फ़ोल्डर में, चार फाइलें बनाएँ: main.rs - मुख्य प्रोग्राम का कोड, dot.cpp - C ++ बाइंडिंग (CUDA C के लिए आवरण), dot_gpu.h, dot_gpu.cu - वह फ़ाइल जिसमें GPU पर कोड निष्पादित होता है।

कुल हम इस तरह की एक परियोजना संरचना है:

 rust-cuda/ src/ main.rs dot.cpp dot_gpu.h dot_gpu.cu Cargo.toml build.rs

Build.rs फ़ाइल में, यह लिखना सबसे महत्वपूर्ण है:

 println!("cargo:rustc-link-search=native=/Developer/NVIDIA/CUDA-10.1/lib"); println!("cargo:rustc-link-search=/Developer/NVIDIA/CUDA-10.1/lib"); println!("cargo:rustc-env=LD_LIBRARY_PATH=/Developer/NVIDIA/CUDA-10.1/lib"); println!("cargo:rustc-link-lib=dylib=cudart");

जहाँ /Developer/NVedia/CUDA-10.1/lib CUDA निष्पादन योग्य फ़ाइलों का पथ है, एक यूनिक्स जैसी प्रणाली पर, यह पथ मिल सकता है, उदाहरण के लिए, कमांड के साथ

 which nvcc

इसके अलावा, build.rs फ़ाइल में, आपको dot.cpp और dot_gpu.cpp फ़ाइलों के लिए पथ निर्दिष्ट करना होगा:

 .files(&["./src/dot.cpp", "./src/dot_gpu.cu"])

सभी build.rs कोड

 extern crate cc; fn main() { cc::Build::new() .cuda(true) .cpp(true) .flag("-cudart=shared") .files(&["./src/dot.cpp", "./src/dot_gpu.cu"]) .compile("dot.a"); println!("cargo:rustc-link-search=native=/Developer/NVIDIA/CUDA-10.1/lib"); println!("cargo:rustc-link-search=/Developer/NVIDIA/CUDA-10.1/lib"); println!("cargo:rustc-env=LD_LIBRARY_PATH=/Developer/NVIDIA/CUDA-10.1/lib"); println!("cargo:rustc-link-lib=dylib=cudart"); }

अब आप मुख्य प्रोग्राम कोड लिखना शुरू कर सकते हैं। Main.rs फ़ाइल में, आपको Rust कोड से सीधे कॉल करने के लिए C / C ++ फ़ंक्शन के लिए एक इंटरफ़ेस बनाने की आवश्यकता है। आप एफएफआई अनुभाग में आधिकारिक दस्तावेज में इसके बारे में अधिक पढ़ सकते हैं।

 extern "C" { //  C        fn dot(v1: *mut c_float, v2: *mut c_float, N: size_t) -> c_float; }

इसे कॉल करने के लिए, आपको असुरक्षित कोड ब्लॉक का उपयोग करने की आवश्यकता है, तर्क के रूप में हम वीईसी प्रकार के लिए एक परस्पर सूचक पास करते हैं:

 unsafe { gpu_res = dot(v1.as_mut_ptr(), v2.as_mut_ptr(), VEC_SIZE); }

पूर्ण main.rs फ़ाइल कोड

 extern crate libc; extern crate rand; use libc::{c_float, size_t}; use rand::Rng; const VEC_SIZE: usize = 10; const MAX: f32 = 10.; const MIN: f32 = 0.; extern "C" { fn dot(v1: *mut c_float, v2: *mut c_float, N: size_t) -> c_float; } fn cpu_dot(v1: Vec<f32>, v2: Vec<f32>) -> f32 { let mut res: f32 = 0.; for i in 0..v1.len() { res += v1[i] * v2[i]; } return res; } fn main() { let mut v1: Vec<f32> = Vec::new(); let mut v2: Vec<f32> = Vec::new(); let mut gpu_res: c_float; let mut cpu_res: f32 = 0.; let mut rng = rand::thread_rng(); for _ in 0..VEC_SIZE { v1.push(rng.gen_range(MIN, MAX)); v2.push(rng.gen_range(MIN, MAX)); } println!("{:?}", v1); println!("{:?}", v2); println!("GPU computing started"); unsafe { gpu_res = dot(v1.as_mut_ptr(), v2.as_mut_ptr(), VEC_SIZE); } println!("GPU computing finished"); println!("GPU dot product result: {}", gpu_res); cpu_res = cpu_dot(v1, v2); println!("CPU dot product result: {}", cpu_res); }

अब हम C ++ में बाइंडिंग लिखना शुरू करते हैं, साथ ही CUD C में वैक्टर के स्केलर उत्पाद की गणना के लिए कोड भी लिखते हैं।

Dot.cpp फ़ाइल में, हम बाध्यकारी फ़ंक्शन लिखते हैं, हम वास्तव में इस फ़ंक्शन को रस्ट कोड से कॉल करते हैं:

 extern "C" { float dot(float *v1, float *v2, size_t N) { float *gpu_res; float res = 0.0; gpu_res = gpu_dot(v1, v2, N); //   GPU for (int i = 0; i < blocksPerGrid; i++) { res += gpu_res[i]; } free(gpu_res); return res; } }

पूर्ण dot.cpp फ़ाइल कोड

 #include <iostream> #include "dot_gpu.h" using namespace std; void display_vector(float *v, size_t N) { cout << "["; for (size_t i = 0; i < N; i++) { cout << v[i]; if (i != N - 1) { cout << ", "; } } cout << "]" << endl; } extern "C" { float dot(float *v1, float *v2, size_t N) { cout << "Calling gpu dot product" << endl; cout << "Got two vectors from rust:" << endl; display_vector(v1, N); display_vector(v2, N); float *gpu_res; float res = 0.0; gpu_res = gpu_dot(v1, v2, N); for (int i = 0; i < blocksPerGrid; i++) { res += gpu_res[i]; } free(gpu_res); return res; } }

निम्नलिखित dot_gpu.cu फ़ाइल से कोड है जिसमें मुख्य गणना की जाती है, मैं कोड को इस ट्यूटोरियल में नहीं समझाऊंगा, क्योंकि यह CUDA प्रोग्रामिंग के लिए समर्पित नहीं है।

dot_gpu.cu

 #include "dot_gpu.h" __global__ void dot__(float *v1, float *v2, float *res, int N) { __shared__ float cache [threadsPerBlock]; int tid = threadIdx.x + blockIdx.x * blockDim.x; int cacheIndex = threadIdx.x; float temp = 0.0; while (tid < N) { temp += v1[tid] * v2[tid]; tid += blockDim.x * gridDim.x; } cache[cacheIndex] = temp; __syncthreads(); int i = blockDim.x / 2; while (i != 0) { if (cacheIndex < i) { cache[cacheIndex] += cache[cacheIndex + i]; } __syncthreads(); i /= 2; } if (cacheIndex == 0) { res[blockIdx.x] = cache[0]; } } float * gpu_dot (float *v1, float *v2, size_t N) { float *dev_v1, *dev_v2, *dev_res, *res; res = new float[blocksPerGrid]; cudaMalloc((void**)&dev_v1, N * sizeof(float)); cudaMalloc((void**)&dev_v2, N * sizeof(float)); cudaMalloc((void**)&dev_res, blocksPerGrid * sizeof(float)); cudaMemcpy(dev_v1, v1, N * sizeof(float), cudaMemcpyHostToDevice); cudaMemcpy(dev_v2, v2, N * sizeof(float), cudaMemcpyHostToDevice); dot__<<<blocksPerGrid, threadsPerBlock>>>(dev_v1, dev_v2, dev_res, (int)N); cudaMemcpy(res, dev_res, blocksPerGrid * sizeof(float), cudaMemcpyDeviceToHost); cudaFree(dev_v1); cudaFree(dev_v2); cudaFree(dev_res); return res; }

हमारे सभी छोटे कार्यक्रम लिखे और बनाने के लिए तैयार हैं। कंसोल में इसे इकट्ठा करने के लिए, कमांड को कॉल करें:

 cargo build

चलाने के लिए:

 cargo run

कार्यक्रम के निर्माण के बाद, लक्ष्य फ़ोल्डर परियोजना की मुख्य निर्देशिका में दिखाई देगा। हमारे कार्यक्रम की निष्पादन योग्य फ़ाइल फ़ोल्डर में स्थित होगी: ./getget/debug/

इसके अलावा, अगर हम अपनी निष्पादन योग्य फ़ाइल चलाते हैं, तो हमें एक त्रुटि मिलती है: dyld पुस्तकालय लोड नहीं हुआ। यही है, वह cuda गतिशील पुस्तकालय के लिए रास्ता नहीं मिल सकता है। इस समस्या को हल करने के लिए, आप कंसोल में निष्पादन योग्य फ़ाइल शुरू करने से पहले CUDA के लिए जंगला टूलचिन फ़ोल्डर में पर्यावरण चर LD_LIBRARY_PATH = path_to_CUDA_lib_directory / या प्रतीकात्मक लिंक चला सकते हैं:

 ln -s /Developer/NVIDIA/CUDA-10.1/lib/* /Users/Alexander/.rustup/toolchains/nightly-x86_64-apple-darwin/lib

जहाँ /User/Alexander/.rustup/toolchains/nightly-x86_64-apple-darwin/lib स्थापित रस्ट टूलचिन के लिए मेरा मार्ग है, यह आपके लिए थोड़ा भिन्न हो सकता है।

कार्गो रन के माध्यम से प्रोग्राम शुरू करते समय, इस तरह की त्रुटि नहीं हुई, क्योंकि हमने बिल्ड.rs फ़ाइल में पर्यावरण चर LD_LIBRARY_PATH को पंजीकृत किया था।

अंत में

हमारे पास CUDA C कोड को सीधे Rust कोड से चलाने की क्षमता है। इसे सत्यापित करने के लिए, हमने एक छोटा कार्यक्रम बनाया, यह वैक्टर के साथ काम करता है और GPU पर सभी गणना करता है। पूरा कोड जीथब पर भी देखा जा सकता है।

रस्ट + CUDA C में लिखना

CUDA सी

RUST + CUDA C

अंत में

More articles: