Pipeline hazards forwarding stalls और flushes
लक्ष्य और निश्चित pipeline contract
Structural, data और control hazards पहचानें; forwarding के साथ/बिना dependencies schedule करें; stall तथा flush अलग करें; दी हुई branch penalty निकालें। पूर्वज्ञान: pipeline timing और register-transfer पाठ।
In-order single-issue IF–ID–EX–MEM–WB pipeline लें। हर stage एक cycle है। ID में registers पढ़ते और WB में लिखते हैं। WB इतनी जल्दी लिखता है कि उसी cycle के ID को नया value मिल सके। ALU result EX के अंत में और load data MEM के अंत में मिलता है। Forwarding enabled हो तो पहले pipeline registers से EX के शुरू में दोनों ALU inputs को data मिल सकता है; data समय में पीछे नहीं जा सकता। Instruction/data memories अलग हैं जब तक प्रश्न कुछ और न कहे। Branch delay slot तथा out-of-order execution नहीं हैं। Stall की संख्याएँ इन्हीं assumptions पर निर्भर हैं।
1. Dependence program की है; hazard timing पर निर्भर है
I1, R1 लिखे और बाद का I2 बिना intervening write के R1 पढ़े तो RAW dependence है। हर dependence stall नहीं बनाती: पर्याप्त gap या forwarding सही समय पर data दे सकता है। WAR तथा WAW name-dependence categories हैं। इस fixed-latency in-order pipeline में reads ID में और writes WB में क्रम से होते हैं, इसलिए WAR/WAW execution hazards नहीं बनते। Out-of-order या variable-latency में यह निष्कर्ष जरूरी नहीं।
Structural hazard अपर्याप्त shared hardware की प्रतिस्पर्धा है। Data hazard में सही operand समय पर उपलब्ध नहीं। Control hazard में अगला सही instruction address अभी तय नहीं। समान program अलग implementations में अलग stalls ले सकता है।
2. लगातार ALU dependence
I1: ADD R1,R2,R3; I2: SUB R4,R1,R5। बिना stalls I1: IF1 ID2 EX3 MEM4 WB5; I2: IF2 ID3 EX4 MEM5 WB6। I1 का result EX3 के बाद है, इसलिए forwarding EX4 को value दे सकता है: zero stalls।
Forwarding न हो तो I2 को cycle 5 तक ID में रखना होगा ताकि I1 के WB से लिखा R1 पढ़े। अब EX6 होगा, intended EX4 से दो cycles देर। Early-write/late-read convention जरूरी है; अलग convention पर एक और stall हो सकता है। Stall waiting instruction और upstream progress रोकता है, जबकि older instructions आगे जाते हैं। Bubble premature execution रोकता है।
3. Load-use में वही bypass पर्याप्त क्यों नहीं
I1: LD R1,0(R2); I2: ADD R3,R1,R4। I1 का data MEM4 के अंत में मिलता है, पर I2 को EX4 के शुरू में चाहिए था। Forwarding के साथ एक stall डालें: I2 EX5 में MEM4 का result लेगा। बिना forwarding WB5 तक इंतजार कर EX6 में जाए: इस model में दो stalls।
Load और consumer के बीच स्वतंत्र useful instruction रखने से bubble बच सकता है। लेकिन move तभी सही है जब register/memory dependencies, control behavior तथा relevant exception semantics सुरक्षित हों। केवल instruction का नाम अलग होना independence नहीं है।
4. सबसे नया लागू value forward करें
I1: ADD R1,R2,R3; I2: ADD R1,R1,R4; I3: SUB R5,R1,R6। I3 के EX पर दो पुराने pipeline registers में R1 से जुड़े values हो सकते हैं। I3 को I2 का नया value चाहिए, I1 का stale value नहीं। निकटतम valid producer की प्राथमिकता है। Producer सच में register लिखता हो और data समय पर तैयार हो। Destination number match अकेला पर्याप्त नहीं; EX/MEM में load का address, loaded data नहीं है।
5. Structural conflicts और branch flushes
एक single-ported shared instruction/data memory हो तो load का MEM और दूसरे instruction का IF एक साथ memory माँग सकते हैं। Arbitration, stall या अधिक bandwidth चाहिए। Register forwarding memory-port conflict नहीं हटाता।
Branch उदाहरण में predict-not-taken मानें; branch EX के अंत में resolve होता है और अगले cycle में target fetch शुरू होता है। Taken branch जब EX में है, दो younger fall-through instructions ID और IF में हैं। वे गलत path के हैं; architectural state बदलने से पहले flush करने होंगे। इन assumptions में penalty दो lost issue slots है। सही predicted untaken branch पर ऐसा flush नहीं। Branch operand dependence अलग stalls जोड़ सकती है; isolated penalty निकालते समय उन्हें बाहर रखा है।
हल किया long-stream उदाहरण: useful instructions में 20% branches; branches में 30% mispredicted; हर misprediction 2 cycles जोड़ता है; अन्य costs नहीं। Extra CPI=0.20×0.30×2=0.12, steady CPI=1.12। 30% को सभी instructions का fraction न मानें। Finite batch में k−1 शुरुआती cycles अभी भी जुड़ेंगे; overlapping penalties दो बार न गिनें।
सामान्य गलतियाँ
Forwarding value बनने से पहले उसे नहीं दे सकता। Stall count के लिए stage, availability और consumption times लिखें। Flush गलत-path work मिटाता है; stall सही instruction को आगे के लिए रखता है। Dependence और hazard समान नहीं। Branch penalty resolution, prediction और fetch timing पर निर्भर है, सिर्फ depth पर नहीं।
मौलिक अभ्यास: छह single-correct MCQ
ये मौलिक शिक्षण प्रश्न हैं, पिछले वर्षों के प्रश्न नहीं। ठीक एक उत्तर चुनें।
P01. बताए full-forwarding model में लगातार ALU producer और ALU consumer को कितने stalls चाहिए?
A. 0 B. 1 C. 2 D. 3
उत्तर: A
A: Cycle 3 के अंत का result EX4 के शुरू में पहुँचता है।
B: एक stall बताए load-use में है, इस ALU case में नहीं।
C: दो stalls forwarding न होने पर हैं।
D: Bypass से देर का register read जरूरी नहीं।
P02. बताए forwarding model में immediate dependent load-use pair कितने stalls लेता है?
A. 0 B. 1 C. 2 D. 4
उत्तर: B
A: मूल EX शुरू होने पर load data तैयार नहीं।
B: एक bubble consumer EX4 को EX5 करता है।
C: MEM-to-EX forwarding में दो stalls जरूरी नहीं।
D: चार extra cycles नहीं चाहिए।
P03. Forwarding नहीं, लेकिन same-cycle WB-write/ID-read है। Adjacent ALU dependence में कितने stalls?
A. 0 B. 1 C. 2 D. 3
उत्तर: C
A: ID3 पुराना value पढ़ेगा।
B: ID4 अभी WB5 से पहले है।
C: Consumer ID5 तक रुके और EX4 के बजाय EX6 जाए: दो stalls।
D: तीन मानना same-cycle WB/ID सुविधा भूलना है।
P04. Load MEM तथा IF एक single-ported memory माँगते हैं। कौन-सा hazard?
A. RAW data B. Structural C. Control D. WAW
उत्तर: B
A: इस conflict के लिए register dependence जरूरी नहीं।
B: दोनों को वही अपर्याप्त hardware port चाहिए।
C: अगले PC का निर्णय कारण नहीं है।
D: यह एक register में दो ordered writes का वर्णन नहीं।
P05. 25% instructions branches हैं; उनमें 20% mispredicted। हर miss 3 cycles जोड़ता है; अन्य penalties नहीं। Steady CPI?
A. 1.05 B. 1.15 C. 1.60 D. 1.75
उत्तर: B
A: 0.05 misses/instruction है; प्रत्येक तीन cycles लेता है।
B: 1+0.25×0.20×3=1.15।
C: यह 20% सभी instructions पर लगाता है।
D: यह हर branch को penalty देता है।
P06. ADD R1,R2,R3; ADD R1,R1,R4; SUB R5,R1,R6 में SUB कौन-सा R1 ले?
A. दोनों ADD से पहले का value B. पहले ADD का result C. दूसरे ADD का result D. किसी भी ADD का result
उत्तर: C
A: दोनों पहले writes आवश्यक program value बदलते हैं।
B: दूसरा write पहले result को बदल देता है।
C: सबसे नया preceding writer दूसरा ADD है।
D: Results समान जरूरी नहीं; program order दूसरा चुनता है।
स्रोत और दायरा
यह 2026 course के बताए भाग का पाठ है, पूरे COA syllabus की समाप्ति नहीं। सभी गणनात्मक उदाहरण और प्रश्न मौलिक हैं। 2027 की पूर्णता का दावा नहीं।
प्रगति सहेजने के लिए साइन इन करें। साइन इन