कैसे और क्यों FLOPS को मापने के लिए

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


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

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

व्यावहारिक माप लिनपैक बेंचमार्क लॉन्च करना है। बेंचमार्क मैट्रिक्स के गुणा को कई दसियों गुना करने के संचालन को निष्पादित करता है और परीक्षण निष्पादन समय के औसत मूल्य की गणना करता है। चूंकि एल्गोरिथ्म के कार्यान्वयन में एफपी संचालन की संख्या अग्रिम में ज्ञात है, एक मूल्य को दूसरे से विभाजित करके, हम वांछित FLOPS प्राप्त करते हैं। Intel MKL लाइब्रेरी (गणित कर्नेल लाइब्रेरी) में LAPACK पैकेज, रैखिक बीजगणित की समस्याओं को हल करने के लिए पुस्तकालयों का एक पैकेज है। बेंचमार्क इसी पैकेज के आधार पर बनाया गया है। यह माना जाता है कि इसकी प्रभावशीलता सैद्धांतिक रूप से संभव के 90% के स्तर पर है, जो बेंचमार्क को "संदर्भ माप" माना जाता है। Windows, Linux और MacOS के लिए अलग-अलग, Intel Optimized LINPACK बेंचमार्क डाउनलोड किया जा सकता है , या कंपोज़रक्स / mkl / बेंचमार्क निर्देशिका में लिया जा सकता है, यदि आपके पास Intel Parallel Studio XE स्थापित है।

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



ठीक है, अब चलो उन विवरणों में तल्लीन करते हैं, जैसा कि आप जानते हैं, सभी बुराई। हमारे पास तीन FLOPS रेटिंग / माप हैं: सैद्धांतिक, बेंचमार्क और प्रोग्राम। प्रत्येक मामले के लिए FLOPS कंप्यूटिंग की सुविधाओं पर विचार करें।

एक प्रणाली के लिए FLOPS का सैद्धांतिक मूल्यांकन
यह समझने के लिए कि प्रोसेसर में एक साथ संचालन की संख्या की गणना कैसे की जाती है, आइए इंटेल सैंडी ब्रिज प्रोसेसर की पाइपलाइन में आउट-ऑफ-ऑर्डर ब्लॉक डिवाइस पर एक नज़र डालें।



यहां हमारे पास कंप्यूटिंग डिवाइस के लिए 6 पोर्ट हैं, और, एक चक्र (या प्रोसेसर साइकिल) में, डिस्पैचर को 6 माइक्रोएपरेशंस: 3 मेमोरी ऑपरेशन और 3 कंप्यूटिंग वाले को सौंपा जा सकता है। एक गुणन ऑपरेशन ( MUL ) और एक जोड़ ( ADD ) को एक साथ X87 FP इकाइयों और SSE या AVX दोनों में किया जा सकता है। 256 बिट SIMD रजिस्टरों की चौड़ाई को देखते हुए, हम निम्नलिखित परिणाम प्राप्त कर सकते हैं:



8 MUL (32-बिट) और 8 ADD (32-बिट): 16 SP FLOP / चक्र , यानी प्रति चक्र में 16 एकल सटीक फ़्लोटिंग पॉइंट ऑपरेशन।
4 एमयूएल (64-बिट) और 4 एडीडी (64-बिट): 8 डीपी फ्लॉप / चक्र , यानी प्रति चक्र 8 डबल सटीक फ़्लोटिंग-पॉइंट ऑपरेशन।

मेरे 1-सॉकेट Xeon E3-1275 (4 कोर @ 3.574GHz) के लिए सैद्धांतिक शिखर FLOPS है:
16 (FLOP / चक्र) * 4 * 3.574 (Gcycles / sec) = 228 GFLOPS SP
8 (FLOP / चक्र) * 4 * 3.574 (Gcycles / sec) = 114 GFLOPS DP

