Multicore vs manycore designs: Worked examples — Hinglish deep dive

6.1.4 · D3 · Hardware › Parallelism & Multicore › Multicore vs manycore designs

Yeh page parent topic ka "boss fight" hai. Hum woh do formulas lenge jo parent ne introduce ki thi — Amdahl's Law se speedup formula aur throughput formula — aur inhe har kone mein push karenge: easy cases, broken cases, "exactly zero" wale cases, aur woh jo dekhne mein toh ek design ko favour karte lagte hain lekin secretly doosre ko karte hain.

Koi bhi number aane se pehle, chalo un do symbols ko dobara anchor karte hain jo hum baar baar use karenge, kyunki kaafi "wrong answers" inhe mix up karne se aate hain.

Yeh exact formulas hain jo hum use karenge, parent se copy ki gayi hain taaki koi bhi symbol bina earn kiye use na ho:

Do chips examples mein baar baar aayenge, toh chalo unke parameters ek baar yahan fix kar lete hain aur naam de dete hain, rather than mid-problem mein numbers sneakily daalne ke:

Scenario matrix

Is topic ke har sawaal ka jawaab inhi cells mein se kisi ek mein aata hai. Neeche ke worked examples mein label hai ki woh kaun sa cell cover karte hain, aur milke sab cells hit ho jaate hain.

Cell	Jo "input extreme" test ho rahi hai	Yeh kya probe karta hai
A	$P = 0$ (kuch bhi parallel nahi)	Serial floor — degenerate low end
B	$P = 1$ (perfectly parallel)	Manycore dream — degenerate high end
C	$0 < P < 1$ , chhota $N$	Realistic multicore
D	$N \to \infty$ (limiting behaviour)	Amdahl's ceiling
E	Throughput vs latency clash	Same chips, opposite winners
F	Area/transistor tradeoff	Kyun do philosophies exist karti hain
G	Utilization collapse ( $U \to$ small)	Jab manycore ki flood sukh jaaye
H	Real-world word problem	Description se design choose karna
I	Exam twist (the trap)	Jahan "obvious" answer galat hota hai

Worked examples

Example 1 — Cell A: kuch bhi parallel nahi ( $P = 0$ )

$P$ likho. "100% serial" matlab parallel fraction $P = 0$ hai. Yeh step kyun? English ("serial") ko us symbol mein translate karna jis par formula kaam karta hai — yahin sabse zyada errors hote hain. $P$ parallel fraction hai, toh serial-only matlab $P = 0$ hai, $P = 1$ nahi.
Amdahl mein substitute karo: $S = \frac{1}{( 1 - 0 ) + \frac{0}{512}} = \frac{1}{1 + 0} = 1$ Yeh step kyun? $\frac{P}{N}$ term wahi jagah hai jahan $N$ appear karta hai. Agar $P = 0$ hai, toh woh poora term gayab ho jaata hai aur $N$ invisible ho jaata hai — cores literally is problem ko touch nahi kar sakte.
Interpret karo: $S = 1$ matlab "exactly ek core jitna fast." Baaki 511 cores idle baithte hain. Yeh step kyun? Ek degenerate case ko name karna zaroori hai taaki aap ise live pehchan sako: dependency chains parallelism ko completely defeat karti hain.

Verify: $N = 1$ (ek core, baseline) ko same formula mein plug karo: $S = \frac{1}{1 + 0} = 1$ . Same answer jaise $N = 512$ — confirm karta hai ki extra cores ne kuch nahi add kiya. Units: speedup dimensionless hai (times ka ratio), aur $1$ "no change" value hai. ✓

Example 2 — Cell B & D: perfect parallelism, phir limit

