🎩 😉 🧑🏽 SIMD निर्देशों का उपयोग करके गणित के कार्यों को गति देने के लिए एक खस्ता मॉड्यूल लिखना 👼🏻 🔥 👨🏽

सुन्न और डरावना पैकेज विभिन्न कंप्यूटिंग समस्याओं को जल्दी से हल करने के लिए उत्कृष्ट सुविधाएँ प्रदान करते हैं। सार्वभौमिक कार्यों (ufunc) की अवधारणा, स्केलर मूल्यों के साथ और विभिन्न आयामों के सरणियों के साथ काम करना, आपको पायथन भाषा में निहित सादगी और लालित्य को बनाए रखते हुए उच्च प्रदर्शन प्राप्त करने की अनुमति देता है। एक सार्वभौमिक फ़ंक्शन का उपयोग आमतौर पर एक बड़े डेटा सेट पर एकल ऑपरेशन करने के लिए किया जाता है, जो कि SIMD निर्देशों का उपयोग करके अनुकूलन के लिए आदर्श है, लेकिन मुझे मुफ्त सॉफ़्टवेयर के आधार पर तैयार समाधान नहीं मिला है जो SIMD का उपयोग गणितीय कार्यों जैसे कि सुन्न की गणना करने की अनुमति देता है साइन, कोसाइन और घातांक। मैं खरोंच से इन कार्यों की गणना के लिए एल्गोरिदम को लागू नहीं करना चाहता था, लेकिन सौभाग्य से इंटरनेट पर सी भाषा में कई मुफ्त पुस्तकालय थे। संदेह के ~~आलस्य को~~ दूर करने के बाद, मैंने अपने स्वयं के खगोलीय-मॉड्यूल को लिखने का फैसला किया, साइन, कोसाइन और प्रतिपादक के लिए सार्वभौमिक कार्य की पेशकश की। विवरण और परीक्षण के परिणाम के लिए, बिल्ली में आपका स्वागत है।

SIMD निर्देशों के बारे में थोड़ा सा

SIMD निर्देश आपको एक साथ एक ही रजिस्टर में लिखे गए कई नंबरों पर एक ही ऑपरेशन को करने की अनुमति देता है। इस प्रकार, एक चक्र में, आप एक ही बार में कई संख्याओं को संसाधित कर सकते हैं और संभावित रूप से कई बार उत्पादकता बढ़ा सकते हैं।
उदाहरण के लिए, SIMD अनुदेश सेट उन्नत वेक्टर एक्सटेंशन (AVX) 256-बिट रजिस्टरों के साथ संचालन की अनुमति देता है, जिनमें से प्रत्येक में आठ 32-बिट फ़्लोटिंग-पॉइंट नंबर (एकल-सटीक संख्या), या चार 64-बिट (डबल-सटीक संख्या) शामिल हो सकते हैं । संचालन का सेट बल्कि मामूली है, मुख्य रूप से इसके अलावा, घटाव, गुणा और भाग। इन ऑपरेशनों का उपयोग करते हुए त्रिकोणमितीय कार्यों का सटीक और तेज़ कार्यान्वयन एक तुच्छ कार्य नहीं है और, पहिया को सुदृढ़ नहीं करने के लिए, यह किसी प्रकार के तैयार पुस्तकालय का उपयोग करने के लायक है। मालिकाना इंटेल एमकेएल के अलावा (जो पहले से ही जानता है कि कैसे खस्ता के साथ काम करना है), केवल तीन विकल्प ( एक , दो , तीन ) थे।
पहला विकल्प एक हेडर फ़ाइल है जिसमें बहुत ही मामूली कार्य होता है, जिसमें वस्तुतः कोई दस्तावेज या परीक्षण नहीं होता है। दूसरा विकल्प Ccm vecmathlib लाइब्रेरी है, जिसने किसी कारण से अनुशंसित GCC-4.7 संकलक के उपयोग के बावजूद मेरे लिए संकलन करने से इनकार कर दिया था। एक आशाजनक विकल्प, लेकिन अभी भी क्रूड लगता है। तीसरा विकल्प - SLEEF लाइब्रेरी - को वीसीमैथलीब के लिए धन्यवाद मिला, जो इसके कोड बेस का उपयोग करता है। कोड की सादगी और स्पष्टता के साथ-साथ परीक्षणों की अधिकता के कारण मुझे तुरंत विकल्प पसंद आया।

