परिचय

एमू एक उच्च-स्तरीय ग्राफिक्स कार्ड प्रोग्रामिंग भाषा है जिसे रस्ट सिस्टम प्रोग्रामिंग भाषा में नियमित कोड में एम्बेड किया जा सकता है।

यह लेख एमु के सिंटैक्स, इसकी विशेषताओं पर ध्यान केंद्रित करेगा, और वास्तविक कोड में इसके उपयोग के कुछ उदाहरण भी दिखाएंगे।

स्थापना

1. आप जिस लाइब्रेरी की तलाश कर रहे हैं, उसे बाहरी ओपनसीएल निर्भरता की जरूरत है। आपको अपने हार्डवेयर के लिए उपयुक्त ड्राइवर को स्थापित करना होगा।
2. नीचे दिए गए पाठ के Cargo.toml करें। यह नवीनतम उपलब्ध संस्करणों को डाउनलोड करेगा (यदि आपको एक विशिष्ट असेंबली की आवश्यकता है, तो इसके बजाय * आवश्यक संस्करण डालें):
   
   

    [dependencies] em = "*" //   Emu ocl = "*" //   OpenCL 

वाक्य-विन्यास

एमु सिंटैक्स काफी सरल है, क्योंकि यह भाषा केवल कर्नेल फ़ंक्शन लिखने के लिए है जो ओपनसीएल में संकलित है।

डेटा प्रकार

एमु भाषा में नौ डेटा प्रकार हैं जो रस्ट में उन लोगों के समान हैं। निम्नलिखित डेटा प्रकारों की एक तालिका है:

चर

वेरिएबल्स को लेटर कीवर्ड का उपयोग करके घोषित किया जाता है, जो पहचानकर्ता, कोलन, डेटा टाइप, बराबर साइन, असाइन किए गए मान और अर्धविराम के पीछे स्थित होता है।

 let age: i32 = 54; let growth: f32 = 179.432; let married: bool = true; 

रूपांतरण

लक्ष्य प्रकार के बाद, बाइनरी ऑपरेटर का उपयोग करके आदिम डेटा प्रकारों का रूपांतरण किया जाता है। मैं ध्यान देता हूं कि लक्ष्य प्रकार भी माप की एक इकाई हो सकती है (अगला भाग देखें):

 let width: i16 = 324; let converted_width: i64 = width as i64; 

माप की इकाइयों

एमू भाषा आपको माप की इकाइयों के रूप में संख्याओं का इलाज करने की अनुमति देती है, जिसे वैज्ञानिक गणना को सरल बनाने के लिए डिज़ाइन किया गया है। इस उदाहरण में, चर की length शुरू में मीटर में परिभाषित की जाती है, लेकिन फिर माप की अन्य इकाइयों को इसमें जोड़ा जाता है:

 let length: f32 = 3455.345; //  length += 7644.30405 as cm; //  length += 1687.3043 as mm; //  

पूर्वनिर्धारित स्थिरांक

एमु में पूर्वनिर्धारित स्थिरांक का एक सेट है जो अभ्यास में उपयोग करने के लिए सुविधाजनक है। नीचे इसी तालिका है।

इसके अलावा वैज्ञानिक डेटा के अनुरूप स्थिरांक परिभाषित किए गए हैं। आप यहां इन स्थिरांक से युक्त तालिका पा सकते हैं।

सशर्त बयान

एमु सशर्त बयान रस्ट में संबंधित बयानों के समान हैं। निम्नलिखित कोड सशर्त निर्माण का उपयोग करता है:

 let number: i32 = 2634; let satisfied: bool = false; if (number > 0) && (number % 2 == 0) { satisfied = true; } 

छोरों के लिए

फ़ॉर लूप के हेडर को for NUM in START..END रूप में परिभाषित किया गया है, जहाँ NUM एक चर है जो सीमा से मान लेता है - [START; END) इकाई के माध्यम से [START; END) ।

 let sum: u64 = 0; for i in 0..215 { sum += i; } 

जबकि लूप

जबकि लूप का शीर्षक उस while (CONDITION) रूप में परिभाषित किया गया है, जहां CONDITION लूप के लिए अगली पुनरावृत्ति के लिए आगे बढ़ने की शर्त है। यह कोड पिछले उदाहरण के समान है:

 let sum: u64 = 0; let idx: i32 = 0; while (idx < 215) { sum += idx; idx += 1; } 

अंतहीन छोरों

