C # के तहत OpenCL सिर्फ है

हालांकि OpenCL तकनीक 2008 में वापस दिखाई दी, लेकिन इसे अब तक अधिक वितरण नहीं मिला है। प्रौद्योगिकी के लाभ निस्संदेह हैं: गणना का त्वरण, क्रॉस-प्लेटफ़ॉर्म, GPU और CPU के तहत कोड को निष्पादित करने की क्षमता, मानक कई कंपनियों द्वारा समर्थित है: Apple, AMD, Intel, nVidia और कुछ अन्य। कई नुकसान नहीं हैं, लेकिन वे हैं: CUDA के माध्यम से nVidia पर धीमी गति से काम, उपयोग की जटिलता। मंत्रियों का पहला गंभीर विकास के साथ ही प्रभावित करता है, जहां कार्यक्रम की गति क्रॉस-प्लेटफॉर्म की तुलना में अधिक महत्वपूर्ण है। दूसरा एक विशेष विकास पद्धति के पक्ष में विकल्प बनाने वाले डेवलपर्स के लिए मुख्य बाधा है। हेडर, ड्राइवर और मानकों के एक समूह का पता लगाने में बहुत समय लगता है। लेकिन सब कुछ इतना बुरा नहीं है। इस लेख का विषय एक छोटा मार्गदर्शक होगा कि आप ओपन # को सी # के तहत कैसे सरल तरीके से चला सकते हैं और समानांतर प्रोग्रामिंग का आनंद ले सकते हैं।

ड्राइवर सेटअप

सबसे लंबा और सबसे कठिन हिस्सा OpenCL के लिए ड्राइवरों की स्थापना कर रहा है। मैं तुरंत कहूंगा कि यदि सिस्टम एक वर्ष से अधिक समय से कंप्यूटर पर है, तो आपके पास एक एएमडी कार्ड है और सिस्टम में ड्राइवरों को अपडेट किया गया है - यह संभावना है कि सिस्टम को फिर से व्यवस्थित करना होगा।

एएमडी।

हालांकि एएमडी को ड्राइवरों के साथ कुछ समस्याएं हैं, उनके पास बहुत सारे उदाहरणों के साथ एक अद्भुत एसडीके है, और समर्थन फोरम लाइव और ऑपरेशनल हैं। AMD उत्प्रेरक के हाल के संस्करणों में , OpenCL के लिए ड्राइवर स्वचालित रूप से इंस्टॉल किए जाते हैं। यहां काम के लिए एसडीके लिया जा सकता है । स्थापना से पहले, जांचें कि क्या आपका ग्राफिक्स कार्ड ओपनसीएल का समर्थन करता है । एएमडी के लिए, आंशिक समर्थन 4300 श्रृंखला के साथ शुरू होता है, और 5400 के साथ पूर्ण समर्थन।

NVIDIA के।

सिद्धांत रूप में, एनवीडिया में ड्राइवर की समस्याएं कम होती हैं, लेकिन कभी-कभी वे उठते भी हैं। OpenCL का समर्थन लगभग 8600 श्रृंखला से होता है। आपको यहां ड्राइवर मिल सकते हैं ।

इंटेल।

एएमडी और एनवीडिया के विपरीत, मुझे इंटेल ड्राइवरों के साथ समस्याओं का सामना नहीं करना पड़ा है। आप उन्हें यहां ले जा सकते हैं।