प्रेरणा के लिए थोड़ा परीक्षण

मॉड्यूल लिखने के लिए पर्याप्त प्रेरणा पाने के लिए, और एक ही समय में यह पता लगाने के लिए कि SLEEF का उपयोग कैसे करें, मैंने मानक गणित के साथ SLEEF का उपयोग करते समय सी भाषा में साइन की गणना की गति की तुलना करने का निर्णय लिया। स्वाभाविक रूप से, हम एक बड़े डेटा ऐरे के लिए एलीमेंट वाइज गणना की बात कर रहे हैं।
दुर्भाग्य से, SLEEF में व्यावहारिक रूप से कोई प्रलेखन और उदाहरण नहीं हैं, लेकिन काफी स्पष्ट रूप से लिखित परीक्षण हैं, इसलिए यह पता लगाना मुश्किल नहीं था कि पुस्तकालय का उपयोग कैसे करें। SLEEF स्रोत कोड में चार निर्देशिकाएं होती हैं: java , purec , simd और tester । इसके अलावा, लाइब्रेरी के संक्षिप्त विवरण और सामान्य मेकफाइल के साथ एक README फाइल है जो उपरोक्त निर्देशिकाओं से मेकफाइल को खींचती है। स्वाभाविक रूप से, मैं simd डायरेक्टरी में सबसे अधिक दिलचस्पी रखता था, जो कि जैसा कि आप नाम से अनुमान लगा सकते हैं, इसमें SIMD निर्देशों का उपयोग करके अनुकूलित फ़ंक्शन शामिल थे।
simd डायरेक्टरी में simd , simd स्पष्ट है कि SIMD निर्देशों के 4 वेरिएंट समर्थित हैं: SSE2 , AVX , AVX2 और FMA4 । फ़ंक्शन प्रोटोटाइप फ़ाइल sleefsimd.h में परिभाषित किए गए हैं, और निर्देशों के आवश्यक सेट को झंडे का उपयोग करके संकलन में चुना गया है -DENABLE_SSE2 , -DENABLE_AVX , -DENABLE_AVX2 या -DENABLE_FMA4 । iutsse2 प्रत्येक निर्देश सेट का उपयोग करके परीक्षण कार्यों के लिए निष्पादनयोग्य एकत्र करता है: iutsse2 , iutavx , iutavx2 या iutfma4 । इन फ़ाइलों को यूनिवर्सल टेस्टर प्रोग्राम ( tester डायरेक्टरी से) कहा जाता है और टेस्टर से प्राप्त कमांड को निष्पादित करता है। आदेशों का कार्यान्वयन iut.c फ़ाइल में है, जहां से लाइब्रेरी का उपयोग करने का तरीका स्पष्ट हो जाता है।

SLEEF स्रोत कोड में simd / iut.c फ़ाइल से साइन टेस्ट फ़ंक्शन

 double xxsin(double d) { double s[VECTLENDP]; int i; for(i=0;i<VECTLENDP;i++) { s[i] = random()/(double)RAND_MAX*20000-10000; } int idx = random() & (VECTLENDP-1); s[idx] = d; vdouble a = vloadu(s); a = xsin(a); vstoreu(s, a); return s[idx]; }

दोहरी सटीक संख्याओं के लिए, आपको लंबाई की एक सरणी को परिभाषित करना होगा VECTLENDP , उस फ़ंक्शन के तर्कों को भरें जिसमें हम रुचि रखते हैं, और इसे vloadu फ़ंक्शन को पास करें, जो उन्हें उस स्थान पर कॉपी करेगा जहां आपको SIMD का उपयोग करने और प्रकार vdouble का मान वापस करने की आवश्यकता है। हम vdouble फ़ंक्शन में xsin मान पास करते हैं, जो एक बार में सभी VECLENDP तर्कों के लिए साइन मान की गणना करता है और फिर से vdouble वापस करता है। परिणाम vstoreu फ़ंक्शन का उपयोग करके double से सरणी में vstoreu है।
उन लोगों के लिए जो अपनी मशीन पर SLEEF का परीक्षण करना चाहते हैं, मैं प्रोग्राम का पूरा स्रोत कोड देता हूं जो मैंने SLEEF का उपयोग करके SIMD का उपयोग करने से संभावित त्वरण का मूल्यांकन करने के लिए लिखा था।

