Skip to content
ZAVIA

Free · Read online · Parallel Computing · CSC334 · By Uzair Malik

PDC lab guide — parallel and distributed computing in simple Roman Urdu

A free study guide for Parallel and Distributed Computing (CSC334) at COMSATS Abbottabad, prepared by Uzair Malik. Every lab comes with complete and clean code with Roman Urdu comments, a line-by-line explanation in plain words, and a quick cheat-sheet showing exactly which line to change.

Download the PDF — free for subscribers

Reading online above is free for everyone. To download the PDF, subscribe below — one email a week, unsubscribe anytime.

Read online

The full guide, as readable text right here on this page — no PDF, no sign-up needed to read. The PDF download unlocks after subscribing.

PDC LAB MID-TERM — COMPLETE EXAM GUIDE

Course: Parallel and Distributed Computing (CSC334) — BCS-8A/8B — Instructor: Rabbiya Hameed — COMSATS Abbottabad

Ye guide tumhari apni 7 pre-performed lab files (Lab 01 ta Lab 06 + Lab Assignment) se bani hai. Har task ke liye 4 cheezein di gayi hain: (1) Complete & Clean Code — Roman Urdu comments ke sath, (2) Bachon ki tarah asaan line-by-line report, (3) Mam exam mein kya change kar sakti hain — expected twists, (4) Quick Cheat-Sheet — kahan kya badalna hai, exact jagah ke sath.

EXAM KA GOLDEN RULE: Exam mein sawal inhi labs se SLIGHTLY CHANGE ho kar aayega. Matlab code ka DHAANCHA (structure) wohi rahega, sirf ek-do cheezein badlegi: number (N, k), operation (+ ki jagah -, sum ki jagah max), range (10-99 ki jagah kuch aur), ya naam. Is liye har task mein 'Cheat-Sheet' wala hissa sab se zyada important hai — wohi parho exam se ek raat pehle.

Poori Guide Ka Naqsha (Index)

LabTopicTasks
Lab 01Vector Operations on CPU (C language)Q1 Element-wise Add/Sub/Mul, Q2 Scalar k=12, Q3 Dot Product, Q4 Sum/Max/Min/Avg
Lab 02Vector Operations on CPU + GPU (CUDA)Wohi 4 tasks, magar GPU kernels mein — atomicAdd, shared memory
Lab 03Mutual Exclusion & Synchronization (C++ Threads)Mutex Race Condition, Ping-Pong (Condition Variable), Semaphore
Lab 04Advanced Vector Operations on CPUSmoothing, Thresholding, Histogram
Lab 05Advanced Vector Operations on GPU (CUDA)Wohi 3 tasks GPU par — atomic histogram
Lab 062D Convolution in CUDA C512x512 image, 5x5 mask, constant memory + Home Task: Matrix x Vector
AssignmentBara N (2^20, 2^24) — Timing + CUDA HistogramCPU timing, Global index, Histogram ki 3 versions (race / atomic / shared)

HISSA 0 — GOLDEN TEMPLATES (Har Lab Mein Repeat Hone Wale Code)

Ye 5 templates rat lo. Har lab ka 70% code inhi se banta hai. Exam mein change bhi aksar inhi lines mein aata hai.

Template A — Random Numbers 10 se 99 Tak

srand(time(NULL));                       // har dafa naye random numbers ke liye
for (int i = 0; i < N; i++) {
    hA[i] = rand() % 90 + 10;            // % 90 se 0..89 banta hai, +10 karne se 10..99
    hB[i] = rand() % 90 + 10;            // wohi kaam dusre vector ke liye
}
  • rand() % 90 ka matlab: kisi bhi bare number ko 90 se divide karke remainder lo — hamesha 0 se 89 tak aayega.
  • Us mein +10 mila do to range 10 se 99 ban jati hai. Yehi tumhara low=10, high=99 hai.
  • CHEAT: Agar Mam range 0-50 kahein to line hogi: rand() % 51 + 0. Formula: rand() % (high-low+1) + low. Misal 20-70: rand() % 51 + 20.

Template B — CUDA Ke 5 Steps (Har GPU Program Mein)

// STEP 1: GPU par jagah lo (cudaMalloc)
// STEP 2: Data CPU se GPU bhejo (cudaMemcpy HostToDevice)
// STEP 3: Kernel chalao  kernel<<<blocks, threads>>>(...)
// STEP 4: Result GPU se wapas CPU lao (cudaMemcpy DeviceToHost)
// STEP 5: GPU ki jagah khaali karo (cudaFree)
  • Yaad karne ka tareeqa: Hotel wala hisaab — kamra lo (Malloc), samaan rakho (H2D), kaam karo (Kernel), samaan wapas lo (D2H), kamra chhoro (Free).
  • CHEAT: Direction ulta likhna sab se aam ghalti hai. HostToDevice = bhejna, DeviceToHost = wapas lana.

Template C — Thread Ka Number (Index) Nikalna

int i = threadIdx.x;                                  // CHOTA kaam: N=60, sirf 1 block — Lab 02/05 ke solved codes
int i = blockIdx.x * blockDim.x + threadIdx.x;        // BARA kaam: bohat se blocks — Assignment / asal sahi tareeqa
if (i < N) { /* kaam sirf tab karo jab i hadd ke andar ho */ }   // GUARD: fazool threads ko roko
  • Misal: blockDim = 8, block number 2 hai, thread number 3 hai to i = 2*8+3 = 19. Har thread ko apna alag i milta hai, is liye sab parallel kaam karte hain.
  • Blocks ki tadaad (ceiling division): blocks = (N + threads - 1) / threads. Misal N=60, threads=8: (60+7)/8 = 8 blocks (64 threads, aakhri 4 guard se ruk jayenge).

Template D — atomicAdd Kyun?

  • Race condition matlab: 2 threads ek hi variable ko ek hi waqt mein badalne ki koshish karein — ek ka kaam zaya ho jata hai.
  • atomicAdd(address, value) ye kaam EK EK karke, line bana kar, sahi tareeqe se karta hai. Koi value zaya nahi hoti.
  • Isi family ke aur functions: atomicMax(address, value), atomicMin(address, value).

Template E — Shared Memory + __syncthreads()

  • Shared memory block ke andar ki tez, choti memory hai — jaise ek hi kamre ke logon ki mushtarika mez.
  • __syncthreads() ka matlab: sab threads RUKO, jab tak sab apna kaam mez par na rakh dein, koi aage nahi barhega. Ye line bhoolna = ghalat result.

LAB 01 — Vector Operations on CPU (Sirf C Language)

Maqsad: Do vectors hA aur hB hain, har ek mein N=60 numbers hain, har number 10 se 99 ke darmiyan hai. In par hisaab kitab karna hai — pehle sirf CPU par, aam C code se, ek ke baad ek (sequential).

Lab 01 — Poora Program (Q1 + Q2 + Q3 + Q4 Ek Sath)

#include <stdio.h>          // printf ke liye
#include <stdlib.h>         // rand(), srand() ke liye
#include <time.h>           // time() ke liye
#define N 60                // vector ka size = 60 numbers
#define K 12                // scalar constant k = 12

int main() {
    int hA[N], hB[N], hC[N];        // hA, hB = input, hC = result rakhne ke liye
    int hProd = 0;                  // dot product ka jawab (shuru mein 0)
    int hSum = 0;                   // sum ka jawab (shuru mein 0)

    srand(time(NULL));              // random numbers har dafa alag aayein
    for (int i = 0; i < N; i++) {   // 0 se 59 tak loop
        hA[i] = rand() % 90 + 10;   // 10..99 ka number hA mein
        hB[i] = rand() % 90 + 10;   // 10..99 ka number hB mein
    }

    // ---------- Q1: Element-wise Add / Sub / Mul ----------
    for (int i = 0; i < N; i++) hC[i] = hA[i] + hB[i];   // jorna: hC = hA + hB
    // Sub ke liye sirf + ki jagah - likhna hai, Mul ke liye * likhna hai

    // ---------- Q2: Scalar (k=12 ke sath) ----------
    for (int i = 0; i < N; i++) hC[i] = hA[i] * K;       // har number * 12
    // Add ke liye hA[i] + K, Sub ke liye hA[i] - K

    // ---------- Q3: Dot Product ----------
    for (int i = 0; i < N; i++) hProd += hA[i] * hB[i];  // jora guna karo, jama karte jao

    // ---------- Q4: Sum / Max / Min / Avg ----------
    int hMax = hA[0];               // pehle number ko hi max farz kar lo
    int hMin = hA[0];               // pehle number ko hi min farz kar lo
    for (int i = 0; i < N; i++) {
        hSum += hA[i];              // har number jama karo
        if (hA[i] > hMax) hMax = hA[i];   // bara number mile to max badal do
        if (hA[i] < hMin) hMin = hA[i];   // chota mile to min badal do
    }
    double hAvg = (double)hSum / N; // average = sum / kul tadaad

    printf("Dot Product = %d\n", hProd);                       // Q3 ka jawab print
    printf("Sum=%d Max=%d Min=%d Avg=%.2f\n", hSum, hMax, hMin, hAvg); // Q4 print
    return 0;
}

