पुस्तकालय कार्यों के लिए FLOP गिनती


13

एक साधारण फ़ंक्शन में FLOPs की संख्या का मूल्यांकन करते समय, कोई अक्सर मूल अंकगणितीय ऑपरेटरों को अभिव्यक्त करने के लिए नीचे जा सकता है। हालांकि, गणितीय विवरणों के मामले में, यहां तक ​​कि विभाजन भी शामिल है, कोई ऐसा नहीं कर सकता है और केवल परिवर्धन और गुणा के साथ कार्यों से FLOP गणना के साथ तुलना करने में सक्षम होने की उम्मीद करता है। एक पुस्तकालय में ऑपरेशन लागू होने पर स्थिति और भी खराब होती है। इसलिए, विशेष कार्यों के प्रदर्शन की कुछ उचित धारणा होना अनिवार्य है।

विशेष कार्यों से, हमारा मतलब चीजों से है:

  • exp ()
  • sqrt ()
  • पाप / क्योंकि / तन ()

जो आमतौर पर सिस्टम लाइब्रेरी द्वारा प्रदान किए जाते हैं।

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

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

सिस्टम बनाम सिस्टम तुलना के लिए विशेष रूप से आर्किटेक्चर के लिए इन्हें मानकीकृत करने के लिए काफी सरल प्रयास किए जा सकते हैं , लेकिन अगर यह विधि बनाम विधि प्रदर्शन की परवाह करता है तो यह स्वीकार्य नहीं है। इन कार्यों की FLOP जटिलता का निर्धारण करने के लिए कौन सी कार्यप्रणाली स्वीकार्य मानी जाती है? क्या कोई बड़ी गड़बड़ी है?


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

धन्यवाद! मैं पर्याप्त स्पष्ट नहीं था। मैंने केवल बेहतर कंट्रास्ट प्रदान करने के लिए संपादन किया है।
पीटर ब्रुने

मुझे यह जानकर आश्चर्य हुआ कि पाप, कॉस और स्क्वैर्ट सभी वास्तव में x86 निर्देशों के x87 फ्लोटिंग-पॉइंट सबसेट में लागू होते हैं। मुझे लगता है कि मुझे आपकी बात समझ में आ गई है, लेकिन मुझे लगता है कि स्वीकार किए गए अभ्यास का मतलब केवल इन पर तैरने वाले बिंदुओं को थोड़ा बड़े स्थिरांक के साथ व्यवहार करना है :)
एरन अहमदिया

@AronAhmadia एक दशक में x87 का उपयोग करने का कोई कारण नहीं है। विभाजित करें और sqrt()एसएसई / एवीएक्स में हैं, लेकिन वे इसके अलावा और बहुसंकेतन से अधिक समय लेते हैं। इसके अलावा, वे सैंडी ब्रिज एवीएक्स पर खराब रूप से वेक्टरित हैं, एसएसई निर्देश के साथ दो बार ले रहे हैं (आधी चौड़ाई के साथ)। उदाहरण के लिए, डबल सटीक AVX (4 डबल्स वाइड) एक पैक को हर चक्र (मेमोरी पर कोई निर्भरता या स्टॉल न मानते हुए) में जोड़ा जा सकता है, जो कि प्रति चक्र 8 फ्लॉप है। डिवाइड उन "4 फ्लॉप" को करने के लिए 20 और 44 चक्रों के बीच लेता है।
जेड ब्राउन

पावरपीसी पर sqrt () वैकल्पिक है। इस वास्तुकला के कई एम्बेडेड चिप्स इंस्ट्रक्शन को लागू नहीं करते हैं, उदाहरण के लिए फ्रीस्केल एमपीसी 5 एक्सएक्सएक्स सीरीज़।
डेमियन

जवाबों:


10

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

हार्डवेयर समर्थित फ्लोटिंग पॉइंट ऑपरेशन

