CPU निष्पादन समय CPI और स्पीडअप
सीखने के लक्ष्य और दायरा
Instruction count, cycles per instruction और clock frequency से CPU time निकालें; instruction mix को सही weights दें; दो designs की तुलना करें; और Amdahl के नियम से optimization की सीमा जानें। पूर्वज्ञान: भिन्न, प्रतिशत, इकाई परिवर्तन तथा instruction और clock cycle का अंतर। यह performance की गणना का आधार है; benchmarking, pipelines, multicore scaling और power का पूरा अध्ययन नहीं।
जब तक अलग न कहा जाए, तुलना में समान निश्चित काम का समान परिणाम प्राप्त किया जाता है। Count का अर्थ वास्तव में execute हुए dynamic instructions हैं, listing की lines नहीं। दी हुई average CPI में प्रश्न में बताए खर्च शामिल हैं। अपने आप stalls न जोड़ें और न हटाएँ। उदाहरण मौलिक शिक्षण workloads हैं, किसी commercial processor के measured results नहीं।
1. पहले तय करें क्या माप रहे हैं
CPU execution time, बताए model में task को CPU पर execute करने में लगा समय है। Elapsed या wall-clock time में I/O का इंतजार, scheduling और अन्य delays भी हो सकते हैं। केवल CPU time घटाने से elapsed time का हर भाग नहीं घटता।
Latency पूछती है कि एक task पूरा होने में कितना समय लगता है। Throughput पूछती है कि प्रति इकाई समय कितने tasks पूरे होते हैं। दोनों जुड़े हैं, लेकिन समान नहीं। अधिक tasks साथ चलाने से throughput बढ़ सकती है, जबकि एक task पहले खत्म न हो।
Clock frequency f, प्रति second cycles की संख्या है। Clock period τ, प्रति cycle seconds है; इसलिए τ=1/f। 2 GHz पर f=2×10^9 cycles/s और τ=0.5 ns है। Clock cycle और instruction एक नहीं: एक instruction कई cycles ले सकता है, और overlap करने वाला implementation औसतन एक cycle में एक से अधिक instructions पूरा कर सकता है।
2. CPU-time सूत्र की व्युत्पत्ति
I dynamic instruction count और CPI_avg औसत cycles per instruction हो। कुल cycles=I×CPI_avg, इसलिए
T_CPU = I × CPI_avg × τ = I × CPI_avg / f.
इकाइयाँ कटती हैं: instructions × cycles/instruction × seconds/cycle = seconds। GHz और nanosecond की गलती पकड़ने के लिए इकाइयाँ साथ लिखें। यह गणना का संबंध है, यह वादा नहीं कि एक factor बदलने पर बाकी factors स्थिर ही रहेंगे।
हल किया उदाहरण: program 120 million instructions, average CPI=1.5 और 3 GHz clock पर चलता है। कुल cycles 180 million हैं। T=180×10^6/(3×10^9)=0.060 s=60 ms। केवल instruction count को frequency से भाग देना गलत रूप से CPI=1 मान लेता है।
3. Instruction mix से weighted CPI
Class i में n_i instructions execute हों और प्रत्येक के लिए c_i cycles लगें। कुल cycles=Σ(n_i c_i), कुल instructions=Σn_i और CPI_avg=Σ(n_i c_i)/Σn_i है। यदि p_i=n_i/I instruction fraction है, तो CPI_avg=Σ(p_i c_i), जहाँ Σp_i=1।
हल किया उदाहरण: 50% arithmetic instructions की CPI 1, 30% loads की CPI 3 और 20% branches की CPI 2 हो। CPI_avg=0.50×1+0.30×3+0.20×2=1.8। 100 million instructions और 2 GHz पर समय 0.09 s है। साधारण mean (1+3+2)/3=2 गलत ढंग से तीनों classes की संख्या बराबर मानता है।
Instruction fraction और execution-time fraction अलग हैं। Loads का time fraction 0.30×3/1.8=1/2 है, हालांकि वे instructions के केवल 30% हैं। किसी एक class को तेज करने पर यह अंतर महत्वपूर्ण है।
4. Clock के अंक नहीं, समय की तुलना करें
पुराने के मुकाबले नए design का speedup S=T_old/T_new है। S>1 पर नया तेज, S=1 पर समान और S<1 पर धीमा है। Time reduction का fraction (T_old−T_new)/T_old=1−1/S है। 2× speedup का अर्थ 50% कम समय है, 200% कम समय नहीं।
हल की गई तुलना: दोनों machines 200 million instructions execute करती हैं। A की CPI=1.2 और clock 2 GHz है, इसलिए T_A=0.12 s। B की CPI=1.8 और clock 3 GHz है, इसलिए T_B=0.12 s। B की frequency अधिक है, लेकिन इस workload में speedup नहीं है।
Optimization से instruction count भी बदल सकता है। समान frequency पर I_new=0.8 I_old और CPI_new=1.25 CPI_old हों तो उनका product पुराने product का 1.0 गुना रहता है। समय नहीं बदलता। इसी तरह count या clock अलग होने पर केवल कम CPI से बेहतर performance सिद्ध नहीं होती।
5. Time budget से Amdahl का नियम
पुराने execution time का p fraction, s गुना तेज हो जाए और बाकी 1−p fraction अपरिवर्तित रहे। काम निश्चित है, नया overhead नहीं है और अन्य परिवर्तन नहीं हैं। पुराने समय T से नया समय (1−p)T+pT/s मिलेगा। इसलिए
S = 1 / [(1−p) + p/s].
p पुराने समय का fraction है, नए समय का नहीं, और आवश्यक रूप से instruction fraction भी नहीं। s≥1 और 0≤p<1 पर सुधारा गया भाग अनंत तेज हो जाए तब भी S_max=1/(1−p) है। p=0 पर लाभ नहीं; p=1 पर S=s है और s बढ़ने पर unchanged-part की कोई finite सीमा नहीं रहती।
हल किया उदाहरण: पुराना समय 100 ms है। एक component 60 ms लेता है और तीन गुना तेज हो जाता है। अब वह 20 ms लेगा; बाकी component 40 ms ही लेगा। नया समय 60 ms, speedup 100/60=5/3≈1.667 और समय में कमी 40% है। अनंत सुधार पर अधिकतम speedup 100/40=2.5× होगा।
पिछले instruction mix में loads पुराने समय का आधा भाग लेते हैं। उनकी class CPI को 3 से 1.5 करने पर नई average CPI=0.5+0.45+0.4=1.35 है। Speedup=1.8/1.35=4/3। स्वतंत्र जाँच के लिए Amdahl में p=0.5 और s=2 रखें: 1/(0.5+0.25)=4/3।
मुख्य बातें और सामान्य गलतियाँ
- Task, count, CPI, frequency और units लिखें। समान काम के execution times की तुलना करें।
- CPI को instruction counts से weight दें; साधारण mean या time percentages से नहीं।
- 1 GHz=10^9 cycles/s, 1 ns=10^−9 s और 1 ms=10^−3 s याद रखें।
- Speedup, performance बढ़ने का प्रतिशत और समय घटने का प्रतिशत अलग हैं।
- Amdahl में p पुराने समय का fraction है। अपरिवर्तित भाग कुल लाभ सीमित करता है।
- सरल model की assumptions जरूरी हैं। वास्तविक performance के लिए measurements चाहिए।
मौलिक अभ्यास: छह single-correct MCQ
ये मौलिक प्रश्न हैं, पिछले वर्षों के प्रश्न नहीं। हर प्रश्न में ठीक एक विकल्प चुनें।
P01. Task 150 million instructions, average CPI 1.6 और clock frequency 2.4 GHz पर चलता है। CPU execution time कितना है?
A. 62.5 ms B. 100 ms C. 160 ms D. 10 ms
उत्तर: B
A: यह instruction count को frequency से भाग देता है, लेकिन CPI छोड़ देता है।
B: Cycles=150×10^6×1.6=240×10^6; समय=0.1 s=100 ms।
C: यह 240 million cycles को 2.4 billion cycles/s से सही भाग नहीं देता।
D: सही समय 0.1 s है, 0.01 s नहीं; इकाई में दस गुने की गलती है।
P02. Instruction fractions क्रमशः 40%, 40% और 20% हैं और class CPIs 1, 2 और 4 हैं। Average CPI क्या है?
A. 7/3 B. 1.4 C. 2.0 D. 2.8
उत्तर: C
A: 7/3 बिना weights का mean है; इसमें class counts बराबर मान लिए जाते हैं।
B: इसमें CPI-4 class का पूरा weighted contribution नहीं आया।
C: 0.4×1+0.4×2+0.2×4=2.0।
D: यह दूसरे weights से मिल सकता है, दी गई 40%, 40%, 20% instruction mix से नहीं।
P03. A और B समान संख्या में instructions execute करते हैं। A की CPI 1.5 और clock 3 GHz; B की CPI 1.2 और clock 2 GHz है। कौन-सी तुलना सही है?
A. A, B से 1.2× तेज है B. B, A से 1.2× तेज है C. दोनों का समय समान है D. A, B से 1.5× तेज है
उत्तर: A
A: प्रति instruction समय A में 0.5 ns और B में 0.6 ns; T_B/T_A=1.2।
B: यह समय का अनुपात उलटता है; A पहले खत्म होता है।
C: CPI/f अनुपात 0.5 और 0.6 ns हैं, समान नहीं।
D: केवल clock ratio 1.5 है; B की कम CPI भी शामिल करनी होगी।
P04. पुराने execution time का ठीक 75% भाग तीन गुना तेज होता है। बाकी अपरिवर्तित है और नया overhead नहीं है। कुल speedup कितना है?
A. 3× B. 4× C. 1.5× D. 2×
उत्तर: D
A: समय का केवल 75% भाग तेज हुआ; पूरा program तीन गुना तेज नहीं है।
B: चार अनंत सुधार की सीमा 1/0.25 है, finite factor 3 का परिणाम नहीं।
C: नया समय पुराने का 0.25+0.75/3=0.5 है, इसलिए 2, न कि 1.5।
D: S=1/(0.25+0.75/3)=1/0.5=2।
P05. Optimization से निश्चित task का समय 80 ms से 60 ms होता है। सही speedup और समय में कमी कौन-सी हैं?
A. 0.75× और 25% B. 4/3× और 25% C. 4/3× और 33⅓% D. 1.25× और 20%
उत्तर: B
A: 0.75 नया समय/पुराना समय है; speedup इसका उलटा है।
B: Speedup=80/60=4/3; समय में कमी=(80−60)/80=25%।
C: 33⅓% inverse-time performance की वृद्धि है, समय में कमी नहीं।
D: दोनों अनुपात गलत हैं; घटे हुए 20 ms, 80 ms का चौथाई हैं।
P06. 25% instructions की CPI 4 और बाकी की CPI 1 है। केवल पहली class की CPI 2 की जाती है; count और clock समान हैं। Speedup क्या है?
A. 8/7 B. 2 C. 7/5 D. 5/7
उत्तर: C
A: 8/7 तब मिलता है जब 25% instruction fraction को गलत रूप से पुराने समय का fraction मान लें।
B: केवल एक class दो गुनी तेज है; बाकी समय भी लगता है।
C: पुरानी CPI=0.25×4+0.75×1=1.75; नई CPI=0.25×2+0.75=1.25; speedup=1.75/1.25=7/5।
D: यह नया समय/पुराना समय है, speedup का उलटा।
स्रोत और दायरा
यह Computer Organization का आधारभूत पाठ है, पूरे विषय या पूरे पाठ्यक्रम की समाप्ति नहीं। आधिकारिक syllabus विषय का संबंध बताता है; technical references मूल परिभाषाओं की जाँच के लिए हैं। शिक्षण models, हल किए उदाहरण और अभ्यास मौलिक हैं। जाँच: 14 अक्टूबर 2026।
प्रगति सहेजने के लिए साइन इन करें। साइन इन