$P = 1$ confirm karo. Independent entries ⇒ zero serial fraction. Yeh step kyun? $P = 1$ wahi ek value hai jo speedup ko bina ceiling ke grow karne deti hai — isliye ise verify karna worth it hai.
Part (a): $S = \frac{1}{( 1 - 1 ) + \frac{1}{6912}} = \frac{1}{0 + \frac{1}{6912}} = 6912$ . Yeh step kyun? Serial term $(1 - P) = 0$ gone hone ke baad, speedup exactly $N$ ho jaata hai — linear scaling, manycore ka dream.
Part (b), the limit: jaise $N \to \infty$ , $\frac{1}{N} \to 0$ , isliye $S \to \frac{1}{( 1 - P ) + 0} = \frac{1}{1 - P} = \frac{1}{0} \to \infty.$ Yeh step kyun? Yeh ONLY woh $P$ hai jiske liye limit infinite hai. Yeh Cells B aur D ke beech boundary dikhata hai: perfect parallelism ki koi ceiling nahi hai; kuch bhi kam hone par hoti hai (agla example).

Verify: Reality check — parent notes mein actual A100 speedup ~4000× hai, 6912× se kam. Yeh consistent hai: hamara $S = 6912$ theoretical max hai (utilization $U = 1$ ); real mein memory bandwidth $U$ ko 1 se neeche kheenchti hai, isliye real speedup < 6912. Model over-estimate karta hai, under-estimate nahi — sahi direction. ✓

Example 3 — Cell D: imperfect $P$ ke liye Amdahl's ceiling

Limit $N \to \infty$ lo: $S_{m a x} = \frac{1}{1 - P} = \frac{1}{1 - 0.95} = \frac{1}{0.05} = 20.$ Yeh step kyun? Yeh Amdahl ka sabse important consequence hai: sirf 5% serial slice aapko hamesha ke liye 20× par cap kar deta hai.

Ab neeche wali figure dekho. Har curve fixed $P$ ke liye $S (P, N)$ hai jaise hum $N$ ko right ki taraf badhate hain. Blue $P = 0.95$ curve pehle steeply climb karta hai, phir bend ho jaata hai aur red dashed line se $20$ par flat ho jaata hai — woh red line exactly woh $S_{m a x} = 1/ (1 - P)$ hai jo humne abhi compute ki. Picture is step ka visual proof hai: chahe aap kitna bhi right jaao (zyada cores), curve apni ceiling cross nahi kar sakta.

Ceiling ka aadha paane ke liye $N$ dhundho ( $S = 10$ ): solve karo $\frac{1}{0.05 + \frac{0.95}{N}} = 10$ . Phir $0.05 + \frac{0.95}{N} = 0.1 \Rightarrow \frac{0.95}{N} = 0.05 \Rightarrow N = \frac{0.95}{0.05} = 19$ . Yeh step kyun? Yeh curve ki cruelty expose karta hai: 19 cores aapko $10 \times$ tak pahuncha dete hain, lekin $20 \times$ reach karne ke liye infinitely many chahiye. Figure mein yeh white dot hai $(19, 10)$ par — notice karo yeh red ceiling tak sirf halfway par baitha hai, halanki hum pehle hi 19 cores spend kar chuke hain. Us dot ke right mein sab kuch diminishing returns ka region hai.

Verify: $N = 19$ wapas plug karo: $S = \frac{1}{0.05 + 0.95/19} = \frac{1}{0.05 + 0.05} = \frac{1}{0.1} = 10$ . ✓ Aur $10 = 20/2$ , exactly ceiling ka aadha. ✓

Example 4 — Cell C: realistic multicore, chhota $N$

$P = 0.30$ , $N = 8$ substitute karo: $S = \frac{1}{( 1 - 0.30 ) + \frac{0.30}{8}} = \frac{1}{0.70 + 0.0375} = \frac{1}{0.7375} .$ Yeh step kyun? Serial term $0.70$ denominator mein dominate karta hai — yeh wahi "killer" hai jo parent ne warn kiya tha. Yeh fixed rehta hai chahe aap kitne bhi cores add karo.
Compute karo: $S = \frac{1}{0.7375} \approx 1.36$ . Yeh step kyun? Bahut chhota speedup — phir bhi multicore yahan sahi choice hai (step 3 dekho), yahi poori baat hai.
Base core speeds compare karo. Ek REF-CPU core karta hai $f \times IPC = 4 GHz \times 4 = 16$ GIPS; ek REF-GPU core karta hai $1.5 GHz \times 1 = 1.5$ GIPS — REF-CPU core ek thread par $16/1.5 \approx 10.7 \times$ faster hai. Kyunki is workload ka 70% ek thread par chalta hai, woh base speed dominate karta hai; modest $1.36 \times$ parallel bonus pehle se hi fast core ke upar sawaar hota hai. Yeh step kyun? Speedup ek core ke relative hai; base core matter karta hai. Named REF-CPU / REF-GPU numbers use karna (vague "high IPC" ki jagah) comparison ko concrete banata hai: multicore branchy code mein isliye jeet jaata hai kyunki uska base thread ~10× quicker hai, core count ki wajah se nahi.

Verify: $1/0.7375 = 1.3559 \dots \approx 1.36$ . ✓ Base-speed ratio $16/1.5 = 10.67$ . ✓ Sanity: $P < 1$ ke saath, $S$ strictly $N = 8$ se kam aur $1$ se zyada hona chahiye — aur $1 < 1.36 < 8$ hold karta hai. ✓

Example 5 — Cell E: same do chips, throughput winner flip ho jaata hai

Compute karne se pehle ek chhota unit note. $f_{clock}$ (GHz mein) clock ticks per second hai; $IPC$ instructions per tick hai. Inhe multiply karo, "ticks" cancel ho jaate hain: $f_{clock} \times IPC$ ki units instructions per second hain — yeh honest per-core work rate hai, aur yahan "single-thread performance" ka yahi matlab hai. (Neeche shorthand $4 \times 4 = 16$ ka matlab hai "ek core par 16 giga-instructions per second," kyunki $4 GHz \times 4 IPC$ .)

REF-CPU throughput: $Θ = 8 \times 4 \times 4 \times 0.9 = 115.2$ GIPS. Yeh step kyun? Throughput formula ke charon factors multiply karo; GHz × IPC deta hai billions of instructions/sec per core, ×cores×U deta hai chip total.
REF-GPU throughput: $Θ = 512 \times 1.5 \times 1 \times 0.7 = 537.6$ GIPS. Yeh step kyun? Same formula, ulta balance: tiny per-core numbers, bahut bada core count. Count product mein jeet jaata hai.
Ratio: $537.6/115.2 = 4.667 \approx 4.7 \times$ → REF-GPU throughput mein jeetta hai. Yeh step kyun? Confirm karta hai ki firehose eyedropper ko volume par beat karta hai.
Single-thread: ek core $f \times IPC$ instructions per second karta hai. REF-CPU: $4 \times 4 = 16$ GIPS; REF-GPU: $1.5 \times 1 = 1.5$ GIPS. Ratio $16/1.5 = 10.67 \times$ → REF-CPU latency mein jeetta hai. Yeh step kyun? Flip dikhata hai: throughput loser latency winner hai. Same silicon, opposite verdicts, depending on aapne kya poochha.

Verify: $8 \cdot 4 \cdot 4 \cdot 0.9 = 115.2$ ✓; $512 \cdot 1.5 \cdot 1 \cdot 0.7 = 537.6$ ✓; $537.6/115.2 \approx 4.667$ ✓; $16/1.5 \approx 10.667$ ✓. Units: GIPS = giga-instructions per second (ek rate) throughput ke liye; single-thread numbers ( $16$ , $1.5$ ) bhi GIPS hain lekin per core, isliye inhe whole-chip totals se compare mat karo — isliye do alag ratios hain. ✓

Example 6 — Cell F: transistor tradeoff, area se

Complex cores: $N_{complex} = 200/10 = 20$ . Yeh step kyun? Area budget ÷ area-per-core = count. Die fixed pie hai; har mota core ek bada slice leta hai.
Simple cores: $N_{simple} = 200/0.2 = 1000$ . Yeh step kyun? Same pie, patle slices ⇒ bahut zyada unhe fit ho sakte hain.
Ratio: $\frac{N _{simple}}{N _{complex}} = \frac{A _{complex}}{A _{simple}} = \frac{10}{0.2} = 50$ . Yeh step kyun? Ratio ko die size ki zaroorat bhi nahi — yeh sirf area ratio hai. Ek mota core = pachaas patle wale. Yahi physical reason hai ki do philosophies saath exist nahi kar saktin: Power Consumption aur area ek fixed budget hai jise aap ek baar spend karte ho.

Ab us arithmetic ko neeche wali figure se compare karo. Left panel ek single die tile hai jo almost entirely ek blue $10 mm^{2}$ core se bhara hai — multicore ka tarika, sab kuch bada aur clever hone par kharch karna. Right panel same-size tile hai (yellow "same area" arrow dekho jo dono ko bridge karta hai) jo $50$ tiny green $0.2 mm^{2}$ cores ke $10 \times 5$ grid se tiled hai — manycore ka tarika. Aankh ek dum woh cheez dekh leti hai jo step 3 ne prove ki: ek mota core aur pachaas patle cores same silicon occupy karte hain. Woh equal area hi woh poori wajah hai "aap dono nahi rakh sakte."

Verify: $200/10 = 20$ ✓; $200/0.2 = 1000$ ✓; $1000/20 = 50 = 10/0.2$ ✓. Units: mm² / mm² = dimensionless count. ✓

Example 7 — Cell G: utilization collapse (manycore ki flood sukh jaati hai)

$U = 0.1$ ke saath REF-GPU throughput recompute karo: $Θ = 512 \times 1.5 \times 1 \times 0.1 = 76.8$ GIPS. Yeh step kyun? $U$ sab kuch linearly multiply karta hai — divergence (dekho SIMD vs MIMD) manycore ki kryptonite hai kyunki iski cores instruction streams share karti hain aur saath mein stall karti hain.
Compare karo: $76.8 < 115.2$ → REF-CPU ab throughput mein bhi jeet jaata hai. Yeh step kyun? Yeh manycore side ka degenerate case hai: jab workload irregular ho, uska numerical advantage gayab ho jaata hai. Yeh sawaal ka jawaab deta hai "firehose eyedropper se kab haarta hai?" — jab firehose 90% hawa ho.
Break-even $U$ solve karo (part b): REF-GPU throughput ko REF-CPU ke 115.2 GIPS ke barabar set karo aur $U$ ke liye solve karo: $512 \times 1.5 \times 1 \times U = 115.2 \Rightarrow 768 U = 115.2 \Rightarrow U = \frac{115.2}{768} = 0.15.$ Yeh step kyun? Yeh vague chinta "manycore kabhi kabhi haarti hai" ko ek exact, predictable threshold mein convert karta hai. $U = 0.15$ se neeche REF-GPU, REF-CPU se peeche pad jaata hai; usse upar REF-GPU jeetta hai. Ab aap workload regularity se akele winner forecast kar sakte ho, bina poori calculation dobara chalaye — is cell mein sabse useful number.

Verify: $512 \cdot 1.5 \cdot 0.1 = 76.8$ ✓; $76.8 < 115.2$ ✓; $115.2/768 = 0.15$ ✓ — aur indeed normal $U = 0.7$ (Example 5) $0.15$ se kaafi upar hai, consistent REF-GPU ke wahan jeetne ke saath, jabki $U = 0.1$ $0.15$ se neeche hai, consistent iske yahan haarne ke saath. ✓

Example 8 — Cell H: real-world word problem

Database classify karo. Query planning sequential hai with unpredictable branches; index traversal pointer chasing hai; locks serial critical sections hain ⇒ low $P$ , irregular. → multicore. Yeh step kyun? Low parallel fraction + branchy control flow exactly Cell A/C territory hai jahan core count help nahi kar sakta aur fast single-thread (Thread-Level Parallelism with few strong threads) matter karta hai.
Training loop classify karo. Dense matmul ⇒ $P \approx 1$ , regular, Cache Coherence-light, bandwidth-bound. → manycore. Yeh step kyun? $P \approx 1$ Cell B hai — wahi regime jahan thousands of cores linearly pay off karte hain.
Decision: database → multicore CPU; training → manycore GPU. Agar exactly ek kharidna ho, toh decide karo ki kaun si service revenue ki bottleneck hai: agar latency-per-transaction woh cheez hai jo customers pay karte hain, toh multicore CPU khareedo aur occasional training ke liye GPU time rent karo; agar product hi trained model hai, toh manycore GPU khareedo aur database existing host CPU par chalao. Genuinely sahi architecture, agarchi, yeh hai ki dono rakho aur har workload ko us chip par route karo jo use suit kare — yeh exactly Heterogeneous Computing design pattern hai. Yeh step kyun? Yeh reader ko force karta hai notice karne ke liye ki "kaun better hai" hamesha workload-relative hota hai; koi universal winner nahi hai, aur real systems yeh dilemma dono use karke resolve karte hain.

Verify: Example 4 (branchy 30%-parallel → multicore $S \approx 1.36$ , base-speed matters) aur Example 2 ( $P = 1$ matmul → manycore $S \approx N$ ) se cross-check karo. Dono worked examples is classification se agree karte hain. ✓

Example 9 — Cell I: exam trap

Trap spot karo: $P = 0.90$ hai, $1.0$ nahi. Naive reader core count se multiply kar deta hai. Yeh step kyun? "90% parallel" word deliberately 100% ke kareeb hai taaki aapko linear scaling mein tempt kare. Sirf $P = 1$ linearly scale karta hai (Example 2).
Sahi se compute karo: $S = \frac{1}{( 1 - 0.9 ) + \frac{0.9}{1000}} = \frac{1}{0.1 + 0.0009} = \frac{1}{0.1009}$ . Yeh step kyun? Serial $0.1$ term include karo — wahi term jise trap aapko bhulwana chahta hai.
Result: $S \approx 9.91$ . Ceiling ( $N \to \infty$ ) sirf $\frac{1}{0.1} = 10 \times$ hai. Yeh step kyun? $\approx 9.91 \times$ , $1000 \times$ ke kareeb bhi nahi. Answer: FALSE. 1000 cores aapko ek bekar $10 \times$ ceiling ka 99% dilate hain.

Verify: $1/ (0.1 + 0.9/1000) = 1/0.1009 = 9.9108 \dots \approx 9.91$ ✓; ceiling $1/0.1 = 10$ ✓; aur $9.91 < 10$ (limit se neeche hona chahiye) ✓. ✓

Recall Quick self-test

512 cores par 100% serial task speedup kya deta hai? ::: Exactly $1$ — cores useless hain (Cell A). $P = 0.95$ ke liye speedup ceiling? ::: $1/ (1 - 0.95) = 20 \times$ (Cell D). Ek $10 mm^{2}$ core kitne $0.2 mm^{2}$ cores ke barabar hai? ::: $10/0.2 = 50$ (Cell F). Kis utilization ke neeche 512-core REF-GPU, 115.2 GIPS REF-CPU se haar jaata hai? ::: $U = 0.15$ (Cell G). "90% parallel on 1000 cores ≈ 1000×" — true ya false? ::: False, yeh $\approx 9.91 \times$ hai, ceiling $10 \times$ (Cell I).