Computer Architecture MCQ — প্রশ্নব্যাংক বাংলায় | পর্ব ৫৯

Q: Latch আর flip-flop — দুটিই এক বিট রাখে। তাহলে পার্থক্য কোথায়, আর race-around condition কেন শুধু পুরোনো JK-তে?

দুটিই feedback দিয়ে এক বিট ধরে রাখে; পার্থক্য কখন নতুন মান নেয়। D latch সাড়া দেয় enable-এর স্তর দেখে — EN = 1 থাকার পুরো সময় Q, D-কে অনুসরণ করে (“স্বচ্ছ”), আর EN = 0 হলে শেষ মান আটকে রাখে। Flip-flop সাড়া দেয় clock-এর ধারে — উঠন্ত (বা নামন্ত) ধারের ঠিক আগের D-টুকুই নেয়, বাকি সময় D যা-ই করুক। Master–slave D flip-flop আসলে দুটি latch পরপর, উল্টো enable-এ — একটি খোলা থাকলে অন্যটি বন্ধ, তাই সব মিলিয়ে শুধু ধারে মান পার হয়। রেলস্টেশনের সিগন্যালের কথা ভাবুন: latch হলো এমন গেট, যা সবুজ বাতি জ্বলে থাকার পুরো সময় খোলা — যত ট্রেন আসে, পার হয়ে যায়। Flip-flop হলো এমন গেট, যা বাঁশি বাজার মুহূর্তে একটি ট্রেনকেই ঢুকতে দেয়। এই পার্থক্যই race-around ব্যাখ্যা করে। JK-তে J = K = 1 মানে উল্টে দেওয়া (toggle). Level-triggered JK-তে clock উঁচু থাকার পুরো সময় gate খোলা; আউটপুট উল্টায়, feedback দিয়ে ফিরে এসে আবার উল্টায় — pulse যদি propagation delay-এর চেয়ে লম্বা হয়, ফল অনিশ্চিত।

Q: Moore আর Mealy — একই কাজের দুই নকশা। কোনটি কখন বেছে নেবেন, আর “এক cycle দেরি” কথাটির মানে কী?

Moore machine -এর output শুধু বর্তমান state-এর ফাংশন; প্রতিটি state-এর গায়েই output লেখা থাকে। Mealy machine -এর output বর্তমান state আর বর্তমান input — দুটির ফাংশন; output লেখা থাকে transition-এর তীরে। ফলে input বদলালে Mealy-র output একই cycle-এ বদলাতে পারে, আর Moore-এর output বদলায় পরের clock ধারে state বদলানোর পরে — এটিই “এক cycle দেরি”। উদাহরণ: “1011” ধরার একটি sequence detector. Mealy নকশায় শেষ 1 আসার মুহূর্তেই z = 1, আর state লাগে কম (সাধারণত চারটি)। Moore নকশায় একটি বাড়তি “পেয়েছি” state লাগে, যেখানে z = 1; সেখানে পৌঁছাতে একটি clock ধার লাগে। কোনটি কখন? Mealy-র সুবিধা: কম state, দ্রুত সাড়া। অসুবিধা: input থেকে output-এ combinational পথ, তাই input-এর glitch সরাসরি output-এ যেতে পারে, আর দুটি Mealy machine পরপর জুড়লে দীর্ঘ combinational পথ বা loop তৈরি হতে পারে।

Q: Carry flag আর overflow flag — একই যোগে দুটির মান আলাদা কেন, আর কোনটি কখন দেখবেন?

Adder জানে না সংখ্যাগুলো signed না unsigned — সে শুধু বিট যোগ করে। একই বিট-প্যাটার্নের দুটি ব্যাখ্যা থাকে বলেই দুটি flag. Carry (C) বলে unsigned ব্যাখ্যায় ফল n বিটে ধরেনি (MSB থেকে carry বেরিয়েছে)। Overflow (V) বলে signed ব্যাখ্যায় ফল সীমার বাইরে — একই চিহ্নের দুটি সংখ্যা যোগে উল্টো চিহ্নের ফল, যা hardware-এ V = c n ⊕ c n−1 . চারটি ৮ বিটের উদাহরণ মনে রাখুন: 0xFF + 0x01 = 0x00 — C = 1 (২৫৫ + ১ = ২৫৬), V = 0 (−১ + ১ = ০, সঠিক)। 0x7F + 0x01 = 0x80 — C = 0, V = 1 (১২৭ + ১ = −১২৮ হয়ে গেল)। 0x80 + 0x80 = 0x00 — দুটিই 1. আর 0x60 + 0x50 = 0xB0 — C = 0, V = 1. কোনটি কখন? C/C++-এ unsigned চলকের তুলনা বা বহু-word যোগে (add-এর পরে adc) carry দেখা হয়; signed int-এর তুলনায় overflow আর sign flag. তাই x86-এ unsigned তুলনার শাখা (jb, ja) C দেখে, signed-এর (jl, jg) দেখে SF আর OF (অর্থাৎ V).

Q: Write-through বনাম write-back, আর write-allocate বনাম no-write-allocate — চারটি শব্দ কোন দুই প্রশ্নের উত্তর?

চারটি শব্দ দুটি আলাদা প্রশ্নের উত্তর, আর গুলিয়ে যায় ঠিক সেখানেই। প্রথম প্রশ্ন — write hit-এ কী হবে? Write-through : cache আর নিচের স্তর দুটিতেই সাথে সাথে লেখা; সরল, নিচের স্তর সবসময় হালনাগাদ, কিন্তু প্রতিটি store মেমরির ট্রাফিক তৈরি করে — তাই প্রায় সবসময় সাথে একটি write buffer থাকে। Write-back : শুধু cache-এ লেখা, আর line-এ dirty বিট চালু; line সরানোর সময়ই পুরো block নিচে যায়। একই block-এ বারবার লেখা হলে ট্রাফিক অনেক কম, কিন্তু miss-এ dirty block বের করার খরচ যোগ হয়। দ্বিতীয় প্রশ্ন — write miss-এ কী হবে? Write-allocate : আগে block-টি cache-এ আনা, তারপর লেখা — পরের লেখা বা পড়া hit হবে, এই আশায়। No-write-allocate : cache এড়িয়ে সরাসরি নিচে লেখা। প্রচলিত জুটি: write-back + write-allocate (block আনলেই পরের লেখাগুলো cache-এ জমে — আধুনিক CPU-র L1 data cache-এ সাধারণত এটি), আর write-through + no-write-allocate (প্রতিটি store এমনিতেই নিচে যায়, তাই block আনার লাভ কম)।

Q: Local miss rate আর global miss rate — L2-এর “৪০% miss” কোন অর্থে, আর AMAT-এর দুই রীতির পার্থক্য কী?

Local miss rate = একটি স্তরে যত access এসেছে , তার কত ভাগ miss. Global miss rate = CPU-র মোট access-এর কত ভাগ ওই স্তরেও miss করে নিচে গেল। L1-এর ক্ষেত্রে দুটি এক, কারণ সব access L1-এ আসে। L2-তে আসে শুধু L1-এর miss, তাই L2-এর global = L1-এর miss rate × L2-এর local. L1 ৫% miss আর L2-এর local ৪০% হলে global মাত্র ২% — L2 “খারাপ” দেখালেও মেমরিতে যাওয়া access ৫% থেকে ২%-এ নামিয়েছে। AMAT-এর সূত্রে local-ই বসে: AMAT = HT 1 + MR 1 × (HT 2 + MR 2,local × MP 2 ). L2-এর local miss rate সরাসরি সব access-এর ওপর বসানো (1 + 0.05 × 12 + 0.4 × 150) সবচেয়ে প্রচলিত ভুল — এই পাতার একটি distractor ঠিক তা-ই (৬১.৬ cycle). দ্বিতীয় ফাঁদ রীতির: এই কোর্স AMAT = hit time + miss rate × miss penalty লেখে, যেখানে miss-এও আগে hit time লাগে ধরা হয় (cache আগে দেখা হয়, তারপর নিচে যাওয়া)। কিছু বই লেখে AMAT = (১ − MR) × HT + MR × (মোট miss-এর সময়), যেখানে miss-এর সময়ে hit time আলাদা ধরা হয় না বা ভেতরে ধরা থাকে।

Q: MIPS আর MFLOPS — সহজ সংখ্যা, তবু কেন ভুল রায় দেয়? “peak” আর আসল গতির পার্থক্য কী?

MIPS = instruction count ÷ (সময় × ১০ ৬ ) = f ÷ (CPI × ১০ ৬ )। সমস্যা হলো এটি লৌহসূত্রের তিন গুণকের একটি — instruction count — বাদ দেয়। তিনটি ফাঁদ: (১) ভিন্ন ISA-তে একই কাজে instruction-সংখ্যা আলাদা, তাই MIPS তুলনা অর্থহীন; (২) একই machine-এ প্রোগ্রামভেদে MIPS বদলায়; (৩) compiler optimization সস্তা instruction বাদ দিলে প্রোগ্রাম দ্রুত হয়, অথচ গড় CPI বাড়ায় MIPS কমে — পর্ব ০৩-এর উদাহরণে দ্রুত compiler-টির MIPS কম (২৮০০ বনাম ৩২০০)। MFLOPS (প্রতি সেকেন্ডে মিলিয়ন floating-point operation) কাজের কাছাকাছি, কারণ একই হিসাবে FLOP-সংখ্যা ISA-ভেদে কম বদলায়। তবু ফাঁদ আছে: সব operation সমান নয় (ভাগ বা বর্গমূল যোগের চেয়ে অনেক ধীর, অথচ গোনা হয় একই এককে); FMA-কে দুটি operation গোনা হয়; আর integer-নির্ভর প্রোগ্রামে এটি প্রায় কিছুই বলে না। সবচেয়ে বড় ফাঁদ “peak”: peak FLOPS = core × clock × প্রতি cycle-এ FLOP — একটি তাত্ত্বিক ছাদ, যা কেবল নিখুঁত SIMD কোড আর cache-এ বসা ডেটায় ছোঁয়া যায়।

এক নজরে · এই পাতা কীভাবে ব্যবহার করবেন

১১৪টি প্রশ্ন, কোর্সের ক্রমে: প্রথমে কৌশল — প্রশ্নের ধরন, বাদ দেওয়ার পদ্ধতি, একক যাচাই আর দ্রুত অনুমান; তারপর মডিউল ১ থেকে ৯ — প্রতিটির একটি অংশ, শুরুতে “যা ঝালিয়ে নেবেন” তালিকায় সংশ্লিষ্ট পর্বের লিংক।
আগে খাতায় উত্তর, তারপর চাপুন: যে অপশনই চাপুন, ব্যাখ্যা দেখাবে — সঠিকটি কেন সঠিক, আর ভুলটি কোন ভুল ধারণা বা কোন হিসাবের ভুল থেকে এসেছে।
কঠিনতার মাত্রা দেওয়া আছে: প্রতিটি প্রশ্নের শুরুতে (সহজ), (মাঝারি) বা (কঠিন)। মেশানো আছে সংজ্ঞা, ছোট numerical, “কোনটি মিথ্যা”, আর চাকরির পরীক্ষার প্রিয় ছোট তথ্য — universal gate, flip-flop, select লাইন, RISC বনাম CISC, addressing mode, cache mapping, DMA, interrupt আর virtual memory.
প্রতিটি numerical script দিয়ে যাচাই করা: রীতি (convention) প্রশ্নেই লেখা; চারটি ছোট JavaScript সহায়ক দিয়ে আপনিও সংখ্যা বদলে মিলিয়ে নিতে পারবেন।
স্কোর নিজে নিজে: পাতার নিচে প্রথম চেষ্টার মোট স্কোর দেখাবে। যে মডিউলে বেশি ভুল, তার পর্বগুলো আবার পড়ুন, তারপর শুধু ভুল প্রশ্নগুলো আবার করুন।

এই পর্বে যা করবেন

আর্কিটেকচার আর ডিজিটাল লজিকের MCQ কোন কোন ছাঁচে আসে তা চেনা, আর বাদ দেওয়ার পদ্ধতি ও সময় ভাগ শেখা
বিটের যোগফল, ns ↔ GHz, KiB বনাম KB, MT/s বনাম MHz — একক আর যোগফল যাচাই দিয়ে ভুল অপশন কেটে দেওয়া
Latch বনাম flip-flop, Moore বনাম Mealy, carry বনাম overflow, write-back বনাম write-through, local বনাম global miss rate — বড় জোড়া-বিভ্রান্তি দূর করা
পুরো কোর্সের ১১৪টি প্রশ্নে নিজের দুর্বল মডিউল খুঁজে বের করা, আর সেই পর্বে ফিরে যাওয়া
AI দিয়ে আরও MCQ বানানো, আর তার “সঠিক উত্তর” হাতে বা script-এ হিসাব করে যাচাই করা

১ · MCQ কীভাবে সামলাবেন — প্রশ্নের ধরন, বাদ দেওয়া, একক যাচাই আর দ্রুত অনুমান

ধরুন রাজশাহীর তানিয়া একটি সরকারি প্রতিষ্ঠানের assistant programmer পদের লিখিত পরীক্ষায় বসেছেন। কম্পিউটার অংশে আর্কিটেকচারের অনেকগুলো MCQ, সময় কম, আর ভুলে নম্বর কাটে। প্রশ্নগুলো চেনা: “universal gate কোনটি?”, “32:1 mux-এ কয়টি select লাইন?”, “cache-এর index কত বিট?” — কিন্তু অপশনে ১৭ | ৯ | ৬ আর ১৭ | ৬ | ৯ পাশাপাশি, “3.44 গুণ” আর “5 গুণ” দুটিই আছে। পরে মিলিয়ে দেখলেন, বেশিরভাগ ভুল জ্ঞানের অভাবে নয় — একটি রীতি (AMAT-এ hit time ধরা হবে কি না), একটি একক (MT/s বনাম MHz), বা একটি শব্দ (“মিথ্যা”) চোখ এড়িয়ে যাওয়ায়।

প্রশ্নকর্তা জেনেশুনে এমন ভুল অপশন রাখেন, যা কোনো আধা-সত্য নিয়ম বা চেনা হিসাবের ভুল থেকে আসে। এমন বিভ্রান্তিকর অপশনকে বলে distractor. “Carry বেরোলেই overflow”, “pipeline-এ k ধাপ মানে k গুণ দ্রুত”, “L2-এর local miss rate-ই global”, “register renaming RAW দূর করে” — এই কোর্সের distractor-গুলো ঘুরেফিরে দশ-বারোটি ভুল ধারণা থেকেই আসে। সেগুলো চিনে ফেললে অর্ধেক কাজ শেষ।

পরীক্ষাগুলো সাধারণত কেমন

বাংলাদেশে চাকরির লিখিত পরীক্ষায় (IT officer, ব্যাংকের IT, assistant programmer, BCS-ধাঁচের পরীক্ষার কম্পিউটার অংশ) প্রথম ধাপে সাধারণত MCQ থাকে; অনেক পরীক্ষায় ভুলে নম্বর কাটে (negative marking), তবে কত কাটে বা আদৌ কাটে কি না, পরীক্ষাভেদে আলাদা — নিজের পরীক্ষার বিজ্ঞপ্তি দেখে নিন। এ ধরনের পরীক্ষায় প্রায়ই আসে সংখ্যা পদ্ধতির রূপান্তর, universal gate, flip-flop-এর ধরন, mux-decoder-এর মাপ, RISC বনাম CISC, addressing mode, cache mapping, DMA আর interrupt-এর ধরন। বিশ্ববিদ্যালয়ের Digital Logic Design বা Computer Architecture কোর্সের quiz-এ numerical-এর ভাগ বেশি — K-map, Booth, IEEE 754, CPI, pipeline-এর cycle, cache-এর বিট আর AMAT. আর embedded বা systems ইন্টারভিউর অনলাইন screening-এ আসে বাস্তব আচরণ — endianness, overflow, false sharing, volatile. এই পাতার প্রশ্ন তিন ধরনের পাঠকের কথা ভেবেই মেশানো।