Task 1.1 — Element-wise Add / Subtract / Multiply (Q1)

Bachon Ki Tarah Report

  • Maqsad: Do vectors ke SAMNE WALE numbers ko jorna / ghatana / guna karna. hA ka pehla number hB ke pehle se, dusra dusre se — jora jora (pair by pair).
  • hC ek khaali dabba hai jisme har jore ka jawab rakha jata hai. Loop i=0 se i=59 tak ek ek jora uthata hai.
  • Data ka safar: hA[i] aur hB[i] uthay -> hisaab hua -> jawab hC[i] mein gaya -> printf ne dikhaya.

Mam Kya Change Kar Sakti Hain? (Expected Twists)

  • Twist 1: Sirf EK operation mangain (sirf Subtraction, ya sirf Multiplication) — baqi do hata dein.
  • Twist 2: Result ke liye alag teen arrays mangain: hAdd, hSub, hMul — teeno jawab ek sath rakho.
  • Twist 3: N=60 ki jagah N=50 ya N=100 kar dein.
  • Twist 4: Teesra vector jor dein: hA + hB + hD jaisi soorat.

Quick Cheat-Sheet

  • Subtraction chahiye: hC[i] = hA[i] + hB[i]; wali line mein + hata kar - likh do: hC[i] = hA[i] - hB[i];
  • Teen alag arrays: loop ke andar teeno lines likh do — hAdd[i]=hA[i]+hB[i]; hSub[i]=hA[i]-hB[i]; hMul[i]=hA[i]*hB[i];
  • N badalna: sab se upar #define N 60 wali line mein 60 ki jagah naya number. Aur kahin kuch nahi badalna — isi liye N ko define kiya jata hai.

Task 1.2 — Scalar Operations, k = 12 (Q2)

Bachon Ki Tarah Report

  • Scalar matlab EK akele number (yahan k=12) se poore vector ka hisaab. Har element ko 12 se jorna/ghatana/guna karna hai.
  • Q1 se farq sirf itna: wahan dusra VECTOR tha, yahan dusri cheez ek CONSTANT hai. Loop bilkul wohi hai.

Expected Twists

  • Twist 1: k ki value badal dein (k=5, k=20) — sab se aasan aur sab se zyada mumkin twist.
  • Twist 2: Division mangain: hC[i] = hA[i] / K; (integer division mein decimal hissa kat jata hai).
  • Twist 3: k user se input mangain: scanf se k lo, phir use karo.

Quick Cheat-Sheet

  • k badalna: #define K 12 wali line mein 12 ki jagah nayi value. (Agar code mein K ki jagah direct 12 likha ho to har jagah badalna parega — is liye #define behtar hai.)
  • Operation badalna: hA[i] * K mein * ki jagah +, - ya / likh do.

Task 1.3 — Dot Product / MAC (Q3)

Bachon Ki Tarah Report

  • MAC matlab Multiply And Accumulate — guna karo aur jama karte jao.
  • hProd ek 'gulak' (piggy bank) hai jo 0 se shuru hoti hai. Har jore ko guna karke gulak mein daal dete hain: hProd += hA[i] * hB[i];
  • Loop khatam = gulak mein poora dot product mojood hai. Jawab EK hi number hai, poora vector nahi — ye is task ki pehchan hai.

Expected Twists

  • Twist 1: Weighted sum mangain (har guna ke sath k bhi guna kar dein).
  • Twist 2: Sirf EVEN positions (i=0,2,4...) ka hisaab — loop mein i += 2 kar dein.
  • Twist 3: N chota karke haath se check karwayein (N=5) taake tum calculation dikha sako.

Quick Cheat-Sheet

  • Weighted dot product: line banegi hProd += K * hA[i] * hB[i]; — sirf K ka izafa.
  • Sirf even index: for ki line mein i++ ki jagah i += 2 likh do.
  • SAB SE AAM GHALTI: hProd = 0 karna bhool jana. Bhool gaye to purani garbage value mein jama hoga, jawab ghalat.

Task 1.4 — Sum / Max / Min / Average (Q4)

Bachon Ki Tarah Report

  • Ek hi loop mein chaar kaam: hSum mein sab jama, hMax mein sab se bara, hMin mein sab se chota, aakhir mein hAvg = hSum / N.
  • hMax aur hMin ko hA[0] se shuru karna ZAROORI hai — 0 se shuru karo to min kabhi nahi milega (saare numbers 10 se bare hain, 0 hi min reh jayega). Ye examiner ka pasandeeda sawal hai.
  • (double)hSum likhne se division decimal mein hoti hai. Na likho to 245/60 = 4 aayega, 4.08 nahi — decimal kat jayega.

Expected Twists

  • Twist 1: Sirf EK cheez mangain — sirf Max, ya sirf Average.
  • Twist 2: Dusra bara number (second maximum) ya numbers ki gintee jo average se bare hon (count above average).
  • Twist 3: Sirf EVEN numbers ka sum/average — andar if (hA[i] % 2 == 0) laga do.
  • Twist 4: Range badal dein — max/min ki initial value ka sawal yahin se banta hai.

Quick Cheat-Sheet

  • Sirf Max chahiye: loop mein sirf if (hA[i] > hMax) wali line rakho, baqi hata do.
  • Even numbers ka sum: loop ke andar if (hA[i] % 2 == 0) hSum += hA[i]; — baqi numbers skip.
  • Average se bare kitne: pehle avg nikalo, phir dusra loop chala kar count++ karo jahan hA[i] > hAvg ho.

LAB 02 — Vector Operations on GPU (CUDA)

Maqsad: Lab 01 wale wohi 4 kaam, magar is dafa GPU par. Farq sirf itna hai: CPU mein loop ek ek karke chalta tha, GPU mein har element ke liye EK THREAD ban jata hai — 60 threads ek sath kaam karte hain. Isi liye kernel mein loop NAHI hota, thread apna number (i) khud nikalta hai.

Lab 02 — Poora Program (Kernel Hisse + main Ka Dhaancha)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define N 60
#define K 12

// ----- Q1 KERNEL: element-wise add/sub/mul — har thread ek element -----
__global__ void addSubMul(int *dA, int *dB, int *dAdd, int *dSub, int *dMul) {
    int i = blockIdx.x * blockDim.x + threadIdx.x; // mera global number
    if (i < N) {                    // guard: fazool thread bahar rahe
        dAdd[i] = dA[i] + dB[i];    // jorna
        dSub[i] = dA[i] - dB[i];    // ghatana
        dMul[i] = dA[i] * dB[i];    // guna karna
    }
}

// ----- Q2 KERNEL: scalar k ke sath -----
__global__ void scalarOps(int *dA, int *dAdd, int *dSub, int *dMul) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < N) {
        dAdd[i] = dA[i] + K;        // har element + 12
        dSub[i] = dA[i] - K;        // har element - 12
        dMul[i] = dA[i] * K;        // har element * 12
    }
}

// ----- Q3 KERNEL: dot product — atomicAdd ke sath -----
__global__ void dotProductAtomic(int *dA, int *dB, int *dProd) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < N) {
        int temp = dA[i] * dB[i];   // pehle apna guna khud karo
        atomicAdd(dProd, temp);     // phir LINE mein lag kar gulak mein daalo
    }
}

