🚵🏽 😣 🚳 बेकार MPI में गैर-अवरुद्ध संदेश को स्थगित कर दिया: उन लोगों के लिए प्रकाश विश्लेषण और ट्यूटोरियल जो थोड़े "विषय में" हैं 👉🏻 😟 👨‍👧‍👧

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

हमारा "दिया:"

तो, हमारे कम्प्यूटेशनल कार्य का सार यह है कि कितनी बार एक प्रोग्राम जो गैर-अवरुद्ध विलंबित पॉइंट-टू-पॉइंट ट्रांसफर का उपयोग करता है, वह ब्लॉक-टू-पॉइंट ट्रांसफर का उपयोग करने वाले की तुलना में तेज़ है। हम आयाम 64, 256, 1024, 4096, 8192, 16384, 65536, 262144, 1048576, 4194304, 16777216, 33554432 तत्वों के इनपुट सरणियों के लिए मापन करेंगे। डिफ़ॉल्ट रूप से, इसे चार प्रक्रियाओं द्वारा हल करने का प्रस्ताव है। और यहाँ, वास्तव में, हम क्या विचार करेंगे:

आउटपुट पर, हमें तीन वैक्टर मिलना चाहिए: Y1, Y2 और Y3, जो शून्य प्रक्रिया एकत्र करेगा। मैं 16 जीबी रैम के साथ इंटेल प्रोसेसर पर आधारित इस पूरी चीज का अपने सिस्टम पर परीक्षण करूंगा। कार्यक्रमों को विकसित करने के लिए, हम Microsoft संस्करण 9.0.1 (लेखन के समय, यह प्रासंगिक है), Visual Studio सामुदायिक 2017 और फ़ोर्टन से MPI मानक के कार्यान्वयन का उपयोग करेंगे।

materiel

मैं विस्तार से वर्णन नहीं करना चाहूंगा कि एमपीआई के कार्यों का उपयोग किस प्रकार किया जाएगा, आप हमेशा इसके लिए प्रलेखन पर जा सकते हैं और देख सकते हैं, इसलिए मैं केवल एक संक्षिप्त अवलोकन दूंगा कि हम क्या उपयोग करेंगे।

विनिमय अवरुद्ध

पॉइंट-टू-पॉइंट मैसेजिंग को ब्लॉक करने के लिए, हम फ़ंक्शन का उपयोग करेंगे:

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

गैर-अवरुद्ध विनिमय को स्थगित कर दिया

गैर-अवरोधक बिंदु-से-बिंदु संदेश के लिए, हम कार्यों का उपयोग करेंगे:

MPI_Send_init - पृष्ठभूमि में डेटा भेजने के लिए वातावरण तैयार करता है जो कुछ भविष्य में होगा और कोई ताले नहीं;
MPI_Recv_init - यह फ़ंक्शन पिछले एक के समान काम करता है, केवल इस बार डेटा प्राप्त करने के लिए;
MPI_Start - संदेश प्राप्त करने या प्रसारित करने की प्रक्रिया शुरू करता है, यह a.k.a की पृष्ठभूमि में भी चलता है। बिना अवरोध के;
MPI_Wait - का उपयोग चेक करने के लिए किया जाता है और यदि आवश्यक हो, तो संदेश भेजने या प्राप्त करने के पूरा होने की प्रतीक्षा करें, लेकिन यह आवश्यक होने पर प्रक्रिया को रोक देता है (यदि डेटा "भेजा नहीं गया" या "प्राप्त नहीं हुआ")। उदाहरण के लिए, एक प्रक्रिया डेटा का उपयोग करना चाहती है जो अभी तक नहीं पहुंची है - अच्छा नहीं है, इसलिए, उस जगह के सामने MPI_Wait डालें जहां उसे इस डेटा की आवश्यकता होती है (इसे डालें भले ही डेटा भ्रष्टाचार का खतरा हो)। एक और उदाहरण, प्रक्रिया ने पृष्ठभूमि डेटा हस्तांतरण शुरू किया, और डेटा स्थानांतरण शुरू करने के बाद, उसने तुरंत इस डेटा को किसी तरह बदलना शुरू कर दिया - अच्छा नहीं है, इसलिए हम प्रोग्राम में उस स्थान के सामने MPI_Wit डालें जहां यह इस डेटा को बदलना शुरू करता है (यहां इसे सम्मिलित करें भले ही बस डेटा भ्रष्टाचार का खतरा है)।