अनंत लूप में एक स्पष्ट निकास स्थिति नहीं होती है और loop कीवर्ड द्वारा परिभाषित की जाती है। हालांकि, उन्हें break द्वारा जारी या बाधित किया जा सकता है और बयान continue (अन्य दो प्रकार के छोरों की तरह)।

 let collapsed: u64 = 1; let idx: i32 = 0; loop { if idx % 2 == 0 { continue; } sum *= idx; if idx == 12 { break; } } 

समारोह से लौटें

अन्य सभी प्रोग्रामिंग भाषाओं की तरह, return वर्तमान फ़ंक्शन का आउटपुट है। यह एक निश्चित मान भी लौटा सकता है यदि फ़ंक्शन हस्ताक्षर (निम्नलिखित अनुभाग देखें) यह अनुमति देता है।

 let result: i32 = 23446; return result; 

अन्य ऑपरेटर

• उपलब्ध असाइनमेंट ऑपरेटर: = , += , -= , *= , /= , %= , &= , ^= , <<= , >>= ;
• सूचकांक ऑपरेटर [IDX] ;
• कॉल ऑपरेटर - (ARGS) ;
• यूनिरी ऑपरेटर्स: * डेरेफेरिंग के लिए; बूलियन डेटा को पलटना, - संख्याओं की उपेक्षा करना;
• बाइनरी ऑपरेटर: + , - , * , / , % , && , || , & , | , ^ , >> , << , > , < , >= , <= , == , == != ।

कार्यों

एमु पर कार्यों के तीन भाग हैं: पहचानकर्ता, पैरामीटर और फ़ंक्शन का शरीर, निष्पादन योग्य निर्देशों के अनुक्रम से मिलकर। दो संख्याओं को जोड़ने के कार्य पर विचार करें:

 add(left f32, right f32) f32 { return left + right; } 

जैसा कि आपने देखा होगा, यह फ़ंक्शन डेटा प्रकार f32 का उपयोग करके इसमें पारित दो तर्कों का योग देता है।

पता स्थान

फ़ंक्शन का प्रत्येक पैरामीटर एक विशिष्ट पता स्थान से मेल खाता है । डिफ़ॉल्ट रूप से, सभी पैरामीटर __private__ स्थान के अनुरूप हैं।

पैरामीटर पहचानकर्ता में उपसर्गों global_ और local_ को जोड़ना स्पष्ट रूप से इसके पते की जगह को इंगित करता है।

दस्तावेज़ीकरण सभी वैक्टरों के लिए global_ उपसर्ग का उपयोग करने की सलाह देता है और किसी अन्य चीज़ को उपसर्ग करने की नहीं।

अंतर्निहित कार्य

एमू बिल्ट-इन फ़ंक्शन (ओपनसीएल से लिया गया) का एक छोटा सा सेट प्रदान करता है जो आपको GPU डेटा को प्रबंधित करने की अनुमति देता है:

• get_work_dim() - आयामों की संख्या लौटाता है;
• get_global_size() - दिए गए आयाम के लिए वैश्विक तत्वों की संख्या लौटाता है;
• get_global_id() - निर्दिष्ट आयाम के लिए तत्व का विशिष्ट पहचानकर्ता लौटाता है;
• get_global_size() - दिए गए आयाम के लिए वैश्विक तत्वों की संख्या लौटाता है;
• get_local_id() - दिए गए आयाम के लिए एक विशिष्ट कार्यसमूह के भीतर एक स्थानीय तत्व के लिए एक विशिष्ट पहचानकर्ता लौटाता है;
• get_num_groups() - दिए गए आयाम के लिए कार्यसमूहों की संख्या लौटाता है;
• get_group_id() - कार्यसमूह के लिए एक विशिष्ट पहचानकर्ता देता है।

एप्लिकेशन कोड में, सबसे अधिक बार आपको अभिव्यक्ति get_global_id(0) , जो कॉल के साथ जुड़े वेक्टर तत्व के वर्तमान सूचकांक को आपके कर्नेल फ़ंक्शन पर लौटाता है।

कोड निष्पादन

नियमित रस्ट कोड से एमु फ़ंक्शन को कॉल करने के लिए सिंटैक्स पर विचार करें। एक उदाहरण के रूप में, हम एक फ़ंक्शन का उपयोग करेंगे जो एक सदिश के सभी तत्वों को दिए गए संख्या से गुणा करता है:

 use em::emu; emu! { multiply(global_vector [f32], scalar f32) { global_vector[get_global_id(0)] *= scalar; } } 