सिस्टम पर ड्राइवरों को स्थापित करने की गारंटी नहीं है कि वे आपके लिए काम करेंगे। AMD की संख्या बहुत अधिक है (समस्याएँ तब उत्पन्न हुईं जब 2 में से 3 कंप्यूटरों पर), nVidia के लिए यह बड़ा है (3 में से 1)। इसलिए, स्थापना के बाद, मैं अनुशंसा करता हूं कि आप पहले यह जांच लें कि ओपनसीएल जुड़ा हुआ है या नहीं। यह वीडियो कार्ड के मापदंडों को दिखाने वाले कार्यक्रमों के माध्यम से सबसे अधिक किया जा सकता है। मैं GpuCapsViewer , opencl-z और GPU-Z का भी उपयोग करता हूं ।
यदि समस्याएं उत्पन्न हुईं ... सभी पुराने ड्राइवरों को निकालें, पुनर्व्यवस्थित करें। एएमडी के लिए - ड्राइवरों के सही संस्करण को स्थापित करना सुनिश्चित करें। लैपटॉप ड्राइवर अक्सर छोटी गाड़ी होते हैं। यदि समस्याएं गायब नहीं हुई हैं, तो विंडोज को फिर से इंस्टॉल करना आपको बचाएगा।

रैपर

चूँकि हमारा लक्ष्य C # के तहत OpenCL पर यथासंभव सरल प्रोग्राम करना है, हम विकृतियों से नहीं निपटेंगे और OpenCL हेडर को कनेक्ट करेंगे, लेकिन हम तैयार पुस्तकालयों का उपयोग करेंगे जो विकास को सरल बनाते हैं। सबसे पूर्ण और छोटी गाड़ी संस्करण, जैसा कि मुझे लगता है, आज cloo.dll है , जो OpenTK का हिस्सा है। कई ऑपरेशन को स्वचालित करने के लिए सबसे आसान है, OpenCLTemplate , जो क्लो के लिए एक ऐड-ऑन है। बाद के minuses में से, कुछ ग्लिच जब एएमडी के साथ काम करते हैं, उदाहरण के लिए नवीनतम ड्राइवरों (11.6) के साथ, उपकरणों को शुरू करने से इनकार कर सकते हैं। OpenSource प्रोजेक्ट के बाद से, मैंने अपने पास मौजूद glitches को ठीक किया और ठीक किया, लेकिन मुझे नहीं पता कि वे लाइब्रेरी के नए संस्करण को कब जारी करेंगे। कुछ कम ज्ञात रैपर भी हैं जो इंटरनेट पर पाए जा सकते हैं।

पहला कार्यक्रम

पहले कार्यक्रम के रूप में, हम OpenCL के माध्यम से दो वैक्टर, v1 और v2 के योग की गणना करते हैं। Cloo.dll का उपयोग करके लिखा गया उदाहरण कार्यक्रम:

क्लो कार्यक्रम

private void button4_Click( object sender, EventArgs e)
{
// , . Platforms[1]
//
ComputeContextPropertyList Properties = new ComputeContextPropertyList(ComputePlatform.Platforms[1]);
ComputeContext Context = new ComputeContext(ComputeDeviceTypes.All, Properties, null , IntPtr .Zero);

// , (GPU CPU).
// . , C99 OpenCL.
string vecSum = @"
__kernel void
floatVectorSum(__global float * v1,
__global float * v2)
{
int i = get_global_id(0);
v1[i] = v1[i] + v2[i];
}

" ;
// , vecSum
List <ComputeDevice> Devs = new List <ComputeDevice>();
Devs.Add(ComputePlatform.Platforms[1].Devices[0]);
Devs.Add(ComputePlatform.Platforms[1].Devices[1]);
Devs.Add(ComputePlatform.Platforms[1].Devices[2]);
// vecSum
ComputeProgram prog = null ;
try
{

prog = new ComputeProgram(Context, vecSum); prog.Build(Devs, "" , null , IntPtr .Zero);
}

catch

{ }

//
ComputeKernel kernelVecSum = prog.CreateKernel( "floatVectorSum" );

// , .
float [] v1 = new float [100], v2 = new float [100];
for ( int i = 0; i < v1.Length; i++)
{
v1[i] = i;
v2[i] = 2 * i;
}
// .
ComputeBuffer< float > bufV1 = new ComputeBuffer< float >(Context, ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.UseHostPointer, v1);
ComputeBuffer< float > bufV2 = new ComputeBuffer< float >(Context, ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.UseHostPointer, v2);
// vecSum
kernelVecSum.SetMemoryArgument(0, bufV1);
kernelVecSum.SetMemoryArgument(1, bufV2);
// . , !
ComputeCommandQueue Queue = new ComputeCommandQueue(Context, Cloo.ComputePlatform.Platforms[1].Devices[0], Cloo.ComputeCommandQueueFlags.None);
//. Execute - vecSum (v1.Length)
Queue.Execute(kernelVecSum, null , new long [] { v1.Length }, null , null );
// .
float [] arrC = new float [100];
GCHandle arrCHandle = GCHandle.Alloc(arrC, GCHandleType.Pinned);
Queue.Read< float >(bufV1, true , 0, 100, arrCHandle.AddrOfPinnedObject(), null );
}

