লিখিত ও মৌখিক (ভাইভা) প্রশ্ন — লজিক, ISA, pipeline আর মেমরি

সংজ্ঞা: Stored-program ধারণায় instruction আর ডেটা দুটোই binary সংখ্যা হিসেবে একই read-write মেমরিতে থাকে; CPU মেমরি থেকে instruction এনে চালায়, তাই প্রোগ্রাম বদলাতে hardware বদলাতে হয় না (ENIAC-এর তার জুড়ে প্রোগ্রামের বিপরীতে)।

  von Neumann                      Harvard
 +-----+   one bus   +--------+    +-----+  I-bus  +--------+
 | CPU |<===========>| Memory |    | CPU |<=======>| I-mem  |
 +-----+  (instr +   | instr  |    |     |  D-bus  +--------+
          data)      | + data |    |     |<=======>| D-mem  |
                     +--------+    +-----+         +--------+

ব্যাখ্যা: von Neumann-এ একটি মেমরি আর একটি পথ — একই cycle-এ instruction আর ডেটা দুটো আনা যায় না। Harvard-এ দুটি আলাদা মেমরি আর পথ, তাই একসাথে আনা যায়। আধুনিক CPU “modified Harvard”: ভেতরে আলাদা L1 I-cache আর D-cache, কিন্তু main memory একটিই — প্রোগ্রামারের চোখে একটি address space.

Bottleneck: CPU অনেক দ্রুত, মেমরির একটি পথ ধীর — CPU অপেক্ষায় বসে থাকে (von Neumann bottleneck). কমানোর উপায়: cache-এর স্তর, আলাদা I/D cache, pipelining আর prefetching, চওড়া bus.

উদাহরণ ও উপসংহার: একটি lw instruction-এ দুবার মেমরি লাগে — একবার instruction আনতে, একবার ডেটা পড়তে; আলাদা I/D পথ থাকায় pipeline-এ দুটি একই cycle-এ ভিন্ন instruction-এর জন্য হতে পারে। ছোট microcontroller প্রায়ই খাঁটি Harvard (flash-এ কোড, SRAM-এ ডেটা)।

নম্বর কোথায়: stored-program-এর সংজ্ঞা (২), দুটি লেবেলসহ ছবি (২), পার্থক্য (২), bottleneck ও প্রতিকার (২)। পর্ব ০১ · পর্ব ০২

সূত্র: CPU time = IC × CPI × T_c = IC × CPI ÷ f — লৌহসূত্র। Algorithm, ভাষা আর compiler প্রভাবিত করে IC আর CPI; ISA তিনটিই; microarchitecture CPI আর T_c; technology শুধু T_c.

হিসাব: CPU time = ২ × ১০^৯ × ২.২ ÷ (২ × ১০^৯) = ২.২ s. MIPS = f ÷ (CPI × ১০^৬) = ২০০০ ÷ ২.২ ≈ ৯০৯ MIPS. Load-এর CPI ৩ হলে অবদান ০.৬, নতুন CPI = ১.৮, সময় ১.৮ s, speedup = ২.২ ÷ ১.৮ ≈ ১.২২ গুণ.

উপসংহার: MIPS দিয়ে দুটি ভিন্ন ISA-র যন্ত্র তুলনা করা চলে না — IC বাদ পড়ে; তুলনা করতে হয় একই প্রোগ্রামের execution time দিয়ে।

নম্বর কোথায়: সূত্র ও গুণকের প্রভাব (২), weighted CPI-এর টেবিল (২), CPU time ও MIPS একক সহ (২), নতুন CPI ও speedup (২)। পর্ব ০৩

সংজ্ঞা: n বিটের two's complement-এ MSB-এর ওজন −২^n−১, বাকিগুলোর ধনাত্মক; পরিসর −২^n−১ থেকে ২^n−১ − ১ (৮ বিটে −১২৮ … ১২৭)। ঋণাত্মক করতে সব বিট উল্টে ১ যোগ: −x = ~x + 1, কারণ x + ~x = ২ⁿ − ১।

−৪৫: ৪৫ = 0010 1101 → উল্টে 1101 0010 → +1 = 1101 0011 (0xD3). যাচাই: −১২৮ + ৬৪ + ১৬ + ২ + ১ = −৪৫ ✓.

  carries : 0 1 1 0 0 0 0 0      (c_in to MSB = 1, c_out = 0)
    100   :   0 1 1 0 0 1 0 0
  +  50   :   0 0 1 1 0 0 1 0
  = -106  :   1 0 0 1 0 1 1 0    V = c_in(MSB) XOR c_out = 1 XOR 0 = 1

ব্যাখ্যা: দুটি ধনাত্মক সংখ্যার যোগফলের চিহ্ন-বিট ১ — ফল ১৫০ সীমার বাইরে, বিটগুলো −১০৬ পড়ায়। নিয়ম: একই চিহ্নের দুটি operand-এর ফলের চিহ্ন ভিন্ন হলে overflow; hardware-এ V = C_in ⊕ C_out (MSB-এ)। Carry বলে unsigned ফল সীমার বাইরে (এখানে C = ০ — unsigned ১৫০ ঠিকই আছে)।

উপসংহার: একই adder signed আর unsigned দুটোই যোগ করে; শুধু কোন flag দেখবেন তা আলাদা। Two's complement-এ শূন্য একটিই, তাই sign-magnitude-এর চেয়ে ভালো।

নম্বর কোথায়: সংজ্ঞা ও পরিসর (১), −৪৫ ধাপসহ (২), যোগ ও V (২), carry বনাম overflow (১)। পর্ব ০৫ · পর্ব ২০

সংজ্ঞা: De Morgan: (A + B)′ = A′B′ আর (AB)′ = A′ + B′. ভাষায় — “যোগের উল্টো = উল্টোদের গুণ”, আর উল্টোটাও। (এই পাতায় complement লেখা হয়েছে A′ দিয়ে।)

 A B | A+B (A+B)' | A' B' A'B' | AB (AB)' A'+B'
 0 0 |  0     1   |  1  1   1  |  0   1     1
 0 1 |  1     0   |  1  0   0  |  0   1     1
 1 0 |  1     0   |  0  1   0  |  0   1     1
 1 1 |  1     0   |  0  0   0  |  1   0     0

ব্যাখ্যা: চার সারিতে (A + B)′ আর A′B′ কলাম হুবহু এক, (AB)′ আর A′ + B′-ও — perfect induction, সব ইনপুট পরীক্ষা করে প্রমাণ। n চলকে: (A₁ + … + A_n)′ = A₁′ ⋯ A_n′.

Circuit উদাহরণ: A + B = (A′B′)′ = NAND(A′, B′), আর A′ = NAND(A, A). তাই OR = NAND(NAND(A, A), NAND(B, B)) — তিনটি NAND. এটিই bubble pushing: OR-এর ইনপুটে বুদবুদ ঠেলে দিলে সেটি NAND হয়ে যায়।

প্রোগ্রামিং উদাহরণ: C-তে !(x > 0 && y > 0) আর x <= 0 || y <= 0 একই শর্ত। “দোকান খোলা আর মাল আছে — এমন নয়” মানে “দোকান বন্ধ, অথবা মাল নেই”।

উপসংহার: De Morgan থেকেই SOP → NAND–NAND আর POS → NOR–NOR রূপান্তর; CMOS-এ NAND আর NOR স্বভাবতই inverting বলে এই রূপান্তর chip-এ সবচেয়ে সস্তা।

নম্বর কোথায়: দুটি সূত্র (১), truth table (২), circuit ও প্রোগ্রাম উদাহরণ (২), NAND দিয়ে OR (১)। পর্ব ০৭ · পর্ব ০৮

সংজ্ঞা: K-map হলো truth table-এর এমন সাজানো রূপ, যেখানে সারি আর কলাম Gray ক্রমে (00, 01, 11, 10) — পাশাপাশি দুটি ঘর ঠিক এক চলকে আলাদা, তাই XY + XY′ = X লাগিয়ে দল বানানো যায়। কিনারা পেরিয়েও ঘর পাশাপাশি (torus).

  AB\CD   00   01   11   10
   00   [ 1    1 ]   0  [ 1 ]      P = B'D'  : m0, m2, m8, m10 (four corners)
   01     0  ( 1 )   0    0        Q = B'C'  : m0, m1, m8, m9  (top + bottom rows)
   11     0    0     0    0        R = A'C'D : m1, m5
   10   [ 1    1 ]   0  [ 1 ]

ব্যাখ্যা: চার কোণ একটি ৪-এর দল (B′D′); ওপর আর নিচের সারির প্রথম দুই কলাম কিনারা পেরিয়ে আরেকটি ৪-এর দল (B′C′); m5 একা — তার একমাত্র সঙ্গী m1, তাই A′C′D. সব prime implicant: B′D′, B′C′, A′C′D. প্রতিটিই কোনো একটি 1-কে একাই ঢাকে (m2/m10 শুধু P-তে, m9 শুধু Q-তে, m5 শুধু R-এ), তাই তিনটিই essential.

উত্তর: F = B′C′ + B′D′ + A′C′D (৭টি literal). POS-এর জন্য 0-এর দল: F′ = AB + BD′ + CD, তাই F = (A′ + B′)(B′ + D)(C′ + D′).

NAND–NAND: প্রতিটি গুণফলের জন্য একটি NAND (B′, C′, D′, A′ ইনপুট হিসেবে — দরকারে NOT বা NAND(x, x)), তারপর তিনটির আউটপুট একটি ৩-ইনপুট NAND-এ। De Morgan-এর কারণে দুই স্তরের NAND–NAND = AND–OR.

যাচাই ও উপসংহার: একটি সারি মেলান — m5 = 0101: A′C′D = ১·১·১ = ১ ✓; m6 = 0110: তিনটি পদই ০ ✓. ৪-এর বেশি চলকে K-map চোখে কঠিন — তখন Quine-McCluskey (পর্ব ১০) বা tool.

নম্বর কোথায়: সঠিক map (২), তিনটি দল (৩), PI ও EPI (২), SOP ও POS (২), NAND–NAND (১)। পর্ব ০৯ · পর্ব ১০