इस फ़ंक्शन को ओपनसीएल कोड में अनुवाद करने के लिए, आपको इसके हस्ताक्षर को मैक्रो में रखना होगा build! निम्नानुसार है:

 use em::build; //    build! {...} extern crate ocl; use ocl::{flags, Platform, Device, Context, Queue, Program, Buffer, Kernel}; build! { multiply [f32] f32 } 

रस्ट कोड से आपके द्वारा लिखे गए इमू कार्यों को कॉल करने के लिए आगे की कार्रवाई कम हो जाती है। यह आसान नहीं हो सकता है:

 fn main() { let vector = vec![0.4445, 433.245, 87.539503, 2.0]; let result = multiply(vector, 2.0).unwrap(); dbg!(result); } 

आवेदन उदाहरण

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

 use em::{build, emu}; //    build! {...} extern crate ocl; use ocl::{flags, Buffer, Context, Device, Kernel, Platform, Program, Queue}; emu! { multiply(global_vector [f32], scalar f32) { global_vector[get_global_id(0)] *= scalar; } } build! { multiply [f32] f32 } fn main() { //     : let args = std::env::args().collect::<Vec<String>>(); if args.len() < 3 { panic!(": cargo run -- <SCALAR> <NUMBERS>..."); } //      : let scalar = args[1].parse::<f32>().unwrap(); //      : let vector = args[2..] .into_iter() .map(|string| string.parse::<f32>().unwrap()) .collect(); //    : let result = multiply(vector, scalar).unwrap(); dbg!(result); } 

आप cargo run -- 3 2.1 3.6 6.2 कमांड के साथ इस कोड को निष्पादित कर सकते हैं। परिणामी निष्कर्ष अपेक्षाओं को पूरा करता है:

 [src/main.rs:33] result = [ 6.2999997, 10.799999, 18.599998, ] 

OpenCL से लिंक करें

जैसा कि पहले उल्लेख किया गया है, एमु ओपनसीएल पर सिर्फ एक अमूर्त है, और इसलिए इसमें ओक्ल क्रेट के साथ बातचीत करने की क्षमता है। नीचे दिए गए कोड को आधिकारिक भंडार में एक उदाहरण से लिया गया है :

 use em::emu; //  "ocl"        Rust: extern crate ocl; use ocl::{flags, Platform, Device, Context, Queue, Program, Buffer, Kernel}; //  Emu    (OpenCL)   //     "EMU: &'static str": emu! { //     : multiply(global_buffer [f32], coeff f32) { global_buffer[get_global_id(0)] *= coeff; } } fn multiply(global_buffer: Vec<f32>, coeff: f32) -> ocl::Result<Vec<f32>> { //        , //  , ,   : let platform = Platform::default(); let device = Device::first(platform)?; let context = Context::builder() .platform(platform) .devices(device.clone()) .build()?; let program = Program::builder() .devices(device) .src(EMU) .build(&context)?; let queue = Queue::new(&context, device, None)?; let dims = global_buffer.len(); //    : let buffer = Buffer::<f32>::builder() .queue(queue.clone()) .flags(flags::MEM_READ_WRITE) .len(dims) .copy_host_slice(&global_buffer) .build()?; //       , //    : let kernel = Kernel::builder() .program(&program) .name("multiply") .queue(queue.clone()) .global_work_size(dims) .arg(&buffer) .arg(&coeff) .build()?; //    (    //   : unsafe { kernel.cmd() .queue(&queue) .global_work_offset(kernel.default_global_work_offset()) .global_work_size([dims, 0, 0]) .local_work_size(kernel.default_local_work_size()) .enq()?; } //  ,         // "dims": let mut vector = vec![0.0f32; dims]; buffer.cmd() .queue(&queue) .offset(0) .read(&mut vector) .enq()?; Ok(vector) } fn main() { let initial_data = vec![3.7, 4.5, 9.0, 1.2, 8.9]; //   ,   Emu,  //  "initial_data": let final_data = multiply(initial_data, 3.0).unwrap(); println!("{:?}", final_data); } 

समापन

मुझे उम्मीद है कि आपको लेख पसंद आया होगा। आप रूसी भाषा में रूस्त ( शुरुआती के लिए संस्करण ) में अपने सवालों का त्वरित जवाब पा सकते हैं।