প্রশ্নের ছয় ছাঁচ

ধরন	উদাহরণ	কৌশল
ছোট তথ্য ও সংজ্ঞা	“universal gate কোনটি?”, “TLB কী?”	জোড়ায় মনে রাখুন (NAND–NOR, SRAM–DRAM); কাছের অপশনটি কেন নয়, তাও ভাবুন
ছোট numerical	base, CPI, Amdahl, cache-এর বিট, AMAT	রীতি আর একক আগে খাতায়, তারপর হিসাব; উত্তরের মাপ আগে আন্দাজ করুন
“কোনটি মিথ্যা”	“write policy নিয়ে কোনটি মিথ্যা?”	প্রতিটি অপশনের পাশে স বা মি লিখুন; “মিথ্যা” শব্দে দাগ দিন
ধাপে ধাপে trace	K-map-এর দল, flip-flop-এর পরের state, cache-এর hit-miss	ছোট টেবিল এঁকে প্রতিটি ধাপ লিখুন — মাথায় নয়
জোড়া-ধারণা	latch বনাম flip-flop, Moore বনাম Mealy, WAR বনাম RAW	সংজ্ঞার একটি শব্দ (level/edge, state/input) ধরে পার্থক্য করুন
ISA আর কোড	RISC-V-এর encoding, offset, calling convention	RISC-V আর পুরোনো MIPS-এর রীতি গুলিয়ে ফেলবেন না (branch offset-এর ভিত্তি PC বনাম PC + 4)

কৌশল ১ · বাদ দেওয়ার পদ্ধতি — cache-এর একটি প্রশ্নে ধাপে ধাপে

সঠিক উত্তর সরাসরি খোঁজার চেয়ে ভুলগুলো বাদ দেওয়া প্রায়ই সহজ। একে বলে elimination method. প্রতিটি অপশনকে জিজ্ঞেস করুন: “এটি সত্য হলে কোন নিয়মটি সত্য হতে হবে?” তারপর একটি নিয়ম বা ছোট হিসাব দিয়ে অপশনটি কেটে দিন। নিচের ডায়াগ্রামে set-associative cache-এর ঠিকানা-ভাগের একটি প্রশ্ন এভাবে সমাধান করা হয়েছে — চারটি অপশনের তিনটিই তিনটি পরিচিত ফাঁদ থেকে বানানো।

প্রশ্ন পড়া32 বিটকী কী জানা?
যোগফল= 32?গ বাদ
offsetlog₂ 32ঘ বাদ
set গোনা÷ wayখ বাদ
উত্তরকফাঁদগুলো মনে রাখুন

প্রশ্ন (মাঝারি)tag | index | offset

৩২ বিট byte address, 16 KiB data,
2-way set-associative, block 32 byte.

ক) 19 | 8 | 5
খ) 18 | 9 | 5
গ) 19 | 9 | 5
ঘ) 19 | 5 | 8

ধাপ ২যোগফল যাচাই

tag + index + offset = address-এর বিট

ক) 19 + 8 + 5 = 32  ✓
খ) 18 + 9 + 5 = 32  ✓
গ) 19 + 9 + 5 = 33  ✗
ঘ) 19 + 5 + 8 = 32  ✓

গ) 19 | 9 | 5

ধাপ ৩offset আসে block থেকে

offset = log₂(block) = log₂ 32 = 5

ঘ)-তে offset 8 — মানে block 256 byte;
index আর offset-এর ঘর উল্টে গেছে

ঘ) 19 | 5 | 8

ধাপ ৪set-সংখ্যা

block = 16384 ÷ 32 = 512
set   = 512 ÷ 2 way = 256 = 2⁸
index = 8,  tag = 32 − 8 − 5 = 19

খ) way দিয়ে ভাগ ভুলে গেছে
   (512 set ধরে index 9)

খ) 18 | 9 | 5

ধাপ ৫উত্তর আর শিক্ষা

উত্তর: ক) 19 | 8 | 5

তিন ফাঁদ:
গ → যোগফল না মেলানো
ঘ → offset আর index-এর ঘর গোলানো
খ → way দিয়ে ভাগ ভুলে যাওয়া

প্রশ্নটি আসলে কী চায়, আগে দেখুন। তিনটি সংখ্যার ক্রম tag | index | offset — ক্রমটি প্রশ্নেই লেখা। জানা আছে চারটি জিনিস: ঠিকানা ৩২ বিট, data 16 KiB, way ২টি, block ৩২ byte. কোনো হিসাবের আগে একটি সহজ পরীক্ষা হাতে আছে।
যোগফল যাচাই — সবচেয়ে সস্তা ছাঁকনি। তিনটি অংশ মিলে সবসময় ঠিকানার মোট বিট। ক, খ, ঘ-তে যোগফল ৩২, কিন্তু গ-তে ৩৩ — কোনো হিসাব ছাড়াই গ বাদ।
Offset আসে শুধু block-এর আকার থেকে। log₂ 32 = ৫. ঘ-তে offset ৮ মানে block ২৫৬ byte — আসলে index আর offset-এর ঘর উল্টে গেছে। ঘ বাদ।
Set গুনুন — way দিয়ে ভাগ করতে ভুলবেন না। মোট block ১৬৩৮৪ ÷ ৩২ = ৫১২, set = ৫১২ ÷ ২ = ২৫৬ = ২^৮, তাই index ৮ আর tag ৩২ − ৮ − ৫ = ১৯. খ ধরে নিয়েছে direct-mapped (৫১২টি set) — way দিয়ে ভাগ বাদ। খ বাদ।
উত্তর ক — আর তিনটি ফাঁদ মনে রাখুন। যোগফল না মেলানো, offset আর index গোলানো, আর way দিয়ে ভাগ ভুলে যাওয়া। মডিউল ৮-এর অংশে একই ধাঁচের আরও দুটি প্রশ্ন আছে — সেখানে এই চার ধাপ নিজে চালিয়ে দেখুন।

কৌশল ২ · একক আর রীতি আগে, হিসাব পরে

আর্কিটেকচারের numerical-এ সবচেয়ে বেশি নম্বর হারায় হিসাবের ভুলে নয়, রীতি আর এককের ভুলে। একই প্রশ্নের দুটি উত্তর দুটি ভিন্ন রীতি থেকে আসতে পারে, আর প্রশ্নকর্তা প্রায়ই দুটিকেই অপশনে রাখেন। এই কোর্সের পর্বগুলো যে রীতি মানে, এই পাতার প্রশ্নগুলোও তা-ই মানে; ভিন্ন হলে প্রশ্নে লেখা আছে।

বিষয়	রীতি বা একক	যাচাইয়ের কৌশল
সময় আর কম্পাঙ্ক	১ GHz ↔ ১ ns, ২ GHz ↔ ৫০০ ps; CPU time = IC × CPI ÷ f	একক মেলান: cycle ÷ (cycle/s) = সেকেন্ড; উত্তর ঘণ্টায় এলে কোথাও ভুল
মেমরির মাপ	KiB, MiB = ২^১০, ২^২০ byte; bandwidth-এ GB/s = ১০^৯ byte/s	cache-এর মাপ সবসময় ২-এর ঘাত; DRAM-এর হার দশমিকে
Cache-এর ঠিকানা	offset = log₂ block, index = log₂ set, set = মাপ ÷ block ÷ way	tag + index + offset = ঠিকানার বিট
AMAT	AMAT = HT + MR × MP (miss-এও আগে hit time); multi-level-এ L2-এর local miss rate	AMAT সবসময় hit time-এর বেশি আর মেমরির সময়ের কম
Pipeline	k ধাপে n instruction: k + n − 1 cycle; clock = সবচেয়ে ধীর ধাপ + register overhead	speedup কখনো k-এর বেশি নয়
Stall-এর CPI	CPI = ১ + Σ (ভগ্নাংশ × সম্ভাবনা × penalty)	প্রতিটি পদে তিনটি গুণক আছে কি না দেখুন
DRAM	DDR4-3200 মানে 3200 MT/s, clock 1600 MHz; CL cycle-এ	CAS ns = CL ÷ clock; bandwidth = MT/s × bus-এর byte
Flag	C = unsigned carry, V = signed overflow	একই যোগে দুটি প্রশ্ন আলাদা — দুটিই আলাদা হিসাব করুন

রীতি লেখার পর উত্তরের মাপ আগে আন্দাজ করুন, তারপর হিসাব। নিচের ছোট হিসাবটি এই পাতার কয়েকটি বহুল-প্রচলিত numerical আবার করে; যেকোনো সংখ্যা বদলে নিজের প্রশ্নের উত্তর মিলিয়ে দেখতে পারেন:

// Re-check the most common architecture MCQ numericals before trusting an answer key.
const amdahl = (f, s) => 1 / ((1 - f) + f / s);
function split(addrBits, sizeBytes, blockBytes, ways) {
  const off = Math.log2(blockBytes), idx = Math.log2(sizeBytes / blockBytes / ways);
  return `tag ${addrBits - idx - off} | index ${idx} | offset ${off}`;
}
console.log("CPU time 2e9 x 1.5 / 3 GHz  :", 2e9 * 1.5 / 3e9, "s");
console.log("MIPS at 2 GHz, CPI 0.8      :", 2e9 / (0.8 * 1e6));
console.log("Amdahl f=0.4, s=8           :", amdahl(0.4, 8).toFixed(2));
console.log("Amdahl 90% parallel, 16 core:", amdahl(0.9, 16).toFixed(2), "(limit", (1 / 0.1).toFixed(0) + ")");
console.log("fmax = 1/(50+350+100 ps)    :", (1 / 500e-12 / 1e9).toFixed(2), "GHz");
console.log("Pipeline k=5, n=100         :", 5 + 100 - 1, "cycles");
console.log("16 KiB 2-way 32 B, 32-bit   :", split(32, 16384, 32, 2));
console.log("32 KiB direct 64 B, 32-bit  :", split(32, 32768, 64, 1));
console.log("AMAT 1 + 0.04 x 80          :", (1 + 0.04 * 80).toFixed(1), "cycles");
console.log("AMAT two-level              :", (1 + 0.05 * (12 + 0.4 * 150)).toFixed(1),
            "cycles, L2 global miss", (0.05 * 0.4 * 100).toFixed(0) + "%");
console.log("DDR4-3200 x 8 bytes         :", 3200e6 * 8 / 1e9, "GB/s");
console.log("Power at 0.8 V and 0.8 f    :", (0.8 ** 3).toFixed(3), "x");

আউটপুট (নির্ধারিত, প্রতিবার একই):

CPU time 2e9 x 1.5 / 3 GHz  : 1 s
MIPS at 2 GHz, CPI 0.8      : 2500
Amdahl f=0.4, s=8           : 1.54
Amdahl 90% parallel, 16 core: 6.40 (limit 10)
fmax = 1/(50+350+100 ps)    : 2.00 GHz
Pipeline k=5, n=100         : 104 cycles
16 KiB 2-way 32 B, 32-bit   : tag 19 | index 8 | offset 5
32 KiB direct 64 B, 32-bit  : tag 17 | index 9 | offset 6
AMAT 1 + 0.04 x 80          : 4.2 cycles
AMAT two-level              : 4.6 cycles, L2 global miss 2%
DDR4-3200 x 8 bytes         : 25.6 GB/s
Power at 0.8 V and 0.8 f    : 0.512 x

প্রথম দুই লাইন লৌহসূত্র আর MIPS: ১ সেকেন্ড আর 2500 MIPS. তৃতীয় আর চতুর্থ লাইনে Amdahl-এর সূত্র — 40% অংশ 8 গুণ দ্রুত হলে মাত্র ১.৫৪ গুণ, আর ৯০% সমান্তরাল প্রোগ্রাম ১৬ core-এ ৬.৪ গুণ, যেখানে সীমা ১০. এরপর setup-সহ f_max ২ GHz আর ১০০টি instruction-এ ১০৪ cycle. মাঝের দুই লাইন cache-এর ঠিকানা-ভাগ — প্রথমটি ঠিক উপরের ডায়াগ্রামের উত্তর (১৯ | ৮ | ৫)। তারপর AMAT এক আর দুই স্তরে (৪.২ আর ৪.৬ cycle, L2-এর global miss ২%), DDR4-3200-এর ২৫.৬ GB/s, আর voltage ও frequency দুটিই ২০% কমালে dynamic power প্রায় অর্ধেক (০.৫১২)। প্রতিটি সংখ্যা নিচের কোনো না কোনো প্রশ্নের উত্তর।

কৌশল ৩ · দ্রুত অনুমান — হিসাবের আগেই অর্ধেক অপশন বাদ

অনেক numerical-এ পুরো হিসাব লাগে না; একটি সীমা (bound) জানলেই বেশিরভাগ অপশন কেটে যায়। Amdahl-এর speedup কখনো core-সংখ্যা বা 1 ÷ (serial ভগ্নাংশ)-এর বেশি নয়; pipeline-এর speedup কখনো ধাপ-সংখ্যার বেশি নয়; AMAT সবসময় hit time আর মেমরির সময়ের মাঝে; CPI-তে stall যোগ হলে CPI কখনো আদর্শের কম হয় না। নিচের ডায়াগ্রামে একটি multicore প্রশ্ন এভাবে দুই লাইনের হিসাবে সমাধান হয়েছে।

প্রশ্নf = 0.9N = 16
ছাদ1 ÷ 0.1ক, খ বাদ
সীমা ≠ উত্তরN সসীমঘ বাদ
যাচাই0.15625গ = 6.4

প্রশ্ন (মাঝারি)Amdahl, স্থির কাজ

একটি প্রোগ্রামের ৯০% পুরোপুরি সমান্তরাল,
বাকি ১০% serial. ১৬টি core-এ speedup?

ক) 16
খ) 14.4
গ) 6.4
ঘ) 10

ধাপ ২অসীম core-এও ছাদ

N → ∞ হলে speedup → 1 ÷ (1 − f)
                 = 1 ÷ 0.1 = 10

১৬ আর ১৪.৪ দুটিই ১০-এর বেশি —
অসম্ভব

ক) 16   খ) 14.4

ধাপ ৩ছাদ ছোঁয়া যায় না

১০ পাওয়া যেত শুধু অসীম core-এ।
১৬ core-এ সমান্তরাল অংশের সময়
0.9 ÷ 16 > 0, তাই speedup < 10

ঘ) 10

ধাপ ৪এক লাইনে যাচাই

নতুন সময় = 0.1 + 0.9 ÷ 16
          = 0.1 + 0.05625 = 0.15625
speedup   = 1 ÷ 0.15625 = 6.4

উত্তর: গ) 6.4

প্রশ্ন থেকে দুটি সংখ্যা তুলুন। সমান্তরাল ভগ্নাংশ f = ০.৯, core N = ১৬, আর কাজের আকার স্থির — তাই Amdahl, Gustafson নয়। অপশনগুলো দেখে বুঝে নিন কোনটি কোন ভুল থেকে এসেছে: ১৬ “রৈখিক”, ১৪.৪ = ০.৯ × ১৬, ১০ = সীমা।
আগে ছাদ টানুন। Core যতই বাড়ুক, serial ১০% সময় থেকেই যায়, তাই speedup কখনো ১ ÷ ০.১ = ১০ ছাড়ায় না। ১৬ আর ১৪.৪ — দুটিই এক আঘাতে বাদ।
সীমা আর উত্তর এক নয়। ১০ পাওয়া যেত কেবল অসীম core-এ; ১৬টি core-এ সমান্তরাল অংশেরও কিছু সময় লাগে, তাই উত্তর ১০-এর কম। ঘ বাদ — বাকি থাকল শুধু গ।
এক লাইনে মিলিয়ে নিন। নতুন সময় ০.১ + ০.৯ ÷ ১৬ = ০.১৫৬২৫, speedup = ৬.৪ — উপরের script-এর চতুর্থ লাইনও এটিই দেখায়। পরীক্ষায় সময় কম থাকলে ধাপ ৩-এর পরেই উত্তর দেওয়া যেত; সময় থাকলে ধাপ ৪ নিশ্চয়তা দেয়।