// ----- Q4 KERNEL: sum/max/min — atomic family ke sath -----
__global__ void statsAtomic(int *dA, int *dSum, int *dMax, int *dMin) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < N) {
        atomicAdd(dSum, dA[i]);     // sum: sab ek gulak mein, atomically
        atomicMax(dMax, dA[i]);     // max: bara ho to hi badlega
        atomicMin(dMin, dA[i]);     // min: chota ho to hi badlega
    }
}

int main() {
    int hA[N], hB[N], hAdd[N], hSub[N], hMul[N];
    int hProd = 0, hSum = 0, hMax = 0, hMin = 999;  // atomic ke liye shuruati values
    int *dA, *dB, *dAdd, *dSub, *dMul, *dProd, *dSum, *dMax, *dMin;
    int bytes = N * sizeof(int);    // ek vector ki bytes mein size = 60*4 = 240

    srand(time(NULL));
    for (int i = 0; i < N; i++) { hA[i] = rand() % 90 + 10; hB[i] = rand() % 90 + 10; }

    // STEP 1: GPU par jagah lo
    cudaMalloc(&dA, bytes); cudaMalloc(&dB, bytes);
    cudaMalloc(&dAdd, bytes); cudaMalloc(&dSub, bytes); cudaMalloc(&dMul, bytes);
    cudaMalloc(&dProd, sizeof(int)); cudaMalloc(&dSum, sizeof(int));
    cudaMalloc(&dMax, sizeof(int));  cudaMalloc(&dMin, sizeof(int));

    // STEP 2: data bhejo (aur choti values ko unki shuruati value do)
    cudaMemcpy(dA, hA, bytes, cudaMemcpyHostToDevice);
    cudaMemcpy(dB, hB, bytes, cudaMemcpyHostToDevice);
    cudaMemcpy(dProd, &hProd, sizeof(int), cudaMemcpyHostToDevice);
    cudaMemcpy(dSum, &hSum, sizeof(int), cudaMemcpyHostToDevice);
    cudaMemcpy(dMax, &hMax, sizeof(int), cudaMemcpyHostToDevice);
    cudaMemcpy(dMin, &hMin, sizeof(int), cudaMemcpyHostToDevice);

    // STEP 3: kernels chalao — block size 8, blocks = (60+7)/8 = 8
    int threads = 8, blocks = (N + threads - 1) / threads;
    addSubMul<<<blocks, threads>>>(dA, dB, dAdd, dSub, dMul);
    dotProductAtomic<<<blocks, threads>>>(dA, dB, dProd);
    statsAtomic<<<blocks, threads>>>(dA, dSum, dMax, dMin);

    // STEP 4: results wapas lao
    cudaMemcpy(hAdd, dAdd, bytes, cudaMemcpyDeviceToHost);
    cudaMemcpy(&hProd, dProd, sizeof(int), cudaMemcpyDeviceToHost);
    cudaMemcpy(&hSum, dSum, sizeof(int), cudaMemcpyDeviceToHost);
    cudaMemcpy(&hMax, dMax, sizeof(int), cudaMemcpyDeviceToHost);
    cudaMemcpy(&hMin, dMin, sizeof(int), cudaMemcpyDeviceToHost);
    double hAvg = (double)hSum / N;  // average CPU par hi nikalta hai

    printf("Dot=%d Sum=%d Max=%d Min=%d Avg=%.2f\n", hProd, hSum, hMax, hMin, hAvg);

    // STEP 5: GPU jagah khaali karo
    cudaFree(dA); cudaFree(dB); cudaFree(dAdd); cudaFree(dSub); cudaFree(dMul);
    cudaFree(dProd); cudaFree(dSum); cudaFree(dMax); cudaFree(dMin);
    return 0;
}

Lab 02 — Bachon Ki Tarah Report

  • __global__ void wala function KERNEL kehlata hai — ye GPU par chalta hai, CPU par nahi. Kernel ko bulane ka tareeqa: naam<<<blocks, threads>>>(arguments).
  • Naam ke aage h = host (CPU ki memory), d = device (GPU ki memory). dA ko CPU wala code direct nahi parh sakta — is liye cudaMemcpy se copy karna parta hai. Ye exam ka confirm sawal hai.
  • Manual ke solved code mein sirf threadIdx.x likha hai kyunke wahan farz kiya gaya ke 1 hi block hai. Global wala formula (blockIdx.x * blockDim.x + threadIdx.x) dono soorton mein sahi hai — exam mein yehi likhna, galat nahi hoga.
  • Shared memory wali doosri soorat (manual ki Activity 4): har thread apna number shared array mein rakhta hai, __syncthreads() se sab rukte hain, phir sirf thread 0 loop chala kar sum/max/min nikalta hai. Ye tareeqa chote N ke liye hai.

Lab 02 — Expected Twists

  • Twist 1: Block size 8 ki jagah 16 ya 32 kar dein — sirf threads wali value badlegi, blocks dobara hisaab hoga: (N + threads - 1) / threads.
  • Twist 2: Q4 mein shared-memory wala tareeqa mangain atomic ki jagah (ya ulta). Dono is guide mein hain.
  • Twist 3: Sirf do operations mangain (Add aur Mul) — Sub wali lines hata do.
  • Twist 4: CPU vs GPU result compare karwa kar 'matches CPU' print karwayein — ye Assignment mein confirm hai, us ka code aage diya hai.

Lab 02 — Quick Cheat-Sheet

  • Kernel mein loop MAT likhna — thread ka i hi loop ki jagah hai. Agar Mam N bara dein (masalan 600) to sirf N badlo, blocks ka formula khud sambhal lega.
  • atomicMax ke liye dMax ki shuruati value SAB SE CHOTI rakho (0), atomicMin ke liye SAB SE BARI (999 ya INT_MAX) — ulta kiya to jawab kabhi badlega hi nahi.

LAB 03 — Mutual Exclusion & Synchronization (C++ Threads)

Ye lab GPU wali nahi hai — ye aam CPU par kai THREADS chala kar un ko apas mein ladne se bachane ki lab hai. Teen hathiyaar hain: (1) Mutex — ek waqt mein ek thread, (2) Condition Variable — bari bari (turn by turn), (3) Semaphore — ek waqt mein ginay hue threads (jaise 2).

Task 3.1 — Race Condition Aur Mutex

#include <iostream>
#include <thread>           // thread banane ke liye
#include <mutex>            // mutex (taala) ke liye
using namespace std;

int shared_var = 0;         // DONO threads ki mushtarika cheez — yahin jhagra hota hai
mutex mtx;                  // TAALA: jis ke paas hoga, wohi andar jayega

void increment() {
    for (int i = 0; i < 10000; i++) {   // har thread 10000 dafa +1 karega
        mtx.lock();         // taala lagao — dusra thread yahin ruk jayega
        shared_var++;       // CRITICAL SECTION: andar sirf EK thread hai
        mtx.unlock();       // taala kholo — ab dusra aa sakta hai
    }
}

int main() {
    thread t1(increment);   // pehla thread shuru
    thread t2(increment);   // dusra thread shuru
    t1.join();              // t1 ke khatam hone ka intezaar
    t2.join();              // t2 ke khatam hone ka intezaar
    cout << "Final value: " << shared_var << endl;  // hamesha 20000 aayega
    return 0;
}

Bachon Ki Tarah Report

  • Race condition ki misal: do log ek hi register par ek sath number likhein — ek ka likha mita diya jata hai. shared_var++ asal mein 3 steps hain (parho, +1 karo, likho) — beech mein dusra thread ghus jaye to ek increment zaya.
  • Mutex ek washroom wale taale jaisa hai: lock() = andar ja kar taala, unlock() = bahar aa kar kholna. Jawab hamesha 20000 is liye aata hai ke koi increment zaya nahi hota.
  • join() ka matlab: main wahan khara intezaar karega jab tak thread apna kaam khatam na kar le. join na karo to program pehle khatam ho sakta hai aur print adhoora reh sakta hai.