SLEEF का उपयोग करके साइन गणना की गति का अनुमान लगाने का कार्यक्रम

 #include <stdio.h> #include <stdlib.h> #include <time.h> #include <math.h> #include "sleefsimd.h" #define TESTSIZE (VECTLENDP*10000000) double s[TESTSIZE]; double r1[TESTSIZE]; double r2[TESTSIZE]; #define COUNT 10 int main(int argc, char *argv[]) { int k, i; clock_t t1, t2; double time1, time2; double max, rmax; srandom(time(NULL)); for(i = 0; i < TESTSIZE; i++) { s[i] = random()/(double)RAND_MAX*20000-10000; } printf("Testing sin, %d values\n", TESTSIZE*COUNT); t1 = clock(); for(k = 0; k < COUNT; k++) { for(i = 0; i < TESTSIZE; i++) { r1[i] = sin(s[i]); } } t2 = clock(); time1 = (double)(t2 - t1)/CLOCKS_PER_SEC; printf("Finish sin, spent time = %lg sec\n\n", time1); printf("Testing xsin\n"); t1 = clock(); for(k = 0; k < COUNT; k++) { for(i = 0; i < TESTSIZE; i += VECTLENDP) { vdouble a = vloadu(s+i); a = xsin(a); vstoreu(r2+i, a); } } t2 = clock(); time2 = (double)(t2 - t1)/CLOCKS_PER_SEC; printf("Finish xsin, spent time = %lg sec\n\n", time2); printf("Speed ratio: %lf\n", time1/time2); max = r1[0] - r2[0]; rmax = (r1[0] - r2[0])/r1[0]; for(i = 0; i < TESTSIZE; i++) { double delta = (r1[i] - r2[i]); if(abs(delta) > abs(max)) max = delta; delta = (r1[i] - r2[i])/r1[i]; if(abs(delta) > abs(max)) rmax = delta; } printf("Max absolute delta: %lg, relative delta %lg\n", max, rmax); return 0; }

मेरे कंप्यूटर पर समर्थित कमांड का सबसे उन्नत सेट AVX है, इसलिए मैंने निम्नलिखित कमांड के साथ कार्यक्रम ( simd/speedtest.c स्रोत में simd/speedtest.c फ़ाइल में लिखा गया है) संकलित किया:

 gcc -O3 -Wall -Wno-unused -Wno-attributes -DENABLE_AVX -mavx speedtest.c sleefsimddp.c sleefsimdsp.c -o speedtest -lm

मुझे लगभग 4 बार त्वरण की उम्मीद थी, लेकिन परिणाम मेरी सारी उम्मीदों से अधिक हो गया:

 Testing sin, 400000000 values Finish sin, spent time = 14.95 sec Testing xsin Finish xsin, spent time = 1.31 sec Speed ratio: 11.412214 Max absolute delta: 5.55112e-17, relative delta 1.58441e-16

10 से अधिक बार त्वरण, एक प्रोसेसर कोर पर 2 · 10 ^-16 ( double स्वयं की सटीकता के आदेश की तुलना में) के सापेक्ष गणना त्रुटि के साथ! बेशक, एक वास्तविक अनुप्रयोग में, त्वरण कम होगा, लेकिन अपने स्वयं के खस्ता मॉड्यूल लिखने के लिए प्रेरणा पहले से ही पर्याप्त है।

सार्वभौमिक कार्यों के बारे में कुछ शब्द

संख्यात्मक रूप से, डेटा को बहुआयामी सरणियों के रूप में दर्शाया जाता है। सार्वभौमिक कार्य किसी भी आयाम के सरणियों के साथ तत्व द्वारा काम करते हैं, और कई मापदंडों के मामले में, उनका आयाम संयोग नहीं हो सकता है। एक सार्वभौमिक फ़ंक्शन के मापदंडों को विशेष नियमों (इसे ब्रॉडकास्टिंग कहा जाता है) के अनुसार पहले एक आयाम में घटाया जाता है, और फिर आवश्यक गणना को मूल रूप से किया जाता है। आउटपुट सबसे बड़े आयामों का एक सरणी है।
उदाहरण के लिए, एक ही ऐड फंक्शन (जो कि स्वचालित रूप से प्रयोग किया जाता है "सुन्न सरणियों के लिए ऑपरेटर" का उपयोग करते समय) आपको दो संख्याओं या एक-आयामी सरणियों को जोड़ने की अनुमति देता है, या किसी संख्या को एक सरणी या एक-आयामी सरणी को दो-आयामी एक में जोड़ने की अनुमति देता है।