সংজ্ঞা: Ripple-carry adder-এ n টি full adder শিকলে জোড়া — প্রতিটি ঘর ডান থেকে carry আসার অপেক্ষা করে। Carry-lookahead adder (CLA) সব carry সরাসরি মূল ইনপুট থেকে হিসাব করে।

Generate ও propagate: g_i = a_ib_i (ঘর নিজেই carry বানায়), p_i = a_i ⊕ b_i (ঢোকা carry পার করে)। তাহলে c_i+1 = g_i + p_ic_i, আর বারবার বসিয়ে:

c1 = g0 + p0 c0
c2 = g1 + p1 g0 + p1 p0 c0
c3 = g2 + p2 g1 + p2 p1 g0 + p2 p1 p0 c0
c4 = g3 + p3 g2 + p3 p2 g1 + p3 p2 p1 g0 + p3 p2 p1 p0 c0
s_i = p_i XOR c_i

Delay-এর প্রমাণ: Ripple-এ c_i আসার পর একটি AND আর একটি OR লাগে — ২ delay; g, p তৈরি সময় ১-এ, তাই আরোহে c_i তৈরি হয় সময় 2i + 1-এ: c_n = 2n + 1 (৪ বিটে ৯, ৩২ বিটে ৬৫, ৬৪ বিটে ১২৯)। CLA-তে g, p সময় ১-এ, ওপরের AND-OR দুই স্তর → প্রতিটি carry সময় ৩-এ, sum-এর XOR সময় ৪-এ — ৪ বিটে ৪ gate delay, n-এর ওপর নির্ভর করে না (fan-in সীমার ভেতরে)।

উপসংহার: বাস্তবের ৬৪ বিট adder বহুস্তর lookahead বা prefix adder (Kogge–Stone, Brent–Kung) — সময় আর আয়তনের বিনিময়।

নম্বর কোথায়: দুটির সংজ্ঞা (২), g ও p (১), চারটি সমীকরণ (৩), ripple delay-এর যুক্তি (২), CLA delay ও তুলনা (২)। পর্ব ১১

