Foundations — Multicore vs manycore designs

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

Parent note Multicore vs Manycore Designs padhne se pehle, tumhe usme aane wale har symbol ko earn karna hoga. Yeh page har ek ko zero se build karta hai, ek aisi order mein jahan har idea pehle wale par lean karta hai. Yahan yeh assume nahi kiya gaya ki tumne pehle kabhi CPU diagram dekha hai.

1. "Core" kya hota hai? (har cheez ke peeche ki picture)

Ek chip (woh kala square jo tumhe computer kholne par dikhta hai) andar bahut saare aaise workers side by side rakh sakta hai. Yahi is chapter ka poora subject hai: kitne workers, aur har ek kitna clever hai.

Figure dekho. Left par, ek bada worker ek badi desk ke saath (bahut saare tools). Right par, bahut saare chhote workers choti choti desks ke saath. Same total floor space. Yahi tradeoff hai, ek baar draw kiya taaki tum kabhi na bhuulo.

2. Die area $A$ — "floor space" symbol

Parent note mein aisi cheezein likhi hain jaise $A_{\text{total}}$, $A_{\text{core}}$, $A_{\text{cache}}$. Letter $A$ ka matlab sirf area hai — koi cheez chip surface par kitni jagah leti hai.

Chote subscripts (letter ke neeche ke chhote words) sirf batate hain ki hum kaunsa area mean kar rahe hain:

3. Counting symbol $N$

$N$ is pure topic ka star hai. Har formula disguise mein ek hi sawaal poochta hai: $N$ badhne par kya hota hai?

Yahan area idea se seedha pehla payoff milta hai. Agar poori chip $A_{\text{total}}$ hai aur har core ko $A_{\text{simple}}$ chahiye, toh tum jitne cores fit kar sakte ho woh hai:

$N=\frac{A_{\text{total}}}{A_{\text{per core}}}$

Yeh bas division = "chhoti cheez badi cheez mein kitni baar fit hoti hai?" hai — usi tarah jaise tum pizza ke slices count karne ke liye pizza ka area slice ke area se divide karte ho. Ek tiny core ($0.2{\text{mm}}^2$) ek fat core ($10{\text{mm}}^2$) se 50× zyada baar fit hota hai, jo exactly parent ka "1 complex core ≈ 50 simple cores" hai.

4. Clock speed $f$ — "har worker kitni tez tick karta hai" symbol

Har worker ke paas ek metronome imagine karo. Ek $4\text{GHz}$ metronome ek second mein 4 billion baar tick karta hai; worker har tick par ek baar act kar sakta hai.

5. IPC — instructions per tick

$f$ aur IPC ko confuse mat karo:

• $f$ = ticks per second kitne hain (metronome speed)
• IPC = ek tick mein kitna kaam hota hai (worker ke kitne haath hain)

Figure mein ek clever core dikhta hai (har tick mein 4 boxes clear) aur saath mein chaar simple cores (har ek tick mein 1 box). Notice karo: chaar simple cores milke bhi 4 boxes per tick clear karte hain — lekin sirf tab jab chaar independent kaam dene ke liye hoon. Yeh thought pakad ke rakho; yahi wajah hai ki manycore ko "data parallelism" chahiye.

6. Latency vs Throughput — "fast" hone ke do tarike

Yeh is pure topic mein sabse gehri confusion hai, isliye hum dono ko ek picture ke saath define karte hain.

Figure mein do checkout lanes dekho. Ek express lane ek lightning-fast cashier ke saath low latency deta hai — tumhare items seconds mein scan ho jaate hain. Daas slow cashiers ki ek row high throughput deti hai — store overall per minute zyada customers serve karta hai, chahe har customer thoda zyada wait kare.

Parent note ka throughput formula ab padhne layak hai:

$\text{Throughput}=N_{\text{cores}}\times f_{\text{clock}}\times \text{IPC}\times \text{Utilization}$

Seedhe shabdon mein: (kitne workers hain) × (har ek ke ticks per second) × (har ek ke jobs per tick) × (actually kaam karne ka fraction). Yeh bas un chaar ideas ko multiply karna hai jo ab tumhare paas hain.

7. Utilization $U$ — "fraction actually busy" symbol

8. Parallel fraction $P$ — Amdahl's Law ki key

Ek kaam ko ek bar samjho. Uska kuch hissa "shareable" colour karo (length $P$) aur kuch "akele karna hai" (length $1-P$). Shareable part $N$ workers ko dene se woh $P/N$ ho jaata hai. Akela wala part kabhi nahi shrinks.

Yeh akeli picture hi speedup formula hai:

$\text{Speedup}=\frac{1}{(1-P)+\frac{P}{N}}$

• $(1-P)$ term = woh zidd wala akela part (kabhi nahi shrinks).
• $P/N$ term = shareable part, $N$ mein split.

Poori derivation Amdahl's Law mein hai; yahan tumhe sirf dekhte hi har symbol pehchanna hai.

Yeh foundations topic ko kaise feed karte hain

Upar se neeche padho: core aur area ideas number-of-cores tradeoff create karte hain; clock, IPC, utilization throughput lens build karte hain; latency vs throughput aur Amdahl's $P$ decide karte hain ki kisi diye gaye kaam ke liye kaunsi philosophy jeetti hai.

Aage explore karne ke liye related foundations

• Thread-Level Parallelism — independent jobs cores ko kaise handout hote hain.
• SIMD vs MIMD — "bahut saare workers ek saath" ke do flavours.
• Cache Coherence — workers ke memory share karne ka sar dard.
• Memory Hierarchy — kyun cache area $A_{\text{cache}}$ itna important hai.
• Power Consumption — kyun slow, simple cores tumhe zyada pack karne dete hain.
• Heterogeneous Computing — bade aur chhote cores ko ek hi chip par rakhna.

Equipment checklist

Right side cover karo aur khud ko test karo. Agar koi jawab fuzzy lage, parent note se pehle woh section dobara padho.