उदाहरण

 >>> from numpy import array, add >>> add(1, 2) 3 >>> add(array([1,2]), array([4,5])) #       array([5, 7]) >>> add(array([1,2]), 1) #      (..   ) array([2, 3]) >>> add(array([[1,2],[3,4]]), array([1,2])) #      () array([[2, 4], [4, 6]])

अंग्रेजी में सुन्न पर अधिक विस्तृत जानकारी आधिकारिक दस्तावेज में , रूसी में पाई जा सकती है - उदाहरण के लिए यहां ।

हम एक सार्वभौमिक फ़ंक्शन और SIMD निर्देशों के साथ अपने संख्यात्मक मॉड्यूल लिखते हैं

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

एक खस्ता मॉड्यूल में साइन की गणना के लिए फ़ंक्शन

 static void double_xsin(char **args, npy_intp *dimensions, npy_intp* steps, void* data) { npy_intp i; npy_intp n = dimensions[0]; char *in = args[0], *out = args[1]; npy_intp in_step = steps[0], out_step = steps[1]; double tmp[VECTLENDP]; vdouble a; int slow_n = n % VECTLENDP; if(in_step != sizeof(double) || out_step != sizeof(double)) slow_n = n; for(i = 0; i < slow_n; i += VECTLENDP) { int j; for(j = 0; j < VECTLENDP && i + j < slow_n; j++) { tmp[j] = *(double *)in; in += in_step; } a = vloadu(tmp); a = xsin(a); vstoreu(tmp, a); for(j = 0; j < VECTLENDP && i + j < slow_n; j++) { *(double *)out = tmp[j]; out += out_step; } } if(n > slow_n) { double *in_array = (double *)in; double *out_array = (double *)out; for(i = 0; i < n - slow_n; i += VECTLENDP) { a = vloadu(in_array + i); a = xsin(a); vstoreu(out_array + i, a); } } }

इनपुट्स और आउटपुट के लिए पॉइंटर्स अरपी हमारे पास आर्ग्स ऐरे में हैं। हमारे मामले में, फ़ंक्शन में एक इनपुट और एक आउटपुट है, इसलिए इनपुट का पता args[0] , और आउटपुट args[1] । तत्वों की संख्या dimensions[0] को पारित की जाती dimensions[0] । इनपुट के माध्यम से नेविगेट करने के लिए, आपको पॉइंटर को steps[0] बढ़ाना होगा steps[0] , और आउटपुट पर, steps[1] (यह महत्वपूर्ण है कि पॉइंटर टाइप char , क्योंकि steps में बाइट्स में मान होते हैं)। दुर्भाग्य से, मैं खस्ताहाल दस्तावेज़ों में बयान नहीं पा सका कि steps में मान संगत डेटा प्रकारों के आकार के बराबर होना चाहिए, हालांकि एक प्रयोग से पता चला है कि मेरे सिस्टम पर नॉनज़रो आयाम के सरणियों के लिए यह नियम है। इसके उल्लंघन के मामले में, गणना धीमी हो जाएगी, क्योंकि tmp सरणी से तत्वों की अतिरिक्त प्रतिलिपि आवश्यक है।
संख्यात्मक में एक ही सार्वभौमिक फ़ंक्शन विभिन्न डेटा प्रकारों के साथ काम कर सकता है, लेकिन प्रत्येक डेटा प्रकार के लिए एक अलग सी-फ़ंक्शन लिखा जाता है। एक सार्वभौमिक फ़ंक्शन को पंजीकृत करते समय, हम समर्थित प्रकारों को इंगित करते हैं और इनपुट और आउटपुट प्रकारों के प्रत्येक संयोजन के लिए हम एक पॉइंटर को एक सी-फ़ंक्शन को पास करते हैं जो इस संयोजन के साथ काम करेगा:

 static PyUFuncGenericFunction funcs[] = {&double_xsin}; static char types[] = {NPY_DOUBLE, NPY_DOUBLE}; static void *data[] = {NULL};