সংজ্ঞা: SR latch দুটি cross-coupled NOR gate-এর একটি bistable circuit: Q = NOR(R, Q′), Q′ = NOR(S, Q). Feedback-এর কারণে এটি এক বিট মনে রাখে।

 R ---[NOR1]---+---> Q        Q  = NOR(R, Q')
        ^      |              Q' = NOR(S, Q)
        |      v   (cross-coupled feedback)
 S ---[NOR2]---+---> Q'

 S R | Q+          meaning
 0 0 | Q           hold
 0 1 | 0           reset
 1 0 | 1           set
 1 1 | 0 (Q' = 0)  forbidden

Race-এর ব্যাখ্যা: S = R = 1 দিলে দুটি NOR-এরই একটি ইনপুট ১, তাই Q = Q′ = ০ — “Q′ হলো Q-এর উল্টো” সম্পর্ক ভাঙে। আসল সমস্যা আসে তারপর: S আর R একসাথে ০-তে নামালে দুটি gate-ই দেখে অন্য আউটপুট ০, তাই দুটিই ১ হতে চায়। সমান delay ধরলে (এক একক, দুই gate একসাথে বদলায়) আউটপুট 00 → 11 → 00 → 11 … দোলে; বাস্তবে একটি gate সামান্য দ্রুত, তাই latch কোনো এক দিকে পড়ে — কিন্তু কোন দিকে, আগে বলা যায় না। এটিই race.

Timing diagram-এ যা আঁকবেন: তিনটি রেখা S, R, Q একই সময়-অক্ষে। S = ১ পালসে Q ওঠে (একটু delay পরে), R = ১ পালসে নামে; তারপর S আর R একসাথে ১ → Q = ০; একসাথে ০ হওয়ার মুহূর্তের পর Q-এর জায়গায় দ্রুত দোলা বা ধূসর “অনিশ্চিত” অংশ — লিখুন “race: মান অনির্দিষ্ট”।

Latch বনাম flip-flop: Latch level-sensitive — enable চালু থাকার পুরো সময় স্বচ্ছ, D-র প্রতিটি বদল Q-তে যায়; flip-flop edge-triggered — শুধু clock-এর ধারের মুহূর্তের D ধরে। দুটি D latch উল্টো enable-এ জুড়ে master–slave D flip-flop হয়।

Race-around: level-triggered JK-তে J = K = ১ আর clock pulse propagation delay-এর চেয়ে লম্বা হলে Q একটি pulse-এর মধ্যেই বারবার উল্টায় — শেষ মান অনিশ্চিত। প্রতিকার: master–slave বা edge-triggered গঠন (প্রতি ধারে ঠিক একবার toggle). Excitation table (JK): 0→0: 0X, 0→1: 1X, 1→0: X1, 1→1: X0.

উপসংহার: আধুনিক synchronous নকশায় প্রায় সব স্মৃতি-উপাদান edge-triggered D flip-flop; SR-এর আচরণ আসে asynchronous preset/clear হিসেবে।

নম্বর কোথায়: circuit ও truth table (২), নিষিদ্ধ অবস্থা আর race (৩), timing diagram (২), latch বনাম flip-flop (২), race-around ও প্রতিকার (১)। পর্ব ১৫

সংজ্ঞা: Setup time — clock ধারের আগে D যতক্ষণ স্থির থাকতে হবে; hold time — ধারের পরে যতক্ষণ স্থির থাকতে হবে। (Harris & Harris-এর লেখা: t_pcq = clock-to-Q-এর সর্বোচ্চ, t_ccq = সর্বনিম্ন; t_pd, t_cd = logic-এর সর্বোচ্চ ও সর্বনিম্ন delay.)

Setup-এর শর্ত: একটি ধারে ছাড়া ডেটা পরের ধারের t_setup আগে পৌঁছাতে হবে: T_c ≥ t_pcq + t_pd + t_setup = ৩০ + ৩৫০ + ২০ = ৪০০ ps → f_max = ১ ÷ ৪০০ ps = ২.৫ GHz.

Hold-এর শর্ত: একই ধারে নতুন ডেটা এত দ্রুত পৌঁছানো চলবে না যে পরের flip-flop-এর hold জানালা ভাঙে: t_ccq + t_cd ≥ t_hold. এখানে ২০ + ১৫ = ৩৫ ps < ৪০ ps — ৫ ps-এর hold violation. শর্তে T_c নেই, তাই clock ধীর করে সারে না; ছোট পথে অন্তত ৫ ps-এর buffer বসাতে হয়।

clk   ____|‾‾‾‾‾‾|______|‾‾‾‾‾‾|____
           ^ edge 1        ^ edge 2
D2    ====X=============X=======      setup window: before edge 2
          |<-tpcq+tpd-->|<tsu>|
          |<tccq+tcd>|               hold window: right after edge 1

Metastability: একটি asynchronous বোতামের সংকেত clock-এর সাথে মেলে না; কখনো সেটি ঠিক setup–hold জানালার ভেতরে বদলাবেই। তখন flip-flop ০ আর ১-এর মাঝামাঝি ভোল্টেজে কিছুক্ষণ আটকে থাকতে পারে — metastability. এটি এড়ানো যায় না, শুধু বিরল করা যায়: MTBF = e^t_r/τ ÷ (T₀ · f_clk · f_data). Resolution time t_r সূচকে বসে, তাই প্রথম flip-flop-এর পরে মাঝে কোনো logic ছাড়া দ্বিতীয় একটি flip-flop (two-flip-flop synchronizer) প্রায় এক cycle বাড়তি সময় দিয়ে MTBF বহুগুণ বাড়ায়।

উপসংহার: setup ঠিক করে গতি, hold ঠিক করে নির্ভুলতা; আর clock domain পেরোনো প্রতিটি সংকেতে synchronizer — বহু-বিট মান হলে Gray code বা async FIFO.

নম্বর কোথায়: দুটি সংজ্ঞা (২), setup শর্ত ও f_max (২), hold শর্ত, violation ও সমাধান (৩), metastability ও synchronizer (৩)। পর্ব ১৮

সংজ্ঞা: Moore-এর output শুধু বর্তমান state থেকে (এক cycle পরে, স্থির); Mealy-র output state আর বর্তমান input থেকে (একই cycle-এ, তবে input-এর ঝাঁকুনি output-এ যায়)। একই কাজে Mealy-তে state সমান বা কম।

ব্যাখ্যা: প্রতিটি state হলো “এখন পর্যন্ত মিলে যাওয়া সবচেয়ে লম্বা prefix”. S3-এ 1 এলে “1011” পূর্ণ — z = ১, আর overlapping বলে শেষের “1” নতুন শুরুর prefix, তাই S1-এ যাই। S3-এ 0 এলে “1010”-এর শেষ “10” prefix — S2. State diagram-এ চারটি বৃত্ত, প্রতিটি থেকে দুটি তীর, তীরে “x/z” লিখুন।

Moore: output state-এ বসাতে “1011 পাওয়া গেছে” নামে একটি বাড়তি state লাগে — ৫টি state, ⌈log_২ ৫⌉ = ৩টি flip-flop; Mealy-তে ৪টি state, ২টি flip-flop.

উপসংহার: output-এর পরিচ্ছন্নতা জরুরি হলে (যেমন traffic light) Moore; কম state আর এক cycle আগে সাড়া চাইলে Mealy.

নম্বর কোথায়: পার্থক্য (২), সঠিক state table (৩), overlap-এর যুক্তি (১), Moore-এর হিসাব (২)। পর্ব ১৭ · পর্ব ১৯

সংজ্ঞা ও নিয়ম: Booth-এর algorithm two's complement সংখ্যা সরাসরি গুণ করে। প্রতি ধাপে (Q₀, Q₋₁) দেখুন: 10 → A = A − M; 01 → A = A + M; 00 বা 11 → কিছু নয়; তারপর A:Q:Q₋₁-এর arithmetic right shift. n বার; ফল A:Q-এর 2n বিট।

উদাহরণ: M = 0011 (৩), Q = 1100 (−৪), −M = 1101. নিচের stepper-এ প্রতিটি ধাপ:

কেন কাজ করে: two's complement-এ Q = −q_n−1২ⁿ⁻¹ + Σq_i২ⁱ. q₋₁ = ০ ধরলে দেখানো যায় Q = Σ_i=0ⁿ⁻¹ (q_i−1 − q_i)২ⁱ — দুই যোগফলের পদ মিলিয়ে বাতিল করলে শুধু −q_n−1২ⁿ⁻¹ আর বাকিগুলো থাকে। প্রতিটি অঙ্ক d_i = q_i−1 − q_i ∈ {−১, ০, +১}: (q_i, q_i−1) = (১, ০) → −১ (বিয়োগ), (০, ১) → +১ (যোগ)। তাই M × Q = Σd_i·M·২ⁱ, আর প্রতিটি shift ২ⁱ-এর ওজন বসায়।

সবচেয়ে খারাপ ক্ষেত্র: পালাক্রমের বিট (0101…) — প্রতিটি ধাপে যোগ বা বিয়োগ, n টি কাজ; যেমন (−৩) × ৫-এ (Q = 0101) চারটি ধাপেই কাজ। সমাধান radix-4 Booth: তিন বিট দেখে অঙ্ক {−২ … +২}, partial product প্রায় অর্ধেক।

নম্বর কোথায়: নিয়ম (২), সম্পূর্ণ টেবিল (৪), সঠিক ফল ও যাচাই (১), প্রমাণের মূল যুক্তি (২), worst case (১)। পর্ব ২১

নিজের সংখ্যায় টেবিল মেলাতে এই ছোট tracer — পরীক্ষার টেবিলের মতোই ছাপে:

// Booth's algorithm, n-bit, printed as the exam table: step, (Q0,Q-1), action, A, Q, Q-1.
function booth(M, Q, n) {
  const mask = (1 << n) - 1, bits = v => v.toString(2).padStart(n, "0");
  let A = 0, q = Q & mask, q1 = 0;
  const m = M & mask;
  console.log(`M = ${bits(m)} (${M}), Q = ${bits(q)} (${Q}), n = ${n}`);
  console.log("step Q0Q-1 action   A     Q     Q-1");
  console.log(`init  --    ----   ${bits(A)}  ${bits(q)}  ${q1}`);
  for (let i = 1; i <= n; i++) {
    const pair = `${q & 1}${q1}`;
    let act = "shift ";
    if (pair === "10") { A = (A - m) & mask; act = "A-M,sh"; }
    if (pair === "01") { A = (A + m) & mask; act = "A+M,sh"; }
    q1 = q & 1;                                   // arithmetic right shift of A:Q:Q-1
    q = (q >>> 1) | ((A & 1) << (n - 1));
    A = (A >>> 1) | (A & (1 << (n - 1)));
    console.log(`  ${i}   ${pair}    ${act} ${bits(A)}  ${bits(q)}  ${q1}`);
  }
  let p = (A << n) | q;
  if (p & (1 << (2 * n - 1))) p -= 1 << (2 * n);  // read 2n bits as two's complement
  console.log(`product A:Q = ${bits(A)} ${bits(q)} = ${p} (check ${M * Q})\n`);
}
booth(3, -4, 4);
booth(-3, 5, 4);

M = 0011 (3), Q = 1100 (-4), n = 4
step Q0Q-1 action   A     Q     Q-1
init  --    ----   0000  1100  0
  1   00    shift  0000  0110  0
  2   00    shift  0000  0011  0
  3   10    A-M,sh 1110  1001  1
  4   11    shift  1111  0100  1
product A:Q = 1111 0100 = -12 (check -12)

M = 1101 (-3), Q = 0101 (5), n = 4
step Q0Q-1 action   A     Q     Q-1
init  --    ----   0000  0101  0
  1   10    A-M,sh 0001  1010  1
  2   01    A+M,sh 1111  0101  0
  3   10    A-M,sh 0001  0010  1
  4   01    A+M,sh 1111  0001  0
product A:Q = 1111 0001 = -15 (check -15)

সংজ্ঞা: Single precision ৩২ বিট: ১ বিট sign (s), ৮ বিট biased exponent (E, bias ১২৭), ২৩ বিট fraction (f). Normal সংখ্যার মান = (−১)^s × ১.f × ২^{E−১২৭}; শুরুর ১-টি লেখা হয় না (hidden bit) — ২৩ ঘরে ২৪ বিটের নির্ভুলতা।

Encode: ১৩.৬২৫ = 1101.101_২ (০.৬২৫ = ০.৫ + ০.১২৫) = 1.101101 × ২^৩. s = ১, E = ৩ + ১২৭ = ১৩০ = 1000 0010, f = 1011 0100 0…0.

 s  E (8)      f (23)
 1  10000010   10110100000000000000000
 = 1100 0001 0101 1010 0000 ... 0000  = 0xC15A0000

উদাহরণে বিশেষ মান: ১/০ = +∞, ১/(−০) = −∞ (তুলনায় −০ == +০ সত্য, আচরণে আলাদা); ০/০ আর √−১ = NaN, আর NaN == NaN মিথ্যা। Subnormal শূন্যের কাছে ফাঁক ভরে (gradual underflow) — x ≠ y হলে x − y ≠ ০ নিশ্চিত।

Bias কেন: biased exponent-এ ধনাত্মক float-এর বিট-রূপ unsigned integer হিসেবে তুলনা করলেও ক্রম ঠিক থাকে, আর শূন্যের সব বিট ০।

উপসংহার: ০.১-এর মতো ভগ্নাংশ binary-তে অসীম পর্যাবৃত্ত, তাই float-এ গোল হয় (0x3DCCCCCD); টাকার হিসাব কখনো float-এ নয়।

নম্বর কোথায়: বিন্যাস ও সূত্র (২), encode-এর ধাপ ও hex (৩), বিশেষ মানের টেবিল (৩), উদাহরণ ও bias-এর কারণ (২)। পর্ব ২৩ · পর্ব ২৪

সংজ্ঞা: Addressing mode হলো instruction-এর field থেকে operand কোথায় আছে তা বের করার নিয়ম; হিসাব করা মেমরি-ঠিকানাটি effective address (EA), আর operand = M[EA].

হিসাব: PC-relative-এ EA = ২০২ + ৫০০ = ৭০২ — শর্ত, PC-এর মানটি fetch-এর পরের। (RISC-V-তে শাখার target গোনা হয় শাখা instruction-এর নিজের ঠিকানা থেকে: target = PC + offset — বই ধরে প্রথাটি লিখে দিন।)

উপসংহার: RISC-V-তে load-store-এর mode একটিই — rs1 + ১২ বিটের signed offset; বাকিগুলো কয়েকটি instruction জুড়ে বানানো হয়। x86-এ base + index × scale + displacement এক instruction-এ।

নম্বর কোথায়: সংজ্ঞা (১), সাতটি mode (৫), PC-relative হিসাব ও প্রথা (১), RISC-V বনাম x86 (১)। পর্ব ২৮

সংজ্ঞা: Instruction format হলো ৩২ বিটকে field-এ ভাগের নিয়ম। RV32I-এ ছয়টি: R (register–register), I (immediate, load), S (store), B (branch), U (upper immediate — lui, auipc), J (jal).

I-type:  imm[11:0]     rs1    funct3  rd     opcode
         000000001010  00101  000     00101  0010011
       = 0000 0000 1010 0010 1000 0010 1001 0011 = 0x00A28293

ব্যাখ্যা: opcode 0010011 (OP-IMM), funct3 000 (addi), rd = rs1 = ৫ (00101), imm = ১০ = 000000001010. বাঁ থেকে বিট জুড়ে চার চার করে hex.

একই জায়গার কারণ: decode শেষ হওয়ার আগেই register file পড়া শুরু করা যায়, আর rd বাছতে mux লাগে না; imm-এর sign বিট সবসময় বিট ৩১-এ, তাই sign extension-ও আগে শুরু। দাম — S আর B-তে immediate ভাঙা ভাঙা, হাতে encode করা একটু কঠিন।

নম্বর কোথায়: ছয় format (১), field-ভাগ ও বিট (৩), hex (১), কারণ (১)। পর্ব ২৭ · পর্ব ২৬

সংজ্ঞা: Single-cycle datapath-এ প্রতিটি instruction এক clock cycle-এ শুরু থেকে শেষ হয়; তাই প্রতিটি unit একবারই ব্যবহার হয় — আলাদা instruction আর data memory লাগে।

 PC --> I-mem --instr--> Reg file --rs1--> ALU --addr--> D-mem --+
  ^       |             (rs1, rs2, rd)  ^  rs2      |               |
  |       +--> Imm-gen ---------------->[ALUSrc mux] |  ALU result -+->[MemtoReg mux]--> rd
  +--[PCSrc mux]<-- PC+4 / PC+imm (Branch AND Zero)

lw-এর পথ: PC থেকে instruction আনা → rs1 পড়া, imm-gen-এ ১২ বিট sign-extend → ALU-তে rs1 + imm (ALUSrc = ১) → data memory পড়া (MemRead = ১) → MemtoReg = ১ দিয়ে মেমরির মান rd-তে (RegWrite = ১)। পাঁচটি unit-ই লাগে বলে lw-ই critical path, আর সেটিই clock period ঠিক করে।

X-এর কারণ: sw আর beq-এ RegWrite = ০ — register file কিছু লেখে না, তাই MemtoReg mux কী বাছল তাতে কিছু যায় আসে না। PCSrc = Branch AND Zero; Zero আসে ALU-র rs1 − rs2 থেকে (ALUOp = 01 → বিয়োগ)।

উপসংহার: CPI = ১ হলেও single-cycle ধীর — সবচেয়ে লম্বা instruction সবার clock ঠিক করে; সমাধান multi-cycle বা pipeline.

নম্বর কোথায়: লেবেলসহ datapath (৩), lw-এর পথ (২), চার সারির টেবিল (৩), X-এর যুক্তি ও PCSrc (২)। পর্ব ৩২ · পর্ব ৩৩

সংজ্ঞা: Pipelining হলো instruction-এর কাজকে ধাপে ভাগ করে ভিন্ন instruction-এর ভিন্ন ধাপ একসাথে চালানো — গার্মেন্টস কারখানার assembly line-এর মতো। এটি throughput বাড়ায়, একটি instruction-এর latency কমায় না। ধাপ: IF (fetch), ID (decode ও register পড়া), EX (ALU), MEM (ডেটা মেমরি), WB (register-এ লেখা)।

cycle:   1    2    3    4    5    6    7    8    9
I1      IF   ID   EX   MEM  WB
I2           IF   ID   EX   MEM  WB
I3                IF   ID   EX   MEM  WB
I4                     IF   ID   EX   MEM  WB
I5                          IF   ID   EX   MEM  WB    -> k + n - 1 = 5 + 5 - 1 = 9 cycles

হিসাব: T_stage = সবচেয়ে ধীর ধাপ + overhead = ২০০ + ২০ = ২২০ ps. Single-cycle T_c = ৮০০ + ২০ = ৮২০ ps. ১০০০ instruction-এ: single-cycle ৮২০ × ১০০০ = ৮,২০,০০০ ps; pipeline (৫ + ৯৯৯) × ২২০ = ২,২০,৮৮০ ps; speedup ≈ ৩.৭১. সীমা (n → ∞) = ৮২০ ÷ ২২০ ≈ ৩.৭৩ — ৫ নয়, কারণ ধাপ অসম আর register-এর খরচ আছে।

ব্যাখ্যা: প্রতিটি ধাপের পরে একটি pipeline register (IF/ID, ID/EX, EX/MEM, MEM/WB) ফল আর বাকি control signal পরের ধাপে বয়ে নেয়, যাতে পাঁচটি instruction একে অপরের মান নষ্ট না করে।

উপসংহার: ধাপ আরও ভাঙলে clock দ্রুত হয়, কিন্তু overhead আর hazard-এর দাম বাড়ে — তাই একটি সর্বোত্তম গভীরতা আছে।

নম্বর কোথায়: সংজ্ঞা ও ধাপ (২), diagram (২), T_stage (২), ১০০০ instruction-এর speedup (২), সীমা ও ৫ না হওয়ার কারণ (২)। পর্ব ৩৫

সংজ্ঞা: Structural — দুটি instruction একই hardware চায় (একটিই memory port থাকলে IF আর MEM); data — operand এখনো লেখা হয়নি (RAW); control — শাখার ফল জানার আগেই পরের instruction আনতে হয়।

cycle:              1    2    3    4    5    6    7
add x1, x2, x3     IF   ID   EX   MEM  WB
sub x4, x1, x5          IF   ID   EX   MEM  WB         EX/MEM -> EX (cycle 4)
and x6, x1, x7               IF   ID   EX   MEM  WB    MEM/WB -> EX (cycle 5)

lw  x1, 0(x2)      IF   ID   EX   MEM  WB
add x3, x1, x4          IF   ID   **   EX   MEM  WB    1 bubble, then MEM/WB -> EX

Forwarding: ALU-র ফল EX-এর শেষেই তৈরি, WB পর্যন্ত অপেক্ষার দরকার নেই — forwarding unit ALU-র ইনপুট mux-এ EX/MEM বা MEM/WB থেকে মান আনে। শর্ত (rs1-এর জন্য): EX/MEM.RegWrite = ১ আর EX/MEM.rd ≠ ০ আর EX/MEM.rd = ID/EX.rs1 → ForwardA = 10; না হলে MEM/WB-এর একই শর্তে ForwardA = 01. দুটিই মিললে EX/MEM জেতে — সেটি প্রোগ্রামে পরের, তাই সর্বশেষ মান।

Load-use: lw-এর মান আসে MEM-এর শেষে, অথচ পরের instruction-এর EX সেই একই cycle-এ — সময়ের পেছনে তীর অসম্ভব। Hazard detection unit ID-তে ধরে: ID/EX.MemRead আর ID/EX.rd = IF/ID.rs1 বা rs2 হলে PC আর IF/ID আটকে একটি bubble ঢোকায়।

CPI: আদর্শ ১ + load-use ০.২৫ × ০.৪ × ১ = ০.১০ + branch ০.১৫ × ০.৬ × ১ = ০.০৯ → CPI = ১.১৯. (শাখা EX-এ নিষ্পত্তি হলে penalty ২ → ১ + ০.১০ + ০.১৮ = ১.২৮.)

উপসংহার: ৫ ধাপের in-order pipeline-এ WAR আর WAW hazard হয় না — সবাই ID-তে পড়ে, WB-তে ক্রমে লেখে; সেগুলো আসে out-of-order core-এ।

নম্বর কোথায়: তিন hazard ও উদাহরণ (২), diagram (২), forwarding-এর শর্ত ও অগ্রাধিকার (২), load-use-এর কারণ (২), CPI (২)। পর্ব ৩৬ · পর্ব ৩৭

সংজ্ঞা: শাখার দিক আর target জানার আগেই IF-কে পরের instruction আনতে হয়; ভুল পথে আনা প্রতিটি instruction একটি নষ্ট cycle. CPI = ১ + (শাখার অনুপাত) × (ভুলের হার) × (penalty) — যেমন ২০% শাখা, ৫% ভুল, ২০ cycle penalty-তে CPI = ১.২. Branch prediction অনুমান করে এগিয়ে যায়, ভুল হলে flush.

   T        T        T        T(stay)
 00 -----> 01 -----> 10 -----> 11
 strong N  weak N    weak T    strong T
   <-----    <-----    <-----
   N(stay at 00)   N        N           predict T when high bit = 1

উত্তর: শুরু 00 → ৪টি ভুল (প্রথম দুটি “গরম হওয়া”); শুরু 11 → ২টি — শুধু দুটি N-এ। কারণ: N-এ 11 থেকে 10-তে নামে, উঁচু বিট তখনো ১, অনুমান উল্টায় না — একটি ব্যতিক্রমে অনুমান বদলায় না। ১-বিট predictor (শুরু T) একই ধারায় ৩টি ভুল করে — দুই N-এ আর প্রথম N-এর পরের T-তে।

BTB: Branch target buffer PC দিয়ে খোঁজা একটি ছোট cache — IF-এই বলে দেয় এটি শাখা কি না আর target কত (tag সহ)। BHT শুধু দিক বলে।

নম্বর কোথায়: প্রয়োজন ও CPI সূত্র (২), state diagram (২), trace দুই অবস্থায় (৩), BTB (১)। পর্ব ৩৭

সংজ্ঞা: Superscalar core চলার সময় hardware দিয়ে ঠিক করে প্রতি cycle-এ কোন কয়েকটি instruction একসাথে issue হবে; VLIW-এ compiler আগেই কয়েকটি স্বাধীন কাজ এক bundle-এ বেঁধে দেয়, hardware সরল থাকে। ৪-way-এ আদর্শ CPI ০.২৫, কিন্তু dependence, cache miss আর ভুল branch-এ slot নষ্ট হয়।

Renaming: শুধু name dependence — WAR আর WAW — দূর হয়, কারণ সেগুলো একই register-নাম পুনর্ব্যবহারের ফল, ডেটার প্রবাহ নয়। RAW (true dependence) থাকে।

1: fdiv f0, f2, f4      (long latency)
2: fadd f6, f0, f8      RAW on f0   -> waits for 1 (Qj = tag of 1)
3: fsub f8, f10, f14    WAR on f8 with 2 -> renamed, runs early
4: fmul f6, f10, f8     WAW on f6 with 2, RAW on f8 from 3

Tomasulo-র ব্যাখ্যা: issue-এর সময় প্রতিটি instruction একটি reservation station পায়; operand তৈরি থাকলে মান (Vj), না থাকলে যে station মান দেবে তার tag (Qj) লেখা হয় — একটির জন্য দুটির একটিই ভরা। Register status টেবিল বলে কোন register-এর পরের মান কোন tag দেবে। ফল তৈরি হলে common data bus-এ tag-সহ ঘোষণা হয়, অপেক্ষমাণ সবাই একসাথে নেয়। ওপরের উদাহরণে ৩ নম্বর instruction ২-এর আগেই f8-এ লিখতে পারে, কারণ ২ issue-এর সময়েই f8-এর মান নিজের station-এ কপি করে নিয়েছে (f0-এর জন্য শুধু tag) — WAR মিলিয়ে গেল।

ROB: Reorder buffer একটি বৃত্তাকার সারি — issue-এর ক্রমে লেজে ঢোকে, ফল ROB-এ জমে, মাথা থেকে প্রোগ্রাম-ক্রমে commit হয়। ভুল branch বা exception হলে মাথার পেছনের সব ফেলে দেওয়া হয় — তাই out-of-order চললেও exception precise আর speculation নিরাপদ।

উপসংহার: আধুনিক বড় core-এ physical register file, rename map আর free list; শত শত micro-op একসাথে উড়ন্ত। দাম power আর area — তাই ছোট দক্ষ core প্রায়ই in-order.

নম্বর কোথায়: superscalar বনাম VLIW (২), renaming কী দূর করে (২), উদাহরণে dependence চেনা (২), RS-এর Vj/Qj ও CDB (২), ROB ও precise exception (২)। পর্ব ৩৯ · পর্ব ৪০

সংজ্ঞা: Direct-mapped-এ প্রতিটি block-এর একটিই ঘর (index দিয়ে ঠিক); set-associative-এ একটি set-এর কয়েকটি way-এর যেকোনোটিতে; fully associative-এ যেকোনো ঘরে।

হিসাব: offset = log_২ ৩২ = ৫. Line-এর সংখ্যা = ৬৪ KiB ÷ ৩২ = ২,০৪৮.

ঠিকানা ভাগ: 0x12345678 → tag = ওপরের ১৬ বিট = 0x1234; নিচের ১৬ বিট 0x5678 = 0101 0110 0111 1000 → offset = শেষ ৫ বিট 11000 = 0x18 (২৪), index = মাঝের ১১ বিট 010 1011 0011 = 0x2B3 (৬৯১)।

মোট বিট: প্রতি line-এ data ৩২ × ৮ = ২৫৬ + tag ১৬ + valid ১ = ২৭৩; ২,০৪৮ × ২৭৩ = ৫,৫৯,১০৪ বিট (৫৪৬ Kibit) — শুধু data-র ৫,২৪,২৮৮-এর চেয়ে প্রায় ৬.৬% বেশি।

 address: [ tag 16 | index 11 | offset 5 ]
                |        |          |
                |        v          |
   index 0  [V][ tag ][ 32-byte data ]
   ...         |   |        |
   index 691[1][1234][ ... data ... ] --> mux (offset) --> word
   ...         |   |
               |   +-->( = )<-- tag from address
               +------>AND --> hit

উপসংহার: direct-mapped-এ একটি comparator, সবচেয়ে কম hit time, কিন্তু একই index-এর block-এ conflict miss; way বাড়ালে conflict কমে, কিন্তু comparator-ও বাড়ে।

নম্বর কোথায়: তিন সংগঠনের ভাগ (৩), ঠিকানার ভাগ (২), মোট বিট (২), সংগঠনের ছবি (২), উপসংহার (১)। পর্ব ৪৫ · পর্ব ৪৬

সংজ্ঞা: Write-through প্রতিটি store cache আর নিচের স্তর দুটোতেই লেখে (write buffer দিয়ে অপেক্ষা লুকায়); write-back শুধু cache-এ লেখে, dirty bit রাখে, আর block সরানোর সময় একবার নিচে লেখে। Write miss-এ write-allocate block আগে এনে তারপর লেখে; no-write-allocate সরাসরি নিচে লেখে। সাধারণ জুটি: write-back + write-allocate, write-through + no-write-allocate.

সূত্র: AMAT = hit time + miss rate × miss penalty; দুই স্তরে MP_L1 = HT_L2 + MR_L2(local) × MP_L2.

হিসাব: MP_L1 = ১০ + ০.২ × ১০০ = ৩০ cycle; AMAT = ১ + ০.০৫ × ৩০ = ২.৫ cycle. L2-এর global miss rate = ০.০৫ × ০.২ = ১% (CPU-র সব access-এর ১% মেমরিতে যায়)।

CPI: I-stall = ১ × ০.০২ × ১০০ = ২; D-stall = ০.৩৬ × ০.০৪ × ১০০ = ১.৪৪; CPI = ২ + ২ + ১.৪৪ = ৫.৪৪ — perfect cache-এর চেয়ে ৫.৪৪ ÷ ২ = ২.৭২ গুণ ধীর।

উপসংহার: clock দ্বিগুণ করলে মেমরির ns-এ মাপা latency একই থাকে, তাই miss penalty-র cycle দ্বিগুণ — CPU দ্বিগুণ দ্রুত হয় না। L1-এর লক্ষ্য দ্রুত hit, L2/L3-এর লক্ষ্য কম miss.

নম্বর কোথায়: write policy ও allocate (৩), সূত্র (১), AMAT ও global MR (৩), CPI (৩)। পর্ব ৪৭ · পর্ব ৪৪

সংজ্ঞা: Virtual memory-তে প্রতিটি process নিজের virtual address দেখে; MMU প্রতিটি access-এ তা physical address-এ অনুবাদ করে — page-এর এককে, page table দিয়ে। TLB সাম্প্রতিক অনুবাদের ছোট cache.

এক স্তরের আকার: VPN = ৩২ − ১২ = ২০ বিট → ২^২০ PTE × ৪ byte = ৪ MiB প্রতি process — বেশিরভাগ ফাঁকা হলেও; তাই multi-level page table, যেখানে অব্যবহৃত অংশের নিচের টেবিল থাকেই না।

Sv32 ভাগ: 10 | 10 | 12. 0x00403ABC → VPN[1] = বিট ৩১–২২ = ১, VPN[0] = বিট ২১–১২ = ৩, offset = 0xABC. প্রতিটি টেবিলে ১০২৪ PTE × ৪ byte = ঠিক একটি ৪ KiB page.

 VA 0x00403ABC
   -> TLB lookup (VPN 0x00403)  hit? -> PA = PPN : 0xABC
   miss:
   satp.PPN x 4096 + VPN[1] x 4  -> root PTE (V=1, R=W=X=0: pointer)
   PTE.PPN  x 4096 + VPN[0] x 4  -> leaf PTE (R/W/X/U checked, A/D set)
   PA = leaf.PPN x 4096 + 0xABC ; refill TLB ; invalid PTE -> page fault

EAT: EAT = t_TLB + (১ − h) × L × t_PTE + t_mem = ১ + ০.০২ × ৩ × ১০০ + ১০০ = ১০৭ cycle; সব hit হলে ১০১, সব access-এ TLB miss হলে ১ + ৩০০ + ১০০ = ৪০১ — প্রায় চার গুণ।

উপসংহার: ASID থাকলে context switch-এ TLB মুছতে হয় না; huge page TLB reach বাড়ায়; page fault হলে OS page এনে instruction আবার চালায়।

নম্বর কোথায়: সংজ্ঞা ও উপাদান (২), page table-এর আকার (২), Sv32 ভাগ (২), walk-এর ধাপ (২), EAT (২)। পর্ব ৫০

সংজ্ঞা: Polling-এ CPU বারবার device-এর status register পড়ে; interrupt-এ device কাজ শেষে CPU-কে সংকেত দেয়; DMA-তে DMA controller বা bus-master device নিজেই মেমরিতে block আনা-নেওয়া করে, CPU শুধু শুরু করে আর শেষে একটি interrupt পায়।

হিসাব: সেকেন্ডে ১ ÷ ২০ µs = ৫০,০০০ poll × ৪০০ = ২ কোটি cycle = ২ GHz-এর ১% — ঘটনা থাকুক বা না থাকুক। Crossover: r* = C_poll ÷ (P × C_irq) = ৪০০ ÷ (২০ µs × ৩০০০) ≈ সেকেন্ডে ৬,৬৬৭টি ঘটনা. এর কম হলে interrupt সস্তা (কি-বোর্ড), বেশি হলে polling (দ্রুত network card); মাঝামাঝি interrupt coalescing.

DMA-র ধাপ: driver buffer আর descriptor বানায় → device-এর doorbell register-এ MMIO write → device bus-এ নিজে memory read/write চালায় → শেষে descriptor-এ অবস্থা লিখে একটি interrupt. CPU-র খরচ প্রতি transfer-এ, প্রতি byte-এ নয়; তবে মেমরির bandwidth ভাগ হয় (পুরোনো নাম cycle stealing).

উপসংহার: বড় block-এ DMA; আধুনিক NIC আর NVMe তিনটিই মেশায়।

নম্বর কোথায়: তিনটির সংজ্ঞা (৩), polling-এর ভাগ (১), r* (২), DMA-র ধাপ (২)। পর্ব ৫২ · পর্ব ৫১

সংজ্ঞা: একই ঠিকানার কপি কয়েকটি private cache-এ থাকলে একটি core লিখলে অন্যরা পুরোনো (stale) মান পড়তে পারে। Cache coherence নিশ্চিত করে: প্রতিটি ঠিকানার লেখা সবাই একই ক্রমে দেখে — একসাথে একজন লেখক অথবা অনেক পাঠক (SWMR).

চার অবস্থা: M (Modified — শুধু এখানে, ময়লা, মেমরি পুরোনো), E (Exclusive — শুধু এখানে, পরিষ্কার), S (Shared — কয়েকজনের কাছে, পরিষ্কার), I (Invalid). Bus-এ BusRd (পড়তে চাই), BusRdX (লিখতে চাই — সবাই বাতিল), BusUpgr (S থেকে লিখতে — শুধু বাতিল, ডেটা লাগে না), আর M-এর মালিকের Flush.

E কেন: অন্য কারও কপি না থাকলে পড়া line E-তে আসে; পরে লিখলে bus ছাড়াই নিঃশব্দে M. ব্যক্তিগত ডেটা পড়ে-লেখার কাজে (a[i] = a[i] + 1) প্রতি line-এ একটি BusUpgr বাঁচে — MSI-তে ২টি transaction, MESI-তে ১টি।

উপসংহার: snooping অনেক core-এ স্কেল করে না — প্রতিটি miss broadcast; বড় সিস্টেমে directory শুধু কপি-ধারীদের বার্তা পাঠায়। Coherence একটি ঠিকানার প্রশ্ন; ভিন্ন ঠিকানার ক্রম হলো consistency (x86-এর TSO, RISC-V-এর RVWMO).

নম্বর কোথায়: সমস্যা ও SWMR (২), চার অবস্থা ও bus বার্তা (৩), trace (৩), E-এর লাভ (১), উপসংহার (১)। পর্ব ৫৩

সংজ্ঞা: Flynn instruction আর ডেটার ধারা গোনে: SISD (সাধারণ scalar CPU), SIMD (SSE/AVX, vector unit, GPU-র ধারণা), MISD (প্রায় নেই — তাত্ত্বিক বা ত্রুটি-সহনশীল বিশেষ সিস্টেম), MIMD (multicore, cluster).

UMA বনাম NUMA: UMA-তে সব মেমরি সব প্রসেসর থেকে সমান দূরে (ছোট SMP); NUMA-তে প্রতিটি node-এর কাছের মেমরি দ্রুত, অন্য node-এর ধীর — address space তবু একটি; তাই ডেটা কোথায় বরাদ্দ হলো (first-touch) পারফরম্যান্স ঠিক করে।

হিসাব: Amdahl: ১ ÷ (০.০৫ + ০.৯৫ ÷ ৬৪) ≈ ১৫.৪২ (সীমা ১ ÷ ০.০৫ = ২০)। Gustafson: ০.০৫ + ০.৯৫ × ৬৪ = ৬০.৮৫. পার্থক্যের কারণ — Amdahl কাজ স্থির রাখে (strong scaling), Gustafson কাজ N-এর সাথে বাড়ায় (weak scaling).

উপসংহার: একই সংখ্যা দুই প্রশ্নের উত্তর — “একই কাজ কত দ্রুত?” বনাম “একই সময়ে কত বড় কাজ?”

নম্বর কোথায়: Flynn (২), UMA–NUMA (২), দুই সূত্র ও মান (৩), ব্যাখ্যা (১)। পর্ব ৫৪ · পর্ব ০৩

সংজ্ঞা: SIMT-এ প্রোগ্রামার প্রতিটি thread-এর কোড আলাদা করে লেখেন, hardware ৩২টি thread-কে (NVIDIA-র warp) এক instruction-এ একসাথে চালায়; কোন lane সক্রিয় তার mask hardware সামলায়।

Divergence: warp-এর thread-রা ভিন্ন পথে গেলে পথগুলো পালা করে চলে, বাকি lane বসে থাকে। Issue = ১০ + ১০ = ২০টি instruction; সক্রিয় lane-slot = ২৪ × ১০ + ৮ × ১০ = ৩২০; মোট slot = ২০ × ৩২ = ৬৪০ → efficiency = ৫০%.

Coalescing: পাশাপাশি thread পাশাপাশি ঠিকানা পড়লে warp-এর load এক-দুটি memory transaction-এ হয়; stride বড় হলে ৩২টি পর্যন্ত — bandwidth নষ্ট।

নম্বর কোথায়: SIMT (২), divergence ও হিসাব (৩), coalescing (১)। পর্ব ৫৫

অনুমান: k টি সমান ধাপ, প্রতিটি τ সময়; register overhead আর hazard নেই; pipeline-হীন যন্ত্রে একটি instruction-এ kτ.

ধাপ ১: pipeline-হীন সময় = n·kτ. ধাপ ২: pipeline-এ প্রথম instruction k cycle-এ বের হয় (ভরাট হওয়া), তারপর প্রতি cycle-এ একটি করে — বাকি n − ১টির জন্য n − ১ cycle; মোট (k + n − ১)τ. ধাপ ৩: S = n·kτ ÷ (k + n − ১)τ = nk ÷ (k + n − ১).

সীমা: লবকে n দিয়ে ভাগ করলে S = k ÷ (১ + (k − ১)/n). n → ∞ হলে (k − ১)/n → ০, S → k; আর যেকোনো সসীম n-এ হর ১-এর বেশি (k > ১), তাই S < k. বাস্তবে ধাপ অসম আর overhead থাকায় সীমা = T_single ÷ T_stage (পর্ব ৩৫-এর সংখ্যায় ৮২০ ÷ ২২০ ≈ ৩.৭৩), আর hazard থাকলে S = ideal ÷ (১ + প্রতি instruction-এ stall).

পর্ব ৩৫

অনুমান: প্রতিটি access আগে L1 দেখে (hit time HT, hit বা miss যাই হোক খরচ হয়); miss হলে বাড়তি MP সময় লাগে।

প্রমাণ: গড় সময় = (hit-এর ভাগ) × HT + (miss-এর ভাগ) × (HT + MP) = (১ − MR)·HT + MR·(HT + MP) = HT + MR × MP. ∎

দুই স্তর: L1-এর miss penalty নিজেই L2-এর গড় সময়: MP_L1 = HT_L2 + MR_L2 × MP_L2, তাই AMAT = HT_L1 + MR_L1 × (HT_L2 + MR_L2 × MP_L2) — এখানে MR_L2 local (L2-এ পৌঁছানো access-এর ভাগ)। Global miss rate_L2 = MR_L1 × MR_L2(local) (সংখ্যার উদাহরণ ঘ-০৩-এ)।

সাবধান: local-এর জায়গায় global বসালে ভুল — L2-এর local miss rate প্রায়ই বড় দেখায় (২০–৫০%), কারণ সহজ access-গুলো L1-ই মিটিয়ে দেয়।

পর্ব ৪৭

অনুমান: পুরোনো execution time = ১; তার f ভগ্নাংশ s গুণ দ্রুত করা যায়, বাকি (১ − f) অপরিবর্তিত।

প্রমাণ: নতুন সময় = (১ − f) + f/s. Speedup = ১ ÷ ((১ − f) + f/s). s → ∞ হলে f/s → ০, তাই সীমা ১ ÷ (১ − f); যেকোনো সসীম s-এ f/s > ০, তাই speedup সীমা ছোঁয় না। f = ০.৮, s = ৪-এ ১ ÷ (০.২ + ০.২) = ২.৫, সীমা ৫. Multicore রূপ (s = N): ১ ÷ ((১ − f) + f/N).

Gustafson: Amdahl কাজ স্থির রাখে; Gustafson ধরে N টি প্রসেসরে সমান্তরাল অংশের কাজও N গুণ হয়, আর serial অংশ s (নতুন সময়ের ভগ্নাংশ) স্থির — তাই scaled speedup = s + (১ − s)N.

পর্ব ০৩ · পর্ব ৫৪

Architecture হলো প্রোগ্রামারের চোখে দৃশ্যমান অংশ — ISA: instruction, register, addressing, মেমরি মডেল। Organization বা microarchitecture হলো সেগুলো hardware-এ কীভাবে বানানো — pipeline, cache, control signal. একই ISA-র বহু ভিন্ন বাস্তবায়ন হয় (একই x86-64-এর নানা কোম্পানির chip).
পরের প্রশ্ন: cache-এর আকার কোনটির বিষয়? — organization-এর; বদলালে প্রোগ্রাম শুধু দ্রুত বা ধীর হয়, ফল বদলায় না। পর্ব ০১

CPU আর মেমরির মাঝের একটি পথ দিয়ে instruction আর ডেটা দুটোই আসে, আর মেমরি CPU-র চেয়ে অনেক ধীর — তাই CPU অপেক্ষায় বসে থাকে। Cache, আলাদা I/D cache, prefetching আর চওড়া bus দিয়ে কমানো হয়।
পরের প্রশ্ন: memory wall কী? — CPU আর DRAM-এর গতির ফারাক বছরে বছরে বাড়তে থাকার সমস্যা। পর্ব ০১ · পর্ব ০২

যে অংশ দ্রুত হয়নি, সেটিই সীমা: speedup = ১ ÷ ((১ − f) + f/s), সর্বোচ্চ ১ ÷ (১ − f). ৯৫% সমান্তরাল হলে হাজার core-এও ২০ গুণের বেশি নয়।
পরের প্রশ্ন: তাহলে supercomputer কেন লাখো core নেয়? — সমস্যাও বড় হয় (Gustafson), serial অংশের ভাগ কমে। পর্ব ০৩

সবচেয়ে কম গুরুত্বের byte আগে: A: 78, A+1: 56, A+2: 34, A+3: 12. Big-endian-এ উল্টো — 12 আগে। x86 আর সাধারণত চলা ARM ও RISC-V little-endian; network byte order big-endian.
পরের প্রশ্ন: C-তে কীভাবে জানবেন? — একটি uint32_t = 1-এর প্রথম byte memcpy বা unsigned char দিয়ে পড়ুন; ১ হলে little-endian. পর্ব ০৬

শুধু NAND দিয়েই NOT (A NAND A), AND (NAND-এর পরে NOT) আর OR (দুই ইনপুট উল্টে NAND) বানানো যায়, আর {AND, OR, NOT} দিয়ে যেকোনো function হয়। NOR-ও একইভাবে universal.
পরের প্রশ্ন: শুধু NAND-এ XOR-এ কমপক্ষে কয়টি? — ৪টি। পর্ব ০৮

Gray ক্রম — পাশাপাশি ঘর ঠিক এক চলকে আলাদা, তাই পাশাপাশি দুটি 1 মিলিয়ে XY + XY′ = X লাগানো যায়। প্রথম আর শেষ কলামও পাশাপাশি (map-টি আসলে torus).
পরের প্রশ্ন: দলের আকার কেন ২-এর ঘাত? — k টি চলক অনুপস্থিত হলে term-টি ঠিক ২^kটি minterm ঢাকে। পর্ব ০৯

যে ইনপুট কখনো আসে না (যেমন BCD-তে ১০–১৫), তাকে দরকারমতো ১ ধরে দল বড় করা যায় — literal কমে। ঝুঁকি: “অসম্ভব” ইনপুট সত্যিই এলে (reset-এর গোলমাল, noise) circuit একটি অনিচ্ছাকৃত আউটপুট দেয়।
পরের প্রশ্ন: QM-এর PI chart-এ don't care কলাম থাকে? — না; শুধু জোড়া বানানোর টেবিলে। পর্ব ০৯ · পর্ব ১০

A = C = ১ রেখে B বদলালে এক পদ নামে, অন্যটি একটু পরে ওঠে — মাঝে ক্ষণিকের ০ (static-1 hazard, glitch). সমাধান consensus পদ AC যোগ: F = AB′ + BC + AC — যুক্তি একই, কিন্তু B-এর বদলে AC ১ ধরে রাখে।
পরের প্রশ্ন: synchronous নকশায় কি এটা সমস্যা? — সাধারণত না; flip-flop শুধু clock ধারে মান নেয়, ততক্ষণে logic স্থির। পর্ব ১০

Half adder দুই বিট যোগ করে: S = A ⊕ B, C = AB. Full adder তিন বিট (ডান থেকে আসা carry সহ): S = A ⊕ B ⊕ C_in, C_out = AB + C_in(A ⊕ B) — majority. দুটি half adder আর একটি OR-এ একটি full adder.
পরের প্রশ্ন: n বিট ripple-এর delay? — c_n 2n + 1 gate delay-তে, O(n). পর্ব ১১

Enable-সহ decoder-এর enable-এ data দিলেই সেটি demux — প্রতিটি আউটপুট = minterm × data. Priority encoder-এ “কোনো ইনপুট চালু নেই” আর “শুধু I₀ চালু” দুটিতেই কোড 0…0; V (valid) ছাড়া আলাদা করা যায় না।
পরের প্রশ্ন: 16:1 mux-এ কয়টি 2:1? — ১৫টি। পর্ব ১২

Latch level-sensitive — enable চালু থাকার পুরো সময় স্বচ্ছ; flip-flop edge-triggered — শুধু clock ধারের মুহূর্তের মান নেয়। তাই flip-flop-এর পথে একটি clock cycle-এ ডেটা একটি ধাপই এগোয়।
পরের প্রশ্ন: D flip-flop দিয়ে T flip-flop? — D = T ⊕ Q, একটি XOR. পর্ব ১৫

Ring-এ n টি (একটি ১ ঘোরে), Johnson-এ 2n টি (শেষ বিট উল্টে শুরুতে)। ২ⁿ-এর বাকিগুলো অব্যবহৃত — সেখানে আটকে না যেতে reset বা self-correcting feedback লাগে।
পরের প্রশ্ন: n বিট LFSR-এর সর্বোচ্চ period? — ২ⁿ − ১, শুধু primitive polynomial-এ। পর্ব ১৬

= সঙ্গে সঙ্গে বসায় — combinational always @(*)-এ; <= সব ডান দিক আগে পড়ে, block-এর শেষে একসাথে বসায় — clock-চালিত block-এ, যাতে সব flip-flop পুরোনো মান দেখে। a <= b; b <= a; সঠিক অদলবদল, = দিয়ে নয়।
পরের প্রশ্ন: inferred latch কেন আসে? — combinational block-এর কোনো পথে output মান না পেলে; default বা else দিন। পর্ব ১৪ · পর্ব ১৫

Hold-এর শর্ত t_ccq + t_cd ≥ t_hold — একই ধারে নতুন ডেটা কত দ্রুত পৌঁছায় তার কথা; এতে T_c নেই। তাই ছোট পথে buffer বসিয়ে t_cd বাড়াতে হয়। Setup violation-ই শুধু clock ধীর করে সারে।
পরের প্রশ্ন: clock skew কোন শর্তকে কীভাবে বদলায়? — skew দুটিতেই খরচ হিসেবে যোগ হতে পারে; setup-এ T_c বাড়াতে হয়, hold-এ আরও বেশি t_cd লাগে। পর্ব ১৮

Carry — unsigned ফল সীমার বাইরে (MSB থেকে carry বেরোল); overflow — signed ফল সীমার বাইরে (V = c_n ⊕ c_n−1). একই যোগে একটি থাকতে পারে, অন্যটি না — ৮ বিটে ১০০ + ৫০-এ V = ১, C = ০।
পরের প্রশ্ন: RISC-V-তে flag নেই — carry কীভাবে? — যোগের পর sltu: ফল কোনো operand-এর চেয়ে ছোট হলে carry. পর্ব ২০

2n বিট। Unsigned-এ সর্বোচ্চ (২ⁿ − ১)^২ = ২²ⁿ − ২ⁿ⁺¹ + ১ < ২²ⁿ; signed-এ (−২^n−১)^২ = +২^2n−২-এর জন্যও 2n বিট লাগে। RISC-V-তে mul নিচের অর্ধেক, mulh/mulhu ওপরের অর্ধেক দেয়।
পরের প্রশ্ন: Booth-এর worst case? — পালাক্রমের বিট 0101…। পর্ব ২১

০.১, ০.২ আর ০.৩ — তিনটিই binary-তে অসীম পর্যাবৃত্ত, তাই double-এ গোল হয়ে রাখা; যোগফলও গোল হয়, আর ভুলগুলো একই দিকে মেলে না। এটি কোনো ভাষার bug নয় — IEEE 754 double ব্যবহারকারী সব ভাষায় একই। তুলনা করুন সহনসীমা দিয়ে।
পরের প্রশ্ন: টাকার হিসাব? — integer পয়সা বা decimal type, float নয়। পর্ব ২৩

Exponent মেলাতে ছোট সংখ্যাকে ডানে shift করলে বিট হারায়; G আর R দুটি বাড়তি বিট ধরে রাখে (বিয়োগের পর বাঁয়ে normalise করতে লাগে), আর S বাকি সব হারানো বিটের OR — বলে দেয় ঠিক মাঝামাঝি (tie) নাকি তার একটু ওপরে। তিনটি মিলে correct rounding নিশ্চিত।
পরের প্রশ্ন: IEEE-র ডিফল্ট rounding? — round to nearest, ties to even — দীর্ঘ হিসাবে একদিকে পক্ষপাত থাকে না। পর্ব ২৪

Restoring-এ প্রতি ধাপে A:Q বাঁয়ে shift, তারপর A − M; ঋণাত্মক হলে q₀ = ০ আর M যোগ করে আগের মান ফেরানো — সবচেয়ে খারাপ ক্ষেত্রে 2n টি যোগ-বিয়োগ। Non-restoring ফেরায় না: A ঋণাত্মক থাকলে পরের ধাপে shift করে M যোগ, কারণ ২(A + M) − M = ২A + M — প্রতি ধাপে একটি কাজ, শেষে দরকারে একটি সংশোধন। ৪ বিটে ৭ ÷ ২: প্রথম দুই ধাপে restore, ভাগফল 0011, ভাগশেষ 0001.
পরের প্রশ্ন: C-তে −৭ / ২ আর −৭ % ২? — −৩ আর −১ (শূন্যের দিকে কাটা); Python-এ −৪ আর ১। পর্ব ২২ · পর্ব ২০

শুধু load আর store মেমরি ছোঁয়; হিসাব সব register-এ — RISC-V, ARM, MIPS. x86 register–memory: add [rbx], eax-এর মতো instruction মেমরিতে সরাসরি হিসাব করে।
পরের প্রশ্ন: stack machine-এ কয়-address instruction? — ০-address; operand stack-এর মাথায়। পর্ব ২৫

সবসময় ০; লেখা বাতিল হয়। এতে অনেক pseudo-instruction বিনা খরচে হয়: mv = addi rd, rs, 0, nop = addi x0, x0, 0, neg, j, beqz. Hardware-এ rd = ০ হলে write enable বন্ধ।
পরের প্রশ্ন: forwarding-এ এর প্রভাব? — rd ≠ ০ শর্ত লাগে, নইলে x0-এ “লেখা” মান forward হয়ে ভুল করত। পর্ব ২৬

lui t0, 0x12346 তারপর addi t0, t0, -1. addi-র ১২ বিট immediate signed, আর নিচের ১২ বিট 0xFFF ≥ 0x800 — sign extension-এ সেটি −১, তাই lui-তে ১ বাড়িয়ে দিতে হয়। Assembler-এর li এটি নিজে করে।
পরের প্রশ্ন: subi নেই কেন? — addi-তে ঋণাত্মক immediate-ই বিয়োগ। পর্ব ২৬

Caller-saved (t, a) — callee নষ্ট করতে পারে; দরকার হলে caller call-এর আগে সেভ করে। Callee-saved (s, sp) — callee ব্যবহার করলে prologue-এ সেভ আর epilogue-এ ফেরত দেয়। দুই রকম রাখায় leaf function সস্তা থাকে, আর দীর্ঘায়ু মান একবারেই সংরক্ষিত।
পরের প্রশ্ন: jal ra, f 0x400-এ থাকলে ra? — 0x404. পর্ব ৩০

এক cycle-এ প্রতিটি unit একবারই ব্যবহার করা যায়, অথচ lw-কে একই cycle-এ দুবার মেমরি ছুঁতে হয় — instruction আনতে আর ডেটা পড়তে। Multi-cycle-এ একটি মেমরিই চলে, কারণ দুটি কাজ ভিন্ন cycle-এ।
পরের প্রশ্ন: multi-cycle-এ lw কয় cycle? — ৫ (sw আর R-type ৪, beq ৩)। পর্ব ৩২ · পর্ব ৩৪

না — একটি instruction-এর latency একই বা register overhead-এর জন্য একটু বেশি; বাড়ে throughput, প্রতি cycle-এ প্রায় একটি instruction শেষ হয়। লন্ড্রিতে একটি কাপড়ের সময় কমে না, কিন্তু ঘণ্টায় অনেক বেশি কাপড় বের হয়।
পরের প্রশ্ন: k ধাপে n instruction-এ কত cycle? — k + n − ১। পর্ব ৩৫

প্রতিটি ধাপের ফল (ALU result, পড়া মান), rd-এর নম্বর আর পরের ধাপগুলোর control signal — যাতে পাঁচটি instruction একসাথে চললেও একজনের মান আরেকজন নষ্ট না করে। যেমন WB-তে লেখার rd আসে MEM/WB register থেকে, IF/ID-এর নতুন instruction থেকে নয়।
পরের প্রশ্ন: control signal কোথায় তৈরি হয়? — ID-তে, তারপর ধাপে ধাপে বয়ে যায়। পর্ব ৩৫

সব instruction register পড়ে একই ধাপে (ID) আর লেখে একই ধাপে (WB), প্রোগ্রামের ক্রমে — তাই পরের instruction-এর লেখা কখনো আগের instruction-এর পড়ার আগে বা আগের লেখার আগে ঘটে না। Out-of-order core-এ এগুলো আসে, renaming দূর করে।
পরের প্রশ্ন: কোনটি true dependence? — RAW. পর্ব ৩৬

EX/MEM — কারণ সেই instruction প্রোগ্রামে পরে, তাই তার মানটিই সর্বশেষ। add x1,x1,x2; add x1,x1,x3; add x1,x1,x4-এ তৃতীয়টির জন্য দুটি উৎসই x1 দাবি করে; MEM/WB নিলে দ্বিতীয় যোগের অবদান নীরবে হারাত। তাই MEM hazard-এর শর্তে “EX hazard নেই” অংশ থাকে।
পরের প্রশ্ন: rd ≠ ০ শর্ত কেন? — ভ-২১ দেখুন। পর্ব ৩৬

১-বিট লুপ থেকে বেরোনোর N-এ উল্টে যায়, তাই পরের প্রবেশের প্রথম T-তেও ভুল — দুবার। ২-বিট strongly taken (11) থেকে weakly taken (10)-এ নামে, উঁচু বিট তখনো ১ — অনুমান উল্টায় না, তাই শুধু বেরোনোর সময় একবার।
পরের প্রশ্ন: BTB কী বলে? — IF-এই: এটি শাখা কি না, আর target. পর্ব ৩৭

একটি instruction-সীমায় থামে, পরের instruction-এর ঠিকানা mepc-তে, কারণ mcause-এ, interrupt বন্ধ করে (mstatus.MIE = ০, আগের মান MPIE-তে), PC = mtvec — handler শুরু। ফিরতে mret.
পরের প্রশ্ন: vectored mode-এ timer (cause ৭), mtvec = 0x80000001? — 0x80000000 + ৪ × ৭ = 0x8000001C. পর্ব ৩৮

WAR আর WAW — name dependence, একই register-নাম পুনর্ব্যবহারের ফল; প্রতিটি লেখাকে নতুন physical register দিলে মিলিয়ে যায়। RAW (true) পারে না — সত্যিকারের ডেটার প্রবাহ।
পরের প্রশ্ন: physical register কখন free? — একই architectural register-এর পরের লেখক commit করলে আগের mapping-এরটি। পর্ব ৪০ · পর্ব ৩৯

In-order commit-এর জন্য — ফল আগে ROB-এ জমে, মাথা থেকে প্রোগ্রাম-ক্রমে register বা মেমরিতে যায়। তাতে exception precise থাকে, আর ভুল branch-এর পর অনুমাননির্ভর কাজ নির্ভুলভাবে ফেলে দেওয়া যায়।
পরের প্রশ্ন: store কখন মেমরিতে লেখে? — commit-এ; তার আগে store queue-তে, পরের load সেখান থেকে forward পেতে পারে। পর্ব ৪০

Predictor-কে ভুল পথে চালিয়ে বৈধ কোডকেই অনুমানের মধ্যে গোপন ডেটা ছোঁয়ানো, তারপর cache-এর সময়-পার্থক্য দিয়ে তা বোঝা — architectural state ফেরে, cache-এর ছাপ ফেরে না। প্রতিরক্ষা: speculation barrier, index masking, retpoline, site isolation, constant-time কোড।
পরের প্রশ্ন: Meltdown-এর প্রধান software প্রতিরক্ষা? — KPTI. পর্ব ৪১

২৫৬ ÷ ১৬ = ১৬টি — একটি instruction-এ ১৬টি যোগ। Saturating যোগে সীমা ছাড়ালে সর্বোচ্চ-সর্বনিম্নে আটকায় (ছবি, অডিও), wrap-এ mod ২ⁿ.
পরের প্রশ্ন: compiler float-এর sum += a[i] নিজে vectorize করে না কেন? — যোগের ক্রম বদলাতে হয়, আর float যোগ associative নয়। পর্ব ৪২

Fine — প্রতি cycle-এ thread বদল; coarse — লম্বা stall-এ (যেমন cache miss) বদল, pipeline আবার ভরার দাম; SMT — একই cycle-এ কয়েকটি thread থেকে issue. Fine আর coarse শুধু vertical waste (পুরো খালি cycle) কমায়, SMT horizontal-ও।
পরের প্রশ্ন: SMT কেন একক thread-কে ধীর করতে পারে? — sibling-এর সাথে slot, unit আর cache ভাগ। পর্ব ৪৩

Temporal — একই ঠিকানা শিগগির আবার: লুপের counter, sum. Spatial — পাশের ঠিকানা শিগগির: array-র পরপর উপাদান, পরপর instruction. ডেস্কের ওপর আজকের খাতা রাখা temporal; আলমারি থেকে পুরো তাক আনা spatial.
পরের প্রশ্ন: কোন locality-র জন্য block বড় করা হয়? — spatial. পর্ব ৪৪

Compulsory (প্রথমবার ছোঁয়া), capacity (working set cache-এর চেয়ে বড়), conflict (একই set-এ ভিড়)। একই আকারের fully associative cache-ও miss করলে capacity, না করলে conflict.
পরের প্রশ্ন: কোনটি associativity বাড়িয়ে কমে? — conflict. পর্ব ৪৫

Set অর্ধেক, index ১ বিট কম, tag ১ বিট বেশি; offset অপরিবর্তিত। ৬৪ KiB/৩২ B-এ direct-mapped ১৬/১১/৫, 2-way ১৭/১০/৫, 4-way ১৮/৯/৫।
পরের প্রশ্ন: VIPT L1-এর আকার কেন সীমিত? — index + offset page offset-এর ভেতরে রাখতে: আকার ≤ way × page size. পর্ব ৪৬

৮টি way-এর ৮! = ৪০,৩২০টি ক্রম মনে রাখতে প্রতি set-এ কমপক্ষে ⌈log_২ ৮!⌉ = ১৬ বিট, আর প্রতিটি hit-এ জটিল হালনাগাদ। Tree pseudo-LRU ৭ বিটে প্রায় একই কাজ করে।
পরের প্রশ্ন: LRU কখন random-এর চেয়ে খারাপ? — চক্রাকার access-এ, working set way-এর চেয়ে একটু বড় হলে — প্রতিবার miss. পর্ব ৪৬

Local — ঐ cache-এ যত access পৌঁছেছে তার কত অংশ miss; global — CPU-র মোট access-এর কত অংশ ঐ স্তরেও miss. Global_L2 = MR_L1 × local_L2; ৫% × ২০% = ১%. AMAT-এর সূত্রে local বসে।
পরের প্রশ্ন: L2-এর local miss rate বড় দেখায় কেন? — সহজ access L1-ই মেটায়, L2 পায় শুধু কঠিনগুলো। পর্ব ৪৭

C row-major — একই সারির উপাদান মেমরিতে পাশাপাশি; সারি ধরে হাঁটলে stride ১, একটি cache line-এর সব উপাদানের জন্য একটি miss. কলাম ধরে বড় N-এ প্রতিটি access-এ নতুন line — প্রায় প্রতিবার miss.
পরের প্রশ্ন: matrix গুণে কোন loop-ক্রম ভালো? — ikj বা kij — ভেতরের লুপ j দুটি array-কেই সারি ধরে হাঁটায়। পর্ব ৪৮

TLB reach = entry-সংখ্যা × page size — TLB একসাথে কতটা মেমরির অনুবাদ ধরে; বাড়াতে বেশি entry বা huge page. ASID ভিন্ন process-এর একই VPN আলাদা রাখে, তাই context switch-এ TLB মুছতে হয় না।
পরের প্রশ্ন: ৬৪ entry × ৪ KiB? — ২৫৬ KiB. পর্ব ৫০

Compiler জানে না মানটি বাইরে থেকে বদলায়; volatile ছাড়া সে পড়াটি লুপের বাইরে তুলে বা বাদ দিয়ে দিতে পারে — লুপ চিরকাল ঘোরে। volatile প্রতিটি access সত্যিই মেমরিতে করায়, কিন্তু atomicity বা core-এর মধ্যে ক্রম দেয় না — তার জন্য fence.
পরের প্রশ্ন: multithreaded কোডে volatile কি যথেষ্ট? — না; atomic আর memory ordering লাগে। পর্ব ৫১ · পর্ব ৩১

Level — কারণ না মোছা পর্যন্ত লাইন সক্রিয়; একাধিক device একটি লাইন ভাগ করতে পারে, কিন্তু handler কারণ না মুছলে interrupt storm. Edge — একটি বদল একটি ঘটনা; লাইন ভাগ কঠিন, আর অবস্থা হারালে ঘটনা হারাতে পারে।
পরের প্রশ্ন: MSI কী? — device একটি নির্দিষ্ট ঠিকানায় memory write করে interrupt জানায়, আলাদা তার লাগে না। পর্ব ৫২

পড়ার সময় অন্য কারও কপি না থাকলে line E-তে আসে — পরিষ্কার, কিন্তু একান্ত। পরে লিখলে bus ছাড়াই M; MSI-তে S থেকে BusUpgr লাগত। ব্যক্তিগত ডেটা পড়ে-লেখার কাজে প্রতি line-এ একটি transaction বাঁচে।
পরের প্রশ্ন: M অবস্থার line অন্য core পড়তে চাইলে? — মালিক Flush করে S-এ নামে। পর্ব ৫৩

Coherence — একটি ঠিকানার লেখাগুলো সবাই একই ক্রমে দেখে কি না। Consistency — ভিন্ন ঠিকানার access-গুলোর দৃশ্যমান ক্রম। x86 (TSO)-এ store buffer-এর জন্য store-এর পরের ভিন্ন ঠিকানার load আগে চলে যেতে পারে; ARM আর RISC-V (RVWMO) আরও ঢিলা — ক্রম চাইলে fence বা acquire/release.
পরের প্রশ্ন: SB litmus-এ x86-এ r1 = r2 = ০ সম্ভব? — হ্যাঁ; mfence তা থামায়। পর্ব ৫৩

দুই thread দুটি আলাদা ভ্যারিয়েবলে লেখে, কিন্তু সেগুলো একই cache line-এ — প্রতিটি লেখায় line অন্য core থেকে invalidate হয়ে ping-pong করে। সমাধান: ভ্যারিয়েবলগুলো আলাদা line-এ রাখা (padding, alignas(64)) বা thread-local-এ জমিয়ে শেষে একবার লেখা।
পরের প্রশ্ন: line-এর আকার কত ধরা নিরাপদ? — অনেক সাধারণ CPU-তে ৬৪ byte; নির্দিষ্ট যন্ত্রে মেপে বা sysfs-এ দেখে নিন। পর্ব ৪৮

Microcontroller-এ CPU, flash, SRAM আর peripheral (GPIO, ADC, timer, UART) এক chip-এ — ছোট, কম power, নির্দিষ্ট কাজে; microprocessor-এর মেমরি আর বেশিরভাগ I/O chip-এর বাইরে — সাধারণ কাজের কম্পিউটারে।
পরের প্রশ্ন: voltage আর frequency দুটিই ২০% কমালে dynamic power? — P ≈ αCV^২f, তাই ০.৮^৩ = ০.৫১২ গুণ — প্রায় অর্ধেক; এটিই DVFS-এর যুক্তি। পর্ব ৫৬