यह चिप AVX निर्देशों का समर्थन करती है , इसलिए रजिस्टरों की लंबाई 32 बाइट्स (4 डबल्स को पकड़कर) होती है। सुपरस्केलर आर्किटेक्चर निर्देशों को ओवरलैप करने की अनुमति देता है, अधिकांश अंकगणितीय निर्देशों को पूरा करने के लिए कुछ चक्र लेने के बावजूद, भले ही एक नया निर्देश अगले चक्र पर शुरू करने में सक्षम हो। इन शब्दार्थों को आमतौर पर विलंबता / उलटा थ्रूपुट लिखकर संक्षिप्त किया जाता है, 5/2 के मान का मतलब होगा कि निर्देश को पूरा करने के लिए 5 चक्र लगते हैं, लेकिन आप हर दूसरे चक्र में एक नया निर्देश शुरू कर सकते हैं (यह मानते हुए कि ऑपरेंड उपलब्ध हैं, इसलिए कोई डेटा नहीं निर्भरता और स्मृति की प्रतीक्षा नहीं)।

प्रति कोर में तीन फ़्लोटिंग अंक अंकगणितीय इकाइयां हैं, लेकिन तीसरा हमारी चर्चा के लिए प्रासंगिक नहीं है, हम प्रासंगिक दो ए और एम इकाइयों को बुलाएंगे क्योंकि उनके प्राथमिक कार्य इसके अलावा और गुणन हैं। उदाहरण के निर्देश ( Agner Fog की सारणी देखें )

  • vaddpd: 1 जोड़, 1 चक्र, विलंबता / व्युत्क्रम थ्रूपुट के लिए A को कब्जे में लेकर जोड़ा गया पैक 3/1 है
  • vmulpd: पैक्ड गुणा, यूनिट एम, 5/1
  • vmaxpd: चुनिंदा जोड़ीदार अधिकतम, इकाई ए, 3/1
  • vdivpd: पैक्ड डिवाइड, यूनिट एम (और कुछ ए), इनपुट के आधार पर 21/20 से 45/44
  • vsqrtpd: वर्गमूल, कुछ ए और एम, 21/21 से 43/43 इनपुट के आधार पर पैक
  • vrsqrtps: एकल परिशुद्धता इनपुट के लिए कम सटीकता वाले पारस्परिक वर्गमूल को पैक किया गया (8 floats)

जो कुछ ओवरलैप हो सकता है vdivpdऔर vsqrtpdजो स्पष्ट रूप से सूक्ष्म और AFAIK है, उसके लिए सटीक शब्दार्थ कहीं भी प्रलेखित नहीं हैं। अधिकांश उपयोगों में, मुझे लगता है कि ओवरलैप के लिए बहुत कम संभावना है, हालांकि मैनुअल में शब्दों से पता चलता है कि कई धागे इस निर्देश में ओवरलैप के लिए अधिक संभावना प्रदान कर सकते हैं। यदि हम प्रत्येक चक्र पर vaddpdऔर vmulpdप्रत्येक चक्र पर कुल 8 फ्लॉप के लिए चोटी फ्लॉप को हिट कर सकते हैं। घने मैट्रिक्स-मैट्रिक्स गुणा ( dgemm) इस शिखर के करीब यथोचित प्राप्त कर सकते हैं।

विशेष निर्देशों के लिए फ्लॉप की गिनती करते समय, मैं देखूंगा कि एफपीयू का कितना कब्जा है। तर्क के लिए मान लीजिए कि आपके इनपुट की सीमा में, vdivpdइकाई एम को पूरी तरह से पूरा करने के लिए औसतन 24 चक्र लगे, लेकिन इसके अलावा (यदि यह उपलब्ध था) आधे चक्रों के लिए समवर्ती रूप से निष्पादित किया जा सकता है। FPU उन चक्रों (पूरी तरह से interleaved vaddpdऔर vmulpd) के दौरान 24 पैक किए गए गुणक और 24 पैक किए गए अतिरिक्त प्रदर्शन करने में सक्षम है , लेकिन एक के साथ vdivpd, सबसे अच्छा हम कर सकते हैं 12 अतिरिक्त पैक जोड़ता है। यदि हम मानते हैं कि विभाजन करने का सबसे अच्छा तरीका हार्डवेयर (उचित) का उपयोग करना है, तो हम vdivpd36 पैक "फ्लॉप" के रूप में गिन सकते हैं , यह दर्शाता है कि हमें प्रत्येक स्केलर को 36 "फ्लॉप" के रूप में विभाजित करना चाहिए।

पारस्परिक वर्गमूल के साथ, कभी-कभी हार्डवेयर को हरा पाना संभव होता है, खासकर यदि पूर्ण सटीकता की आवश्यकता नहीं है, या यदि इनपुट की सीमा संकीर्ण है। जैसा कि ऊपर उल्लेख किया गया है, vrsqrtpsनिर्देश बहुत सस्ती है, इसलिए (यदि एकल परिशुद्धता में) आप vrsqrtpsएक या दो न्यूटन पुनरावृत्तियों के बाद सफाई कर सकते हैं। ये न्यूटन पुनरावृत्तियों बस हैं