Expected Twists

  • Twist 1 (manual ki Home Task 1): Increment ki jagah DECREMENT — shared_var ko 20000 se shuru karo, dono threads -- karein, final 0 aayega.
  • Twist 2 (manual ka Lab Task 3): 10000 ki jagah 1000 dafa.
  • Twist 3: Teen threads bana dein (t3 bhi) — final 30000.
  • Twist 4: Mutex HATA kar chalao aur ghalat (20000 se kam) result ki wajah samjhao — ye theory sawal ban sakta hai.

Quick Cheat-Sheet

  • Decrement: main mein shared_var = 20000; kar do aur function mein shared_var++; ki jagah shared_var--; likh do. Taale wali lines bilkul wohi rahengi.
  • Threads barhana: thread t3(increment); aur t3.join(); ki do lines add kar do.

Task 3.2 — Ping-Pong (Condition Variable)

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>     // cv ke liye
using namespace std;

mutex mtx;
condition_variable cv;
bool ping_turn = true;              // pehle Ping ki bari (true = Ping)

void printPing() {
    for (int i = 0; i < 5; i++) {
        unique_lock<mutex> lock(mtx);              // taala pakro
        cv.wait(lock, [] { return ping_turn; });   // apni bari tak SOYE raho
        cout << "Ping ";                           // bari mili — print karo
        ping_turn = false;                         // ab Pong ki bari
        cv.notify_all();                           // sab ko jaga do
    }
}

void printPong() {
    for (int i = 0; i < 5; i++) {
        unique_lock<mutex> lock(mtx);
        cv.wait(lock, [] { return !ping_turn; });  // Pong ki bari tab jab ping_turn false ho
        cout << "Pong" << endl;
        ping_turn = true;                          // wapas Ping ki bari
        cv.notify_all();
    }
}

int main() {
    thread t1(printPing);
    thread t2(printPong);
    t1.join(); t2.join();
    return 0;
}   // Output: Ping Pong  Ping Pong ... (5 dafa)

Bachon Ki Tarah Report

  • Condition variable ek 'bari batane wala board' hai. cv.wait ka matlab: jab tak meri bari nahi, mujhe sula do — CPU zaya nahi hota.
  • ping_turn ek jhanda (flag) hai. Ping print karke jhanda gira deta hai (false) aur notify_all se sab ko jagata hai — magar sirf Pong wala aage barhta hai kyunke usi ki shart poori hai. Ping wala wapas so jata hai.
  • unique_lock is liye use hota hai kyunke cv.wait ko lock ko khud lock/unlock karna parta hai (sote waqt taala khul jata hai taake dusra andar aa sake).

Expected Twists

  • Twist 1 (manual ka Lab Task 5 + Home Task 2 — SAB SE MUMLIN): Ping/Pong ki jagah NUMBERS 1-10 aur LETTERS A-J bari bari print karo: 1 A 2 B 3 C ...
  • Twist 2: Ping/Pong 5 ki jagah 10 dafa.
  • Twist 3: Pehle Pong shuru karwayein — ping_turn = false se shuru kar do.

Quick Cheat-Sheet

  • Numbers/Letters wala twist: printPing mein cout << i+1 << " "; aur printPong mein cout << (char)('A' + i) << endl; likh do, loop 5 ki jagah 10 kar do. DHAANCHA 100% wohi hai — sirf print wali line badli hai.
  • Dafa badalni ho: dono functions ke loop mein i < 5 ki jagah i < 10 — DONO mein badalna hai, warna ek thread intezaar karta reh jayega aur program atak (hang) jayega.

Task 3.3 — Semaphore (Ek Waqt Mein Sirf 2 Threads)

#include <iostream>
#include <thread>
#include <chrono>           // sleep ke liye
#include <semaphore.h>      // POSIX semaphore: sem_t, sem_wait, sem_post
using namespace std;

sem_t semaphore;            // TOKENS wali tokri — kitne andar ja sakte hain

void accessResource(int thread_id) {
    sem_wait(&semaphore);  // token lo — tokri khaali ho to yahin RUK jao
    cout << "Thread " << thread_id << " is accessing the resource." << endl;
    this_thread::sleep_for(chrono::seconds(2));  // 2 second kaam ka natak
    cout << "Thread " << thread_id << " is done." << endl;
    sem_post(&semaphore);   // token wapas tokri mein — agla andar aa sakta hai
}

int main() {
    sem_init(&semaphore, 0, 2);   // shuru mein 2 tokens = ek waqt mein 2 threads
    thread t1(accessResource, 1);
    thread t2(accessResource, 2);
    thread t3(accessResource, 3);
    thread t4(accessResource, 4);
    t1.join(); t2.join(); t3.join(); t4.join();
    sem_destroy(&semaphore);     // aakhir mein semaphore khatam
    return 0;
}

Bachon Ki Tarah Report

  • Semaphore ek tokri mein rakhe tokens hain. sem_init mein teesra number (2) batata hai ke ek waqt mein KITNE threads andar ho sakte hain.
  • sem_wait = token uthana (na mile to darwaze par intezaar), sem_post = kaam khatam karke token wapas rakhna.
  • Mutex se farq: mutex mein sirf 1 (malik wala taala), semaphore mein ginay hue kai (2, 3...) — aur token koi bhi wapas rakh sakta hai.

Expected Twists

  • Twist 1 (manual ki Home Task 3): Sirf 1 thread ek waqt mein — sem_init ki value 2 se 1 kar do. Ab ye bilkul mutex jaisa bartao karega.
  • Twist 2: 3 tokens kar dein (value 3) — 3 threads ek sath andar.
  • Twist 3: Threads 4 ki jagah 5 ya 6 kar dein.

Quick Cheat-Sheet

  • Poora twist EK number mein hai: sem_init(&semaphore, 0, 2); — aakhri 2 ko badal do. 1 = ek ek karke, 3 = teen ek sath. Is se zyada asaan twist ho hi nahi sakta, is liye ye exam mein aana bohat mumkin hai.

LAB 04 — Advanced Vector Operations on CPU

Teen naye kaam hain: Smoothing (padosi numbers ka average), Thresholding (number ko us ke group ka number 0/1/2/3 dena), Histogram (har group mein kitne numbers aaye, gintee karna). Teeno ka khaana peena ek hi hai: N=60, numbers 10-99, groups ye hain: [10-31]=bin0, [32-54]=bin1, [55-76]=bin2, [77-99]=bin3.

GROUPS YAAD KARNE KA TRICK: Pehla group 10 se shuru. Har group ki upar wali hadd: 31, 54, 76, 99. Code mein hum < 32, < 55, < 77 likhte hain — matlab '32 se chota hai to bin 0'. Dono ek hi baat hai.

Lab 04 — Poora Program

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define N 60

int main() {
    int hA[N], hC[N];               // hA = asal numbers, hC = jawab
    int hB1 = 0, hB2 = 0, hB3 = 0, hB4 = 0;  // histogram ke 4 dabbe (bins)

    srand(time(NULL));
    for (int i = 0; i < N; i++) hA[i] = rand() % 90 + 10;   // 10..99

    // ---------- Q1: SMOOTHING ----------
    hC[0] = hA[0];                  // pehla element WESA KA WESA (us ka left padosi nahi)
    hC[N-1] = hA[N-1];              // aakhri element bhi wesa ka wesa (right padosi nahi)
    for (int i = 1; i < N-1; i++)   // beech wale: 1 se N-2 tak
        hC[i] = (hA[i-1] + hA[i] + hA[i+1]) / 3;  // left + khud + right, divide 3

    // ---------- Q2: THRESHOLDING ----------
    for (int i = 0; i < N; i++) {
        if (hA[i] < 32)      hC[i] = 0;   // 10..31 -> 0
        else if (hA[i] < 55) hC[i] = 1;   // 32..54 -> 1
        else if (hA[i] < 77) hC[i] = 2;   // 55..76 -> 2
        else                 hC[i] = 3;   // 77..99 -> 3
    }

    // ---------- Q3: HISTOGRAM ----------
    for (int i = 0; i < N; i++) {
        if (hA[i] < 32)      hB1++;   // bin1 mein ek aur
        else if (hA[i] < 55) hB2++;   // bin2 mein ek aur
        else if (hA[i] < 77) hB3++;   // bin3 mein ek aur
        else                 hB4++;   // bin4 mein ek aur
    }
    printf("Bin1=%d Bin2=%d Bin3=%d Bin4=%d  (kul = %d)\n",
           hB1, hB2, hB3, hB4, hB1+hB2+hB3+hB4);  // kul hamesha N=60 hona chahiye
    return 0;
}