types सरणी में इनपुट और आउटपुट दोनों प्रकार होते हैं, इसलिए यह funcs और data सरणियों से अधिक लंबा है। data पॉइंटर्स की एक सरणी प्रत्येक प्रकार के संयोजन के लिए अपने स्वयं के अतिरिक्त पैरामीटर को निर्दिष्ट करने की अनुमति देती है, जिसे अंतिम तर्क void* data रूप में सी-फ़ंक्शन को पास किया जाएगा। विशेष रूप से, इसका उपयोग एकल सी-फ़ंक्शन का उपयोग करके विभिन्न सार्वभौमिक कार्यों को लागू करने के लिए किया जा सकता है।
हमारे सार्वभौमिक फ़ंक्शन को पंजीकृत करने के लिए, आपको PyUFunc_FromFuncAndData पर कॉल PyUFunc_FromFuncAndData और इसके ऊपर दिए गए सरणियों को पास करने की आवश्यकता है ( funcs , data और types ), साथ ही सार्वभौमिक फ़ंक्शन के इनपुट और आउटपुट तर्कों की संख्या, समर्थित प्रकार संयोजनों की संख्या, मॉड्यूल में फ़ंक्शन का नाम और दस्तावेज़ लाइन।

पूर्ण मॉड्यूल स्रोत कोड

 #include "Python.h" #include "numpy/ndarraytypes.h" #include "numpy/ufuncobject.h" #include "numpy/npy_3kcompat.h" #include "sleef/sleefsimd.h" /* The loop definition must precede the PyMODINIT_FUNC. */ static void double_xsin(char **args, npy_intp *dimensions, npy_intp* steps, void* data) { npy_intp i; npy_intp n = dimensions[0]; char *in = args[0], *out = args[1]; npy_intp in_step = steps[0], out_step = steps[1]; double tmp[VECTLENDP]; vdouble a; int slow_n = n % VECTLENDP; if(in_step != sizeof(double) || out_step != sizeof(double)) slow_n = n; for(i = 0; i < slow_n; i += VECTLENDP) { int j; for(j = 0; j < VECTLENDP && i + j < slow_n; j++) { tmp[j] = *(double *)in; in += in_step; } a = vloadu(tmp); a = xsin(a); vstoreu(tmp, a); for(j = 0; j < VECTLENDP && i + j < slow_n; j++) { *(double *)out = tmp[j]; out += out_step; } } if(n > slow_n) { double *in_array = (double *)in; double *out_array = (double *)out; for(i = 0; i < n - slow_n; i += VECTLENDP) { a = vloadu(in_array + i); a = xsin(a); vstoreu(out_array + i, a); } } } static PyMethodDef AvxmathMethods[] = { {NULL, NULL, 0, NULL} }; static PyUFuncGenericFunction funcs[1] = {&double_xsin}; static char types[] = {NPY_DOUBLE, NPY_DOUBLE}; static void *data[] = {NULL}; void register_xsin(PyObject *module) { PyObject *xsin, *d; import_array(); import_umath(); xsin = PyUFunc_FromFuncAndData(funcs, data, types, 1, 1, 1, PyUFunc_None, "sin", "AVX-accelerated sine calculation", 0); d = PyModule_GetDict(module); PyDict_SetItemString(d, "sin", xsin); Py_DECREF(xsin); } #if PY_VERSION_HEX >= 0x03000000 static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, "avxmath", NULL, -1, AvxmathMethods, NULL, NULL, NULL, NULL }; PyMODINIT_FUNC PyInit_avxmath(void) { PyObject *m; m = PyModule_Create(&moduledef); if (!m) { return NULL; } register_xsin(m); return m; } #else PyMODINIT_FUNC initavxmath(void) { PyObject *m; m = Py_InitModule("avxmath", AvxmathMethods); if (m == NULL) { return; } register_xsin(m); } #endif

मॉड्यूल का निर्माण करने के लिए, मैंने प्रलेखन से मानक setup.py उपयोग किया, मॉड्यूल नाम की जगह और SLEEF लाइब्रेरी सी-फाइल्स, कंपाइलर और लिंकर झंडे को जोड़ना। मैंने avxmath.c नाम की फ़ाइल में avxmath.c आगे मॉड्यूल के स्रोत कोड को सहेजा, simd स्रोत कोड से sleef निर्देशिका का नाम बदलकर sleef दिया और साथ ही इसे setup.py बगल में रख दिया।

Avxmath मॉड्यूल बनाने के लिए Setup.py फ़ाइल

 def configuration(parent_package='', top_path=None): import numpy from numpy.distutils.misc_util import Configuration config = Configuration('', parent_package, top_path) config.add_extension('avxmath', ['avxmath.c', 'sleef/sleefsimddp.c', 'sleef/sleefsimdsp.c'], extra_compile_args=['-O3', '-Wall', '-Wno-unused', '-Wno-attributes', '-DENABLE_AVX','-mavx'], extra_link_args=['-lm']) return config if __name__ == "__main__": from numpy.distutils.core import setup setup(configuration=configuration)