কৌশল ৪ · negative marking আর সময় ভাগ

ভুলে নম্বর কাটলে আন্দাজ একটি হিসাবের সিদ্ধান্ত। ঠিক হলে +১ আর ভুলে −০.২৫ ধরলে চারটি অপশনের মধ্যে অন্ধ আন্দাজের গড় লাভ মাত্র +০.০৬২৫; একটি অপশন নিশ্চিতভাবে বাদ দিয়ে তিনটি থেকে +০.১৬৭; দুটি বাদ দিয়ে +০.৩৭৫. সাধারণ নিয়ম: k টি অপশন বাকি থাকলে আন্দাজ লাভজনক, যতক্ষণ কাটা নম্বর ১ ÷ (k − ১)-এর কম। অর্থাৎ লাভ আসে বাদ দেওয়ার দক্ষতা থেকে, ভাগ্য থেকে নয়।

সময় ভাগ করুন দুই দফায়। প্রথম দফায় ছোট তথ্য আর সংজ্ঞার প্রশ্ন — প্রতিটি আধা মিনিটের কম। Numerical আর যেগুলোতে দ্বিধা, সেগুলোর পাশে চিহ্ন দিয়ে এগিয়ে যান। দ্বিতীয় দফায় চিহ্ন দেওয়া প্রশ্ন, খাতায় ছোট হিসাবসহ: cache-এর প্রশ্নে আগে set-সংখ্যা, pipeline-এর প্রশ্নে আগে সবচেয়ে ধীর ধাপ, IEEE 754-এর প্রশ্নে আগে exponent.

বারোটি বড় ফাঁদ

নিচের প্রতিটি সারি এই পাতার একাধিক প্রশ্নে distractor হয়ে ফিরে আসবে। শুরুর আগে একবার চোখ বুলিয়ে নিন, আর শেষে আপনার ভুলগুলো কোন সারিতে পড়ল, মিলিয়ে দেখুন।

ফাঁদ	ভুল ধারণা	সঠিক কথা
Carry বনাম overflow	“carry বেরোলেই overflow”	C = unsigned-এর সীমা, V = signed-এর; −1 + 1-এ C = 1 কিন্তু V = 0
One's বনাম two's complement	“−x = সব বিট উল্টানো”	উল্টে তারপর ১ যোগ; one's complement-এ শূন্যের দুটি রূপ
Universal gate	“AND আর OR universal”	শুধু NAND আর NOR — প্রতিটি একাই NOT বানাতে পারে
Latch বনাম flip-flop	“দুটি একই”	latch level-sensitive, flip-flop edge-triggered
Moore বনাম Mealy	“Moore-এর output input-এ সাথে সাথে বদলায়”	Moore: শুধু state; Mealy: state আর input
Hold violation	“clock ধীর করলেই সারে”	hold-এর শর্তে clock period নেই; ছোট পথে delay যোগ করতে হয়
IEEE 754-এর bias	“single-এ bias ১২৮”	single ১২৭, double ১০২৩; hidden 1 ভুলবেন না
RISC-V বনাম MIPS	“branch-এর লক্ষ্য PC + 4 + offset”	RISC-V-তে branch-এর নিজের ঠিকানা + offset; jal রাখে PC + 4
Pipeline-এর speedup	“k ধাপ মানে k গুণ”	অসম ধাপ, register overhead, hazard — বাস্তবে k-এর কম
Renaming	“renaming সব dependence দূর করে”	WAR আর WAW দূর হয়; RAW (true dependence) থাকে
Local বনাম global miss rate	“L2-এর ৪০% miss মানে সব access-এর ৪০%”	global = L1 miss rate × L2 local miss rate
Way দিয়ে ভাগ	“index = log₂(মাপ ÷ block)”	set-associative-এ আরও way দিয়ে ভাগ; fully associative-এ index ০

এই পাতার প্রশ্নগুলো সম্পর্কে: প্রশ্নগুলো এই কোর্সের জন্য নতুন করে লেখা — বিশ্ববিদ্যালয়, চাকরির লিখিত পরীক্ষা আর ইন্টারভিউতে এ ধরনের প্রশ্ন প্রায়ই আসে, এমন ধারণা থেকে বানানো; কোনোটিই কোনো নির্দিষ্ট পরীক্ষার আসল প্রশ্ন নয়। প্রতিটি numerical-এর উত্তর ছোট প্রোগ্রামে মিলিয়ে দেখা, আর রীতি প্রশ্নেই লেখা। অন্যভাবে বলা না থাকলে ISA মানে RISC-V RV32I, আর datapath ও control-এর রীতি Patterson–Hennessy-র RISC-V সংস্করণের মতো — কোর্সের পর্বগুলো যেভাবে শিখিয়েছে।

২ · মডিউল ১ — আর্কিটেকচারের ভিত্তি (১৩টি প্রশ্ন)

এই অংশ কোর্সের ভিত্তি: ISA বনাম microarchitecture, von Neumann-এর নকশা, Moore-এর সূত্র, পারফরম্যান্সের হিসাব আর ডেটার বিট-রূপ। সবচেয়ে বেশি ভুল হয় তিন জায়গায়: লৌহসূত্রে CPI বা clock-এর দিক উল্টে ফেলা, two's complement-এ ১ যোগ করতে ভোলা, আর carry flag ও overflow flag গুলিয়ে ফেলা।

যা ঝালিয়ে নেবেন · পর্ব ০১–০৬

পর্ব ০১ · কম্পিউটার আর্কিটেকচার কী আর পর্ব ০২ · ইতিহাস আর প্রবণতা — স্তর, stored program, von Neumann bottleneck, Moore আর Dennard
পর্ব ০৩ · পারফরম্যান্স মাপা — CPU time, CPI, MIPS-এর ফাঁদ, Amdahl
পর্ব ০৪ · সংখ্যা পদ্ধতি আর পর্ব ০৫ · Integer-এর বিট-রূপ — রূপান্তর, two's complement, overflow
পর্ব ০৬ · ডেটার বিট-রূপ — UTF-8, endianness, bit manipulation

(সহজ) নিচের কোনটি microarchitecture-এর সিদ্ধান্ত, ISA-র নয়?

Pipeline-এ কয়টি ধাপ (stage) থাকবে
কোন কোন instruction আছে আর প্রতিটির অর্থ কী
Programmer কয়টি register দেখতে পান
মেমরির ঠিকানা কোন কোন addressing mode-এ তৈরি হয়

(সহজ) “von Neumann bottleneck” বলতে কী বোঝায়?

ALU একসাথে একটির বেশি যোগ করতে পারে না
CPU আর মেমরির মাঝের একটিমাত্র পথে instruction ও ডেটা দুটোকেই আসা-যাওয়া করতে হয়, তাই সেই পথই গতির সীমা টানে
Transistor আর ছোট করা সম্ভব নয়
Disk-এর গতি RAM-এর চেয়ে অনেক কম

(মাঝারি) একটি প্রোগ্রামে 2 × 10⁹টি instruction, গড় CPI 1.5, আর প্রসেসরের clock 3 GHz. CPU time কত?

0.67 s
0.44 s
1.0 s
9.0 s

(মাঝারি) একটি 2 GHz প্রসেসরের একটি প্রোগ্রামে গড় CPI 0.8 (প্রতি cycle-এ গড়ে একের বেশি instruction শেষ হয়)। এই প্রোগ্রামে প্রসেসরের MIPS rating কত?

1600
2000
2.5
2500

(কঠিন) MIPS (million instructions per second) নিয়ে কোন বক্তব্যটি মিথ্যা?

MIPS = instruction count ÷ (execution time × 10⁶)
ভিন্ন ISA-র দুই machine-এর মধ্যে যার MIPS বেশি, সে সব প্রোগ্রাম সবসময় কম সময়ে শেষ করে
একই machine-এ ভিন্ন প্রোগ্রামের MIPS আলাদা হতে পারে
Compiler optimization-এ প্রোগ্রাম দ্রুত হলেও MIPS কমে যেতে পারে

(মাঝারি) একটি প্রোগ্রামের চলার সময়ের 40% এমন অংশে যায়, যা নতুন hardware 8 গুণ দ্রুত করে; বাকি অংশ অপরিবর্তিত। Amdahl-এর সূত্রে পুরো প্রোগ্রামের speedup প্রায় কত?

1.54
8
3.2
1.67

(সহজ) ১৯৭৫ সালের সংশোধিত রূপে Moore-এর সূত্র কী বলে?

প্রসেসরের clock frequency প্রতি ১৮ মাসে দ্বিগুণ হয়
প্রতি বছর chip-এর power অর্ধেক হয়
একটি chip-এ transistor-এর সংখ্যা মোটামুটি প্রতি ২ বছরে দ্বিগুণ হয়
প্রতি ২ বছরে প্রসেসরের দাম দ্বিগুণ হয়

(সহজ) (2AF)₁₆-এর দশমিক মান কত?

1257
175
512
687

(সহজ) ৮ বিট two's complement-এ −20 কীভাবে লেখা হয়?

1001 0100
1110 1100
1110 1011
0001 0100

(সহজ) ১৬ বিট two's complement-এ কোন পরিসরের পূর্ণসংখ্যা রাখা যায়?

−32767 থেকে +32767
0 থেকে 65535
−32768 থেকে +32767
−65536 থেকে +65535

(মাঝারি) একটি ৮ বিট adder-এ 0x60 + 0x50 যোগ করা হলো (ফল 0xB0). Carry flag (C) আর overflow flag (V) কত?

C = 1, V = 0
C = 1, V = 1
C = 0, V = 0
C = 0, V = 1

(সহজ) একটি little-endian মেশিনে ৩২ বিটের মান 0xA1B2C3D4 ঠিকানা 0x100 থেকে রাখা হলো। ঠিকানা 0x103-এ কোন byte আছে?

0xA1
0xD4
0xB2
0xC3

(মাঝারি) UTF-8-এ “কA” (বাংলা ক, U+0995, আর ইংরেজি A) — এই দুই অক্ষরের string-এ মোট কয়টি byte?

// Check number-representation answers: bases, two's complement, flags, IEEE 754 single.
const hex = (v, w) => "0x" + (v >>> 0).toString(16).toUpperCase().padStart(w, "0");
const bin8 = v => (v & 0xFF).toString(2).padStart(8, "0").replace(/^(\d{4})/, "$1 ");
console.log("(2AF)16 =", parseInt("2AF", 16), "= octal", parseInt("2AF", 16).toString(8));
console.log("-20 in 8-bit two's complement:", bin8(-20));
function add8(a, b) {                      // 8-bit add with C, V, Z flags
  const s = a + b, r = s & 0xFF, sa = a >> 7, sb = b >> 7, sr = r >> 7;
  const v = sa === sb && sr !== sa ? 1 : 0;
  return `${hex(a, 2)} + ${hex(b, 2)} = ${hex(r, 2)}  C=${s >> 8} V=${v} Z=${r === 0 ? 1 : 0}`;
}
console.log(add8(0x60, 0x50));
console.log(add8(0x80, 0x80));
const bits = x => new Uint32Array(new Float32Array([x]).buffer)[0];
const fromBits = u => new Float32Array(new Uint32Array([u]).buffer)[0];
for (const x of [-6.25, -12.5, 0.75]) {
  const u = bits(x), E = (u >>> 23) & 255;
  console.log(`${x}: ${hex(u, 8)}  sign ${u >>> 31}, E ${E} (e = ${E - 127})`);
}
console.log("0x3F400000 ->", fromBits(0x3F400000), "| float(2^24 + 1) ->", Math.fround(2 ** 24 + 1));
console.log("0.1 + 0.2 === 0.3:", 0.1 + 0.2 === 0.3, "| NaN === NaN:", NaN === NaN, "| -0 === 0:", -0 === 0);

আউটপুট (নির্ধারিত, প্রতিবার একই):

(2AF)16 = 687 = octal 1257
-20 in 8-bit two's complement: 1110 1100
0x60 + 0x50 = 0xB0  C=0 V=1 Z=0
0x80 + 0x80 = 0x00  C=1 V=1 Z=1
-6.25: 0xC0C80000  sign 1, E 129 (e = 2)
-12.5: 0xC1480000  sign 1, E 130 (e = 3)
0.75: 0x3F400000  sign 0, E 126 (e = -1)
0x3F400000 -> 0.75 | float(2^24 + 1) -> 16777216
0.1 + 0.2 === 0.3: false | NaN === NaN: false | -0 === 0: true

এই সহায়ক মডিউল ১ আর মডিউল ৪-এর সংখ্যার প্রশ্ন মেলায়। (2AF)₁₆ = ৬৮৭, যার octal রূপ 1257 — একটি distractor ঠিক এটিই। −20-এর two's complement 1110 1100. দুটি ৮ বিট যোগে flag আলাদা আলাদা: 0x60 + 0x50-এ C = 0 কিন্তু V = 1, আর 0x80 + 0x80-এ তিনটিই 1. এরপর IEEE 754-এর বিট: −6.25 = 0xC0C80000 (E = ১২৯), আর তার পাশের distractor 0xC1480000 আসলে −12.5. শেষ দুই লাইন floating point-এর চার প্রিয় ফাঁদ নিশ্চিত করে: 2²⁴ + 1 float-এ 16777216 হয়ে যায়, 0.1 + 0.2 ≠ 0.3, NaN নিজের সমান নয়, আর −0 = +0. (JavaScript-এর সংখ্যা IEEE 754 double; Float32Array দিয়ে single-এর বিট দেখা হয়েছে।)

৩ · মডিউল ২ — Combinational লজিক (১৪টি প্রশ্ন)

Boolean algebra, gate, K-map, Quine-McCluskey, adder, mux-decoder, ALU আর Verilog — চাকরির পরীক্ষায় এই মডিউল থেকেই সবচেয়ে বেশি ছোট তথ্যের প্রশ্ন আসে। প্রিয় প্রশ্ন: universal gate, NAND দিয়ে XOR-এ কয়টি gate, multiplexer-এ কয়টি select লাইন, আর K-map-এর কোণার দল। ফাঁদ: K-map-এ Gray ক্রম (00, 01, 11, 10) ভুলে যাওয়া, আর ripple-carry-র delay-তে শুরুর gate বাদ দেওয়া।

যা ঝালিয়ে নেবেন · পর্ব ০৭–১৪

পর্ব ০৭ · Boolean algebra আর পর্ব ০৮ · Logic gate আর transistor — De Morgan, SOP-POS, CMOS, universal gate
পর্ব ০৯ · K-map আর পর্ব ১০ · Quine-McCluskey আর hazard
পর্ব ১১ · Adder, পর্ব ১২ · Mux, decoder, encoder আর পর্ব ১৩ · ALU নকশা
পর্ব ১৪ · Verilog — assign, always, blocking বনাম non-blocking

(সহজ) নিচের কোন জোড়ার প্রতিটি gate একাই (অন্য কোনো gate ছাড়া) যেকোনো Boolean function বানাতে পারে?

AND আর OR
NAND আর NOR
XOR আর XNOR
NOT আর AND

(মাঝারি) শুধু ২-input NAND gate দিয়ে একটি ২-input XOR বানাতে কমপক্ষে কয়টি gate লাগে?