इस प्रकार, शब्दार्थ गैर-अवरुद्ध विनिमय के साथ कॉल का क्रम इस प्रकार है:

MPI_Send_init / MPI_Recv_init - प्राप्त करने या प्रसारित करने के लिए वातावरण तैयार करना
MPI_Start - प्राप्त / संचारण की प्रक्रिया शुरू करें
MPI_Wait - हम संचारित या डेटा डेटा के नुकसान ("अंडरसेंडिंग" और "अंडरपोर्टिंग" सहित) के जोखिम को बुलाते हैं

मैंने अपने परीक्षण कार्यक्रमों में MPI_Startall , MPI_Waitall का भी उपयोग किया, उनका अर्थ मूल रूप से क्रमशः MPI_Start और MPI_Wait के समान है, केवल वे कई पैकेजों और / या प्रसारणों पर काम करते हैं। लेकिन यह प्रारंभ और प्रतीक्षा कार्यों की पूरी सूची नहीं है, संचालन की पूर्णता की जांच के लिए कई और कार्य हैं।

अंतर-प्रक्रिया वास्तुकला

स्पष्टता के लिए, हम चार प्रक्रियाओं द्वारा गणना करने के लिए एक ग्राफ का निर्माण करते हैं। इस मामले में, किसी को सभी वेक्टर अंकगणितीय कार्यों को प्रक्रियाओं पर समान रूप से समान रूप से वितरित करने का प्रयास करना चाहिए। यहाँ मुझे क्या मिला है:

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

खैर, हमने आखिर सवालों का जवाब कब दिया:

हम किस तरह की समस्या को हल कर रहे हैं?
इसे हल करने के लिए हम किन उपकरणों का उपयोग करेंगे?
हम इसे कैसे हल करेंगे?

यह केवल इसे हल करने के लिए बनी हुई है ...

हमारा "समाधान:"

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

मैंने कोड की पठनीयता को बढ़ाने के लिए सभी वेक्टर अंकगणितीय ऑपरेशनों को अलग-अलग प्रक्रियाओं (ऐड, सब, म्यू, डिव) में निकाला। सभी इनपुट सरणियों को उन फ़ार्मुलों के अनुसार आरम्भ किया जाता है जिन्हें मैंने लगभग यादृच्छिक रूप से इंगित किया था। चूंकि शून्य प्रक्रिया अन्य सभी प्रक्रियाओं से काम के परिणामों को इकट्ठा करती है, इसलिए, यह सबसे लंबे समय तक काम करता है, इसलिए यह कार्यक्रम के रनटाइम के बराबर अपने काम के समय पर विचार करना तर्कसंगत है (जैसा कि हम याद करते हैं, हम पहले और दूसरे मामलों में: अंकगणितीय / मैसेजिंग में रुचि रखते हैं)। हम MPI_WIME फ़ंक्शन का उपयोग करके समय अंतराल को मापेंगे, और साथ ही मैंने यह प्रदर्शित करने का निर्णय लिया कि मैंने MPI_Wtick (कहीं न कहीं मेरी आत्मा का उपयोग करते हुए घड़ियों का क्या संकल्प लिया है, मुझे आशा है कि वे मेरे आक्रामक टीएससी में फिट होंगे, इस मामले में, मैं उन्हें त्रुटि को माफ करने के लिए भी तैयार हूं। समय के साथ जुड़े समारोह को MPI_WIME कहा जाता था)। इसलिए, हम उन सभी को एक साथ रखेंगे जो मैंने ऊपर लिखे थे और ग्राफ के अनुसार हम अंत में इन कार्यक्रमों को विकसित करेंगे (और निश्चित रूप से डिबग भी)।

कोड को देखने की किसे परवाह है:

ब्लॉकिंग डेटा ट्रांसफर वाला प्रोग्राम