Task 4.1 — Smoothing

Bachon Ki Tarah Report

  • Smoothing matlab number ko 'narm' karna: har number ko us ke dono padosiyon ke sath mila kar average nikalna, taake achanak upar-neeche wali values smooth ho jayein. Jaise 3 doston ke marks 30, 90, 30 — beech wale ka smooth = (30+90+30)/3 = 50.
  • Pehla aur aakhri is liye copy hote hain kyunke un ka ek padosi hai hi nahi — hA[-1] ya hA[60] parhna ghalat (out of bounds) hoga. Yehi 'boundary handling' hai, examiner ka sawal yahin banta hai.
  • Integer division: (10+20+25)/3 = 55/3 = 18 (18.33 nahi) — decimal kat jata hai. Manual mein ye baat khaas likhi hai.

Expected Twists

  • Twist 1: 3 ki jagah 5 padosi (2 left + khud + 2 right) ka average — divide 5, boundary par pehle 2 aur aakhri 2 copy.
  • Twist 2: Sirf left padosi ke sath average: (hA[i-1] + hA[i]) / 2.
  • Twist 3: Weighted smoothing: beech wale ko zyada wazan: (hA[i-1] + 2*hA[i] + hA[i+1]) / 4.

Quick Cheat-Sheet

  • 5-padosi wala: loop i=2 se i<N-2 tak, line: hC[i] = (hA[i-2]+hA[i-1]+hA[i]+hA[i+1]+hA[i+2]) / 5; aur upar hC[1]=hA[1]; hC[N-2]=hA[N-2]; ki 2 lines add kar do.
  • Weighted wala: sirf hisaab wali line badlo — upar wali cheat line hi jawab hai.

Task 4.2 — Thresholding

Bachon Ki Tarah Report

  • Thresholding matlab darwaze (thresholds) bana kar har number ko batana ke tum kis group ke ho. Number khud jawab nahi banta, us ke GROUP KA NUMBER (0,1,2,3) hC mein jata hai.
  • if-else ki seedhi neeche ki taraf chalti hai: pehli shart fail ho to agli check hoti hai. Is liye < 32, phir < 55, phir < 77 — choti se bari taraf jana zaroori hai, warna sab pehli hi shart mein phans jayenge.

Expected Twists

  • Twist 1: Groups 4 ki jagah 2 kar dein (sirf < 55 aur >= 55 — matlab 0 ya 1).
  • Twist 2: Groups ki ranges badal dein (masalan 10-49 -> 0, 50-99 -> 1, ya naye 4 groups).
  • Twist 3: Jawab 0-3 ki jagah grades dein (A/B/C/D) — hC ko char array kar do.

Quick Cheat-Sheet

  • 2 groups: sirf if (hA[i] < 55) hC[i] = 0; else hC[i] = 1; — beech wali do lines hata do.
  • Range badalna: sirf < ke baad wale numbers badlo. Nayi range [10-49],[50-99] ho to pehli line if (hA[i] < 50) hogi — hamesha 'agli range ki pehli value' likhi jati hai.

Task 4.3 — Histogram

Bachon Ki Tarah Report

  • Histogram matlab GINTEE ka chart: har group mein kitne numbers aaye. Thresholding se farq: wahan har number ko label milta tha (60 jawabat), yahan sirf 4 ginteeyan milti hain (4 jawabat).
  • hB1..hB4 chaar khaali dabbe hain jo 0 se shuru hote hain. Jo number jis group mein jaye, us dabbe mein ++ (ek ka izafa).
  • CHECK: Chaaro bins ka sum hamesha N (60) ke barabar hoga. Kam aaye to samajh jao koi number kisi group mein gaya hi nahi — ranges mein ghalti hai.

Expected Twists

  • Twist 1: Bins 4 ki jagah 3 ya 5 kar dein (ranges usi hisaab se).
  • Twist 2: Histogram ke sath har bin ki PERCENTAGE bhi print karwayein: (hB1 * 100.0 / N).
  • Twist 3: Sab se bara bin (mode group) dhoondna — chaaro ko compare karke max bin print karo.

Quick Cheat-Sheet

  • Percentage: printf wali line mein har bin ke sath %.1f%% add karo: hB1 * 100.0 / N — 100.0 likhna zaroori hai, 100 likha to integer division decimal kaat dega.
  • Bins array mein rakhne ka dusra tareeqa (Assignment mein yehi use hoga): int hB[4] = {0}; aur hB[bin]++; — yahan bin wahi 0-3 hai jo thresholding deta hai.

LAB 05 — Advanced Vector Operations on GPU (CUDA)

Lab 04 wale wohi 3 kaam, ab GPU par. Soch bilkul Lab 02 wali hai: loop khatam, har element ka ek thread. Do khaas baatein: histogram mein saare threads ek hi 4 dabbo ko badalte hain, is liye atomicAdd ke baghair race condition hoga; aur smoothing mein kernel ke andar boundary wala hisaab thread khud karta hai.

Lab 05 — Poora Program

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define N 60

// Q1: Smoothing kernel — har thread apna element smooth karta hai
__global__ void smoothVector(int *dA, int *dC) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i >= N) return;                       // guard
    if (i == 0 || i == N-1) dC[i] = dA[i];    // kinare wale as-is copy
    else dC[i] = (dA[i-1] + dA[i] + dA[i+1]) / 3;  // beech wale: 3 ka average
}

// Q2: Thresholding kernel — har thread apne number ka bin number likhta hai
__global__ void thresholdVector(int *dA, int *dC) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i >= N) return;
    int val = dA[i];                          // pehle apna number uthao
    if (val < 32)      dC[i] = 0;             // 10..31
    else if (val < 55) dC[i] = 1;             // 32..54
    else if (val < 77) dC[i] = 2;             // 55..76
    else               dC[i] = 3;             // 77..99
}

// Q3: Histogram kernel — atomicAdd se race khatam
__global__ void histogramVector(int *dA, int *dB1, int *dB2, int *dB3, int *dB4) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i >= N) return;
    int val = dA[i];
    if (val < 32)      atomicAdd(dB1, 1);     // dabba 1 mein +1, line bana kar
    else if (val < 55) atomicAdd(dB2, 1);     // dabba 2 mein +1
    else if (val < 77) atomicAdd(dB3, 1);     // dabba 3 mein +1
    else               atomicAdd(dB4, 1);     // dabba 4 mein +1
}

int main() {
    int hA[N], hC[N];
    int hB1 = 0, hB2 = 0, hB3 = 0, hB4 = 0, *dA, *dC, *dB1, *dB2, *dB3, *dB4;
    int bytes = N * sizeof(int);
    srand(time(NULL));
    for (int i = 0; i < N; i++) hA[i] = rand() % 90 + 10;

    cudaMalloc(&dA, bytes); cudaMalloc(&dC, bytes);              // arrays ki jagah
    cudaMalloc(&dB1, sizeof(int)); cudaMalloc(&dB2, sizeof(int)); // har bin ki jagah
    cudaMalloc(&dB3, sizeof(int)); cudaMalloc(&dB4, sizeof(int));
    cudaMemcpy(dA, hA, bytes, cudaMemcpyHostToDevice);            // data bhejo
    cudaMemcpy(dB1, &hB1, sizeof(int), cudaMemcpyHostToDevice);   // bins ko 0 se shuru karo
    cudaMemcpy(dB2, &hB2, sizeof(int), cudaMemcpyHostToDevice);
    cudaMemcpy(dB3, &hB3, sizeof(int), cudaMemcpyHostToDevice);
    cudaMemcpy(dB4, &hB4, sizeof(int), cudaMemcpyHostToDevice);

    int threads = 8, blocks = (N + threads - 1) / threads;        // 8 blocks x 8 = 64 threads
    smoothVector<<<blocks, threads>>>(dA, dC);
    cudaMemcpy(hC, dC, bytes, cudaMemcpyDeviceToHost);             // smooth result wapas
    histogramVector<<<blocks, threads>>>(dA, dB1, dB2, dB3, dB4);
    cudaMemcpy(&hB1, dB1, sizeof(int), cudaMemcpyDeviceToHost);   // ginteeyan wapas
    cudaMemcpy(&hB2, dB2, sizeof(int), cudaMemcpyDeviceToHost);
    cudaMemcpy(&hB3, dB3, sizeof(int), cudaMemcpyDeviceToHost);
    cudaMemcpy(&hB4, dB4, sizeof(int), cudaMemcpyDeviceToHost);
    printf("Bins: %d %d %d %d (kul=%d)\n", hB1, hB2, hB3, hB4, hB1+hB2+hB3+hB4);
    cudaFree(dA); cudaFree(dC); cudaFree(dB1); cudaFree(dB2); cudaFree(dB3); cudaFree(dB4);
    return 0;
}