২টি
৩টি
৪টি
৫টি

(সহজ) Boolean algebra-য় A + A′B-এর সরল রূপ কোনটি?

A
AB
B
A + B

(সহজ) F(A, B, C) = Σm(1, 3, 5, 7), যেখানে A সবচেয়ে বাঁয়ের বিট। Minimal SOP কোনটি?

C
A
A′C
B

(মাঝারি) F(A, B, C, D) = Σm(0, 2, 5, 7, 8, 10, 13, 15)-এর minimal SOP কোনটি?

B ⊕ D
BD + B′D′
A′B′D′ + BD
B′D′ + A′BD

(মাঝারি) F(A, B, C) = Σm(0, 2, 3), আর m1 don't care (d). Minimal SOP কোনটি?

A′C′ + A′B
A′ + B
A′
B′C′

(মাঝারি) Quine-McCluskey পদ্ধতিতে (চলকের ক্রম ABCD) নিচের কোন দুটি পদ জোড়া লাগিয়ে একটি নতুন পদ বানানো যায়?

1-10 আর 11-0
0110 আর 1001
0-01 আর 1-10
1-10 আর 1-11

(কঠিন) F = A′B + AC. B = C = 1 রেখে A বদলালে static-1 hazard হতে পারে। কোন পদ যোগ করলে hazard দূর হয় আর truth table অপরিবর্তিত থাকে?

BC
AB
A′C
কোনো পদ যোগে hazard সারে না, শুধু gate-এর delay মেলাতে হয়

(সহজ) Half adder-এর Sum আর Carry-এর সূত্র কোনটি?

Sum = A + B, Carry = AB
Sum = A ⊕ B, Carry = A·B
Sum = A ⊕ B, Carry = A + B
Sum = AB, Carry = A ⊕ B

(মাঝারি) ৩২ বিটের ripple-carry adder: প্রতিটি বিটে g = ab আর p = a ⊕ b, তারপর c_i+1 = g_i + p_ic_i (AND তারপর OR). প্রতিটি gate ১ একক delay, সব ইনপুট সময় ০-তে তৈরি। সবচেয়ে খারাপ ক্ষেত্রে c₃₂ কত একক পরে স্থির হয়?

৩২
৬৪
৬৫
১২

(সহজ) একটি 32:1 multiplexer-এ কয়টি select লাইন লাগে?

৩২টি
১৬টি
৬টি
৫টি

(মাঝারি) Decoder, encoder আর multiplexer নিয়ে কোন বক্তব্যটি মিথ্যা?

n টি input-এর একটি decoder-এ n²টি output থাকে
একটি decoder-এর output কয়েকটি OR gate-এ জুড়ে যেকোনো Boolean function বানানো যায়
Priority encoder একাধিক input চালু থাকলে সবচেয়ে উঁচু অগ্রাধিকারের input-এর কোড দেয়
2ⁿ:1 multiplexer-এ n টি select লাইন লাগে

(কঠিন) ৮ বিট ALU-তে 0x80 + 0x80 যোগ করা হলো। ফল আর flag কী হবে?

ফল 0x00; Z = 1, C = 1, V = 0
ফল 0x00; Z = 1, C = 1, V = 1
ফল 0x100; Z = 0, C = 0, V = 0
ফল 0x00; Z = 1, C = 0, V = 1

(মাঝারি) Verilog-এ always @(posedge clk) begin q1 <= d; q2 <= q1; end থেকে কী ধরনের hardware হয়?

একটি latch, কারণ always block
দুটি flip-flop, আর একই edge-এ q1 ও q2 দুটিই d পায়
দুই ধাপের shift register — প্রতি edge-এ q2 পায় q1-এর আগের মান
এটি synthesizable নয়

K-map বা Boolean সরলীকরণের কোনো অপশন নিয়ে সন্দেহ হলে সবচেয়ে নিশ্চিত প্রমাণ হলো truth table-এর প্রতিটি সারি মিলিয়ে দেখা। নিচের সহায়কটি ঠিক তা-ই করে:

// Prove (or disprove) a Boolean simplification by checking every row of the truth table.
function minterms(n, f) {                  // inputs in order A, B, C, ... (A = MSB)
  const m = [];
  for (let i = 0; i < 2 ** n; i++) {
    const v = Array.from({ length: n }, (_, k) => (i >> (n - 1 - k)) & 1);
    if (f(...v)) m.push(i);
  }
  return m;
}
const same = (n, f, g) => minterms(n, f).join() === minterms(n, g).join();
const not = x => 1 - x;
console.log("A + A'B  == A + B       :", same(2, (a, b) => a | (not(a) & b), (a, b) => a | b));
console.log("A + A'B  == A           :", same(2, (a, b) => a | (not(a) & b), (a) => a));
console.log("BD + B'D' covers m      :", minterms(4, (a, b, c, d) => (b & d) | (not(b) & not(d))).join(" "));
console.log("A'B + AC == A'B + AC + BC:", same(3, (a, b, c) => (not(a) & b) | (a & c),
                                            (a, b, c) => (not(a) & b) | (a & c) | (b & c)));
console.log("A'B + AC == A'B + AC + AB:", same(3, (a, b, c) => (not(a) & b) | (a & c),
                                            (a, b, c) => (not(a) & b) | (a & c) | (a & b)));
const nand = (x, y) => not(x & y);
const xor4 = (a, b) => { const n1 = nand(a, b); return nand(nand(a, n1), nand(b, n1)); };
console.log("4-NAND circuit == A xor B:", same(2, xor4, (a, b) => a ^ b));

আউটপুট (নির্ধারিত, প্রতিবার একই):

A + A'B  == A + B       : true
A + A'B  == A           : false
BD + B'D' covers m      : 0 2 5 7 8 10 13 15
A'B + AC == A'B + AC + BC: true
A'B + AC == A'B + AC + AB: false
4-NAND circuit == A xor B: true

প্রথম দুই লাইন দেখায় A + A′B সমান A + B, কিন্তু শুধু A নয় — absorption-এর ফাঁদ। তৃতীয় লাইনে BD + B′D′ ঠিক Σm(0, 2, 5, 7, 8, 10, 13, 15) ঢাকে। পরের দুই লাইন hazard-এর প্রশ্নের দুই অপশন যাচাই করে: consensus পদ BC যোগ করলে function অপরিবর্তিত (true), কিন্তু AB যোগ করলে বদলে যায় (false). শেষ লাইনে চারটি NAND-এর circuit আর XOR-এর truth table এক। নিজের প্রশ্নের দুটি রাশি same()-এ বসিয়ে একই পরীক্ষা চালাতে পারেন — চলক বেশি হলে n বাড়ান।

৪ · মডিউল ৩ — Sequential লজিক (১১টি প্রশ্ন)

Latch, flip-flop, counter, FSM আর timing — এখানে সংজ্ঞার একটি শব্দই উত্তর ঠিক করে: level-sensitive না edge-triggered, শুধু state না state আর input. Numerical-এ setup-এর হিসাবে clock-to-Q আর setup দুটিই যোগ করতে হয়, আর hold-এর হিসাবে clock period থাকেই না।

যা ঝালিয়ে নেবেন · পর্ব ১৫–১৯

পর্ব ১৫ · Latch আর flip-flop — SR, D, JK, T, characteristic আর excitation table, race-around
পর্ব ১৬ · Register আর counter — ring, Johnson, ripple counter-এর delay
পর্ব ১৭ · FSM — Moore, Mealy, state encoding
পর্ব ১৮ · Timing আর clock আর পর্ব ১৯ · প্রজেক্ট — setup-hold, f_max, synchronizer

(সহজ) Latch আর flip-flop-এর মূল পার্থক্য কোনটি?

Latch edge-triggered, flip-flop level-sensitive
Latch-এ clock বা enable লাগে না, flip-flop-এ লাগে
দুটি একই জিনিস, শুধু নাম আলাদা
Latch level-sensitive — enable সক্রিয় থাকার পুরো সময় input অনুসরণ করে; flip-flop edge-triggered — শুধু clock-এর ধারে মান নেয়

(সহজ) দুটি NOR gate দিয়ে বানানো SR latch-এ কোন input নিষিদ্ধ (forbidden) ধরা হয়?

S = 1, R = 1
S = 0, R = 0
S = 1, R = 0
S = 0, R = 1

(মাঝারি) পুরোনো level-triggered JK flip-flop-এ race-around condition কখন ঘটে?

J = K = 0, clock যত লম্বাই হোক
J = K = 1, আর clock pulse flip-flop-এর propagation delay-এর চেয়ে লম্বা
D flip-flop-এ D clock-এর ধারে বদলালে
SR latch-এ S = R = 0 দিলে

(মাঝারি) একটি D flip-flop দিয়ে T flip-flop বানাতে D ইনপুটে কী দিতে হবে?

D = T
D = T·Q
D = T ⊕ Q
D = T′

(সহজ) একটি decade (mod-10) binary counter বানাতে কমপক্ষে কয়টি flip-flop লাগে?

৩টি
১০টি
৫টি
৪টি

(মাঝারি) ৫টি flip-flop দিয়ে একটি ring counter আর একটি Johnson (twisted-ring) counter বানানো হলো। দুটির state-সংখ্যা যথাক্রমে কত?

ring ৫, Johnson ১০
ring ৫, Johnson ৩২
ring ১০, Johnson ৫
ring ৩২, Johnson ১০

(মাঝারি) একটি ৪ বিটের ripple (asynchronous) counter-এর প্রতিটি flip-flop-এর propagation delay 15 ns. Count নির্ভরযোগ্যভাবে পড়ার জন্য সর্বোচ্চ clock frequency প্রায় কত (decoder-এর delay বাদ)?

66.7 MHz
16.7 MHz
4.17 MHz
60 MHz

(সহজ) Mealy machine-এর output কীসের ওপর নির্ভর করে?

শুধু বর্তমান state
শুধু বর্তমান input
বর্তমান state আর বর্তমান input — দুটিই
শুধু আগের output

(মাঝারি) Moore আর Mealy machine নিয়ে কোন বক্তব্যটি মিথ্যা?

একই কাজে Mealy machine-এ সাধারণত সমান বা কম state লাগে
Mealy-র output-এ input-এর glitch সরাসরি পৌঁছাতে পারে
যেকোনো Mealy machine-কে সমতুল্য Moore machine-এ রূপান্তর করা যায়, তবে output এক clock দেরিতে আসে
Moore machine-এর output input বদলানোর সাথে সাথে, পরের clock-এর আগেই বদলায়

(মাঝারি) একটি flip-flop-এর clock-to-Q delay (t_pcq) 50 ps, setup time 100 ps; দুই register-এর মাঝের logic-এর critical path 350 ps, clock skew শূন্য। সর্বোচ্চ clock frequency কত?

2 GHz
2.5 GHz
2.86 GHz
2.22 GHz

(কঠিন) একটি পথে t_ccq (contamination clock-to-Q) = 30 ps, logic-এর সবচেয়ে ছোট delay t_cd = 20 ps, আর capture flip-flop-এর hold time 60 ps (skew শূন্য)। কোনটি সঠিক?

Hold violation হচ্ছে; clock frequency কমালেই ঠিক হবে
Hold violation হচ্ছে (30 + 20 = 50 < 60); ছোট পথে delay যোগ করতে হবে
কোনো সমস্যা নেই, কারণ মোট delay ধনাত্মক
Setup violation হচ্ছে

৫ · মডিউল ৪ — কম্পিউটারের গাণিতিক কাজ (১২টি প্রশ্ন)

Overflow ধরা, Booth-এর algorithm, restoring আর non-restoring ভাগ, আর IEEE 754. IEEE-র প্রশ্নে তিনটি ধাপ খাতায় লিখুন — চিহ্ন, biased exponent, fraction — আর hidden 1 ভুলবেন না। Rounding-এর প্রশ্নে মনে রাখুন ডিফল্ট নিয়ম ties to even, স্কুলের “অর্ধেক হলে ওপরে” নয়।

যা ঝালিয়ে নেবেন · পর্ব ২০–২৪

পর্ব ২০ · Integer যোগ-বিয়োগ — adder-subtractor, V = c_n ⊕ c_n−1, flag
পর্ব ২১ · গুণ আর পর্ব ২২ · ভাগ — Booth-এর নিয়ম, restoring বনাম non-restoring
পর্ব ২৩ · Floating point আর পর্ব ২৪ · Floating point-এর হিসাব — encode-decode, বিশেষ মান, rounding, associativity

(মাঝারি) Two's complement যোগে signed overflow ধরার প্রচলিত hardware নিয়ম কোনটি (c_n = MSB থেকে বেরোনো carry, c_n−1 = MSB-তে ঢোকা carry)?

c_n = 1 হলেই overflow
ফলের MSB = 1 হলেই overflow
V = c_n ⊕ c_n−1
দুটি operand-এর চিহ্ন আলাদা হলে overflow

(মাঝারি) ৪ বিট two's complement-এ 0110 + 0011 = 1001. ফলটির signed অর্থ আর V flag কী?

ফল 9, V = 0
ফল −7, V = 0
ফল −1, V = 1
ফল −7 পড়া যায়, V = 1 — আসল উত্তর 9, যা সীমার (+7) বাইরে

(মাঝারি) Booth-এর algorithm-এ বর্তমান বিট-জোড়া (Q₀, Q₋₁) = (0, 1) হলে কী করা হয়?

A = A + M, তারপর arithmetic right shift
A = A − M, তারপর arithmetic right shift
শুধু arithmetic right shift
A = A + 2M, তারপর shift

(কঠিন) ৮ বিটের multiplier 0011 1100. Radix-2 Booth-এর algorithm কয়টি যোগ বা বিয়োগ করবে, আর সাধারণ shift-add পদ্ধতি কয়টি যোগ করবে?

Booth ৪টি, shift-add ৪টি
Booth ২টি, shift-add ৪টি
Booth ২টি, shift-add ২টি
Booth ৬টি, shift-add ৪টি

(মাঝারি) Restoring division-এর একটি ধাপে partial remainder থেকে divisor বিয়োগ করার পর ফল ঋণাত্মক হলো। এরপর কী করা হয়?

Quotient বিট 1 বসে, পরের ধাপে যোগ
ভাগ থেমে যায় আর divide error ঘটে
Divisor আবার যোগ করে আগের মান ফেরানো হয় (restore), আর quotient বিট 0
Divisor দ্বিগুণ করে আবার বিয়োগ

(মাঝারি) n বিটের unsigned ভাগে সবচেয়ে খারাপ ক্ষেত্রে মোট কয়টি যোগ-বিয়োগ লাগে — restoring আর non-restoring পদ্ধতিতে?

দুটিতেই n
Restoring n, non-restoring 2n
দুটিতেই 2n
Restoring 2n, non-restoring n + 1

(সহজ) IEEE 754 single precision (৩২ বিট)-এর বিন্যাস কোনটি?

১ sign, ৮ exponent, ২৩ fraction; bias ১২৭
১ sign, ১১ exponent, ৫২ fraction; bias ১০২৩
১ sign, ৮ exponent, ২৩ fraction; bias ১২৮
১ sign, ৭ exponent, ২৪ fraction; bias ৬৩

(মাঝারি) −6.25-কে IEEE 754 single precision-এ hex-এ লিখলে কোনটি?

0x40C80000
0xC0C80000
0xC1480000
0xC0480000

(মাঝারি) ৩২ বিটের pattern 0x3F400000-কে IEEE 754 single precision হিসেবে পড়লে মান কত?

1.5
0.25
0.75
−0.75

(সহজ) IEEE 754-এ exponent field-এর সব বিট 1 আর fraction শূন্য হলে মানটি কী?

NaN
±0
Subnormal সংখ্যা
±∞ (sign বিট অনুযায়ী)

(মাঝারি) IEEE 754 floating point নিয়ে কোন বক্তব্যটি মিথ্যা?