#include "pch.h" #include <iostream> #include <iomanip> #include <fstream> #include <mpi.h> using namespace std; void add(double *A, double *B, double *C, int n); void sub(double *A, double *B, double *C, int n); void mul(double *A, double *B, double *C, int n); void div(double *A, double *B, double *C, int n); int main(int argc, char **argv) { if (argc < 2) { return 1; } int n = atoi(argv[1]); int rank; double start_time, end_time; MPI_Status status; double *A = new double[n]; double *B = new double[n]; double *C = new double[n]; double *D = new double[n]; double *E = new double[n]; double *G = new double[n]; double *T0 = new double[n]; double *T1 = new double[n]; double *T2 = new double[n]; for (int i = 0; i < n; i++) { A[i] = double (2 * i + 1); B[i] = double(2 * i); C[i] = double(0.003 * (i + 1)); D[i] = A[i] * 0.001; E[i] = B[i]; G[i] = C[i]; } cout.setf(ios::fixed); cout << fixed << setprecision(9); MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); if (rank == 0) { start_time = MPI_Wtime(); sub(A, B, T0, n); MPI_Send(T0, n, MPI_DOUBLE, 1, 0, MPI_COMM_WORLD); MPI_Send(T0, n, MPI_DOUBLE, 2, 0, MPI_COMM_WORLD); div(T0, G, T1, n); MPI_Recv(T2, n, MPI_DOUBLE, 1, 0, MPI_COMM_WORLD, &status); add(T1, T2, T0, n); mul(T0, T1, T2, n); MPI_Recv(T0, n, MPI_DOUBLE, 2, 0, MPI_COMM_WORLD, &status); MPI_Send(T2, n, MPI_DOUBLE, 1, 0, MPI_COMM_WORLD); add(T0, T2, T1, n); MPI_Recv(T0, n, MPI_DOUBLE, 1, 0, MPI_COMM_WORLD, &status); MPI_Recv(T2, n, MPI_DOUBLE, 2, 0, MPI_COMM_WORLD, &status); end_time = MPI_Wtime(); cout << "Clock resolution: " << MPI_Wtick() << " secs" << endl; cout << "Thread " << rank << " execution time: " << end_time - start_time << endl; } if (rank == 1) { add(C, C, T0, n); MPI_Recv(T1, n, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &status); MPI_Send(T0, n, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD); mul(T1, G, T2, n); add(T2, C, T0, n); MPI_Recv(T1, n, MPI_DOUBLE, 2, 0, MPI_COMM_WORLD, &status); MPI_Send(T0, n, MPI_DOUBLE, 2, 0, MPI_COMM_WORLD); sub(T1, T0, T2, n); MPI_Recv(T0, n, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &status); add(T0, T2, T1, n); MPI_Send(T1, n, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD); } if (rank == 2) { mul(C, C, T0, n); MPI_Recv(T1, n, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &status); MPI_Recv(T2, n, MPI_DOUBLE, 3, 0, MPI_COMM_WORLD, &status); MPI_Send(T0, n, MPI_DOUBLE, 1, 0, MPI_COMM_WORLD); MPI_Send(T0, n, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD); add(T1, T2, T0, n); mul(T0, G, T1, n); MPI_Recv(T2, n, MPI_DOUBLE, 1, 0, MPI_COMM_WORLD, &status); mul(T1, T2, T0, n); MPI_Recv(T1, n, MPI_DOUBLE, 3, 0, MPI_COMM_WORLD, &status); mul(T0, T1, T2, n); MPI_Send(T2, n, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD); } if (rank == 3) { mul(E, D, T0, n); MPI_Send(T0, n, MPI_DOUBLE, 2, 0, MPI_COMM_WORLD); sub(T0, B, T1, n); mul(T1, T1, T2, n); sub(T1, G, T0, n); mul(T0, T2, T1, n); MPI_Send(T1, n, MPI_DOUBLE, 2, 0, MPI_COMM_WORLD); } MPI_Finalize(); delete[] A; delete[] B; delete[] C; delete[] D; delete[] E; delete[] G; delete[] T0; delete[] T1; delete[] T2; return 0; } void add(double *A, double *B, double *C, int n) { for (size_t i = 0; i < n; i++) { C[i] = A[i] + B[i]; } } void sub(double *A, double *B, double *C, int n) { for (size_t i = 0; i < n; i++) { C[i] = A[i] - B[i]; } } void mul(double *A, double *B, double *C, int n) { for (size_t i = 0; i < n; i++) { C[i] = A[i] * B[i]; } } void div(double *A, double *B, double *C, int n) { for (size_t i = 0; i < n; i++) { C[i] = A[i] / B[i]; } }