लिनपैक बेंचमार्क लॉन्च करें
सिस्टम पर Intel MKL पैकेज से बेंचमार्क चलता है और हमें निम्न परिणाम मिलते हैं (आसान देखने के लिए कट)



यहां यह कहना आवश्यक है कि बेंचमार्क में एफपी संचालन को कैसे ध्यान में रखा जाता है। जैसा कि पहले ही उल्लेख किया गया है, परीक्षण MUL और ADD संचालन की संख्या को पहले से जानता है जो मैट्रिक्स गुणा के लिए आवश्यक हैं। एक सरलीकृत दृश्य में: रेखीय समीकरणों की प्रणाली एक्स = बी को हल किया गया है (कई हजार टुकड़े) आकार एमएक्सके की वास्तविक संख्या (रियल 8) के घने मैट्रिक्स को गुणा करके, और एल्गोरिथ्म को लागू करने के लिए आवश्यक अतिरिक्त और गुणा संचालन की संख्या को माना जाता है (एक सममित मैट्रिक्स के लिए) एनएफएलपी = 2 * (M ^ 3) + (M ^ 2)। अधिकांश बेंचमार्क के लिए गणना डबल-सटीक संख्याओं के लिए की जाती है। एक फ्लोटिंग पॉइंट के साथ कितने ऑपरेशन वास्तव में एल्गोरिथ्म के कार्यान्वयन में किए जाते हैं, उपयोगकर्ताओं को परवाह नहीं है, हालांकि वे अनुमान लगाते हैं कि अधिक। यह इस तथ्य के कारण है कि एक कंप्यूटिंग प्लेटफॉर्म पर अधिकतम एल्गोरिथ्म प्रदर्शन प्राप्त करने के लिए ब्लॉक और ट्रांसफॉर्मेशन (फैक्टराइजेशन) में मैट्रिक्स अपघटन किया जाता है। यही है, हमें यह याद रखने की जरूरत है कि वास्तव में फिजिकल एफएलओपीएस का मूल्य कम करके आंका जाता है, क्योंकि यह अनावश्यक रूप से रूपांतरण संचालन और सहायक परिचालन जैसे कि पारियों की उपेक्षा करता है।

FLOPS प्रोग्राम का मूल्यांकन
तुलनीय परिणामों का पता लगाने के लिए, हम एमकेएल प्रदर्शन पुस्तकालय विकास टीम से गणितीय गुरुओं की सहायता के बिना, हमारे उच्च-प्रदर्शन एप्लिकेशन के रूप में, स्वयं-मैट्रिक्स मैट्रिक्स गुणन उदाहरण का उपयोग करेंगे। C में लिखे मैट्रिक्स गुणन के कार्यान्वयन का एक उदाहरण Intel VTune एम्पलीफायर XE पैकेज के नमूने निर्देशिका में पाया जा सकता है। हम एफपी संचालन (मूल मैट्रिक्स गुणन एल्गोरिथ्म के आधार पर) की गणना करने के लिए सूत्र Nflop = 2 * (M ^ 3) का उपयोग करते हैं और सममित मैट्रिक्स के आकार = 4096 के साथ multiply3 एल्गोरिथ्म के मामले में गुणा के समय को मापते हैं। एक कुशल कोड प्राप्त करने के लिए, हम AVX एक्ट्यूएटर्स के लिए वेक्टर SIMD निर्देश उत्पन्न करने के लिए इंटेल C- कंपाइलर के अनुकूलन विकल्प -O3 (आक्रामक लूप ऑप्टिमाइज़ेशन) और –xavx (एवीएक्स निर्देशों का उपयोग करें) का उपयोग करते हैं। संकलक हमें यह पता लगाने में मदद करेगा कि क्या मैट्रिक्स गुणन चक्र को वेक्टर किया गया है। ऐसा करने के लिए, –vec-report3 विकल्प निर्दिष्ट करें। संकलन परिणामों में हम आशावादी संदेश देखते हैं: "LOOP WAS VECTORIZED" लाइन के विपरीत इनर लूप के शरीर के साथ multiply.c फ़ाइल में है।