Floating-point যোগ associative: (a + b) + c সবসময় a + (b + c)-এর সমান
double-এ 0.1 + 0.2 == 0.3 তুলনা মিথ্যা হয়
NaN নিজের সমানও নয়, তাই x != x সত্য হলে x একটি NaN
+0 আর −0 তুলনায় সমান, যদিও তাদের বিট-প্যাটার্ন আলাদা

(মাঝারি) IEEE 754-এর ডিফল্ট rounding mode (round to nearest, ties to even)-এ 0.5, 1.5 আর 2.5-কে পূর্ণসংখ্যায় round করলে কী পাওয়া যায়?

1, 2, 3
0, 2, 2
0, 1, 2
1, 1, 3

৬ · মডিউল ৫ — Instruction set আর্কিটেকচার (১২টি প্রশ্ন)

RISC বনাম CISC, RISC-V-এর register, format আর encoding, addressing mode, branch আর function call. সবচেয়ে বড় ফাঁদ হলো বইভেদে রীতির পার্থক্য: পুরোনো MIPS-এর PC + 4 + offset আর delay slot, বনাম RISC-V-এর branch-এর নিজের ঠিকানা + offset. আর lui + addi-তে নিচের ১২ বিটের sign বিট 1 হলে ওপরের অংশে ১ বাড়াতে হয়।

যা ঝালিয়ে নেবেন · পর্ব ২৫–৩১

পর্ব ২৫ · ISA কী, RISC বনাম CISC — 0- থেকে 3-address, load–store
পর্ব ২৬ · RISC-V-এর instruction আর পর্ব ২৭ · Instruction format আর encoding — R, I, S, B, U, J
পর্ব ২৮ · Addressing mode আর পর্ব ২৯ · শাখা আর লুপ
পর্ব ৩০ · Function call আর stack আর পর্ব ৩১ · C থেকে assembly — calling convention, x86-64 আর ARM-এর তুলনা

(সহজ) নিচের কোন বৈশিষ্ট্যটি RISC দর্শনের?

পরিবর্তনশীল দৈর্ঘ্যের instruction আর প্রায় সব instruction-এ memory operand
কম register, আর অনেক জটিল addressing mode
নির্দিষ্ট দৈর্ঘ্যের instruction, আর শুধু load ও store মেমরি ছোঁয় (load–store architecture)
একটি instruction-এ পুরো string কপির মতো বড় কাজ

(মাঝারি) Instruction-এর দৈর্ঘ্য নিয়ে কোন বক্তব্যটি মিথ্যা?

ARM64 (AArch64)-এর প্রতিটি instruction ৪ byte
RISC-V-এ C extension থাকলে অনেক প্রচলিত instruction ২ byte-এ লেখা যায়
আধুনিক উচ্চগতির x86 core instruction-কে micro-op-এ ভেঙে চালায়
x86-64-এর প্রতিটি instruction ৪ byte লম্বা

(সহজ) RISC-V RV32I-এ সাধারণ (integer) register কয়টি, আর x0-এর বিশেষত্ব কী?

৩২টি; x0 সবসময় 0 — লিখলেও বদলায় না
১৬টি; x0 সাধারণ register
৩২টি; x31 সবসময় 0
৮টি; x0 হলো PC

(মাঝারি) RV32I-এর addi instruction-এর immediate কোন সীমার মধ্যে হতে পারে?

0 থেকে 4095
−2048 থেকে 2047
−4096 থেকে 4095
−32768 থেকে 32767

(মাঝারি) RISC-V-এর instruction আর format-এর কোন জোড়াগুলো সঠিক?

lw → S, sw → I, jal → J
addi → R, add → I
sw → S, beq → B, lui → U
beq → J, jal → B

(মাঝারি) RISC-V-এর lw x5, 12(x6) কোন addressing mode ব্যবহার করে?

Immediate — 12 নিজেই operand
PC-relative
Direct (absolute) — instruction-এ পুরো ঠিকানা
Base + displacement — ঠিকানা = x6 + 12

(মাঝারি) Instruction fetch হয়ে যাওয়ার পরে operand আনতে মেমরিতে কতবার যেতে হয় — immediate, direct আর memory indirect addressing-এ যথাক্রমে?

০, ১, ২
১, ১, ২
০, ১, ১
০, ২, ৩

(মাঝারি) RV32I-এ ঠিকানা 0x2000-এ beq x5, x6, L, আর L-এর offset +12 byte. x5 = x6 হলে পরের PC কত?

0x2004
0x200C
0x2010
0x2018

(মাঝারি) RISC-V-তে ঠিকানা 0x00400200-এ jal ra, func চলার পরে ra-তে কী থাকবে?

0x00400200
func-এর ঠিকানা
0x00400204
0x00400208

(মাঝারি) RISC-V-এর calling convention (psABI) নিয়ে কোন বক্তব্যটি মিথ্যা?

প্রথম আটটি integer argument a0–a7-এ যায়
Return value a0-তে (দরকারে a1-সহ) ফেরে
s0–s11 আর sp ফেরার আগে আগের মানে ফিরিয়ে দিতে হয় (callee-saved)
t0–t6 callee-saved, তাই call-এর পরে caller নিশ্চিত থাকতে পারেন এগুলো বদলায়নি

(মাঝারি) 0-address (stack) machine-এ, যেখানে শুধু push আর pop মেমরি ছোঁয়, X = (A + B) × (C − D) লিখতে কয়টি instruction লাগে?

৮টি
৭টি
৩টি
৬টি

(কঠিন) RV32I-এ ধ্রুবক 0xABCDE800 একটি register-এ রাখতে lui আর addi-র সঠিক জোড়া কোনটি?

lui 0xABCDE, তারপর addi 0x800
lui 0xABCDE, তারপর addi −2048
lui 0xABCDF, তারপর addi 2048
lui 0xABCDF, তারপর addi −2048

৭ · মডিউল ৬ — প্রসেসর নকশা (১৩টি প্রশ্ন)

Single-cycle আর multi-cycle datapath, control signal-এর টেবিল, pipelining, hazard, forwarding, branch prediction আর exception. Control টেবিলের প্রশ্নে সংকেতের ক্রম সবসময় প্রশ্নেই দেওয়া থাকবে — সেটি ধরে প্রতিটি বিটের অর্থ মিলিয়ে নিন। CPI-এর প্রশ্নে প্রতিটি stall-পদে তিনটি গুণক খুঁজুন: কত ভাগ instruction, তাদের কত ভাগে ঘটে, আর প্রতিবার কত cycle.

যা ঝালিয়ে নেবেন · পর্ব ৩২–৩৮

পর্ব ৩২ · Single-cycle datapath আর পর্ব ৩৩ · Control unit — ALUSrc, MemtoReg, RegWrite, MemRead, MemWrite, Branch, ALUOp
পর্ব ৩৪ · Multi-cycle আর microprogrammed control
পর্ব ৩৫ · Pipelining আর পর্ব ৩৬ · Pipeline hazard — k + n − 1, load-use stall
পর্ব ৩৭ · Branch prediction আর পর্ব ৩৮ · Exception আর interrupt — ২-বিট counter, precise exception

(সহজ) Single-cycle datapath-এ প্রতিটি instruction এক cycle নেয়। তাহলে clock period কী ঠিক করে?

সবচেয়ে দ্রুত instruction
সবচেয়ে ধীর instruction-এর পথ — সাধারণত lw (instruction memory → register → ALU → data memory → register)
সব instruction-এর গড় delay
Register file-এর delay একাই