Lab 05 — Bachon Ki Tarah Report + Twists + Cheat-Sheet

  • CPU se GPU mein sab se bara farq histogram mein hai: CPU par ek hi banda gin raha tha, GPU par 60 threads ek sath 4 hi dabbo ko chhoo rahe hain — atomicAdd na ho to gintee kam ho jayegi (yehi race Assignment mein bare N par saaf nazar aati hai).
  • Twist 1: Block size 8 manual mein diya hai — Mam 16 ya 256 kar sakti hain. Sirf threads wali value badlo, blocks formula khud hisaab dega.
  • Twist 2: Bins ko 4 alag variables ki jagah EK array dB[4] mein rakhna — kernel mein atomicAdd(&dB[bin], 1); jahan bin pehle threshold wale tareeqe se nikla ho. Assignment wali shared-memory version ko yehi array chahiye hota hai.
  • Twist 3: Smoothing ka 5-padosi wala version — Lab 04 wali cheat yahan bhi chalegi, sirf dA/dC ke naam ke sath.
  • CHEAT (array wale bins): kernel se pehle int bin; if (val < 32) bin = 0; else if (val < 55) bin = 1; else if (val < 77) bin = 2; else bin = 3; phir ek hi line atomicAdd(&dB[bin], 1); — chaar atomic wali lines ek mein simat jati hain.

LAB 06 — 2D Convolution in CUDA C

Ab tak hum 1D vector par the, ab 2D IMAGE hai: 512x512 grayscale tasveer. Convolution matlab har pixel ko us ke aas paas ke pixels ke sath ek MASK (choti 5x5 jadvali / filter) se guna-jama karke nayi tasveer banana — jaise photo par blur ya sharpen wala filter lagana. Mask sab threads ke liye ek hi hai aur sirf parhna hai, is liye usay CONSTANT MEMORY mein rakhte hain (tez bhi, sab ko ek sath broadcast bhi ho jata hai).

Lab 06 — Kernel + main Ka Dhaancha

#include <stdio.h>
#include <stdlib.h>
#define MASK_WIDTH 5                 // mask 5x5 ka hai
#define WIDTH 512
#define HEIGHT 512

__constant__ float d_M[MASK_WIDTH * MASK_WIDTH];  // mask CONSTANT memory mein (sirf GPU wala naam)

// Har thread EK output pixel banata hai
__global__ void Convolution2D_Kernel(float *d_N, float *d_P, int ImgWidth, int ImgHeight) {
    int row = blockIdx.y * blockDim.y + threadIdx.y;  // mera row (y wali line)
    int col = blockIdx.x * blockDim.x + threadIdx.x;  // mera column (x wali line)
    if (row >= ImgHeight || col >= ImgWidth) return;  // guard: tasveer se bahar wale threads ruk jao

    float sum = 0.0f;                          // is pixel ka jawab jama hoga yahan
    int radius = MASK_WIDTH / 2;               // 5/2 = 2 (mask ka centre)
    for (int m = 0; m < MASK_WIDTH; m++) {         // mask ki rows par loop
        for (int n = 0; n < MASK_WIDTH; n++) {     // mask ki columns par loop
            int r = row + m - radius;              // tasveer mein woh row jo mask ke neeche hai
            int c = col + n - radius;              // tasveer mein woh column
            float image_val = 0.0f;                // zero-padding: bahar ho to 0 samjho
            if (r >= 0 && r < ImgHeight && c >= 0 && c < ImgWidth)
                image_val = d_N[r * ImgWidth + c];   // 2D -> 1D: row*width + col
            sum += image_val * d_M[m * MASK_WIDTH + n];  // guna karke jama
        }
    }
    d_P[row * ImgWidth + col] = sum;           // jawab output tasveer mein likh do
}

int main() {
    int size = WIDTH * HEIGHT;                    // 512*512 = 262144 pixels
    float *h_N = (float*)malloc(size * sizeof(float));  // input tasveer (CPU)
    float *h_P = (float*)malloc(size * sizeof(float));  // output tasveer (CPU)
    float h_M[MASK_WIDTH * MASK_WIDTH];             // mask (CPU par banao)
    for (int i = 0; i < size; i++) h_N[i] = rand() % 256;       // 0..255 gray values
    for (int i = 0; i < MASK_WIDTH*MASK_WIDTH; i++) h_M[i] = 1.0f/25.0f; // blur mask: sab 1/25

    float *d_N, *d_P;
    cudaMalloc(&d_N, size * sizeof(float));
    cudaMalloc(&d_P, size * sizeof(float));
    cudaMemcpy(d_N, h_N, size * sizeof(float), cudaMemcpyHostToDevice);
    cudaMemcpyToSymbol(d_M, h_M, MASK_WIDTH*MASK_WIDTH*sizeof(float)); // mask constant memory mein bhejo — ye line khaas hai!

    dim3 block(16, 16);                             // block = 16x16 = 256 threads
    dim3 grid((WIDTH + 15) / 16, (HEIGHT + 15) / 16); // grid = 32x32 blocks
    Convolution2D_Kernel<<<grid, block>>>(d_N, d_P, WIDTH, HEIGHT);

    cudaMemcpy(h_P, d_P, size * sizeof(float), cudaMemcpyDeviceToHost);
    printf("Convolution done. Centre pixel = %f\n", h_P[(HEIGHT/2)*WIDTH + WIDTH/2]);
    cudaFree(d_N); cudaFree(d_P); free(h_N); free(h_P);
    return 0;
}

Manual ke printed kernel mein r = i + m likha hai (radius minus kiye baghair) — wo mask ko pixel ke neeche-daaein se shuru karta hai. Upar wale code mein hum ne centre-wala sahi tareeqa (r = row + m - radius) likha hai jo Mam ne lecture mein samjhaya hota hai. Exam mein agar manual wala exact code dekhna allowed hai to dono mein se jo lecture se match kare wohi chunna — faraq sirf in 2 lines ka hai. Boundary ke liye manual 'skip boundary pixels' bhi kehta hai, jabke ye code zero-padding karta hai — dono qabool tareeqay hain, ek chun kar consistent rehna.

Bachon Ki Tarah Report

  • 2D mein thread ka pata bhi 2D hota hai: row ke liye .y wale hisse (blockIdx.y, threadIdx.y, blockDim.y), column ke liye .x wale. Isi liye block dim3(16,16) likha jata hai.
  • 2D tasveer asal mein memory mein EK line mein pari hoti hai, is liye (row, col) ko 1D number banana parta hai: index = row * ImgWidth + col. Ye formula rat lo, exam mein yahin number banta hai.
  • Har thread apne pixel ke gird 5x5 ka khaaka ghumata hai: 25 guna, 25 jama — ye do nested loops (m aur n) hain. Image par loop NAHI hai, wo kaam threads ne baant liya hai.
  • cudaMemcpyToSymbol aam cudaMemcpy se alag hai — ye constant memory (__constant__ wale d_M) mein bhejne ke liye use hota hai. Ye line exam mein khaas poochi ja sakti hai.