y *= (3 - x*y*y)*0.5;

यदि इनमें से कई परिचालनों को निष्पादित करने की आवश्यकता है, तो यह भोले मूल्यांकन के मुकाबले काफी तेज हो सकता है y = 1/sqrt(x)। हार्डवेयर अनुमानित पारस्परिक वर्गमूल की उपलब्धता से पहले, कुछ प्रदर्शन-संवेदनशील कोड ने न्यूटन पुनरावृत्ति के लिए प्रारंभिक अनुमान लगाने के लिए कुख्यात पूर्णांक संचालन का उपयोग किया ।

पुस्तकालय-प्रदत्त गणित कार्य

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

मैं आधार रेखा के रूप में एक अच्छी वेक्टर गणित लाइब्रेरी (जैसे इंटेल का वीएमएल, एमकेएल का हिस्सा) का उपयोग करने का सुझाव देता हूं। प्रत्येक कॉल के लिए चक्र की संख्या को मापें और उस चक्र की संख्या से अधिक प्राप्त करने योग्य फ्लॉप से ​​गुणा करें। इसलिए अगर एक पैक एक्सपोनेंशियल का मूल्यांकन करने के लिए 50 चक्र लगते हैं, तो इसे रजिस्टर फ़्लो के 100 गुना गुणा के रूप में गिनें। दुर्भाग्य से, वेक्टर गणित पुस्तकालयों को कभी-कभी कॉल करना मुश्किल होता है और सभी विशेष कार्य नहीं होते हैं, इसलिए आप स्केलर गणित करना समाप्त कर सकते हैं, इस स्थिति में आप हमारे काल्पनिक स्केलर घातीय को 100 फ्लॉप के रूप में गिनेंगे (भले ही यह अभी भी 50 लेता है। चक्र, तो आप केवल "शिखर" का 25% प्राप्त कर रहे होंगे यदि सभी समय इन घातांक का मूल्यांकन करने में खर्च होता है)।

जैसा कि दूसरों ने उल्लेख किया है, आप पीएपीआई या विभिन्न इंटरफेस का उपयोग करके साइकिल और हार्डवेयर इवेंट काउंटर की गिनती कर सकते हैं। सरल चक्र की गिनती के लिए, आप rdtscइनलाइन असेंबली के एक स्निपेट के साथ निर्देश का उपयोग करके चक्र काउंटर को सीधे पढ़ सकते हैं ।


7

आप उन्हें PAPI का उपयोग करके वास्तविक सिस्टम पर गिन सकते हैं , जो हार्डवेयर काउंटर और सरल परीक्षण कार्यक्रमों तक पहुंच प्रदान करता है। मेरा पसंदीदा PAPI इंटरफ़ेस / आवरण IPM (एकीकृत प्रदर्शन मॉनिटर) है, लेकिन अन्य समाधान मौजूद हैं ( TAU , उदाहरण के लिए)। यह एक काफी स्थिर विधि से विधि तुलना करना चाहिए।


4

मैं इस सवाल का जवाब देने जा रहा हूं जैसे कि आपने पूछा:

"मैं उन एल्गोरिदम के प्रदर्शन की विश्लेषणात्मक रूप से तुलना या भविष्यवाणी कैसे करता हूं जो विशेष रूप से बहुगुणित-ऐड-फ़्लो FLOP गणनाओं के बजाय विशेष कार्यों पर निर्भर करते हैं, जो संख्यात्मक रैखिक बीजगणित से आते हैं"