(মাঝারি) Patterson–Hennessy ধাঁচের single-cycle RISC-V control টেবিলে সংকেতের ক্রম ALUSrc, MemtoReg, RegWrite, MemRead, MemWrite, Branch, ALUOp1, ALUOp0. lw-এর সারি কোনটি (X = don't care)?

0 0 1 0 0 0 1 0
1 X 0 0 1 0 0 0
1 1 1 1 0 0 0 0
0 X 0 0 0 1 0 1

(সহজ) Hardwired আর microprogrammed control unit-এর তুলনায় কোনটি সঠিক?

Microprogrammed দ্রুত, hardwired বদলানো সহজ
দুটির গতি আর নমনীয়তা সবসময় সমান
Hardwired control শুধু CISC-এ ব্যবহার হয়
Hardwired সাধারণত দ্রুত, কিন্তু বদলাতে নতুন circuit লাগে; microprogrammed নমনীয় — control store-এর microcode বদলেই আচরণ বদলায়

(মাঝারি) একটি multi-cycle প্রসেসরে lw ৫, sw ৪, R-type ৪ আর beq ৩ cycle নেয়। প্রোগ্রামে ২৫% lw, ১০% sw, ৪৫% R-type, ২০% beq. গড় CPI কত?

4.05
4.00
5.00
1.00

(মাঝারি) পাঁচ ধাপের একটি pipeline-এ ১০০টি পরস্পর-স্বাধীন instruction (কোনো stall নেই) চালাতে মোট কত cycle লাগে?

৫০০
১০০
১০৫
১০৪

(কঠিন) একটি পাঁচ ধাপের pipeline-এ ধাপের delay 200, 150, 250, 300 আর 200 ps; প্রতিটি pipeline register-এর overhead 20 ps. একই ধাপগুলোর single-cycle নকশার (cycle = সব ধাপের যোগফল) তুলনায় দীর্ঘ প্রোগ্রামে throughput-এর speedup প্রায় কত (কোনো hazard নেই)?

5
3.67
3.44
4.81

(মাঝারি) Forwarding আছে এমন ক্লাসিক পাঁচ ধাপের RISC-V pipeline-এ lw x5, 0(x6)-এর ঠিক পরে add x7, x5, x8. কয়টি stall লাগবে?

০টি — forwarding সব সমস্যা মেটায়
১টি — তারপর MEM/WB থেকে EX-এ forwarding
২টি
৩টি

(মাঝারি) Forwarding-সহ একটি pipeline-এ ২৫% instruction load, আর তাদের ৪০%-এর ঠিক পরের instruction ফলটি ব্যবহার করে (প্রতিটিতে ১ cycle stall). আদর্শ CPI ১ আর অন্য কোনো stall নেই। কার্যকর CPI কত?

1.10
1.25
1.40
1.20

(মাঝারি) একটি pipeline-এ ১৫% instruction branch, ভুল অনুমানের হার ৮%, আর প্রতিটি ভুলে ৪ cycle penalty. আদর্শ CPI ১ আর অন্য stall নেই। CPI কত?

1.60
1.32
1.012
1.048

(মাঝারি) ২-বিট saturating counter predictor-এ 00 = strongly not taken, 01 = weakly not taken, 10 = weakly taken, 11 = strongly taken; taken হলে counter এক বাড়ে, not taken হলে এক কমে। Counter এখন 01, আর branch-টি taken হলো। নতুন state আর পরের অনুমান কী?

11, অনুমান taken
00, অনুমান not taken
10, অনুমান taken
01-ই থাকে, অনুমান not taken

(কঠিন) একটি লুপ ১০ বার ঘোরে: নিচের branch ৯ বার taken, তারপর একবার not taken; লুপটি বহুবার চলে। Steady state-এ প্রতিবার লুপে প্রবেশে ২-বিট predictor (শুরু strongly taken) আর ১-বিট predictor কতবার ভুল অনুমান করে?

২-বিট ১টি, ১-বিট ২টি
দুটিতেই ১টি
দুটিতেই ২টি
২-বিট ২টি, ১-বিট ১টি

(মাঝারি) Pipeline-এ “precise exception” বলতে কী বোঝায়?

Exception সবসময় এক cycle-এর মধ্যে সামলানো হয়
শুধু hardware-এর ভুলে exception হয়, software-এর ভুলে নয়
Exception হলে pipeline-এর সব instruction-ই শেষ করা হয়
আগের সব instruction শেষ, আর দোষী ও পরের কোনো instruction-এর কোনো ছাপ নেই — যেন প্রোগ্রাম ঠিক সেখানে থেমেছে

(মাঝারি) Exception আর interrupt নিয়ে কোন বক্তব্যটি মিথ্যা?

Timer-এর সময় পূর্ণ হয়ে আসা interrupt asynchronous
Page fault একটি asynchronous interrupt, কারণ এর সমাধানে disk লাগে
Illegal instruction একটি synchronous exception
x86-এ NMI (non-maskable interrupt) সাধারণ maskable interrupt-এর মতো interrupt-নিষেধের flag দিয়ে বন্ধ হয় না

৮ · মডিউল ৭ — উন্নত প্রসেসর (১০টি প্রশ্ন)

Superscalar, VLIW, register renaming, reorder buffer, speculation-এর নিরাপত্তা, SIMD আর hardware multithreading. এখানে প্রশ্ন প্রায়ই “কে সিদ্ধান্ত নেয়” (hardware না compiler) আর “কোন dependence কোন কৌশলে দূর হয়” নিয়ে। নিরাপত্তার প্রশ্নগুলো শুধু ধারণা আর প্রতিরক্ষা নিয়ে।

যা ঝালিয়ে নেবেন · পর্ব ৩৯–৪৩

পর্ব ৩৯ · ILP — superscalar আর VLIW আর পর্ব ৪০ · Out-of-order execution — RAW-WAR-WAW, Tomasulo, ROB
পর্ব ৪১ · Speculative execution আর নিরাপত্তা — Spectre, Meltdown, KPTI, retpoline
পর্ব ৪২ · SIMD আর vector আর পর্ব ৪৩ · Hardware multithreading — lane, SMT, Flynn-এর শ্রেণি

(সহজ) Superscalar আর VLIW প্রসেসরের মূল পার্থক্য কোনটি?

Superscalar-এ hardware চলার সময় ঠিক করে কোন instruction একসাথে চলবে; VLIW-এ compiler আগেই একটি চওড়া bundle-এ সাজিয়ে দেয়
Superscalar প্রতি cycle-এ একটির বেশি instruction চালাতে পারে না
VLIW-এ out-of-order hardware বাধ্যতামূলক
দুটি একই, শুধু নাম আলাদা

(মাঝারি) একটি প্রসেসর প্রতি cycle-এ সর্বোচ্চ ৩টি instruction issue করতে পারে। তার আদর্শ সর্বনিম্ন CPI কত?

3
প্রায় 0.33
1
0.25

(মাঝারি) I1: add x1, x2, x3, তারপর I2: sub x2, x4, x5. দুটির মধ্যে কোন dependence?

RAW (true dependence) — I2, I1-এর ফল পড়ে
WAW — দুটি একই register লেখে
WAR (anti-dependence) — I2 লেখে x2, যা I1 আগে পড়ে
কোনো dependence নেই

(মাঝারি) Register renaming কোন dependence দূর করতে পারে না?

WAR (anti-dependence)
WAW (output dependence)
নামের সংঘাত (name dependence)
RAW (true data dependence)

(মাঝারি) Out-of-order প্রসেসরে reorder buffer (ROB)-এর প্রধান কাজ কী?

Instruction-গুলো program-এর ক্রমে commit (retire) করানো, যাতে exception precise থাকে আর ভুল অনুমানের পথ বাতিল করা যায়
Instruction-গুলোকে program-এর ক্রমেই execute করানো
Cache miss কমানো
Branch-এর লক্ষ্য ঠিকানা অনুমান করা

(মাঝারি) নিচের কোন প্রতিরক্ষা-জোড়াটি সঠিক?

KPTI → Spectre v2, retpoline → Meltdown
KPTI → Rowhammer, retpoline → buffer overflow
KPTI → Meltdown, retpoline → Spectre v2 (branch target injection)
দুটিই শুধু Spectre v1-এর প্রতিরক্ষা

(মাঝারি) Speculative execution নিয়ে কোন বক্তব্যটি মিথ্যা?

ভুল অনুমানের পথ flush করলে architectural register আর মেমরির অবস্থা আগের মতো থাকে
Flush করলে cache-এর অবস্থাসহ সব microarchitectural প্রভাবও মুছে যায়
Spectre v1 একটি bounds check-কে অনুমানে পেরিয়ে যাওয়ার (bounds check bypass) সমস্যা
Constant-time code গোপন ডেটার ওপর নির্ভর করে branch বা মেমরি-ঠিকানা বদলায় না

(সহজ) ৫১২ বিটের একটি SIMD register-এ ৩২ বিটের float রাখলে কয়টি lane পাওয়া যায়?

৮টি
৩২টি
৬৪টি
১৬টি

(মাঝারি) কোন hardware multithreading কৌশল একই cycle-এ একাধিক thread থেকে instruction issue করে, ফলে এক cycle-এর ভেতরের খালি slot (horizontal waste) কমায়?

Coarse-grained multithreading
Fine-grained multithreading
Simultaneous multithreading (SMT)
Single-threaded superscalar

(মাঝারি) Flynn-এর শ্রেণিবিভাগ নিয়ে কোন বক্তব্যটি মিথ্যা?

SSE-AVX বা NEON-এর মতো একটি instruction-এ অনেক ডেটা — SIMD
আলাদা আলাদা প্রোগ্রাম চালানো একটি multicore CPU — MIMD
একটি সরল single-cycle প্রসেসর — SISD
MISD আজকের কম্পিউটারের সবচেয়ে প্রচলিত শ্রেণি

৯ · মডিউল ৮ — মেমরি হায়ারার্কি (১৫টি প্রশ্ন)

পরীক্ষায় numerical-এর সবচেয়ে বড় ভাণ্ডার এই মডিউল: locality, direct-mapped আর set-associative cache-এর ঠিকানা-ভাগ, মোট বিট, hit-miss trace, AMAT, write-back বনাম write-through, DRAM, page table আর TLB. প্রতিটি cache-প্রশ্নে অংশ ১-এর চার ধাপ চালান; trace-এর প্রশ্নে ছোট টেবিল আঁকুন — set, ভেতরে কী আছে, hit না miss.

যা ঝালিয়ে নেবেন · পর্ব ৪৪–৫০

পর্ব ৪৪ · মেমরি হায়ারার্কি আর locality আর পর্ব ৪৫ · Cache-এর মৌলিক কথা — ঠিকানা-ভাগ, মোট বিট, 3C
পর্ব ৪৬ · Set-associative আর fully associative আর পর্ব ৪৭ · Cache-এর পারফরম্যান্স — LRU, AMAT, global miss rate, write policy
পর্ব ৪৮ · Cache-বান্ধব প্রোগ্রাম আর পর্ব ৪৯ · Main memory — loop-এর ক্রম, SRAM-DRAM, DDR-এর হিসাব
পর্ব ৫০ · Virtual memory-র hardware — page table-এর আকার, Sv32/Sv39, TLB-এর EAT

(সহজ) একটি লুপে counter চলক i প্রতিবার পড়া আর লেখা হয়। Cache এখানে মূলত কোন locality-র সুবিধা পায়?

Temporal locality — একই ঠিকানা অল্প সময়ের মধ্যে আবার ব্যবহার
Spatial locality
কোনো locality নেই
Sequential locality ছাড়া অন্য কিছু নয়

(মাঝারি) ৩২ বিট byte address, ৩২ KiB data-র একটি direct-mapped cache, block ৬৪ byte. Tag, index আর offset যথাক্রমে কত বিট?

১৭ | ৬ | ৯
১৭ | ৯ | ৬
১৬ | ১০ | ৬
২০ | ৬ | ৬

(মাঝারি) ৩২ বিট address, ৬৪ KiB data-র একটি 4-way set-associative cache, block ৩২ byte. Tag, index আর offset কত বিট?

১৬ | ১১ | ৫
২০ | ৭ | ৫
১৮ | ৯ | ৫
১৯ | ৯ | ৫

(কঠিন) ৩২ বিট address, ৮ KiB data-র একটি direct-mapped cache, block ৩২ byte; প্রতিটি line-এ একটি valid আর একটি dirty বিট। Cache বানাতে মোট কত বিট লাগবে?

65,536 বিট
70,656 বিট
71,168 বিট
70,912 বিট

(মাঝারি) ৪টি block ধরে এমন একটি cache, শুরুতে খালি। Block address-এর ক্রম 1, 5, 1, 9, 5. Direct-mapped, 2-way set-associative (LRU) আর fully associative (LRU) — তিনটিতে যথাক্রমে কয়টি hit?

০, ১, ২
০, ০, ২
১, ১, ২
০, ২, ২

(মাঝারি) AMAT = hit time + miss rate × miss penalty রীতিতে, hit time 1 cycle, miss rate 4%, miss penalty 80 cycle. AMAT কত?

3.2 cycle
4.2 cycle
81 cycle
4.16 cycle

(কঠিন) L1: hit time 1 cycle, miss rate 5%. L2: hit time 12 cycle, local miss rate 40%. Main memory 150 cycle. AMAT আর L2-এর global miss rate কত?

AMAT 4.6 cycle, global miss rate 40%
AMAT 61.6 cycle, global miss rate 2%
AMAT 8.5 cycle, global miss rate 2%
AMAT 4.6 cycle, global miss rate 2%

(মাঝারি) Cache-এর write policy নিয়ে কোন বক্তব্যটি মিথ্যা?

Write-through cache-এর প্রতিটি line-এ dirty বিট লাগে
Write-back cache-এ dirty line সরানোর সময় block নিচের স্তরে লেখা হয়
Write buffer থাকলে write-through cache-এ CPU সাধারণত প্রতিটি store-এ মেমরির জন্য থামে না
প্রচলিত জুটি: write-back + write-allocate, আর write-through + no-write-allocate

(মাঝারি) একটি প্রসেসরের CPI_base 1.2; ৩৫% instruction load/store; I-cache miss rate 2%, D-cache miss rate 6%; miss penalty 60 cycle. Stall-সহ CPI কত?

2.46
6.00
3.66
2.40

(সহজ) SRAM আর DRAM-এর তুলনায় কোনটি সঠিক?

DRAM দ্রুত আর refresh লাগে না, তাই cache-এ DRAM
দুটিই non-volatile
SRAM-এ প্রতি বিটে একটি transistor আর একটি capacitor
SRAM-এর এক বিটে সাধারণত ৬টি transistor, refresh লাগে না — cache-এ; DRAM-এ 1T1C, ঘন কিন্তু নিয়মিত refresh লাগে — main memory-তে

(মাঝারি) DDR4-3200 মেমরির একটি ৬৪ বিট channel-এর সর্বোচ্চ (peak) bandwidth কত?

25.6 GB/s
3.2 GB/s
51.2 GB/s
12.8 GB/s

(মাঝারি) ৩২ বিট virtual address, ৮ KiB page আর ৪ byte page table entry. এক স্তরের page table-এর আকার প্রতি process-এ কত?

4 MiB
2 MiB
512 KiB
8 KiB

(সহজ) TLB (translation lookaside buffer) আসলে কী?

Disk-এর একটি অংশ, যেখানে বাদ পড়া page রাখা হয়
L1 data cache-এর আরেক নাম
সাম্প্রতিক virtual → physical অনুবাদের (page table entry) একটি ছোট দ্রুত cache
Branch-এর লক্ষ্য ঠিকানার buffer

(কঠিন) TLB hit rate 95%, TLB lookup 1 cycle; TLB miss হলে দুই স্তরের page walk (প্রতি স্তরে একটি PTE পড়া, প্রতিটি 100 cycle); তারপর ডেটা-প্রবেশ 100 cycle. Page walk-এর কোনো cache নেই। Effective access time কত?

101 cycle
106 cycle
116 cycle
111 cycle

(মাঝারি) Virtual memory নিয়ে কোন বক্তব্যটি মিথ্যা?

TLB miss মানেই page fault নয় — page table-এ বৈধ entry থাকলে walk শেষে অনুবাদ পাওয়া যায়
Page fault একটি synchronous exception; OS-এর handler page আনে, তারপর instruction আবার চলে
Page fault হলে hardware নিজেই disk থেকে page এনে দেয়, OS কিছুই জানে না
৪ KiB page-এ ঠিকানার নিচের ১২ বিট (page offset) অনুবাদে বদলায় না

Cache-এর trace-এর প্রশ্নে একটি ভুল ঘর পুরো উত্তর বদলে দেয়। নিচের সহায়কটি একই ক্রম তিন রকম cache-এ চালায়, আর শেষে দুই স্তরের AMAT আবার মেলায়:

// Hit/miss trace for block addresses on a 4-block cache: direct-mapped, 2-way LRU, fully associative LRU.
function run(trace, sets, ways) {
  const cache = Array.from({ length: sets }, () => []);   // each set: oldest first
  let hits = 0;
  const log = trace.map(b => {
    const set = cache[b % sets], i = set.indexOf(b);
    if (i >= 0) { hits++; set.splice(i, 1); set.push(b); return b + ":H"; }
    if (set.length === ways) set.shift();                  // evict least recently used
    set.push(b);
    return b + ":M";
  });
  return log.join(" ") + "  -> hits " + hits;
}
const t = [1, 5, 1, 9, 5];
console.log("direct-mapped  (4 sets x 1):", run(t, 4, 1));
console.log("2-way LRU      (2 sets x 2):", run(t, 2, 2));
console.log("fully assoc LRU (1 set x 4):", run(t, 1, 4));
// Two-level AMAT: L2's local miss rate applies only to L1 misses
const l1mr = 0.05, l2local = 0.40;
console.log("L2 global miss rate =", (l1mr * l2local * 100).toFixed(0) + "%",
            "| AMAT =", (1 + l1mr * (12 + l2local * 150)).toFixed(1), "cycles");

আউটপুট (নির্ধারিত, প্রতিবার একই):

direct-mapped  (4 sets x 1): 1:M 5:M 1:M 9:M 5:M  -> hits 0
2-way LRU      (2 sets x 2): 1:M 5:M 1:H 9:M 5:M  -> hits 1
fully assoc LRU (1 set x 4): 1:M 5:M 1:H 9:M 5:H  -> hits 2
L2 global miss rate = 2% | AMAT = 4.6 cycles

Direct-mapped cache-এ 1, 5 আর 9 তিনটিই set ১-এ পড়ে (mod ৪), তাই একে অপরকে সরিয়ে সব miss — খাঁটি conflict miss. 2-way-এ দুটি ঘর থাকায় তৃতীয় access (1) hit, কিন্তু 9 এসে LRU নিয়মে 5-কে সরায়, তাই শেষ 5 miss. Fully associative-এ চারটি ঘরে সবাই আঁটে — ২টি hit. প্রশ্নের উত্তর তাই ০, ১, ২. শেষ লাইন মনে করিয়ে দেয়: L2-এর ৪০% local miss rate সব access-এর মাত্র ২% (global), আর AMAT ৪.৬ cycle.

১০ · মডিউল ৯ — I/O, সমান্তরালতা আর আধুনিক সিস্টেম (১৪টি প্রশ্ন)

Memory-mapped বনাম port-mapped I/O, polling-এর খরচ, DMA, vectored interrupt, MESI, false sharing, Amdahl আর Gustafson, interconnect, GPU আর power. শতাংশের প্রশ্নে দশমিকের ঘরই প্রধান ফাঁদ — cycle/s-কে clock rate দিয়ে ভাগ করে তারপর ১০০ দিয়ে গুণ, প্রতিটি ধাপ খাতায়।

যা ঝালিয়ে নেবেন · পর্ব ৫১–৫৭

পর্ব ৫১ · I/O আর bus আর পর্ব ৫২ · Interrupt আর DMA — polling আর PIO-DMA-র CPU ভাগ, descriptor
পর্ব ৫৩ · Multicore আর cache coherence — MSI-MESI-র transition, false sharing
পর্ব ৫৪ · সমান্তরাল আর্কিটেকচার আর পর্ব ৫৫ · GPU আর AI accelerator — Amdahl-Gustafson, hypercube, warp, coalescing
পর্ব ৫৬ · Power আর embedded আর পর্ব ৫৭ · ক্যাপস্টোন — P = αCV²f, RISC-V simulator

(সহজ) Port-mapped আর memory-mapped I/O নিয়ে কোনটি সঠিক?

RISC-V-এ device register পড়তে বিশেষ in/out instruction লাগে
x86-এ আলাদা I/O ঠিকানা-জগতের জন্য in/out instruction আছে, আর RISC-V-এ device register সাধারণ মেমরি-ঠিকানায় বসে load/store দিয়ে পড়া-লেখা হয়
Memory-mapped I/O-তে device register cache করা নিরাপদ
Port-mapped I/O-তে device মেমরির কিছু ঠিকানা দখল করে

(মাঝারি) একটি 500 MHz CPU একটি যন্ত্রকে সেকেন্ডে ১০০০ বার poll করে, প্রতিটি poll-এ ৪০০ cycle. CPU-র কত শতাংশ সময় polling-এ যায়?

0.8%
8%
0.008%
0.08%

(কঠিন) একটি 1 GHz CPU-তে একটি যন্ত্র 100 MB/s (10⁸ byte/s) ডেটা দেয়। Programmed I/O-তে CPU প্রতি ৪ byte-এর word-এ 20 cycle খরচ করে। DMA-তে 4 KiB (4096 byte)-এর প্রতিটি block-এ setup আর completion interrupt মিলিয়ে 1500 cycle. দুই পদ্ধতিতে CPU-র কত শতাংশ খরচ হয়?

PIO 50%, DMA 0% — DMA-তে CPU-র কোনো খরচ নেই
PIO 50%, DMA প্রায় 3.7%
PIO 5%, DMA প্রায় 0.37%
দুটিতেই 50% — ডেটা একই

(মাঝারি) DMA নিয়ে কোন বক্তব্যটি মিথ্যা?

CPU ঠিকানা, দৈর্ঘ্য আর দিক (descriptor) লিখে দেয়, তারপর যন্ত্র নিজে মেমরিতে পড়ে-লেখে
কাজ শেষে যন্ত্র সাধারণত interrupt দিয়ে জানায়
DMA-তে CPU প্রতিটি word নিজে কপি করে, শুধু interrupt-এর সংখ্যা কমে
Cache-coherent নয় এমন প্ল্যাটফর্মে DMA-র receive buffer পড়ার আগে তার cache line invalidate করতে হয়

(মাঝারি) Vectored interrupt বলতে কী বোঝায়?

Interrupt-এর কারণ বা উৎস অনুযায়ী CPU সরাসরি সংশ্লিষ্ট handler-এর ঠিকানায় যায় (vector table বা base + ৪ × cause)
একটিই handler, যে সব যন্ত্রকে একে একে জিজ্ঞেস করে
SIMD vector instruction-এর ভেতরে ঘটা exception
যে interrupt কখনো mask করা যায় না

(মাঝারি) MESI protocol-এ P1-এর cache-এ একটি line Modified (M) অবস্থায়। এখন P2 সেই line পড়ে। এরপর দুজনের অবস্থা কী?

P1 M, P2 I — P2 পুরোনো মান মেমরি থেকে পায়
P1 I, P2 M
P1 E, P2 E
P1 S, P2 S — P1 হালনাগাদ ডেটা bus-এ দেয় (flush) আর মেমরিও হালনাগাদ হয়

(মাঝারি) দুটি thread আলাদা core-এ চলে; একটি শুধু c[0]++, অন্যটি শুধু c[1]++ করে কোটিবার, যেখানে long c[2] একই cache line-এ। কোনটি সঠিক?

ফল ভুল হবে, কারণ দুজন একই চলক লেখে
কোনো প্রভাব নেই, কারণ চলক আলাদা
ফল সঠিক, কিন্তু false sharing-এ ধীর — line দুই core-এর মধ্যে বারবার invalidate হয়ে ছোটাছুটি করে; আলাদা line-এ রাখলে (যেমন alignas(64)) দ্রুত হয়
Cache বন্ধ করলেই একমাত্র সমাধান

(মাঝারি) একটি প্রোগ্রামের ২০% serial, বাকিটা পুরোপুরি সমান্তরাল। কাজের আকার স্থির রেখে ৮টি core-এ চালালে Amdahl-এর সূত্রে speedup কত, আর অসীম core-এ সর্বোচ্চ সীমা কত?

৮ আর অসীম
প্রায় 3.33 আর 5
6.4 আর 8
প্রায় 3.33 আর 8

(মাঝারি) কাজের আকার core-এর সাথে বাড়ানো হয়; ৩২-core run-এ মাপা serial ভগ্নাংশ 10%. Gustafson-এর সূত্রে scaled speedup কত?

28.9
32
3.2
প্রায় 7.8

(মাঝারি) ১২৮টি node-এর একটি hypercube interconnect-এর diameter আর bisection bandwidth (link-সংখ্যায়) কত?

Diameter 7, bisection 64
Diameter 64, bisection 2
Diameter 7, bisection 7
Diameter 128, bisection 1

(মাঝারি) ৩২-thread-এর একটি GPU warp-এ ১৬টি thread if-পথে (১০টি instruction) আর ১৬টি else-পথে (১০টি instruction) যায়; শাখার বাইরে কোনো instruction নেই। SIMD দক্ষতা কত?

100%
25%
50%
75%

(মাঝারি) ৩২টি thread-এর একটি warp ৪ byte-এর float পড়ে, thread t পড়ে a[t]; array ১২৮ byte সীমানায় align করা, আর মেমরি ১২৮ byte-এর খণ্ডে আসে। কয়টি খণ্ড (transaction) লাগবে?

৩২টি
১টি
২টি
৪টি

(মাঝারি) Dynamic power P ≈ α·C·V²·f. Supply voltage আর clock frequency দুটিই ২০% কমানো হলো (α, C অপরিবর্তিত)। নতুন dynamic power আগের প্রায় কত গুণ?

0.51 গুণ
0.64 গুণ
0.80 গুণ
0.36 গুণ

(মাঝারি) একটি RV32I simulator-এ addi x0, x0, 5 চালানোর পর x0-তে 5 দেখাচ্ছে। সঠিক সমাধান কোনটি?

লেখার সময় rd = 0 হলে লেখা বাদ দেওয়া (বা প্রতি instruction-এর পরে x[0] = 0 করা)
x0-কে সব instruction-এর আগে 5 দিয়ে শুরু করা
এটি ঠিক আছে — x0 সাধারণ register
addi-র decoder বদলানো

AI-এর যুগে — AI দিয়ে আরও MCQ বানান, কিন্তু উত্তর নিজে হিসাব করে যাচাই করুন

এই পাতার প্রশ্ন শেষ হলে আরও অনুশীলন চাইবেন, আর AI চ্যাটবট মুহূর্তে শত শত MCQ বানিয়ে দিতে পারে। কিন্তু মনে রাখুন: আর্কিটেকচারের MCQ-তে AI প্রায়ই ভুল উত্তরকে “সঠিক” বলে চিহ্নিত করে, বা একই প্রশ্নে দুটি সঠিক অপশন রেখে দেয়। সবচেয়ে বেশি ভুল ঠিক এই পাতার ফাঁদগুলোতে: K-map-এ কোণার দল বা don't care বাদ দেওয়া, two's complement-এর সীমার মান (−128) ভুল সামলানো, IEEE 754-এর বিট-প্যাটার্নে exponent এক কম-বেশি, cache-এর index-এ way দিয়ে ভাগ ভুলে যাওয়া, pipeline-এর cycle-সংখ্যায় k + n − 1-এর বদলে k × n. আরও আছে MIPS আর RISC-V-এর রীতি মিশিয়ে ফেলা, synthesizable নয় এমন Verilog-কে hardware বলা, আর chip-এর বানানো spec.

AI-এর প্রচলিত ভুল	উদাহরণ	কীভাবে ধরবেন
ভুল হিসাব, নিশ্চিত সুরে	“2-way 16 KiB-এ index ৯ বিট”	অংশ ১-এর চার ধাপ, বা এই পাতার script-এ সংখ্যা বসিয়ে মেলান
রীতি না বলা	AMAT-এ hit time miss-এও ধরা হবে কি না, চুপ	প্রশ্নে রীতি লেখা চান; দুই রীতিতে হিসাব করে দেখুন উত্তর বদলায় কি না
ISA মিশিয়ে ফেলা	RISC-V-এর প্রশ্নে MIPS-এর delay slot বা PC + 4 + offset	RISC-V-এর unprivileged specification-এ instruction-এর সংজ্ঞা মেলান
দুটি সঠিক অপশন	“A + A′B-এর সমান” প্রশ্নে A + B আর (A + B)·1 দুটিই	প্রতিটি অপশন truth table-এ যাচাই করুন (মডিউল ২-এর script)
বানানো তথ্য	কোনো chip-এর cache-এর মাপ বা core-সংখ্যা ভুল; “অমুক পরীক্ষায় এসেছিল”	নির্মাতার datasheet বা প্রকাশিত manual দেখুন; উৎস দেখাতে না পারলে দাবি বাদ
অ-synthesizable Verilog	delay (#5) বা initial block-কে hardware-এর অংশ বলা	simulator আর synthesis tool দুটিতেই চালিয়ে দেখুন

নিচের প্রম্পটটি AI-কে প্রশ্ন বানাতে বলে, কিন্তু সাথে এমন তথ্যও চায়, যা দিয়ে আপনি উত্তর যাচাই করতে পারবেন। প্রতিটি ধাপ, রীতি আর একক চাওয়াই এখানে আসল কৌশল:

আমি কম্পিউটার আর্কিটেকচার ও ডিজিটাল লজিকের MCQ পরীক্ষার প্রস্তুতি নিচ্ছি (বিশ্ববিদ্যালয়, চাকরির লিখিত পরীক্ষা আর ইন্টারভিউ)। বিষয়: [যেমন: K-map ও don't care / IEEE 754 encoding / RISC-V-এর branch ও encoding / pipeline hazard ও CPI / cache-এর ঠিকানা-ভাগ ও AMAT] কঠিনতা: [সহজ / মাঝারি / কঠিন] ১০টি MCQ বানাও। প্রতিটির জন্য: ১. প্রশ্ন আর ঠিক ৪টি অপশন; শুধু একটি সঠিক। দরকারি সব সংখ্যা প্রশ্নেই থাকবে। ২. যে রীতি ধরছ, প্রশ্নেই লেখো (কোন ISA — RISC-V RV32I না MIPS, AMAT-এ hit time কীভাবে, KiB না KB, chip-এর বিট-ক্রম)। ৩. সঠিক উত্তর, আর প্রতিটি ভুল অপশন কোন ভুল ধারণা বা কোন হিসাবের ভুল থেকে এসেছে — এক লাইনে। ৪. numerical-এ প্রতিটি ধাপ এককসহ দেখাও; cache-এ tag + index + offset-এর যোগফল লেখো। ৫. কোনো বাস্তব chip-এর spec উল্লেখ করলে উৎস বলো, নিশ্চিত না হলে বাদ দাও; কোনো প্রশ্নকে কোনো নির্দিষ্ট পরীক্ষার আসল প্রশ্ন বলে দাবি করবে না।

যাচাইয়ের চেকলিস্ট

প্রতিটি numerical নিজে খাতায় বা ছোট script-এ করেছি; উত্তরের একক অপশনের এককের সাথে মিলেছে
চারটি অপশনের মধ্যে ঠিক একটি সত্য — দুটি সত্য হয়ে যাওয়া প্রশ্ন ঠিক করেছি
Boolean বা K-map-এর উত্তর truth table-এ, আর circuit simulator-এ চালিয়ে মিলিয়েছি
ISA-র প্রশ্ন RISC-V-এর specification বা কোর্সের পর্বের সাথে মিলিয়েছি — MIPS-এর রীতি ঢুকে পড়েনি
বাস্তব chip-এর সংখ্যা নির্মাতার datasheet বা manual-এ দেখেছি, বা নিজের যন্ত্রে (lscpu, /sys) মিলিয়েছি
“অমুক পরীক্ষায় এসেছিল” ধরনের দাবি বাদ দিয়েছি

কেন এই উত্তর? — রিভিশনের কৌশল আর যে জোড়া-ধারণাগুলোতে সবচেয়ে বেশি ভুল হয়

প্রথমটি এই প্রশ্নব্যাংক দিয়ে কীভাবে রিভিশন করবেন তা নিয়ে; বাকিগুলো এমন জোড়া-ধারণা, যেগুলো এত বেশি গুলিয়ে যায় যে আলাদা ব্যাখ্যা দরকার। আগে নিজে ভাবুন — তারপর খুলে উত্তর দেখুন।

প্র ০১এতগুলো প্রশ্ন একবারে পড়ে মনে থাকে না। এই প্রশ্নব্যাংক দিয়ে কীভাবে রিভিশন করলে সবচেয়ে বেশি কাজে লাগে?

প্রশ্নব্যাংকের সবচেয়ে বড় অপব্যবহার হলো একটানা পড়ে যাওয়া — প্রশ্ন দেখা, উত্তর চাপা, “ও আচ্ছা” বলে এগিয়ে যাওয়া। মনে রাখতে সবচেয়ে কার্যকর দুটি অভ্যাস হলো নিজে থেকে মনে করার চেষ্টা (active recall) আর বিরতি দিয়ে ফিরে আসা (spaced repetition):

এক অংশ, পুরো মনোযোগ: একবারে একটি মডিউলের অংশ নিন। চাপার আগে খাতায় নিজের উত্তর আর এক লাইনের কারণ লিখুন — “খ, কারণ set = ৫১২ ÷ ২”. কারণ লিখতে না পারলে আন্দাজটিকে ভুল হিসেবেই গুনুন, ঠিক হলেও।
ভুলের খাতা: প্রতিটি ভুলের জন্য একটি লাইন — কোন নিয়মটি গুলিয়েছিলাম (“global = L1-এর miss rate × L2-এর local”). প্রশ্ন নয়, নিয়মটি লিখুন; পরীক্ষায় একই নিয়ম অন্য সংখ্যায় আসবে।
সংখ্যা বদলে নতুন প্রশ্ন: প্রতিটি numerical-এ একটি সংখ্যা বদলান — 2-way-এর বদলে 4-way, −6.25-এর বদলে −0.375 — আগে খাতায় উত্তর বের করুন, তারপর এই পাতার script-এ মেলান।
পর্বে ফিরে যাওয়া আর মহড়া: একটি অংশে তিনটির বেশি ভুল হলে সেই অংশের “যা ঝালিয়ে নেবেন” তালিকার পর্বগুলো আবার পড়ুন। ১, ৩ আর ৭ দিন পরে শুধু ভুল প্রশ্নগুলো আবার করুন — অপশন পড়ার আগেই নিজের উত্তর বলুন, কারণ পাতার ক্রম একই বলে অবস্থান মুখস্থ হয়ে যেতে পারে। পরীক্ষার আগে কোর্স হোমের মডিউল টেস্টে সময় ধরে মহড়া দিন।

মূল উপলব্ধি: প্রশ্ন পড়া নয়, প্রশ্নের পেছনের নিয়ম মনে রাখাই লক্ষ্য — নিজে উত্তর আর কারণ লিখুন, সংখ্যা বদলে আবার করুন, আর বিরতি দিয়ে ফিরে আসুন।

প্র ০২Latch আর flip-flop — দুটিই এক বিট রাখে। তাহলে পার্থক্য কোথায়, আর race-around condition কেন শুধু পুরোনো JK-তে?

দুটিই feedback দিয়ে এক বিট ধরে রাখে; পার্থক্য কখন নতুন মান নেয়। D latch সাড়া দেয় enable-এর স্তর দেখে — EN = 1 থাকার পুরো সময় Q, D-কে অনুসরণ করে (“স্বচ্ছ”), আর EN = 0 হলে শেষ মান আটকে রাখে। Flip-flop সাড়া দেয় clock-এর ধারে — উঠন্ত (বা নামন্ত) ধারের ঠিক আগের D-টুকুই নেয়, বাকি সময় D যা-ই করুক। Master–slave D flip-flop আসলে দুটি latch পরপর, উল্টো enable-এ — একটি খোলা থাকলে অন্যটি বন্ধ, তাই সব মিলিয়ে শুধু ধারে মান পার হয়।

রেলস্টেশনের সিগন্যালের কথা ভাবুন: latch হলো এমন গেট, যা সবুজ বাতি জ্বলে থাকার পুরো সময় খোলা — যত ট্রেন আসে, পার হয়ে যায়। Flip-flop হলো এমন গেট, যা বাঁশি বাজার মুহূর্তে একটি ট্রেনকেই ঢুকতে দেয়।

এই পার্থক্যই race-around ব্যাখ্যা করে। JK-তে J = K = 1 মানে উল্টে দেওয়া (toggle). Level-triggered JK-তে clock উঁচু থাকার পুরো সময় gate খোলা; আউটপুট উল্টায়, feedback দিয়ে ফিরে এসে আবার উল্টায় — pulse যদি propagation delay-এর চেয়ে লম্বা হয়, ফল অনিশ্চিত। Edge-triggered বা master–slave নকশায় এক ধারে ঠিক একবার উল্টানো হয়। D বা T latch-এও স্বচ্ছতার সমস্যা আছে (যেমন একই phase-এর দুটি latch পরপর থাকলে মান দুই ধাপ দৌড়ে যায়), কিন্তু “race-around” নামটি প্রচলিতভাবে JK-এর জন্যই।

পরীক্ষায় সাধারণ প্রশ্ন: “Synchronous নকশায় কোনটি পছন্দ?” — flip-flop, কারণ সময়ের হিসাব (setup, hold) এক ধারকে ঘিরে করা যায়। Latch-ভিত্তিক নকশাও আছে (time borrowing-এর জন্য), কিন্তু সেটি উন্নত প্রসঙ্গ।

মূল উপলব্ধি: latch = level-sensitive (স্বচ্ছ), flip-flop = edge-triggered; race-around হলো level-triggered JK-তে J = K = 1-এর বারবার উল্টানো, যা edge-triggering সারায়।

প্র ০৩Moore আর Mealy — একই কাজের দুই নকশা। কোনটি কখন বেছে নেবেন, আর “এক cycle দেরি” কথাটির মানে কী?

Moore machine-এর output শুধু বর্তমান state-এর ফাংশন; প্রতিটি state-এর গায়েই output লেখা থাকে। Mealy machine-এর output বর্তমান state আর বর্তমান input — দুটির ফাংশন; output লেখা থাকে transition-এর তীরে। ফলে input বদলালে Mealy-র output একই cycle-এ বদলাতে পারে, আর Moore-এর output বদলায় পরের clock ধারে state বদলানোর পরে — এটিই “এক cycle দেরি”।

উদাহরণ: “1011” ধরার একটি sequence detector. Mealy নকশায় শেষ 1 আসার মুহূর্তেই z = 1, আর state লাগে কম (সাধারণত চারটি)। Moore নকশায় একটি বাড়তি “পেয়েছি” state লাগে, যেখানে z = 1; সেখানে পৌঁছাতে একটি clock ধার লাগে।

কোনটি কখন? Mealy-র সুবিধা: কম state, দ্রুত সাড়া। অসুবিধা: input থেকে output-এ combinational পথ, তাই input-এর glitch সরাসরি output-এ যেতে পারে, আর দুটি Mealy machine পরপর জুড়লে দীর্ঘ combinational পথ বা loop তৈরি হতে পারে। Moore-এর output register-এর মতো স্থির, তাই timing সহজ আর নিরাপদ — বাইরের যন্ত্র (যেমন traffic light-এর বাতি) চালাতে প্রায়ই পছন্দ। পর্ব ১৯-এর vending machine নকশায় দেখেছেন, Mealy-তে একই cycle-এ পণ্য আর ভাংতি দেওয়া যায়।

রেস্তোরাঁর উদাহরণে: Moore ওয়েটার আপনার টেবিলের অবস্থা দেখে কাজ করেন (“এই টেবিলে খাবার দেওয়া হয়েছে, তাই বিল আনি”); Mealy ওয়েটার অবস্থা আর আপনার এই মুহূর্তের ইশারা — দুটি দেখে সাথে সাথে সাড়া দেন।

মূল উপলব্ধি: Moore = output শুধু state-এ, স্থির কিন্তু এক cycle দেরিতে; Mealy = state আর input-এ, দ্রুত আর কম state-এ, কিন্তু glitch আর timing-এর ঝুঁকি বেশি।

প্র ০৪Carry flag আর overflow flag — একই যোগে দুটির মান আলাদা কেন, আর কোনটি কখন দেখবেন?

Adder জানে না সংখ্যাগুলো signed না unsigned — সে শুধু বিট যোগ করে। একই বিট-প্যাটার্নের দুটি ব্যাখ্যা থাকে বলেই দুটি flag. Carry (C) বলে unsigned ব্যাখ্যায় ফল n বিটে ধরেনি (MSB থেকে carry বেরিয়েছে)। Overflow (V) বলে signed ব্যাখ্যায় ফল সীমার বাইরে — একই চিহ্নের দুটি সংখ্যা যোগে উল্টো চিহ্নের ফল, যা hardware-এ V = c_n ⊕ c_n−1.

চারটি ৮ বিটের উদাহরণ মনে রাখুন: 0xFF + 0x01 = 0x00 — C = 1 (২৫৫ + ১ = ২৫৬), V = 0 (−১ + ১ = ০, সঠিক)। 0x7F + 0x01 = 0x80 — C = 0, V = 1 (১২৭ + ১ = −১২৮ হয়ে গেল)। 0x80 + 0x80 = 0x00 — দুটিই 1. আর 0x60 + 0x50 = 0xB0 — C = 0, V = 1.

কোনটি কখন? C/C++-এ unsigned চলকের তুলনা বা বহু-word যোগে (add-এর পরে adc) carry দেখা হয়; signed int-এর তুলনায় overflow আর sign flag. তাই x86-এ unsigned তুলনার শাখা (jb, ja) C দেখে, signed-এর (jl, jg) দেখে SF আর OF (অর্থাৎ V). বিয়োগে আরেকটি ফাঁদ: x86-এর CF বিয়োগে “borrow” বোঝায়, ARM-এর C তার উল্টো (borrow না হলে 1) — পর্ব ১৩-এ দেখেছেন। RISC-V-তে কোনো flag-ই নেই; unsigned carry বের করতে sltu, আর signed overflow ধরতে আলাদা তুলনা লাগে।

মূল উপলব্ধি: C = unsigned-এর সীমা, V = signed-এর সীমা; একই যোগে দুটি প্রশ্ন, দুটি উত্তর — আর কোন flag দেখবেন, তা ঠিক করে সংখ্যাগুলোর ধরন।

প্র ০৫Write-through বনাম write-back, আর write-allocate বনাম no-write-allocate — চারটি শব্দ কোন দুই প্রশ্নের উত্তর?

চারটি শব্দ দুটি আলাদা প্রশ্নের উত্তর, আর গুলিয়ে যায় ঠিক সেখানেই। প্রথম প্রশ্ন — write hit-এ কী হবে? Write-through: cache আর নিচের স্তর দুটিতেই সাথে সাথে লেখা; সরল, নিচের স্তর সবসময় হালনাগাদ, কিন্তু প্রতিটি store মেমরির ট্রাফিক তৈরি করে — তাই প্রায় সবসময় সাথে একটি write buffer থাকে। Write-back: শুধু cache-এ লেখা, আর line-এ dirty বিট চালু; line সরানোর সময়ই পুরো block নিচে যায়। একই block-এ বারবার লেখা হলে ট্রাফিক অনেক কম, কিন্তু miss-এ dirty block বের করার খরচ যোগ হয়।

দ্বিতীয় প্রশ্ন — write miss-এ কী হবে? Write-allocate: আগে block-টি cache-এ আনা, তারপর লেখা — পরের লেখা বা পড়া hit হবে, এই আশায়। No-write-allocate: cache এড়িয়ে সরাসরি নিচে লেখা।

প্রচলিত জুটি: write-back + write-allocate (block আনলেই পরের লেখাগুলো cache-এ জমে — আধুনিক CPU-র L1 data cache-এ সাধারণত এটি), আর write-through + no-write-allocate (প্রতিটি store এমনিতেই নিচে যায়, তাই block আনার লাভ কম)। ডেস্কের ওপরের খাতা আর আলমারির তুলনায়: write-through মানে খাতায় লেখার সাথে সাথে আলমারির মূল রেজিস্টারেও লেখা; write-back মানে খাতায় লিখে একটি তারা-চিহ্ন দেওয়া, আর খাতা ফেরত দেওয়ার সময় তারা-চিহ্নিত পাতাগুলো আলমারিতে তোলা।

MCQ-এর ফাঁদ: “write-through-এ dirty বিট লাগে” (মিথ্যা — line কখনো ময়লা থাকে না), আর “write-back-এ প্রতিটি store মেমরিতে যায়” (মিথ্যা)।

মূল উপলব্ধি: through/back = hit-এ কখন নিচে লেখা; allocate/no-allocate = miss-এ block আনা হবে কি না; dirty বিট শুধু write-back-এর।

প্র ০৬Local miss rate আর global miss rate — L2-এর “৪০% miss” কোন অর্থে, আর AMAT-এর দুই রীতির পার্থক্য কী?

Local miss rate = একটি স্তরে যত access এসেছে, তার কত ভাগ miss. Global miss rate = CPU-র মোট access-এর কত ভাগ ওই স্তরেও miss করে নিচে গেল। L1-এর ক্ষেত্রে দুটি এক, কারণ সব access L1-এ আসে। L2-তে আসে শুধু L1-এর miss, তাই L2-এর global = L1-এর miss rate × L2-এর local. L1 ৫% miss আর L2-এর local ৪০% হলে global মাত্র ২% — L2 “খারাপ” দেখালেও মেমরিতে যাওয়া access ৫% থেকে ২%-এ নামিয়েছে।

AMAT-এর সূত্রে local-ই বসে: AMAT = HT₁ + MR₁ × (HT₂ + MR_2,local × MP₂). L2-এর local miss rate সরাসরি সব access-এর ওপর বসানো (1 + 0.05 × 12 + 0.4 × 150) সবচেয়ে প্রচলিত ভুল — এই পাতার একটি distractor ঠিক তা-ই (৬১.৬ cycle).

দ্বিতীয় ফাঁদ রীতির: এই কোর্স AMAT = hit time + miss rate × miss penalty লেখে, যেখানে miss-এও আগে hit time লাগে ধরা হয় (cache আগে দেখা হয়, তারপর নিচে যাওয়া)। কিছু বই লেখে AMAT = (১ − MR) × HT + MR × (মোট miss-এর সময়), যেখানে miss-এর সময়ে hit time আলাদা ধরা হয় না বা ভেতরে ধরা থাকে। দুই রীতির উত্তর সামান্য আলাদা (যেমন ৪.২ বনাম ৪.১৬) — আর প্রশ্নকর্তা প্রায়ই দুটিকেই অপশনে রাখেন। তাই প্রশ্নে রীতি লেখা না থাকলে প্রচলিত HT + MR × MP ধরুন, আর খাতায় লিখে রাখুন কোন রীতি নিলেন।

মূল উপলব্ধি: global = উপরের সব miss rate-এর গুণফল × নিজের local; AMAT-এ প্রতিটি স্তরের local বসে; আর রীতি (hit time miss-এও ধরা কি না) আগে ঠিক করুন।

প্র ০৭MIPS আর MFLOPS — সহজ সংখ্যা, তবু কেন ভুল রায় দেয়? “peak” আর আসল গতির পার্থক্য কী?

MIPS = instruction count ÷ (সময় × ১০^৬) = f ÷ (CPI × ১০^৬)। সমস্যা হলো এটি লৌহসূত্রের তিন গুণকের একটি — instruction count — বাদ দেয়। তিনটি ফাঁদ: (১) ভিন্ন ISA-তে একই কাজে instruction-সংখ্যা আলাদা, তাই MIPS তুলনা অর্থহীন; (২) একই machine-এ প্রোগ্রামভেদে MIPS বদলায়; (৩) compiler optimization সস্তা instruction বাদ দিলে প্রোগ্রাম দ্রুত হয়, অথচ গড় CPI বাড়ায় MIPS কমে — পর্ব ০৩-এর উদাহরণে দ্রুত compiler-টির MIPS কম (২৮০০ বনাম ৩২০০)।

MFLOPS (প্রতি সেকেন্ডে মিলিয়ন floating-point operation) কাজের কাছাকাছি, কারণ একই হিসাবে FLOP-সংখ্যা ISA-ভেদে কম বদলায়। তবু ফাঁদ আছে: সব operation সমান নয় (ভাগ বা বর্গমূল যোগের চেয়ে অনেক ধীর, অথচ গোনা হয় একই এককে); FMA-কে দুটি operation গোনা হয়; আর integer-নির্ভর প্রোগ্রামে এটি প্রায় কিছুই বলে না।

সবচেয়ে বড় ফাঁদ “peak”: peak FLOPS = core × clock × প্রতি cycle-এ FLOP — একটি তাত্ত্বিক ছাদ, যা কেবল নিখুঁত SIMD কোড আর cache-এ বসা ডেটায় ছোঁয়া যায়। বাস্তব kernel প্রায়ই মেমরির bandwidth-এ আটকায় (roofline-এর ধারণা, পর্ব ৫৪)। অনেক রেটের গড় নিতে হলে সমান কাজের জন্য harmonic mean, আর benchmark-এর অনুপাতে geometric mean — arithmetic mean নয়।

MCQ-তে এ ধরনের প্রশ্ন প্রায়ই আসে: “কোনটি পারফরম্যান্সের একমাত্র নির্ভরযোগ্য মাপ?” — একই কাজের execution time. MIPS, MFLOPS, GHz — সবই আংশিক ছবি।

মূল উপলব্ধি: MIPS instruction count বাদ দেয়, MFLOPS operation-এর ভিন্নতা ঢাকে, আর peak সংখ্যা ছাদ মাত্র; রায় দেয় শুধু একই কাজের মোট সময়।

শেষ ধাপ — ক্রম সাজান আর স্কোর দেখুন

উপরের সব MCQ শেষ করলে নিচে আপনার মোট স্কোর দেখাবে — প্রথম চেষ্টায় কয়টি ঠিক হয়েছে।

ক্রমপাঁচ ধাপের RISC-V pipeline-এ lw x5, 8(x6)-এর কাজগুলো আগে থেকে পরে সাজান (▲▼ চেপে সরান)

PC-র ঠিকানা থেকে instruction memory পড়া (IF)
Decode আর register file থেকে x6 পড়া, immediate 8 sign-extend করা (ID)
ALU-তে x6 + 8 যোগ করে ঠিকানা বানানো (EX)
সেই ঠিকানায় data memory পড়া (MEM)
পড়া মানটি x5-এ লেখা (WB)

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব শব্দ এখানে একসাথে:

মনে রাখুন

বাদ দিন, তারপর বাছুন: প্রতিটি অপশনের পেছনের নিয়মটি খুঁজুন; যোগফল (tag + index + offset), একক (ns ↔ GHz, MT/s) আর সীমা (Amdahl-এর ছাদ, k গুণের বেশি নয়) দিয়ে বেশিরভাগ distractor হিসাবের আগেই কাটে।
রীতি আগে লিখুন: ISA (RISC-V না MIPS), AMAT-এর রীতি, signed না unsigned, KiB না KB — একই প্রশ্নের দুটি “সঠিক” উত্তর দুই রীতি থেকেই আসে।
জোড়া-ধারণা এক শব্দে: latch = level, flip-flop = edge; Moore = state, Mealy = state + input; C = unsigned, V = signed; renaming = WAR/WAW, RAW নয়।
মেমরির হিসাবের তিন সূত্র: set = মাপ ÷ block ÷ way; AMAT = HT + MR × MP, প্রতিটি স্তরে local; global = miss rate-গুলোর গুণফল।
ভুল থেকে নিয়ম: প্রতিটি ভুলের নিয়মটি খাতায় লিখুন, সংখ্যা বদলে আবার করুন, আর এই পাতার script বা নিজের ছোট প্রোগ্রামে মিলিয়ে নিন — AI-এর বানানো প্রশ্নেও একই নিয়ম।

পরের পর্বে: MCQ চেনায় কোনটি সঠিক; লিখিত পরীক্ষা আর ভাইভা চায় কেন সঠিক। পরের পর্বে লজিক, ISA, pipeline আর মেমরির লিখিত ও মৌখিক প্রশ্ন — কীভাবে ধাপে ধাপে উত্তর সাজাবেন, চিত্র আঁকবেন আর প্রমাণ দেবেন।

MCQ প্রশ্নব্যাংক — কম্পিউটার আর্কিটেকচার ও ডিজিটাল লজিক

এই পর্বে যা করবেন

১ · MCQ কীভাবে সামলাবেন — প্রশ্নের ধরন, বাদ দেওয়া, একক যাচাই আর দ্রুত অনুমান

পরীক্ষাগুলো সাধারণত কেমন

প্রশ্নের ছয় ছাঁচ

কৌশল ১ · বাদ দেওয়ার পদ্ধতি — cache-এর একটি প্রশ্নে ধাপে ধাপে

কৌশল ২ · একক আর রীতি আগে, হিসাব পরে

কৌশল ৩ · দ্রুত অনুমান — হিসাবের আগেই অর্ধেক অপশন বাদ

কৌশল ৪ · negative marking আর সময় ভাগ

বারোটি বড় ফাঁদ

২ · মডিউল ১ — আর্কিটেকচারের ভিত্তি (১৩টি প্রশ্ন)

৩ · মডিউল ২ — Combinational লজিক (১৪টি প্রশ্ন)

৪ · মডিউল ৩ — Sequential লজিক (১১টি প্রশ্ন)

৫ · মডিউল ৪ — কম্পিউটারের গাণিতিক কাজ (১২টি প্রশ্ন)

৬ · মডিউল ৫ — Instruction set আর্কিটেকচার (১২টি প্রশ্ন)

৭ · মডিউল ৬ — প্রসেসর নকশা (১৩টি প্রশ্ন)

৮ · মডিউল ৭ — উন্নত প্রসেসর (১০টি প্রশ্ন)

৯ · মডিউল ৮ — মেমরি হায়ারার্কি (১৫টি প্রশ্ন)

১০ · মডিউল ৯ — I/O, সমান্তরালতা আর আধুনিক সিস্টেম (১৪টি প্রশ্ন)

AI-এর যুগে — AI দিয়ে আরও MCQ বানান, কিন্তু উত্তর নিজে হিসাব করে যাচাই করুন

যাচাইয়ের চেকলিস্ট

কেন এই উত্তর? — রিভিশনের কৌশল আর যে জোড়া-ধারণাগুলোতে সবচেয়ে বেশি ভুল হয়

শেষ ধাপ — ক্রম সাজান আর স্কোর দেখুন

শব্দকোষ

মনে রাখুন

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