Expected Twists

  • Twist 1: Mask 5x5 ki jagah 3x3 kar dein — sirf #define MASK_WIDTH 3, aur h_M ki values 9 ho jayengi (blur ke liye 1.0f/9.0f). Kernel bilkul nahi badlega, yahi is design ki khoobi hai.
  • Twist 2: Image size badal dein (256x256 ya 1024x1024) — WIDTH/HEIGHT badlo, grid formula khud sambhal lega.
  • Twist 3: Block 16x16 ki jagah 8x8 ya 32x32 — dim3 block wali line badlo.
  • Twist 4: Mask ki values badal dein (sharpen filter: beech mein 5, kinaro par -1) — sirf h_M ki values badlegi.

Quick Cheat-Sheet

  • 3x3 mask: line 1 mein MASK_WIDTH 5 -> 3, blur wali line mein 1.0f/25.0f -> 1.0f/9.0f. Bas, do jagah.
  • Sharpen mask: h_M ko aise bharo: sab 0, chaaro seedhay padosi -1, centre 5: h_M[2*5+2]=5; h_M[1*5+2]=h_M[3*5+2]=h_M[2*5+1]=h_M[2*5+3]=-1;

Home Task — Rectangular Matrix x Vector Multiplication

Manual ka home task: ek AISI matrix jo square nahi (masalan 3 rows x 4 columns) ko ek vector (4 numbers) se guna karna. Jawab mein 3 numbers aayenge (har row ka ek). CPU aur GPU dono diye ja rahe hain.

// CPU VERSION (C) — har row ka dot product us row ke vector ke sath
// result[row] = M[row][0]*x[0] + M[row][1]*x[1] + M[row][2]*x[2] + M[row][3]*x[3]
// Misal: M = {{1,2,3,4},{5,6,7,8},{9,10,11,12}}, x = {1,1,1,1}
// Jawab hona chahiye: {10, 26, 42}  (agar x={1,0,0,0} ho to jawab pehla column {1,5,9})
for (int row = 0; row < ROWS; row++) {          // har row ke liye
    int sum = 0;                                 // is row ki gulak
    for (int col = 0; col < COLS; col++)         // row ke har number ke liye
        sum += hM[row * COLS + col] * hX[col];   // guna karke jama (2D->1D: row*COLS+col)
    hY[row] = sum;                               // is row ka jawab
}

// GPU VERSION (CUDA) — har ROW ke liye ek thread, andar wala loop wohi
__global__ void matVecKernel(int *dM, int *dX, int *dY, int rows, int cols) {
    int row = blockIdx.x * blockDim.x + threadIdx.x;  // mera row number
    if (row >= rows) return;                          // guard
    int sum = 0;
    for (int col = 0; col < cols; col++)
        sum += dM[row * cols + col] * dX[col];        // wohi guna-jama
    dY[row] = sum;
}
// Launch: matVecKernel<<<1, ROWS>>>(dM, dX, dY, ROWS, COLS);
  • Pehchan: ye asal mein DOT PRODUCT ka bara bhai hai — har row ek alag dot product hai. Lab 01 Q3 samajh aaya to ye free ke number hain.
  • Twist: Matrix square kar dein (4x4) ya sizes badal dein — sirf ROWS/COLS ki values badlegi. Vector ki length HAMESHA columns ke barabar hoti hai, aur jawab ki length rows ke barabar — ye do baatein likh kar dikhana examiner ko khush karta hai.

LAB ASSIGNMENT — Bara N: Timing, Global Index, Histogram Ki 3 Versions

Ye tumhari sab se latest file hai (20 number ki assignment) aur Lab 04/05 ko Lab 02 se jorti hai. Is mein wohi smoothing / thresholding / histogram hai, magar N = 60 ki jagah N = 2^20 (10,48,576) aur N = 2^24 (1,67,77,216) hai. N bara hone se 3 nayi cheezein aati hain: (1) waqt naapna (timing), (2) ek se zyada blocks, is liye GLOBAL index, (3) histogram mein race condition itni bari ho jati hai ke gintee saaf ghalat aati hai — phir us ke 2 ilaaj (atomic, phir shared memory).

Task A1 — CPU Baseline + Timing (Task 1)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>          // clock() ke liye

// teenon kaam functions mein — taake timing alag alag naap sako (Lab 04 wala hi hisaab)
void smoothCPU(int *hA, int *hC, int N) {
    hC[0] = hA[0]; hC[N-1] = hA[N-1];                       // kinare copy
    for (int i = 1; i < N-1; i++) hC[i] = (hA[i-1] + hA[i] + hA[i+1]) / 3;
}
void threshCPU(int *hA, int *hC, int N) {
    for (int i = 0; i < N; i++) {
        if (hA[i] < 32) hC[i] = 0; else if (hA[i] < 55) hC[i] = 1;
        else if (hA[i] < 77) hC[i] = 2; else hC[i] = 3;
    }
}
void histCPU(int *hA, int *hB, int N) {   // hB ek array hai: hB[0..3], shuru mein sab 0
    for (int i = 0; i < N; i++) {
        if (hA[i] < 32) hB[0]++; else if (hA[i] < 55) hB[1]++;
        else if (hA[i] < 77) hB[2]++; else hB[3]++;
    }
}

int main() {
    int N = 1 << 20;                       // 2^20 = 1048576 (2^24 ke liye 1 << 24)
    int *hA = (int*)malloc(N * sizeof(int));   // bara N stack par nahi, malloc se lo
    int *hC = (int*)malloc(N * sizeof(int));
    int hB[4] = {0,0,0,0};
    srand(time(NULL));
    for (int i = 0; i < N; i++) hA[i] = rand() % 90 + 10;

    clock_t start = clock();               // ghari shuru
    smoothCPU(hA, hC, N);                  // kaam karo
    clock_t end = clock();                 // ghari band
    double ms = (double)(end - start) * 1000.0 / CLOCKS_PER_SEC;  // milli-second mein waqt
    printf("Smoothing N=%d time = %.2f ms\n", N, ms);   // isi tarah thresh/hist ki timing bhi lo
    free(hA); free(hC);
    return 0;
}
  • Timing ka formula rat lo: (end - start) * 1000.0 / CLOCKS_PER_SEC = milli-seconds. 1000 se guna na karo to jawab seconds mein aayega.
  • N=60 par pehle VERIFY karna hai (chota N, jawab haath se check ho sakta hai), phir bare N par sirf TIME naapna hai — assignment ki ye tartib hi us ka sawal hai: 'pehle sahi honay ki tasdeeq, phir speed'.
  • Twist: N ki values badal dein (2^18, 2^22) — sirf 1 << 20 wali line badlegi. Ya teeno operations ki timing ka GRAPH/table mangain — teeno ko bari bari clock ke darmiyan rakho.

Task A2 — CUDA Smoothing / Thresholding Baray N Ke Liye (Task 2)

Kernel Lab 05 walay hi hain, sirf 2 tabdeeliyan: (1) i nikalne ke liye GLOBAL formula, (2) launch ke waqt threads = 256 aur blocks = (N + 255) / 256. Chote N=60 par test ke liye threads = 8 diye gaye hain assignment mein.

  • CHEAT: Lab 05 ke kernel mein sirf pehli line badlo: int i = threadIdx.x; ki jagah int i = blockIdx.x * blockDim.x + threadIdx.x; aur guard if (i >= N) return; lazmi rakho — bara N kabhi threads ki exact tadaad ke barabar nahi hota.
  • Verify karne ka code (Task 2c): CPU aur GPU ke hC ko ek loop mein compare karo, pehli jagah jahan farq mile us ka index print karo, sab barabar hon to 'matches CPU' print karo:
int firstMismatch = -1;                          // -1 matlab abhi tak sab barabar
for (int i = 0; i < N; i++) {
    if (hC_cpu[i] != hC_gpu[i]) { firstMismatch = i; break; }  // pehla farq mila, ruk jao
}
if (firstMismatch == -1) printf("matches CPU\n");
else printf("Mismatch at index %d: CPU=%d GPU=%d\n", firstMismatch, hC_cpu[firstMismatch], hC_gpu[firstMismatch]);

Task A3 — Histogram Ki 3 Versions (Task 3) — IS ASSIGNMENT KI JAAN

// Pehle har thread ke liye bin nikalne ka mushtarika hisaab:
//   int val = dA[i];  int bin = (val < 32) ? 0 : (val < 55) ? 1 : (val < 77) ? 2 : 3;