मैं आपके पहले आधार से सहमत हूं, कि कई विशेष कार्यों का प्रदर्शन वास्तुकला पर निर्भर है, और यद्यपि आप आमतौर पर इनमें से प्रत्येक कार्य को निरंतर लागत के रूप में मान सकते हैं, निरंतर का आकार अलग-अलग होगा, यहां तक ​​कि एक से दो प्रोसेसर के बीच भी। कंपनी लेकिन विभिन्न आर्किटेक्चर के साथ ( संदर्भ के लिए एग्नर फॉग की इंस्ट्रक्शन टाइमिंग टेबल देखें )।

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

  1. स्केलेबिलिटी - समानांतर आर्किटेक्चर पर कुशलता से लागू किए जा सकने वाले कार्यों की एल्गोरिथ्म भविष्य के भविष्य के लिए वैज्ञानिक कंप्यूटिंग क्षेत्र पर हावी होगी। एक बेहतर "स्केलेबिलिटी" वाला एल्गोरिदम, कम संचार के माध्यम से हो, सिंक्रोनाइज़ेशन के लिए कम आवश्यकता हो, या बेहतर प्राकृतिक भार संतुलन हो, अधिक धीमी विशेष कार्यों को नियोजित कर सकता है और इसलिए कम संख्या में प्रक्रियाओं के लिए धीमा हो सकता है, लेकिन अंततः संख्या के रूप में पकड़ लेगा। प्रोसेसर की वृद्धि हुई है।

  2. टेम्पोरल लोकल ऑफ़ रेफरेंस - क्या एल्गोरिथम कार्यों के बीच डेटा का पुन: उपयोग करता है, जिससे प्रोसेसर अनावश्यक मेमोरी ट्रैफ़िक से बच सकता है? स्मृति पदानुक्रम के प्रत्येक स्तर जो एक एल्गोरिथ्म ट्रैवर्स प्रत्येक मेमोरी एक्सेस के लिए परिमाण लागत (मोटे तौर पर) का एक और क्रम जोड़ता है। नतीजतन, विशेष संचालन के उच्च घनत्व वाला एक एल्गोरिथ्म संभवतः स्मृति के एक बड़े क्षेत्र पर समान फ़ंक्शन के समतुल्य संख्या के साथ एक एल्गोरिथ्म की तुलना में काफी तेज होगा।

  3. मेमोरी फ़ुटप्रिंट - यह दृढ़ता से पिछले बिंदुओं से संबंधित है, लेकिन जैसे-जैसे कंप्यूटर बड़े और बड़े होते जाते हैं, प्रति कोर मेमोरी की मात्रा वास्तव में ट्रेंडिंग है। एक छोटे से स्मृति पदचिह्न के दो लाभ हैं। पहला यह है कि प्रोग्राम डेटा की एक छोटी राशि संभवतः प्रोसेसर कैश के भीतर पूरी तरह से फिट होने में सक्षम होगी। दूसरा यह है कि बहुत बड़ी समस्याओं के लिए, एक छोटी मेमोरी फुटप्रिंट वाला एल्गोरिथ्म प्रोसेसर मेमोरी में फिट होने में सक्षम हो सकता है, जिससे समस्याओं को हल किया जा सकता है जो अन्यथा कंप्यूटर की क्षमता से अधिक हो जाएगी।


मैं यह दावा करूंगा कि FLOPS / sec को जानने से आप अलग कर सकते हैं कि कौन सी अड़चन शासन (स्मृति, संचार) आप काफी अच्छी तरह से कर रहे हैं। उदाहरण के लिए, न्यूटन-क्रायलोव के तरीकों पर विचार करें, जो कि अपना बहुत समय मैटवेस्क करने में बिताते हैं। Matvecs एक FLOP या दो प्रति मैट्रिक्स प्रविष्टि करते हैं और यही वह है। बेपनाह स्मूदी में बेहतर करने की क्षमता होती है। जेड और मैं इसके बारे में भी बात कर रहे हैं, और एक वैकल्पिक धारणा यह देखने के लिए है कि आप FLOP- बाउंड कम्प्यूटेशन में कितने चक्र खर्च कर रहे हैं। हालाँकि, इसके लिए काफी बारीक निगरानी की आवश्यकता हो सकती है, और कुल FLOPS / sec अधिक व्यावहारिक हो सकते हैं।
पीटर ब्रुने

एरन, इसका अधिकांश उत्तर पीटर के प्रश्न को इस अन्य प्रश्न का उत्तर देने के पक्ष में घेरने में लगता है: scicomp.stackexchange.com/questions/114
जेड ब्राउन

@JedBrown, मैं सहमत हूं, एक साथ और अधिक ठोस जवाब देने के लिए समय निकालने के लिए धन्यवाद।
एरन अहमदिया

0

परेशान क्यों हैं फ्लॉप्स की गिनती? बस हर ऑपरेशन के लिए चक्र गिनें और आपके पास कुछ ऐसा होगा जो सार्वभौमिक हो।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.