बस मामले में, हम जांचेंगे कि गुणक चक्र के लिए संकलक द्वारा कौन से निर्देश उत्पन्न किए गए हैं।
$ icl -g -O3 –xavx –S
टैग __tag_value_multiply3 द्वारा हम वांछित चक्र की तलाश कर रहे हैं - निर्देश सही हैं।

$ vi muliply3.s


कार्यक्रम का परिणाम (~ 7 सेकंड)


हमें निम्न मूल्य देता है FLOPS = 2 * 4096 * 4096 * 4096/7 [s] = 19.6 GFLOPS
परिणाम, ज़ाहिर है, लिनपैक में प्राप्त की गई चीज़ों से बहुत दूर है, जिसे केवल लेख के लेखक और एमकेएल पुस्तकालय के डेवलपर्स के बीच योग्यता अंतर द्वारा समझाया गया है।

खैर, अब मिठाई! असल में, मैंने इस उबाऊ और लंबे-पीटे विषय पर अपना शोध शुरू किया। FLOPS को मापने की एक नई विधि।

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

एक आसान तरीका का विचार इस प्रकार है। प्रोसेसर से यह क्यों नहीं पूछा कि उसने कितने एफपी निर्देश पूरे किए हैं। प्रोसेसर पाइपलाइन, निश्चित रूप से, इस से अनजान है। लेकिन हमारे पास प्रदर्शन काउंटर (पीएमयू - यहां यह उनके बारे में दिलचस्प है) जो यह गणना कर सकते हैं कि एक या दो कंप्यूटिंग यूनिट पर कितने माइक्रो-ऑपरेशन किए गए थे। VTune एम्पलीफायर XE ऐसे काउंटरों के साथ काम कर सकता है।

इस तथ्य के बावजूद कि वीट्यून के कई अंतर्निहित प्रोफाइल हैं, यह अभी तक FLOPS को मापने के लिए एक विशेष प्रोफ़ाइल नहीं है। लेकिन कोई भी हमें 30 सेकंड में अपना यूजर प्रोफाइल बनाने से नहीं रोक रहा है। VTune इंटरफ़ेस के साथ काम करने की मूल बातें से आपको परेशान किए बिना (आप उन्हें प्रारंभ करना ट्यूटोरियल में साथ सीख सकते हैं), मैं तुरंत एक प्रोफ़ाइल बनाने और डेटा एकत्र करने की प्रक्रिया का वर्णन करूंगा।

1. हम एक नई परियोजना बनाते हैं और लक्ष्य एप्लिकेशन के रूप में अपने मैट्रिक्स एप्लिकेशन को निर्दिष्ट करते हैं।
2. लाइटवेट हॉटस्पॉट्स प्रोफाइल का चयन करें (जो हैडवेयर इवेंट-आधारित सैंपलिंग प्रोसेसर काउंटर सैंपलिंग तकनीक का उपयोग करता है) और इसे कस्टम प्रोफ़ाइल बनाने के लिए कॉपी करें। इसे मेरा FLOPS विश्लेषण कहें।
3. हम प्रोफ़ाइल को संपादित करते हैं, वहां सैंडी ब्रिज (ईवेंट्स) प्रोसेसर ईवेंट के नए प्रोसेसर काउंटर जोड़ते हैं। हम उन पर थोड़ा और बसते हैं। उनके नाम पर, कार्यकारी डिवाइस (x87, SSE, AVX) और जिस प्रकार का डेटा ऑपरेशन किया गया था, एन्क्रिप्टेड हैं। प्रोसेसर के प्रत्येक चक्र, काउंटर निष्पादन के लिए असाइन किए गए कम्प्यूटेशनल ऑपरेशन की संख्या को जोड़ते हैं। बस मामले में, हमने एफपी के साथ सभी संभावित कार्यों के लिए काउंटरों को जोड़ा:

• FP_COMP_OPS_EXE। SSE_PACKED_DOUBLE - डबल सटीक डेटा वैक्टर (पैक) (दोहरा)
• FP_COMP_OPS_EXE। SSE_PACKED_SINGLE - एकल सटीक डेटा वैक्टर
• FP_COMP_OPS_EXE। SSE_SCALAR_DOUBLE - स्केलर DP
• FP_COMP_OPS_EXE। SSE_ SCALAR _SINGLE - स्केलर सपा
• SIMD_FP_256.PACKED_DOUBLE - DP AVX डेटा वैक्टर
• SIMD_FP_256.PACKED_SINGLE - AVX डेटा वैक्टर सपा
• FP_COMP_OPS_EXE.x87 - स्केलर डेटा x87

हम केवल विश्लेषण चला सकते हैं और परिणामों की प्रतीक्षा कर सकते हैं। परिणामों में, हम हार्डवेयर ईवेंट्स के दृष्टिकोण पर स्विच करते हैं और मल्टीप्ले 3 फ़ंक्शन के लिए एकत्र किए गए ईवेंट की संख्या की प्रतिलिपि बनाते हैं: 34,648,000,000।



अगला, हम केवल सूत्रों का उपयोग करके FLOPS मानों की गणना करते हैं। हमारे द्वारा सभी प्रोसेसरों के लिए एकत्रित किया गया डेटा, इसलिए उनकी संख्या से गुणा करना यहाँ आवश्यक नहीं है। 256-बिट रजिस्टर में चार 64-बिट डीपी ऑपरेंड पर एक साथ डबल-सटीक डेटा ऑपरेशन किया जाता है, इसलिए हम 4. के एक कारक से गुणा करते हैं, क्रमशः एकल परिशुद्धता के साथ एकाधिक डेटा। 8. अंतिम सूत्र में, हम एक कारक द्वारा निर्देशों की संख्या को गुणा नहीं करते हैं, क्योंकि कोपरोसेसर ऑपरेशन के बाद से x87 केवल अदिश मानों के साथ किया जाता है। यदि कार्यक्रम कई अलग-अलग प्रकार के एफपी ऑपरेशन करता है, तो गुणांक द्वारा गुणा की गई उनकी संख्या परिणामी FLOPS प्राप्त करने के लिए अभिव्यक्त होती है।

FLOPS = 4 * SIMD_FP_256.PACKED_DOUBLE / बीता हुआ समय
FLOPS = 8 * SIMD_FP_256.PACKED_SINGLE / बीता हुआ समय
FLOPS = (FP_COMP_OPS_EXE.x87) / बीता हुआ समय

केवल AVX निर्देशों को हमारे कार्यक्रम में निष्पादित किया गया था, इसलिए, परिणामों में केवल एक काउंटर SIMD_FP_256.PACKED_DOUBLE का मूल्य है।
सुनिश्चित करें कि ये इवेंट हमारे लूप के लिए मल्टिपल 3 फंक्शन (सोर्स व्यू पर स्विच करके) में एकत्रित किए गए हैं:



FLOPS = 4 * 34.6Gops / 7s = 19.7 GFlops
मान पिछले पैराग्राफ में गणना किए गए अनुमान के अनुरूप है। इसलिए, पर्याप्त सटीकता के साथ, हम कह सकते हैं कि मूल्यांकन पद्धति और माप के परिणाम मेल खाते हैं। हालांकि, ऐसे मामले हैं जहां वे मेल नहीं खा सकते हैं। पाठकों की एक निश्चित रुचि के साथ, मैं उनका अध्ययन कर सकता हूं और बता सकता हूं कि अधिक जटिल और सटीक तरीकों का उपयोग कैसे करें। बदले में, मैं वास्तव में आपके मामलों के बारे में सुनना चाहता हूं जब आपको कार्यक्रमों में FLOPS को मापने की आवश्यकता होती है।

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