फ्लॉप के रूप में क्या मायने रखता है?

Question

मैं एक सी प्रोग्राम है जो pseudoish में है कहते हैं:

For i=0 to 10 
    x++ 
    a=2+x*5 
next 

के लिए इस फ्लॉप फिल्मों की संख्या है (1 [x ++] +1 [x * 5] + 1 [2 + (x + 5)) ] * 10 [लूप], 30 फ्लॉप के लिए? मुझे समझ में परेशानी हो रही है कि फ्लॉप क्या है।

ध्यान दें [...] यह इंगित कर रहे हैं कि मुझे "संचालन" के लिए मेरी गणना कहां मिल रही है।

Answer 1

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

दूसरे शब्दों में, आपके लूप बॉडी में 2 जोड़ और 1 गुणा होता है, इसलिए (x फ़्लोटिंग पॉइंट है) प्रत्येक लूप पुनरावृत्ति 3 ऑप्स है; यदि आप लूप को 10 बार चलाते हैं तो आपने 30 ऑप्स किए हैं।

ध्यान दें कि एमआईपीएस को मापते समय, आपका पाश 3 से अधिक निर्देश होंगे क्योंकि इसमें लोड और स्टोर भी शामिल हैं जो फ्लॉप्स माप की गणना नहीं करते हैं।

Answer 2

FLOPS प्रति सेकेंड फ्लोटिंग ऑपरेशंस के लिए खड़ा है। यदि आप पूर्णांक से निपट रहे हैं तो आपके पास आपके कोड में कोई फ़्लोटिंग पॉइंट ऑपरेशन नहीं है।

Answer 3

एक्स एक पूर्णांक या एक फ़्लोटिंग-पॉइंट चर है? यदि यह एक पूर्णांक है, तो आपके लूप में कोई फ़्लॉप नहीं हो सकता है।

Answer 4

पोस्टर यह स्पष्ट है कि फ्लॉप (विस्तृत here) चल बिन्दु (के रूप में पूर्णांक के खिलाफ) प्रति सेकंड संचालन को लेकर चिंतित हैं बना दिया है, तो आप न केवल आप कितने आपरेशन प्रदर्शन कर रहे हैं गिनती करने के लिए है, लेकिन में समय की अवधि क्या है।

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

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

Answer 5

एफएलओपी (लोअरकेस एस प्रति मार्टिनो फर्नांडीस टिप्पणी प्रति एफएलओपी के बहुवचन को इंगित करता है) मशीन भाषा फ्लोटिंग पॉइंट निर्देशों का जिक्र कर रहा है, इसलिए यह निर्भर करता है कि आपका कोड कितना निर्देश संकलित करता है।

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

इस कोड (MIPS पर) करने के लिए संकलन सकता है:

Assignment of variables: x is in $f1, a is in $f2, i is in $f3. 
All other floating point registers are compiler-generated temporaries. 
$f4 stores the loop exit condition of 10.0 
$f5 stores the floating point constant 1.0 
$f6 stores the floating point constant 2.0 
$t1 is an integer register used for loading constants 
    into the floating point coprocessor. 

    lui $t1, *upper half of 0.0* 
    ori $t1, $t1, *lower half of 0.0* 
    lwc1 $f3, $t1 
    lui $t1, *upper half of 10.0* 
    ori $t1, $t1, *lower half of 10.0* 
    lwc1 $f4, $t1 
    lui $t1, *upper half of 1.0* 
    ori $t1, $t1, *lower half of 1.0* 
    lwc1 $f5, $t1 
    lui $t1, *upper half of 2.0* 
    ori $t1, $t1, *lower half of 2.0* 
    lwc1 $f6, $t1 
st: c.gt.s $f3, $f4 
    bc1t end 
    add.s $f1, $f1, $f5 
    lui $t1, *upper half of 5.0* 
    ori $t1, $t1, *lower half of 5.0*   
    lwc1 $f2, $t1 
    mul.s $f2, $f2, $f1 
    add.s $f2, $f2, $f6 
    add.s $f3, $f3, $f5 
    j st 
end: # first statement after the loop 

तो Gabe है परिभाषा के अनुसार, वहाँ पाश (3x add.s और 1x mul.s) के अंदर 4 फ्लॉप रहे हैं। यदि आप लूप तुलना c.gt.s पर भी गिनती करते हैं तो 5 एफएलओपी हैं। प्रोग्राम द्वारा उपयोग किए जाने वाले कुल 40 (या 50) एफएलओपी के लिए इसे 10 से गुणा करें।

एक बेहतर अनुकूलन संकलक यह मान सकता है कि a का मान लूप के अंदर उपयोग नहीं किया जाता है, इसलिए इसे केवल a के अंतिम मान की गणना करने की आवश्यकता है। यह कोड ऐसा दिखता है जैसे

 lui $t1, *upper half of 0.0* 
    ori $t1, $t1, *lower half of 0.0* 
    lwc1 $f3, $t1 
    lui $t1, *upper half of 10.0* 
    ori $t1, $t1, *lower half of 10.0* 
    lwc1 $f4, $t1 
    lui $t1, *upper half of 1.0* 
    ori $t1, $t1, *lower half of 1.0* 
    lwc1 $f5, $t1 
    lui $t1, *upper half of 2.0* 
    ori $t1, $t1, *lower half of 2.0* 
    lwc1 $f6, $t1 
st: c.gt.s $f3, $f4 
    bc1t end 
    add.s $f1, $f1, $f5 
    add.s $f3, $f3, $f5 
    j st 
end: lui $t1, *upper half of 5.0* 
    ori $t1, $t1, *lower half of 5.0*   
    lwc1 $f2, $t1 
    mul.s $f2, $f2, $f1 
    add.s $f2, $f2, $f6 

इस मामले में, आप 2 कहते हैं और पाश अंदर 1 तुलना (10 से mutiplied आप 20 या 30 फ्लॉप देता है) है, प्लस 1 गुणा और लूप के बाहर 1 इसके अलावा उत्पन्न कर सकता है। इस प्रकार, आपके प्रोग्राम में अब 22 या 32 एफएलओपी लगता है कि हम तुलनाओं की गणना करते हैं या नहीं।