आस्थगित गैर-अवरुद्ध डेटा हस्तांतरण के साथ कार्यक्रम

 #include "pch.h" #include <iostream> #include <iomanip> #include <fstream> #include <mpi.h> using namespace std; void add(double *A, double *B, double *C, int n); void sub(double *A, double *B, double *C, int n); void mul(double *A, double *B, double *C, int n); void div(double *A, double *B, double *C, int n); int main(int argc, char **argv) { if (argc < 2) { return 1; } int n = atoi(argv[1]); int rank; double start_time, end_time; MPI_Request request[7]; MPI_Status statuses[4]; double *A = new double[n]; double *B = new double[n]; double *C = new double[n]; double *D = new double[n]; double *E = new double[n]; double *G = new double[n]; double *T0 = new double[n]; double *T1 = new double[n]; double *T2 = new double[n]; for (int i = 0; i < n; i++) { A[i] = double(2 * i + 1); B[i] = double(2 * i); C[i] = double(0.003 * (i + 1)); D[i] = A[i] * 0.001; E[i] = B[i]; G[i] = C[i]; } cout.setf(ios::fixed); cout << fixed << setprecision(9); MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); if (rank == 0) { start_time = MPI_Wtime(); MPI_Send_init(T0, n, MPI_DOUBLE, 1, 0, MPI_COMM_WORLD, &request[0]);// MPI_Send_init(T0, n, MPI_DOUBLE, 2, 0, MPI_COMM_WORLD, &request[1]);// MPI_Recv_init(T2, n, MPI_DOUBLE, 1, 0, MPI_COMM_WORLD, &request[2]);// MPI_Recv_init(T0, n, MPI_DOUBLE, 2, 0, MPI_COMM_WORLD, &request[3]);// MPI_Send_init(T2, n, MPI_DOUBLE, 1, 0, MPI_COMM_WORLD, &request[4]);// MPI_Recv_init(T0, n, MPI_DOUBLE, 1, 0, MPI_COMM_WORLD, &request[5]);// MPI_Recv_init(T2, n, MPI_DOUBLE, 2, 0, MPI_COMM_WORLD, &request[6]);// MPI_Start(&request[2]); sub(A, B, T0, n); MPI_Startall(2, &request[0]); div(T0, G, T1, n); MPI_Waitall(3, &request[0], statuses); add(T1, T2, T0, n); mul(T0, T1, T2, n); MPI_Startall(2, &request[3]); MPI_Wait(&request[3], &statuses[0]); add(T0, T2, T1, n); MPI_Startall(2, &request[5]); MPI_Wait(&request[4], &statuses[0]); MPI_Waitall(2, &request[5], statuses); end_time = MPI_Wtime(); cout << "Clock resolution: " << MPI_Wtick() << " secs" << endl; cout << "Thread " << rank << " execution time: " << end_time - start_time << endl; } if (rank == 1) { MPI_Recv_init(T1, n, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &request[0]);// MPI_Send_init(T0, n, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &request[1]);// MPI_Recv_init(T1, n, MPI_DOUBLE, 2, 0, MPI_COMM_WORLD, &request[2]);// MPI_Send_init(T0, n, MPI_DOUBLE, 2, 0, MPI_COMM_WORLD, &request[3]);// MPI_Recv_init(T0, n, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &request[4]);// MPI_Send_init(T1, n, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &request[5]);// MPI_Start(&request[0]); add(C, C, T0, n); MPI_Start(&request[1]); MPI_Wait(&request[0], &statuses[0]); mul(T1, G, T2, n); MPI_Start(&request[2]); MPI_Wait(&request[1], &statuses[0]); add(T2, C, T0, n); MPI_Start(&request[3]); MPI_Wait(&request[2], &statuses[0]); sub(T1, T0, T2, n); MPI_Wait(&request[3], &statuses[0]); MPI_Start(&request[4]); MPI_Wait(&request[4], &statuses[0]); add(T0, T2, T1, n); MPI_Start(&request[5]); MPI_Wait(&request[5], &statuses[0]); } if (rank == 2) { MPI_Recv_init(T1, n, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &request[0]);// MPI_Recv_init(T2, n, MPI_DOUBLE, 3, 0, MPI_COMM_WORLD, &request[1]);// MPI_Send_init(T0, n, MPI_DOUBLE, 1, 0, MPI_COMM_WORLD, &request[2]);// MPI_Send_init(T0, n, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &request[3]);// MPI_Recv_init(T2, n, MPI_DOUBLE, 1, 0, MPI_COMM_WORLD, &request[4]);// MPI_Recv_init(T1, n, MPI_DOUBLE, 3, 0, MPI_COMM_WORLD, &request[5]);// MPI_Send_init(T2, n, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &request[6]);// MPI_Startall(2, &request[0]); mul(C, C, T0, n); MPI_Startall(2, &request[2]); MPI_Waitall(4, &request[0], statuses); add(T1, T2, T0, n); MPI_Start(&request[4]); mul(T0, G, T1, n); MPI_Wait(&request[4], &statuses[0]); mul(T1, T2, T0, n); MPI_Start(&request[5]); MPI_Wait(&request[5], &statuses[0]); mul(T0, T1, T2, n); MPI_Start(&request[6]); MPI_Wait(&request[6], &statuses[0]); } if (rank == 3) { MPI_Send_init(T0, n, MPI_DOUBLE, 2, 0, MPI_COMM_WORLD, &request[0]); MPI_Send_init(T1, n, MPI_DOUBLE, 2, 0, MPI_COMM_WORLD, &request[1]); mul(E, D, T0, n); MPI_Start(&request[0]); sub(T0, B, T1, n); mul(T1, T1, T2, n); MPI_Wait(&request[0], &statuses[0]); sub(T1, G, T0, n); mul(T0, T2, T1, n); MPI_Start(&request[1]); MPI_Wait(&request[1], &statuses[0]); } MPI_Finalize(); delete[] A; delete[] B; delete[] C; delete[] D; delete[] E; delete[] G; delete[] T0; delete[] T1; delete[] T2; return 0; } void add(double *A, double *B, double *C, int n) { for (size_t i = 0; i < n; i++) { C[i] = A[i] + B[i]; } } void sub(double *A, double *B, double *C, int n) { for (size_t i = 0; i < n; i++) { C[i] = A[i] - B[i]; } } void mul(double *A, double *B, double *C, int n) { for (size_t i = 0; i < n; i++) { C[i] = A[i] * B[i]; } } void div(double *A, double *B, double *C, int n) { for (size_t i = 0; i < n; i++) { C[i] = A[i] / B[i]; } }