* This source code was highlighted with Source Code Highlighter .

और नीचे OpenCLTemplate.DLL के माध्यम से एक ही कार्यक्रम लागू किया गया है

private void btnOpenCL_Click( object sender, EventArgs e)
{
// , (GPU CPU).
// . , C99 OpenCL.
string vecSum = @"
__kernel void
floatVectorSum(__global float * v1,
__global float * v2)
{
int i = get_global_id(0);
v1[i] = v1[i] * v2[i];
}" ;

// . . GPU.
//OpenCLTemplate.CLCalc.InitCL(Cloo.ComputeDeviceTypes.All)
//GPU CPU.
OpenCLTemplate.CLCalc.InitCL();
// .
List <Cloo.ComputeDevice> L = OpenCLTemplate.CLCalc.CLDevices;
//
OpenCLTemplate.CLCalc.Program.DefaultCQ = 0;
// vecSum
OpenCLTemplate.CLCalc.Program.Compile( new string [] { vecSum });
// , .
OpenCLTemplate.CLCalc.Program.Kernel VectorSum = new OpenCLTemplate.CLCalc.Program.Kernel( "floatVectorSum" );
int n = 100;

float [] v1 = new float [n], v2 = new float [n], v3 = new float [n];

// , .
for ( int i = 0; i < n; i++)
{
v1[i] = i;
v2[i] = i*2;
}


//
OpenCLTemplate.CLCalc.Program.Variable varV1 = new OpenCLTemplate.CLCalc.Program.Variable(v1);
OpenCLTemplate.CLCalc.Program.Variable varV2 = new OpenCLTemplate.CLCalc.Program.Variable(v2);

// ,
OpenCLTemplate.CLCalc.Program.Variable[] args = new OpenCLTemplate.CLCalc.Program.Variable[] { varV1, varV2 };

//
int [] workers = new int [1] { n };

// VectorSum args workers
VectorSum.Execute(args, workers);

//
varV1.ReadFromDeviceTo(v3);

}

* This source code was highlighted with Source Code Highlighter .

जैसा कि आप देख सकते हैं, दूसरा विकल्प बहुत सरल और अधिक सहज है।

अंतिम लिंक

सबसे पहले, यह साइट OpenCL पर C # - www.cmsoft.com.br के माध्यम से प्रोग्रामिंग के लिए समर्पित है। दुर्भाग्य से, कुछ लोग इसका नेतृत्व करते हैं, इसलिए उदाहरण अक्सर अपर्याप्त होते हैं, और साइट के लेखकों द्वारा बनाई गई OpenCLTemplate बहुत छोटी है।
एक उपयोगी जगह www.opentk.com साइट है जहाँ वे बहुत जल्दी cloo.dll के माध्यम से प्रोग्रामिंग के बारे में सवालों के जवाब देते हैं
आप sourceforge.net/projects/cloo पर लगभग एक ही उत्तर प्राप्त कर सकते हैं
C99- आधारित OpenCl प्रोग्रामिंग मानक यहाँ वर्णित है - www.khronos.org/opencl

लेख " ओपनक्ल का परिचय " की निरंतरता प्रोग्रामिंग भाषा की सुविधाओं के बारे में बात करती है जिसके साथ हम वीडियो कार्ड का कार्यक्रम करते हैं।