// VERSION (a): BINA synchronization — GALAT gintee (race condition ka saboot)
__global__ void histNaive(int *dA, int *dB, int N) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i >= N) return;
    int val = dA[i];
    int bin = (val < 32) ? 0 : (val < 55) ? 1 : (val < 77) ? 2 : 3;
    dB[bin]++;            // KHATRA: hazaron threads ek sath ++ kar rahe hain — gintee zaya hogi
}

// VERSION (b): atomicAdd global bins par — SAHI, magar sust (har thread line mein)
__global__ void histAtomic(int *dA, int *dB, int N) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i >= N) return;
    int val = dA[i];
    int bin = (val < 32) ? 0 : (val < 55) ? 1 : (val < 77) ? 2 : 3;
    atomicAdd(&dB[bin], 1);   // ek ek karke — sahi gintee, magar N dafa line
}

// VERSION (c): SHARED memory pehle, phir sirf 4 atomic per block — SAHI aur TEZ
__global__ void histShared(int *dA, int *dB, int N) {
    __shared__ int sB[4];                          // is BLOCK ki apni 4-dabbon wali copy
    if (threadIdx.x < 4) sB[threadIdx.x] = 0;      // pehle 4 threads har dabba 0 kar dein
    __syncthreads();                               // RUKO — sab dabbe 0 ho jayein pehle
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < N) {
        int val = dA[i];
        int bin = (val < 32) ? 0 : (val < 55) ? 1 : (val < 77) ? 2 : 3;
        atomicAdd(&sB[bin], 1);                    // shared par atomic (tez, global wali line nahi)
    }
    __syncthreads();                               // RUKO — block ki gintee poori ho jaye
    if (threadIdx.x < 4) atomicAdd(&dB[threadIdx.x], sB[threadIdx.x]); // har block sirf 4 global atomic karega
}

Version (a) Ki Gintee N Ke Barabar Kyun Nahi Hoti? (Theory Jawab — 1 Number Pakka)

  • dB[bin]++ asal mein 3 steps hain: purani value parho, +1 karo, wapas likho. Do threads ek hi bin ki purani value (masalan 100) ek sath parh lein to dono 101 likhenge — do increments hone thay, ek hua. Ek gintee zaya.
  • N = 2^24 par hazaron threads ek hi 4 dabbo par takra rahe hain, is liye hazaron ginteeyan zaya hoti hain aur chaaro bins ka sum N se KAM aata hai. Jitna bara N, utna zyada nuqsan.

Atomic Operations Ka Hisaab (Task 3e — SOLVED)

CheezHisaabJawab
Kul threads (N)2^2416,777,216
Blocks (256 threads/block)16,777,216 / 25665,536 blocks
Version (b) global atomicshar thread 1 atomic = N16,777,216
Version (c) global atomicshar block sirf 4 atomic = 65,536 x 4262,144
Kitni dafa kam?16,777,216 / 262,14464 dafa kam
  • Yaad karne ka tareeqa: Version (c) mein global atomic sirf (blocks x bins) hote hain. Ratio hamesha threads-per-block / bins = 256/4 = 64 aayega — N jo bhi ho.

Expected Twists

  • Twist 1: N ya threads-per-block badal dein (masalan N=2^20, threads=128) — hisaab wohi tareeqa: blocks = N/threads, (b) = N, (c) = blocks x 4, ratio = threads/4.
  • Twist 2: Bins 4 ki jagah 8 kar dein — version (c) mein sB[8], threadIdx.x < 8, aur atomics = blocks x 8 ho jayenge.
  • Twist 3: Shared wali version mein __syncthreads() ki jagah poochein (kyun 2 dafa hai?) — jawab: pehli dafa taake 0 wali initialization sab ko dikhe, dusri dafa taake merge se pehle poori gintee mukammal ho.

AAKHRI HISSA — EK PAGE KA MASTER CHEAT (Exam Se Pehle Ye Parho)

Agar Mam Kahein...To Sirf Ye Badlo
N = 60 ki jagah aur size#define N wali line / N variable ki value — aur kahin kuch nahi
k ki nayi value#define K 12 ki value
Operation badlein (+ - *)hisaab wali EK line mein nishan (+, -, *) badlo
Numbers ki range badleinrand() % (high-low+1) + low — Template A
Sirf even / odd numbersloop ke andar if (hA[i] % 2 == 0) lagao
Block size badlein (CUDA)threads variable ki value; blocks = (N + threads - 1) / threads
Bara N (ek block se zyada)kernel ki pehli line: i = blockIdx.x * blockDim.x + threadIdx.x + guard if (i < N)
Bins / groups badleinsirf < 32, < 55, < 77 wale numbers — 'agli range ki pehli value'
Semaphore mein ek waqt mein X threadssem_init ka AAKHRI number X kar do
Mutex increment -> decrementshared_var++ -> shared_var--; shuruati value ulta kar do
Ping/Pong -> Numbers/Letterssirf cout wali lines: i+1 aur (char)('A'+i), loop 10 kar do
Mask 5x5 -> 3x3 (Convolution)MASK_WIDTH 3 + mask values 1/9 (blur ke liye)
Image size badleinWIDTH/HEIGHT ki values; grid formula khud sambhal lega
Histogram tez karna hoshared-memory version (c): pehle block ke andar gintee, phir 4 atomic per block

Aam Ghaltian Jo Number Katwati Hain

  • 1. hProd / hSum / bins ko 0 se shuru karna bhoolna — jawab mein garbage jama hota hai.
  • 2. hMin ko 0 se shuru karna — min hamesha 0 hi aayega (numbers 10+ hain). hA[0] ya 999 se shuru karo.
  • 3. Average mein (double) na likhna — decimal hissa kat jata hai.
  • 4. cudaMemcpy ki direction ulta likhna — bhejna HostToDevice, wapas lana DeviceToHost.
  • 5. Kernel mein guard (if i < N) bhoolna — threads zyada hon to memory se bahar access, program crash.
  • 6. __syncthreads() bhoolna shared memory ke baad — gintee adhoori merge hoti hai.
  • 7. unlock() / sem_post() bhoolna — dusre threads hamesha ke liye atke rahenge (deadlock/hang).
  • 8. join() bhoolna — main pehle khatam, threads ka kaam adhoora print hoga.

ALLAH HAFIZ WALA RULE: Exam mein naya sawal dekh kar ghabrana nahi — pehle ye dhoondo ke 'ye kis lab ke kis task jaisa hai?' Phir us task ka code likho, aur aakhir mein is Master Cheat table se sirf woh EK tabdeeli lagao jo sawal ne mangi hai. Slightly modified sawal ka jawab = purana code + ek choti si tabdeeli. Yahi is poori guide ka khulasa hai. Best of luck!

What is inside

Lab 01

Vector operations on CPU (C)

Element-wise add, subtract and multiply, scalar with k = 12, dot product, and sum, max, min and average for N = 60.

Lab 02

Vector operations on CPU + GPU (CUDA)

The same four tasks as GPU kernels, with atomicAdd and shared memory.

Lab 03

Mutual exclusion and synchronization (C++ threads)

Mutex race condition, ping-pong with a condition variable, and semaphore.

Lab 04

Advanced vector operations on CPU

Smoothing, thresholding and histogram, explained step by step.

Lab 05

Advanced vector operations on GPU (CUDA)

The same three tasks on the GPU, including an atomic histogram.

Lab 06

2D convolution in CUDA C

512 by 512 image with a 5 by 5 mask and constant memory, plus the matrix-vector home task.

Assignment

Large N timing and CUDA histogram

CPU timing for large N, global indexing, and three histogram versions: race, atomic and shared memory.

Who prepared it

This guide was prepared by Uzair Malik, a BCS Computer Science student at COMSATS University Abbottabad and founder of Zavia, from his own pre-performed labs for CSC334. It is a student study guide, not official course material, and it is not endorsed by the university or the course instructor.

The guide starts with five golden templates that repeat in almost every lab — random numbers in a range, the five CUDA steps, thread indexing, atomicAdd, and shared memory with synchronization — then works through each lab in turn, ending with a one-page master cheat table and a list of common mistakes.

Download the PDF — free for subscribers

Reading online above is free for everyone. To download the PDF, subscribe below — one email a week, unsubscribe anytime.