परीक्षण और विश्लेषण

आइए विभिन्न आकारों के सरणियों के लिए हमारे कार्यक्रम चलाएं और देखें कि क्या होता है। परीक्षण के परिणामों को तालिका में संक्षेपित किया गया है, जिसके अंतिम स्तंभ में हम त्वरण गुणांक की गणना करते हैं और लिखते हैं, जिसे हम निम्नानुसार परिभाषित करते हैं: K _accele = T _ex। _neblok। / टी _{ब्लॉक।}

यदि आप इस तालिका को सामान्य से थोड़ा अधिक ध्यान से देखते हैं, तो आप देखेंगे कि संसाधित तत्वों की संख्या में वृद्धि के साथ, त्वरण गुणांक इस तरह से किसी भी तरह कम हो जाता है:

आइए यह निर्धारित करने की कोशिश करें कि मामला क्या है? ऐसा करने के लिए, मैं एक छोटा परीक्षण कार्यक्रम लिखने का प्रस्ताव करता हूं जो प्रत्येक वेक्टर अंकगणितीय ऑपरेशन के समय को मापेगा और परिणामों को ध्यान से एक साधारण पाठ फ़ाइल में कम करेगा।

यहाँ, वास्तव में, कार्यक्रम ही:

समय का मापन

 #include "pch.h" #include <iostream> #include <iomanip> #include <Windows.h> #include <fstream> using namespace std; void add(double *A, double *B, double *C, int n); void sub(double *A, double *B, double *C, int n); void mul(double *A, double *B, double *C, int n); void div(double *A, double *B, double *C, int n); int main() { struct res { double add; double sub; double mul; double div; }; int i, j, k, n, loop; LARGE_INTEGER start_time, end_time, freq; ofstream fout("test_measuring.txt"); int N[12] = { 64, 256, 1024, 4096, 8192, 16384, 65536, 262144, 1048576, 4194304, 16777216, 33554432 }; SetConsoleOutputCP(1251); cout << "   loop: "; cin >> loop; fout << setiosflags(ios::fixed) << setiosflags(ios::right) << setprecision(9); fout << " : " << loop << endl; fout << setw(10) << "\n " << setw(30) << ".   (c)" << setw(30) << ".   (c)" << setw(30) << ".  (c)" << setw(30) << ".   (c)" << endl; QueryPerformanceFrequency(&freq); cout << "\n : " << freq.QuadPart << " " << endl; for (k = 0; k < sizeof(N) / sizeof(int); k++) { res output = {}; n = N[k]; double *A = new double[n]; double *B = new double[n]; double *C = new double[n]; for (i = 0; i < n; i++) { A[i] = 2.0 * i; B[i] = 2.0 * i + 1; C[i] = 0; } for (j = 0; j < loop; j++) { QueryPerformanceCounter(&start_time); add(A, B, C, n); QueryPerformanceCounter(&end_time); output.add += double(end_time.QuadPart - start_time.QuadPart) / double(freq.QuadPart); QueryPerformanceCounter(&start_time); sub(A, B, C, n); QueryPerformanceCounter(&end_time); output.sub += double(end_time.QuadPart - start_time.QuadPart) / double(freq.QuadPart); QueryPerformanceCounter(&start_time); mul(A, B, C, n); QueryPerformanceCounter(&end_time); output.mul += double(end_time.QuadPart - start_time.QuadPart) / double(freq.QuadPart); QueryPerformanceCounter(&start_time); div(A, B, C, n); QueryPerformanceCounter(&end_time); output.div += double(end_time.QuadPart - start_time.QuadPart) / double(freq.QuadPart); } fout << setw(10) << n << setw(30) << output.add / loop << setw(30) << output.sub / loop << setw(30) << output.mul / loop << setw(30) << output.div / loop << endl; delete[] A; delete[] B; delete[] C; } fout.close(); cout << endl; system("pause"); return 0; } void add(double *A, double *B, double *C, int n) { for (size_t i = 0; i < n; i++) { C[i] = A[i] + B[i]; } } void sub(double *A, double *B, double *C, int n) { for (size_t i = 0; i < n; i++) { C[i] = A[i] - B[i]; } } void mul(double *A, double *B, double *C, int n) { for (size_t i = 0; i < n; i++) { C[i] = A[i] * B[i]; } } void div(double *A, double *B, double *C, int n) { for (size_t i = 0; i < n; i++) { C[i] = A[i] / B[i]; } }

स्टार्टअप पर, यह आपको माप चक्रों की संख्या दर्ज करने के लिए कहता है, मैंने 10,000 चक्रों का परीक्षण किया। आउटपुट पर, हम प्रत्येक ऑपरेशन के लिए औसत परिणाम प्राप्त करते हैं:

समय को मापने के लिए, मैंने उच्च-स्तरीय QueryPerformanceCounter का उपयोग किया। मैं दृढ़ता से इस FAQ को पढ़ने की सलाह देता हूं ताकि इस फ़ंक्शन के साथ समय को मापने के अधिकांश प्रश्न स्वयं से गायब हो जाएं। मेरी टिप्पणियों के अनुसार, यह टीएससी से जुड़ा हुआ है (लेकिन सैद्धांतिक रूप से यह इसके लिए नहीं हो सकता है), लेकिन रिटर्न, मदद के अनुसार, काउंटर की टिक की वर्तमान संख्या। लेकिन तथ्य यह है कि मेरा काउंटर शारीरिक रूप से 32 एनएस के समय अंतराल को माप नहीं सकता है (परिणाम तालिका की पहली पंक्ति देखें)। यह परिणाम इस तथ्य के कारण है कि QueryPerformanceCounter की दो कॉलों के बीच 0 टिक या 1 टिक गुजरती हैं। तालिका में पहली पंक्ति के लिए, हम केवल यह निष्कर्ष निकाल सकते हैं कि 10,000 परिणामों में से लगभग एक तिहाई 1 टिक हैं। तो 64, 256 और यहां तक कि 1024 तत्वों के लिए इस तालिका में डेटा कुछ अनुमानित है। अब, किसी भी प्रोग्राम को खोलते हैं और गणना करते हैं कि प्रत्येक प्रकार के कुल संचालन का सामना होता है, परंपरागत रूप से हम अगले तालिका के अनुसार सब कुछ "फैल" करेंगे:

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

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

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

परिणाम

इस प्रकार, सरणियों की लंबाई में वृद्धि जारी रखने के लिए, आप इस निष्कर्ष पर पहुंचेंगे कि आस्थगित गैर-अवरुद्ध स्थानान्तरण के साथ एक कार्यक्रम केवल अवरुद्ध विनिमय का उपयोग करने वाले की तुलना में बहुत कम तेजी से होगा। और यदि आप सरणियों की लंबाई को अनंत तक ले जाते हैं (अच्छी तरह से, या बस बहुत लंबी सरणियां लेते हैं), तो आपके कार्यक्रम का संचालन समय 100% गणना द्वारा निर्धारित किया जाएगा, और त्वरण गुणांक सुरक्षित रूप से 1 तक पहुंच जाएगा।