सिस्टम में स्थापित किए बिना संकलित करने के लिए, आपको python setup.py build_ext --inplace को चलाने की आवश्यकता है, जिसके परिणामस्वरूप avxmath.so फ़ाइल में तैयार मॉड्यूल होना चाहिए। अब आप हमारे फ़ंक्शन की कार्यक्षमता की जांच कर सकते हैं। अजगर को उसी निर्देशिका में चलाएं जैसे avxmath.so फ़ाइल, और जांचें:

 >>> from numpy import array, pi >>> import avxmath >>> avxmath.sin(0) 0.0 >>> avxmath.sin(pi) 1.2246467991473532e-16 >>> avxmath.sin([0, pi/2, pi, 3*pi/2, 2*pi]) array([ 0.00000000e+00, 1.00000000e+00, 1.22464680e-16, -1.00000000e+00, -2.44929360e-16]) >>>

यह सुनिश्चित करने के बाद कि avxmath मॉड्यूल आयात किया गया है और त्रुटियों के बिना काम कर रहा है, आप नए फ़ंक्शन के प्रदर्शन और सटीकता का एक छोटा परीक्षण कर सकते हैं।

एवक्समैथ मॉड्यूल के पाप फ़ंक्शन और इसके निष्पादन के परिणाम की जांच करने का कार्यक्रम

 import numpy import avxmath import time from numpy import random, pi COUNT=10 x = 2e4*random.random(40000000) - 1e4 t = time.clock() for i in xrange(COUNT): y1 = numpy.sin(x) duration1 = time.clock() - t print "numpy.sin %f sec" % duration1 t = time.clock() for i in xrange(COUNT): y2 = avxmath.sin(x) duration2 = time.clock() - t print "avxmath.sin %f sec" % duration2 delta = y2 - y1 rdelta = delta/y1 print "max absolute difference is %lg, relative %lg" % ( delta[abs(delta).argmax()], rdelta[abs(rdelta).argmax()]) print "speedup is %lg" % (duration1/duration2)

 numpy.sin 15.510000 sec avxmath.sin 2.260000 sec max absolute difference is 2.22045e-16, relative 2.63873e-16 speedup is 6.86283

इसलिए, हमें गणना की सटीकता के साथ 6 गुना से अधिक का त्वरण मिला, जो 3 · 10 ^-16 से भी बदतर नहीं था! मेमोरी की एक सरल प्रतिलिपि के साथ xsin फ़ंक्शन xsin को xsin करना, यह सत्यापित करना आसान है कि 10 बार का त्वरण इस तथ्य के कारण काम नहीं करता था कि हमें प्राप्त 2.26 सेकंड में से लगभग 1 सेकंड ओवरहेड पर खर्च किया गया था। इसी प्रकार, xsin फ़ंक्शन को math.h से सामान्य साइन के xsin बदलने पर, हम पाते हैं कि हमारे परीक्षण में avxmath.sin और numpy.sin का उपयोग करके गणना समय उच्च सटीकता के साथ मेल खाता है।
इस प्रकार, SIMD निर्देशों का उपयोग करते हुए, आप साधारण कार्यों के आयात को स्वनिर्धारित लोगों के स्थान पर बदलकर, खसखस और छींटे का उपयोग करके की गई गणनाओं में काफी तेजी ला सकते हैं। और हां, इस लेख की तुलना में कुछ उन्नत के स्रोत कोड avxmath मॉड्यूल संदर्भ द्वारा avxmath पर उपलब्ध है।
अपडेट : 1e10 या अधिक के आदेश के तर्क मूल्यों के लिए SLEEF की साइन का उपयोग न करें ( टिप्पणी देखें)

SIMD निर्देशों का उपयोग करके गणित के कार्यों को गति देने के लिए एक खस्ता मॉड्यूल लिखना

SIMD निर्देशों के बारे में थोड़ा सा

प्रेरणा के लिए थोड़ा परीक्षण

सार्वभौमिक कार्यों के बारे में कुछ शब्द

हम एक सार्वभौमिक फ़ंक्शन और SIMD निर्देशों के साथ अपने संख्यात्मक मॉड्यूल लिखते हैं

More articles: