Noesis
6.2.6 · D1 · HinglishGPU Architecture

Foundations — Thread blocks and grids

2,809 words13 min read↑ Read in English

6.2.6 · D1 · Hardware › GPU Architecture › Thread blocks aur grids

Parent note padhne se pehle, aapko us mein aane wale har word aur symbol ko apna banana hoga. Yeh page unhe ek-ek karke, bilkul scratch se build karta hai — har ek cheez agli cheez ke liye raasta banati hai.

1. Thread — akela worker

Picture: socho ek insaan ek desk pe baitha hai jiske paas ek chhota task card hai jis par likha hai "A[?] + B[?] add karo". ? abhi fill nahi hua — yahi toh baad mein jo indexing hum build karte hain uska poora point hai. Har thread same card chalata hai; bas woh number alag hota hai jo woh ? mein daalta hai. Figure s01 exactly yahi dikhata hai: ek desk, ek card, aur ek pink arrow jo khali ? ki taraf point kar raha hai jise hume abhi fill karna hai.

Topic ko yeh kyun chahiye: GPU ki power yeh hai ki uske paas hazaaron desks ek hi waqt kaam kar rahi hain. Lekin hazaaron identical workers jo same card chala rahe hain woh sab same number karenge — bekar! Toh humein har worker ko ek alag index dene ka tarika chahiye. Yahi zaroorat neeche ki har cheez ko drive karti hai.

Figure — Thread blocks and grids
Figure s01 — Ek single thread code ki ek copy chalata hai; yellow task card mein unknown index ? hai jise indexing ko compute karna hai.

2. Block — threads ki ek team

Picture: pehle wali desks lo aur unhe ek room mein group karo. Ek room mein sab log:

  • ek saath paas paas baithe hain,
  • wall par ek whiteboard share karte hain (shared memory),
  • "sab yahan ruko!" chilla sakte hain aur tab tak rukenge jab tak saare roommates pakad na lein (`__syncthreads()`).

Topic ko yeh kyun chahiye: hardware physically ek million workers ko ek giant shared whiteboard nahi de sakta — wires bahut lambi aur bahut slow ho jaati hain. Chhote rooms mein group karne se shared whiteboard chhota aur fast rehta hai. Block "kaun sasta cooperate kar sakta hai" ki boundary hai.

3. Grid — sare blocks ka map

Picture: ab ek room se poori building tak zoom out karo, ek floor plan jisme identical rooms tile kiye gaye hain. Building poora warehouse floor cover karti hai (poora array, poori image). Rooms kaam ke dauran ek doosre se baat nahi karte — har ek autonomous hai. Figure s02 dono levels stack karta hai: blue dots threads hain, har yellow box ek block hai, aur poori picture grid hai.

Topic ko yeh kyun chahiye: ek block mein sirf ~1024 threads aa sakte hain, lekin aapke array mein ek million elements ho sakte hain. Aapko bahut saare blocks chahiye. Grid simply "sare blocks hain, poore data set ko cover karne ke liye arranged" hai.

Figure — Thread blocks and grids
Figure s02 — Thread → Block → Grid: har dot ek thread hai, har box ek block hai, aur sare boxes milke grid banate hain.

4. Chaar built-in coordinates (aur unke .x .y .z fields)

Har thread, jaise hi shuru hota hai, usse chaar chhote rulers diye jaate hain. Yeh woh raw symbols hain jo parent note use karta hai.

Picture (ek hotel): blockIdx = aap kis floor par hain, blockDim = rooms-per-floor (ek constant), threadIdx = us floor par aapka room number, gridDim = hotel mein kitne floors hain. Figure s03 yeh hotel draw karta hai aur "you" room ko circle karta hai taaki charo rulers ka physical meaning ho.

Figure — Thread blocks and grids
Figure s03 — Chaar built-in variables ek hotel se padte hain: floors = blockIdx, rooms-per-floor = blockDim, floor-count = gridDim, aapka room number = threadIdx. Yellow room "you" ko mark karta hai.

Topic ko yeh kyun chahiye: yeh chaar hi woh akeele facts hain jo ek thread apne baare mein jaanta hai. Thread jo kuch bhi karta hai — kaunsa array element touch karta hai — yeh sab charo numbers se compute karna hota hai.

5. Multiply-and-add: globalID

Ab har symbol define ho gaya hai, toh hum parent note ka central formula honestly padh sakte hain. Hum sabse simple case se shuru karte hain, phir .x .y .z fields use karke 2D aur 3D tak extend karte hain.

Yeh kya karta hai, plain words mein: "mere se pehle aane wale rooms ke sare workers gino, phir is room mein meri seat number add karo."

Multiplication kyun? Har pehle wale room ne exactly blockDim.x workers contribute kiye. Agar main room number blockIdx.x mein hun, toh mere se pehle blockIdx.x complete rooms aaye. Unhe sab count karne ke liye: (mere se pehle rooms ki sankhya) × (workers per room) = blockIdx.x × blockDim.x. Multiplication repeated addition hai — yeh "blockDim.x ko blockIdx.x baar add karo" ka shortcut hai.

Phir threadIdx.x kyun add karte hain? Woh count sirf mere room ke front door tak pahunchta hai. Meri exact seat dhundhne ke liye, main threadIdx.x aur jagahen step karta hun.

Kaisa dikhta hai: ek number line jahan rooms equal-length fences hain aur globalID poori fence par aapki absolute position hai. Figure s04 woh fence draw karta hai aur ek worker ki absolute seat mark karta hai.

Figure — Thread blocks and grids
Figure s04 — 1D number line: har block blockDim.x seats ki ek equal-length stretch hai; globalID zero se count karte hue aapki absolute seat hai.

Yahi idea 2D aur 3D mein. Higher dimensions mein aap har axis ke liye ek coordinate compute karte ho exactly same multiply-and-add use karke, ek baar .x ke liye, ek baar .y ke liye, (ek baar .z ke liye):

6. Bracket symbols ⌈ ⌉ — ceiling (aur N aur B ka matlab)

Parent note likhta hai . Brackets touch karne se pehle, do letters samjho.

Kyun upar round karte hain, neeche nahi: agar aapke paas N = 1000 elements hain aur B = 256 threads ke blocks hain (yaani blockDim.x = 256), toh 1000/256 = 3.9. Teen blocks mein sirf 768 elements aate hain — 232 bina worker ke reh jaate hain! Aapko ek chautha (partly-empty) block add karna hoga. Aap kabhi neeche round karke data untouched nahi chhod sakte, toh ceiling problem ke by force zaroor hai.

Woh extra empty block exactly wahi reason hai kyun parent ke kernel ko ek if-guard if (i < N) chahiye: block 4 ke leftover workers ke paas koi valid element nahi hai aur unhe woh memory touch karne ki jagah chup rehna hoga jo unki nahi hai.

7. Warp — 32 ka marching squad

Ek aur word jo parent use karta hai.

Picture: har room ke andar workers freely nahi chalte — woh 32 ki rows mein march karte hain, aur poori row ko ek saath same step lena hota hai. Agar ek row ke aadhe ko "left turn" kaha jaye aur aadhe ko "right turn," toh woh dono ek saath nahi kar sakte, toh row left karti hai jab right waale half frozen khade rehte hain, phir vice versa — wasted steps (divergence).

Topic ko yeh kyun chahiye: yahi reason hai kyun parent kehta hai "block size 32 ka multiple hona chahiye." 40 threads ka ek block phir bhi do rows of 32 (64 slots) mein march karta hai, 24 slots har step idle chhod deta hai. Block sizes ko 32 ke multiples tak round karne se kuch waste nahi hota.

Prerequisite map

Thread = one worker

Block = team of threads

Warp = squad of 32

Grid = all blocks

threadIdx seat in room

blockDim room size = B

blockIdx which room

gridDim how many rooms

globalID formula

2D and 3D coordinates via x y z

Ceiling division for block count

N problem size

Multiple of 32 rule

Parent topic: Thread blocks and grids

Map worker to data element

Har upstream cheez parent topic Thread blocks aur grids mein flow karti hai. Jab yeh sab aapka ho jaata hai, parent ke CUDA examples plain English ki tarah padte hain.

Equipment checklist

Right side cover karo aur zor se jawab do. Aage badhne se pehle har ek reflex banana hoga.

Thread kya hai?
Ek worker jo program ki ek copy ek data element par chalata hai.
Block kya hai?
Same SM par threads ka ek fixed group jo fast memory share karte hain aur synchronize kar sakte hain.
Grid kya hai?
Ek saath launch kiye gaye sare blocks ka collection, jo kisi bhi order mein independently chalte hain.
Chaar built-ins .x .y .z ke saath kyun likhte hain?
Yeh 3-component vectors hain; har field ek direction hai (x = columns, y = rows, z = depth).
threadIdx.x ek thread ko kya batata hai?
x-axis ke along apne block ke andar uski position (room mein seat).
blockIdx.y ek thread ko kya batata hai?
Kaunse block mein hai woh, y-axis ke along (rooms ki kaunsi row).
blockDim.x ka matlab kya hai?
x ke along threads per block (room width), sab ke liye same.
gridDim.z ka matlab kya hai?
Depth axis ke along blocks ki sankhya.
1D global ID formula likho.
globalID = blockIdx.x × blockDim.x + threadIdx.x.
2D row aur col formulas likho.
col = blockIdx.x × blockDim.x + threadIdx.x; row = blockIdx.y × blockDim.y + threadIdx.y.
Ek 2D (row, col) ko memory index mein flatten karo.
idx = row × width + col.
blockIdx.x × blockDim.x multiply kyun karte hain?
Is block se pehle aane wale complete blocks ke sare workers count karne ke liye.
N ka matlab kya hai?
Problem size — process karne ke liye data elements ki sankhya.
B ka matlab kya hai aur yeh blockDim se kaise related hai?
Block size (threads per block); yeh blockDim.x ke same number hai.
kya karta hai aur yahan kyun?
Round up karta hai; zaroor hai taaki leftover elements ko bhi (partly empty) block mile.
ka integer form?
(N + B - 1) / B.
if (i < N) guard kyun?
Last block mein spare threads hain jinke paas koi valid element nahi; guard unhe galat memory touch karne se rokta hai.
Warp kya hai aur uska size kya hai?
32 threads ka ek squad jo ek saath same instruction execute karta hai (SIMT); size 32.
Block size 32 ka multiple kyun banate hain?
Warps 32 wide hote hain; doosre sizes last warp mein idle slots chhodte hain.