Operating System MCQ — OS প্রশ্নব্যাংক বাংলায় | পর্ব ৬১

Q: Multiprogramming, multitasking, multiprocessing আর multithreading — চারটি “multi” আসলে কোথায় আলাদা?

চারটি শব্দ চারটি আলাদা প্রশ্নের উত্তর। Multiprogramming উত্তর দেয় “মেমরিতে কয়টি কাজ?”: একাধিক কাজ একসাথে মেমরিতে রাখা, যাতে একটি I/O-র অপেক্ষায় আটকালে CPU আরেকটিকে চালাতে পারে। লক্ষ্য CPU utilisation, আর হিসাবটি সরল — প্রতিটি কাজ সময়ের p অংশ অপেক্ষায় থাকলে n টি কাজে CPU মোটামুটি 1 − p n অংশ ব্যস্ত। ১৯৬০-এর দশকে IBM-এর OS/360-এর মতো সিস্টেম এভাবে দামি mainframe-কে ব্যস্ত রাখত। এখানে কোনো timer-এর পালা বদল বাধ্যতামূলক নয়: একটি কাজ যতক্ষণ নিজে I/O চায় না, ততক্ষণ চলতে পারে। Multitasking বা time-sharing উত্তর দেয় “মানুষ কত দ্রুত সাড়া পাবে?”: multiprogramming-এর ওপর timer interrupt যোগ করে প্রতিটি কাজকে ছোট time slice দেওয়া, যাতে অনেক মানুষ একসাথে বসেও মনে করেন যন্ত্রটি শুধু তাঁরই। ১৯৬০-এর দশকের শুরুতে MIT-র CTSS এই ধারণার প্রথম দিকের সফল উদাহরণ। লক্ষ্য response time. তাই প্রতিটি multitasking সিস্টেম multiprogramming-ও করে, কিন্তু উল্টোটি নয়।

Q: Deadlock, starvation আর livelock — তিনটিতেই কাজ এগোয় না। পার্থক্যটা ঠিক কোথায়, আর প্রতিকারও কেন আলাদা?

Deadlock মানে একদল প্রসেস বা থ্রেডের প্রত্যেকে এমন একটি resource-এর অপেক্ষায়, যা ধরে আছে দলেরই আরেকজন — একটি চক্র। Coffman ও সহকর্মীরা ১৯৭১ সালে দেখান, এর জন্য চারটি শর্ত একসাথে লাগে: mutual exclusion, hold and wait, no preemption আর circular wait. deadlock-এর বৈশিষ্ট্য হলো স্থিরতা: দলের কেউ আর কখনো এগোবে না, বাইরে থেকে কেউ হস্তক্ষেপ (প্রসেস বন্ধ করা বা resource কেড়ে নেওয়া) না করলে। সিস্টেমের বাকি অংশ চলতে পারে, কিন্তু চক্রের সদস্যরা চিরতরে ঘুমিয়ে। Starvation -এ কোনো চক্র নেই, আর সিস্টেম ঠিকই চলছে — শুধু একজন বারবার সুযোগ হারায়, কারণ নিয়মটি সবসময় অন্য কাউকে আগে দেয়। ছোট কাজের স্রোতে SJF-এর লম্বা কাজ, উঁচু অগ্রাধিকারের ভিড়ে নিচের কাজ, reader-দের স্রোতে writer — সবই starvation. এটি নীতির ন্যায্যতার সমস্যা, তাই প্রতিকারও নীতিতে: aging (অপেক্ষার সাথে অগ্রাধিকার বাড়ানো), HRRN-এর ratio, MLFQ-র priority boost, বা ticket lock-এর মতো FIFO ক্রম।

Q: Internal আর external fragmentation — কোন ব্যবস্থায় কোনটি হয়, আর paging কেন একটি দূর করে কিন্তু অন্যটি নয়?

দুটিই অপচয়, কিন্তু অপচয়ের জায়গা আলাদা। Internal fragmentation মানে বরাদ্দ করা ব্লকের ভেতরে অব্যবহৃত অংশ: চাওয়া হয়েছিল ১০,০০০ byte, কিন্তু ব্যবস্থা দেয় শুধু ৪ KiB-এর গুণিতকে, তাই শেষ page-এ ২,২৮৮ byte পড়ে থাকে — আর সেটি অন্য কেউ ব্যবহার করতে পারে না, কারণ ব্লকটি একজনের নামে। External fragmentation মানে বরাদ্দের বাইরে খালি জায়গা ছোট ছোট টুকরোয় ছড়ানো: মোট খালি যথেষ্ট, কিন্তু কোনো একটি টানা hole অনুরোধের মাপের নয়। কোনটি কোথায়, তা নির্ভর করে ব্লকের মাপ স্থির না পরিবর্তনশীল তার ওপর। স্থির মাপ (fixed partition, paging, buddy system, slab) — external প্রায় নেই, কারণ যেকোনো খালি ঘর যেকোনো অনুরোধে চলে; দাম internal. পরিবর্তনশীল মাপ (variable partition, segmentation, file-এর contiguous allocation) — internal নেই, কারণ যত চাই তত দেওয়া হয়; দাম external. buddy system-এ ২-এর ঘাতে গোল করায় internal অপচয় একটি ব্লকে প্রায় অর্ধেক পর্যন্ত যেতে পারে — যেমন ১২৯K চাইলে ২৫৬K দেওয়া হয়।

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

১১৯টি প্রশ্ন, কোর্সের ক্রমে: প্রথমে উত্তর বাছাইয়ের কৌশল, negative marking-এর হিসাব আর প্রচলিত ফাঁদ; তারপর মডিউল ১ থেকে ৯ — প্রতিটি মডিউলের জন্য একটি অংশ, শুরুতে “যা ঝালিয়ে নেবেন” তালিকায় সংশ্লিষ্ট পর্বের লিংক।
আগে খাতায় উত্তর, তারপর চাপুন: যে অপশনই চাপুন, ব্যাখ্যা দেখাবে — সঠিকটি কেন সঠিক, আর ভুলটি কোন ভুল ধারণা থেকে বানানো। ভুল অপশনের ব্যাখ্যাতেই সবচেয়ে বেশি শেখা হয়।
কঠিনতার মাত্রা দেওয়া আছে: প্রতিটি প্রশ্নের শুরুতে (সহজ), (মাঝারি) বা (কঠিন)। প্রশ্নগুলো মেশানো — সংজ্ঞা, ধারণার প্রয়োগ, ছোট numerical, “কোনটি মিথ্যা”, আর Linux ও Windows-এর বাস্তব আচরণ।
প্রতিটি numerical script দিয়ে যাচাই করা: Gantt chart, page fault, EAT, Banker's, disk head movement, inode, RAID, umask — প্রতিটি উত্তর ছোট প্রোগ্রামে মিলিয়ে দেখা, আর রীতিগুলো (tie-নিয়ম, লাফ গোনা হবে কি না) প্রশ্নেই লেখা।
স্কোর নিজে নিজে: পাতার নিচে প্রথম চেষ্টার মোট স্কোর দেখাবে। যে মডিউলে বেশি ভুল, তার পর্বগুলো আবার পড়ুন — তারপর শুধু ভুল প্রশ্নগুলো আবার করুন।

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

অপারেটিং সিস্টেমের MCQ কোন কোন ছাঁচে আসে তা চেনা, আর বাদ দেওয়ার পদ্ধতি ও সময় ভাগ শেখা
ভুল উত্তরে নম্বর কাটলে কখন আন্দাজ করা লাভজনক — expected value দিয়ে হিসাব করা
multiprogramming বনাম multitasking, deadlock বনাম starvation, internal বনাম external fragmentation, process বনাম thread, hard বনাম soft link — বড় জোড়া-বিভ্রান্তিগুলো দূর করা
পুরো কোর্সের ১১৯টি প্রশ্নে নিজের দুর্বল মডিউল খুঁজে বের করা, আর সেই পর্বে ফিরে যাওয়া
AI দিয়ে আরও MCQ বানানো, আর তার “সঠিক উত্তর” হিসাব ও পর্বের সাথে মিলিয়ে যাচাই করা

১ · অপারেটিং সিস্টেমের MCQ কীভাবে সামলাবেন — প্রশ্নের ধরন, বাদ দেওয়ার কৌশল আর negative marking

ধরুন রাজশাহীর তানিয়া একটি ব্যাংকের IT officer পদের লিখিত পরীক্ষায় বসেছেন। কম্পিউটার অংশে অপারেটিং সিস্টেমের ২৫টি MCQ, সময় ২০ মিনিট, আর প্রতিটি ভুলে নম্বর কাটে। প্রশ্নগুলো দেখতে সহজ: “Belady's anomaly কোন algorithm-এ হয়?”, “semaphore-এর মান −২ মানে কী?”, “RR-এ গড় turnaround কত?” — কিন্তু অপশনে LRU-ও আছে, “২ জন অপেক্ষায়”-ও আছে, আর ৬.৩৩ আর ৭.০০ পাশাপাশি। ফল এল প্রত্যাশার চেয়ে কম। বেশিরভাগ ভুল জ্ঞানের অভাবে নয় — একটি শব্দ (“মিথ্যা”), একটি রীতি (একই মুহূর্তে কে আগে সারিতে ঢোকে), বা একটি একক (ms বনাম µs) চোখ এড়িয়ে যাওয়ায়।

প্রশ্নকর্তা জেনেশুনে এমন ভুল অপশন রাখেন, যা কোনো আধা-সত্য নিয়ম বা একটি চেনা হিসাবের ভুল থেকে আসে। এমন বিভ্রান্তিকর অপশনকে বলে distractor. “LRU-ও তো FIFO-র মতো সরল, তাই anomaly হতে পারে”, “unsafe মানেই deadlock”, “load average ৪ মানে CPU ৪০০%” — একেকটি distractor-এর জন্মস্থান। ভালো খবর: OS-এর distractor-গুলো ঘুরেফিরে একই দশ-বারোটি ভুল ধারণা থেকে আসে। সেগুলো চিনে ফেললে অর্ধেক কাজ শেষ।

প্রশ্নের সাত ছাঁচ

বিশ্ববিদ্যালয়ের পরীক্ষা, চাকরির লিখিত পরীক্ষা (IT officer, ব্যাংকের IT, BCS-ধাঁচের কম্পিউটার অংশ, সফটওয়্যার ইঞ্জিনিয়ারের screening) আর অনলাইন অ্যাসেসমেন্টে OS-এর MCQ মোটামুটি সাতটি ছাঁচে পড়ে। কোন ছাঁচের প্রশ্ন, তা চিনতে পারলেই বুঝবেন কোন কৌশল লাগবে:

ধরন	উদাহরণ	কৌশল
সংজ্ঞা	“multiprogramming কী?”, “zombie কী?”	সংজ্ঞার প্রতিটি শব্দ মেলান; কাছের জোড়া-শব্দটি কেন নয়, তাও ভাবুন
ধারণার প্রয়োগ	“কোন নিয়ম deadlock-এর কোন শর্ত ভাঙে?”	দৃশ্যটি নিজের ভাষায় বলুন, তারপর সংজ্ঞায় বসান
ছোট numerical	Gantt chart, page fault, EAT, Banker's, disk, umask	খাতায় ছোট টেবিল; রীতি (tie, লাফ, একক) আগে লিখুন
“কোনটি মিথ্যা”	“zombie সম্পর্কে কোনটি মিথ্যা?”	প্রতিটি অপশনের পাশে স-মি লিখুন; “মিথ্যা” শব্দে দাগ দিন
কোড বা কমান্ডের ফল	fork কতবার, `2>&1`-এর ক্রম, exit status	প্রসেস-গাছ বা fd-টেবিল এঁকে ধাপে ধাপে চালান
বাস্তব সিস্টেম	Linux-এর CFS, `/proc`, Windows-এর commit, WSL2	কোন OS, কোন সংস্করণ — প্রশ্নে দেখে নিন; সর্বজনীন বলে ধরবেন না
তুলনা	“mutex বনাম binary semaphore”, “RM বনাম EDF”	একটি মূল পার্থক্য খুঁজুন (মালিকানা, স্থির বনাম dynamic)

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

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

প্রশ্ন পড়াতিন দাবিsafe, unsafe, deadlock
NeedMax − Allocচার সারি
কে শুরু পারে?কেউ নাক, খ বাদ
deadlock?কেউ অপেক্ষায় নেইঘ বাদ
উত্তরগ) unsafeফাঁদটি মনে রাখুন

প্রশ্ন (কঠিন)A, B, C তিন ধরনের resource

Available = (2, 3, 0)    কেউ এখন নতুন কিছু চাইছে না
        Max         Allocation
P0   (5, 3, 2)      (1, 1, 0)
P1   (3, 2, 2)      (2, 0, 0)
P2   (9, 0, 2)      (3, 0, 2)
P3   (2, 2, 2)      (2, 1, 1)

ক) safe — P3, P0, P1, P2
খ) safe — P1, P3, P0, P2
গ) unsafe, কিন্তু এই মুহূর্তে deadlock নয়
ঘ) এই মুহূর্তেই deadlock

ধাপ ২Need = Max − Allocation

        Need
P0   (4, 2, 2)
P1   (1, 2, 2)
P2   (6, 0, 0)
P3   (0, 1, 1)    ← সবচেয়ে ছোট, তাই চোখ টানে

Work শুরু = Available = (2, 3, 0)

ধাপ ৩কারও Need ≤ Work?

P0 (4,2,2) ≤ (2,3,0)?  A: 4 > 2   ✗
P1 (1,2,2) ≤ (2,3,0)?  C: 2 > 0   ✗
P2 (6,0,0) ≤ (2,3,0)?  A: 6 > 2   ✗
P3 (0,1,1) ≤ (2,3,0)?  C: 1 > 0   ✗

কেউ শুরুই করতে পারে না → safe sequence নেই
ক) safe   খ) safe

ধাপ ৪unsafe কি deadlock?

deadlock = এই মুহূর্তে একদল প্রসেস
           চক্রাকারে একে অপরের অপেক্ষায়

এখানে: কেউ কিছু চাইছে না, সবাই চলছে
      → এখনো কোনো চক্র নেই

unsafe = "ভবিষ্যতে সবাই Max চাইলে
          নিশ্চয়তা নেই" — শুধু ঝুঁকি
ঘ) এই মুহূর্তেই deadlock

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

উত্তর: গ) unsafe, কিন্তু এখন deadlock নয়

safe     ⇒ deadlock অসম্ভব
unsafe   ⇒ deadlock সম্ভব, নিশ্চিত নয়
deadlock ⊂ unsafe

একই টেবিলে Available = (2, 3, 1) হলে
P3 শুরু পারে → P3, P0, P1, P2 — safe

প্রশ্নের তিনটি দাবি আলাদা করুন। চারটি অপশন আসলে তিনটি ভিন্ন দাবি: safe (দুটি ভিন্ন sequence-সহ), unsafe, আর deadlock. প্রশ্নের “কেউ এখন নতুন কিছু চাইছে না” কথাটিতে দাগ দিন — শেষ ধাপে এটিই সিদ্ধান্ত দেবে। প্রথম কাজ: Need বের করা।
Need = Max − Allocation, সারি ধরে। P0 (৪,২,২), P1 (১,২,২), P2 (৬,০,০), P3 (০,১,১). P3-এর Need সবচেয়ে ছোট — আর এখানেই ফাঁদ: “এত ছোট চাহিদা নিশ্চয়ই মেটে” ভেবে অনেকে সরাসরি ক বা খ বেছে ফেলেন। খেয়াল করুন, Available-এ C-এর একটিও খালি নেই।
প্রতিটি সারির প্রতিটি ঘর মেলান। P0 আর P2-এর A বেশি লাগে, P1 আর P3-এর C লাগে — কিন্তু C-এর একটিও খালি নেই। কারও Need ≤ Work নয়, তাই safety algorithm প্রথম ধাপেই আটকে যায়: কোনো safe sequence নেই। ক আর খ দুটিই বাদ — খ-এর sequence তো শুরুতেই P1, যার C লাগে ২টি।
unsafe আর deadlock-কে আলাদা করুন। deadlock মানে এই মুহূর্তে একদল প্রসেস চক্রাকারে একে অপরের ধরা resource-এর অপেক্ষায়। প্রশ্নে বলা আছে কেউ এখন কিছু চাইছে না — সবাই চলছে, কোনো চক্র নেই। unsafe শুধু বলে, সবাই একসাথে নিজের Max চাইলে নিশ্চয়তা নেই। ঘ বাদ।
উত্তর গ — আর শিক্ষাটি মনে রাখুন। safe হলে deadlock অসম্ভব; unsafe হলে সম্ভব, কিন্তু নিশ্চিত নয়; প্রতিটি deadlock অবস্থাই unsafe. এই পাতার মডিউল ৪-এ একই টেবিলে Available = (২, ৩, ১) দেওয়া আছে — একটিমাত্র C বেশি থাকায় P3 শুরু করতে পারে, আর অবস্থা safe হয়ে যায়।

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

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

বিষয়	রীতি	অন্য রীতিতে কী বদলায়
Scheduling-এর মাপ	TAT = CT − AT; WT = TAT − BT; RT = প্রথম শুরু − AT	AT বিয়োগ ভুললে “শুরুর সময়ের গড়” আসে
Round Robin-এর tie	একই মুহূর্তে নতুন আগমন সময়-ফুরানো প্রসেসের আগে সারিতে	উল্টো নিয়মে Gantt আর গড় দুটিই বদলায়
Priority	ছোট সংখ্যা = বেশি অগ্রাধিকার; সমান হলে আগে আসা	কিছু বই ও সিস্টেমে উল্টো — প্রশ্নে দেখুন
SSTF-এর tie	দূরত্ব সমান হলে ছোট cylinder আগে	tie না থাকলে প্রভাব নেই
C-SCAN / C-LOOK	মোট head movement লাফসহ আর লাফ বাদে — দুটিই দেখুন	অনেক বই লাফ গোনে না; উত্তর অনেক কম আসে
Banker's	প্রতিবার সবচেয়ে ছোট index-এর যোগ্য প্রসেস	অন্য বৈধ safe sequence-ও আসতে পারে
TLB-সহ EAT	TLB-র সময় hit আর miss দুই পথেই গোনা	t বাদ দিলে উত্তর ঠিক t পরিমাণ কম
Semaphore-এর মান	পাঠ্যবই-রীতি: ঋণাত্মক মান = অপেক্ষারত প্রসেসের সংখ্যা	POSIX `sem_getvalue` সেখানে ০ দেখাতে পারে

রীতি লেখার পর ছোট টেবিল বানান — Gantt chart-এর প্রতিটি টুকরো, frame-এর প্রতিটি অবস্থা, head-এর প্রতিটি লাফ। মাথায় হিসাব করলে একটি ধাপ বাদ পড়ে, আর ঠিক সেই ভুল উত্তরটিই অপশনে বসে থাকে। এককের দিকে চোখ রাখুন: ms আর µs, KiB আর KB, bit আর byte.

কৌশল ৩ · negative marking — কখন আন্দাজ করবেন

যেসব পরীক্ষায় ভুল উত্তরে নম্বর কাটে (negative marking), সেখানে আন্দাজ করা একটি হিসাবের সিদ্ধান্ত, সাহসের নয়। হিসাবের হাতিয়ার expected value: একটি আন্দাজে গড়ে কত নম্বর আসে = (ঠিক হওয়ার সম্ভাবনা × প্রাপ্ত নম্বর) − (ভুল হওয়ার সম্ভাবনা × কাটা নম্বর)। ধরুন ঠিক হলে +১, ভুল হলে −০.২৫:

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

দুটি সতর্কতা। এক, এই হিসাব ধরে নেয় বাকি অপশনগুলোর প্রতিটি সমান সম্ভাব্য। আপনি যদি একটি ভুল ধারণার কারণে নিশ্চিতভাবে একটি distractor-এর দিকে ঝোঁকেন, তাহলে আসল সম্ভাবনা ১/k-এর চেয়ে কম — এই পাতার ব্যাখ্যাগুলো ঠিক সেই ঝোঁক ভাঙার জন্য। দুই, কত কাটে, পরীক্ষাভেদে আলাদা, আর কোনো কোনো পরীক্ষায় কাটে না — নিজের পরীক্ষার নিয়ম বিজ্ঞপ্তি থেকে আগে জেনে নিন। নিচের হিসাবটি চালিয়ে বিভিন্ন কাটা নম্বরে নিজে দেখুন:

// Expected marks of ONE guess: right = +1, wrong = -penalty.
// k = options still left after you eliminate the ones you are sure are wrong.
function ev(k, penalty) {
  const p = 1 / k;                       // chance a blind pick among k is right
  return p * 1 - (1 - p) * penalty;
}
const fmt = v => (Math.abs(v) < 1e-9 ? 0 : v).toFixed(3).padStart(7);   // show -0.000 as 0.000
const penalties = [0.25, 1 / 3, 0.5];
console.log("options left | -0.25    | -0.333   | -0.50");
for (const k of [4, 3, 2]) {
  const row = penalties.map(x => fmt(ev(k, x)));
  console.log("      " + k + "      | " + row.join("  | "));
}
// break-even penalty: guessing among k pays while penalty < 1/(k-1)
for (const k of [4, 3, 2]) console.log("k = " + k + ": guess pays while penalty < " + (1 / (k - 1)).toFixed(3));
// 100 questions: 60 known for sure, 20 narrowed to 2 options, 20 no idea (4 options), penalty 0.25
const sure = 60, half = 20 * ev(2, 0.25), blind = 20 * ev(4, 0.25);
console.log("expected score: " + sure + " + " + half.toFixed(2) + " + " + blind.toFixed(2) + " = " + (sure + half + blind).toFixed(2));

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

options left | -0.25    | -0.333   | -0.50
      4      |   0.063  |   0.000  |  -0.125
      3      |   0.167  |   0.111  |   0.000
      2      |   0.375  |   0.333  |   0.250
k = 4: guess pays while penalty < 0.333
k = 3: guess pays while penalty < 0.500
k = 2: guess pays while penalty < 1.000
expected score: 60 + 7.50 + 1.25 = 68.75

টেবিলের প্রতিটি ঘর এক আন্দাজের গড় লাভ বা ক্ষতি। প্রথম সারিতে দেখুন: −০.২৫ কাটায় অন্ধ আন্দাজেও সামান্য লাভ (০.০৬৩), −১/৩-এ ঠিক শূন্য, −০.৫-এ ক্ষতি (−০.১২৫)। নিচের তিন লাইন সেই নিয়মটিই দেখায় — চারটি অপশনে সীমা ০.৩৩৩, তিনটিতে ০.৫০০. শেষ লাইনে একটি পূর্ণ পরীক্ষার ছবি: ৬০টি নিশ্চিত, ২০টিতে দুটি অপশনে নামিয়ে আনা আর ২০টি একেবারে অজানা — দুটিতে নামানো ২০টি প্রশ্ন গড়ে দেয় ৭.৫০ নম্বর, অন্ধ ২০টি মাত্র ১.২৫. অর্থাৎ লাভের বড় অংশ আসে বাদ দেওয়ার দক্ষতা থেকে, ভাগ্য থেকে নয়। কোডে penalties বদলে নিজের পরীক্ষার নিয়ম বসিয়ে দেখুন।

সময় ভাগ

২৫টি প্রশ্ন ২০ মিনিটে মানে প্রতিটিতে গড়ে ৪৮ সেকেন্ড, অথচ একটি Gantt chart বা Banker's-এর প্রশ্নেই দুই মিনিট লাগতে পারে। তাই দুই দফায় চলুন: প্রথম দফায় সংজ্ঞা আর সরাসরি প্রশ্ন, সাথে যেগুলোতে নিশ্চিত হতে পারছেন না সেগুলোর পাশে একটি চিহ্ন; দ্বিতীয় দফায় numerical আর চিহ্ন দেওয়া প্রশ্ন। “কোনটি মিথ্যা” ধাঁচের প্রশ্নে চারটি অপশনের পাশে স বা মি লিখে তবেই উত্তর বাছুন — না হলে প্রথম সত্য বাক্যটিই হাতে উঠে আসে।

দশটি বড় ফাঁদ

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

ফাঁদ	ভুল ধারণা	সঠিক কথা
Multiprogramming বনাম multitasking	“দুটি একই”	প্রথমটি মেমরিতে অনেক কাজ রেখে I/O-র ফাঁকে CPU ব্যস্ত রাখে; দ্বিতীয়টি তার সাথে timer দিয়ে নিয়মিত পালা বদলায়
waiting → running	“I/O শেষ হলেই প্রসেস চলে”	আগে ready; CPU কে পাবে, ঠিক করে শুধু scheduler
fork গোনা	“n বার fork মানে n টি প্রসেস”	শর্তহীন n বার fork-এ মোট ২ⁿটি, নতুন ২ⁿ − ১টি; শর্ত থাকলে গাছ এঁকে গুনুন
load average	“৪ মানে CPU ৪০০%”	এটি গণনা, শতাংশ নয়; CPU-সংখ্যার সাথে তুলনা করুন, আর Linux-এ D-অবস্থার task-ও গোনা হয়
Semaphore বনাম mutex	“binary semaphore = mutex”	mutex-এর মালিক আছে; semaphore-এর নেই, যেকোনো থ্রেড signal দিতে পারে
unsafe বনাম deadlock	“unsafe মানেই deadlock”	safe ⇒ deadlock নেই; unsafe ⇒ সম্ভব, নিশ্চিত নয়
Belady's anomaly	“LRU-তেও হতে পারে”	শুধু FIFO-র মতো non-stack নীতিতে; LRU আর OPT stack algorithm
Internal বনাম external	“paging-এ external fragmentation হয়”	paging external দূর করে, internal থাকে (শেষ page); segmentation আর variable partition-এ external
Hard বনাম soft link	“hard link অন্য file system-এও চলে”	hard link = একই inode-এর আরেক নাম, একই file system-এ; অন্য FS বা directory-র জন্য symlink
iowait	“wa বেশি মানে CPU ব্যস্ত”	wa CPU-র অলস সময়ের ভাগ; বাধা I/O-তে, বেশি core দিলে সারে না

এই পাতার প্রশ্নগুলো সম্পর্কে: প্রশ্নগুলো এই কোর্সের জন্য নতুন করে লেখা — বিশ্ববিদ্যালয়, চাকরির লিখিত পরীক্ষা আর ইন্টারভিউতে এ ধরনের প্রশ্ন প্রায়ই আসে, এমন ধারণা থেকে বানানো; কোনোটিই কোনো নির্দিষ্ট পরীক্ষার আসল প্রশ্ন নয়। প্রতিটি numerical-এর উত্তর ছোট প্রোগ্রামে মিলিয়ে দেখা, আর রীতি প্রশ্নেই লেখা। অন্যভাবে বলা না থাকলে Linux-এর আচরণ মানে সাম্প্রতিক Linux kernel আর glibc, আর Windows-এর আচরণ মানে Windows 10/11.

২ · মডিউল ১ — অপারেটিং সিস্টেমের ভিত্তি (১৩টি প্রশ্ন)

এই অংশ কোর্সের শব্দভান্ডার আর কাঠামো: OS-এর দুই দৃষ্টিভঙ্গি (resource manager আর extended machine), ইতিহাসের চারটি “multi”, real-time-এর দুই রকম, terminal আর redirection, hardware-এর interrupt আর cache, system call, kernel-এর গঠন আর বুট। পরীক্ষায় সবচেয়ে বেশি ভুল হয় তিন জায়গায়: multiprogramming আর multitasking গুলিয়ে ফেলা, trap আর interrupt-এর পার্থক্য, আর redirection-এর ক্রম।

যা ঝালিয়ে নেবেন

পর্ব ০১ · অপারেটিং সিস্টেম কী আর কেন আর পর্ব ০২ · OS-এর ইতিহাস আর ধরন — দুই দৃষ্টিভঙ্গি, চার “multi”, 1 − pⁿ, real-time
পর্ব ০৩ · Linux টার্মিনাল — path, redirection, pipe, exit status
পর্ব ০৪ · OS-এর চোখে হার্ডওয়্যার আর পর্ব ০৫ · System call — interrupt বনাম trap, EAT, dual mode, library বনাম syscall
পর্ব ০৬ · OS-এর গঠন আর পর্ব ০৭ · বুট প্রক্রিয়া — monolithic, microkernel, hybrid, module; firmware থেকে PID 1

(সহজ) নিচের কোনটি অপারেটিং সিস্টেমের মূল দায়িত্বের মধ্যে পড়ে না?

কোন প্রোগ্রাম কখন কতক্ষণ CPU পাবে, তা ঠিক করা
একটি প্রোগ্রাম যেন অন্যের মেমরি ছুঁতে না পারে, তা নিশ্চিত করা
ডিস্কের ব্লকগুলোকে নামওয়ালা ফাইল আর ফোল্ডার হিসেবে দেখানো
একটি C প্রোগ্রামের source code-কে machine code-এ অনুবাদ করা

(সহজ) একটি কাজ I/O-র অপেক্ষায় আটকালে OS মেমরিতে রাখা আরেকটি কাজকে CPU দেয়, যাতে CPU অলস না থাকে — কিন্তু চলতি কাজকে timer দিয়ে নিয়মিত থামানো হয় না। এটি কোন ধারণা?

Multitasking (time-sharing)
Multiprocessing
Multithreading
Multiprogramming

(মাঝারি) প্রতিটি কাজ সময়ের ৫০% I/O-র অপেক্ষায় থাকে, আর কাজগুলোর অপেক্ষা পরস্পর স্বাধীন। মেমরিতে ৪টি কাজ রাখলে 1 − pⁿ সূত্রে CPU utilisation কত?

৫০%
৬.২৫%
৮৭.৫%
৯৩.৭৫%

(সহজ) নিচের কোনটি soft real-time সিস্টেমের সবচেয়ে ভালো উদাহরণ?

ভিডিও কলের অডিও-ভিডিও চালানো
হৃদ্‌যন্ত্রের pacemaker
গাড়ির airbag controller
রাতভর চলা বেতনের হিসাবের batch কাজ

(সহজ) বর্তমান ফোল্ডার /home/rina/a/b. cd ../../c সফল হলে pwd কী দেখাবে?

/home/rina/a/c
/c
/home/c
/home/rina/c

(কঠিন) bash-এ ls /nope 2>&1 > out.txt চালানো হলো, আর /nope নামে কিছু নেই। ত্রুটির বার্তা কোথায় যাবে?

out.txt ফাইলে
কোথাও না, বার্তাটি হারিয়ে যায়
out.txt আর terminal দুই জায়গাতেই
terminal-এর পর্দায়

(মাঝারি) Cache access time ৫ ns, main memory access time ১০০ ns, hit ratio ০.৯৫. Miss হলে আগে cache, তারপর memory দেখা হয় — অর্থাৎ hierarchical রীতি। Effective access time কত?

৫ ns
৯.৭৫ ns
১০ ns
১০৫ ns

(সহজ) নিচের কোনটি asynchronous hardware interrupt — চলমান নির্দেশ থেকে নয়, বাইরের ডিভাইস থেকে আসা?

প্রোগ্রামে শূন্য দিয়ে ভাগ করা
syscall instruction চালানো
RAM-এ নেই এমন একটি page ছোঁয়া
network card-এ নতুন প্যাকেট পৌঁছানো

(সহজ) নিচের কোনটি নিজে system call নয়, বরং C library-র একটি ফাংশন, যা দরকার হলে ভেতরে system call ডাকে?

fork()
read()
open()
malloc()

(কঠিন) Linux-এ ARM64 প্রসেসর system call-এ ঢুকতে কোন instruction ব্যবহার করে, আর syscall-এর নম্বর কোন register-এ থাকে?

svc #0; নম্বর x8-এ
syscall; নম্বর rax-এ
ecall; নম্বর a7-এ
int 0x80; নম্বর eax-এ

(সহজ) নিচের কোন অপারেটিং সিস্টেম microkernel নকশার জন্য পরিচিত?

Linux
Windows NT
MS-DOS
QNX

(কঠিন) OS-এর গঠন নিয়ে নিচের কোন বক্তব্যটি মিথ্যা?

Monolithic kernel-এর অংশগুলো সরাসরি ফাংশন কলে একে অপরকে ডাকে
Microkernel-এ একটি read-এ একাধিক বার্তা লাগতে পারে, তাই এটি ধীর হতে পারে
macOS-এর XNU-তে Mach, BSD স্তর আর I/O Kit একই kernel address space-এ চলে
Linux-এর loadable module user mode-এ চলে, তাই module-এর বাগ kernel-কে বিপদে ফেলতে পারে না

(সহজ) একটি Linux PC চালু করলে নিয়ন্ত্রণ সাধারণত কোন ক্রমে হাত বদলায়?

firmware (BIOS/UEFI) → bootloader → kernel → init (PID 1)
bootloader → firmware → kernel → init
firmware → kernel → bootloader → init
firmware → bootloader → init → kernel

৩ · মডিউল ২ — প্রসেস ও থ্রেড (১৪টি প্রশ্ন)

প্রসেসের জীবন: অবস্থা আর PCB, context switch-এর খরচ, fork-exec-wait, shell আর job control, IPC, signal, আর thread. এই মডিউলের প্রশ্নে দুটি অভ্যাস কাজে লাগে — fork-এর প্রশ্নে প্রসেস-গাছ আঁকা, আর exit status বা signal-এর প্রশ্নে সংখ্যাটি bit ধরে ভাবা — exit status-এ ৮ bit, signal-মৃত্যুতে ১২৮ যোগ।

যা ঝালিয়ে নেবেন

পর্ব ০৮ · প্রসেস আর পর্ব ০৯ · Context switch — state diagram, memory layout, PCB, q ÷ (q + s)
পর্ব ১০ · fork, exec আর wait আর পর্ব ১১ · Shell কীভাবে কাজ করে — fork গোনা, zombie, exit status, load average
পর্ব ১২ · Inter-process communication আর পর্ব ১৩ · Signal — pipe, FIFO, shared memory; SIGINT, SIGKILL, ১২৮ + n
পর্ব ১৪ · থ্রেড আর পর্ব ১৫ · POSIX thread হাতে-কলমে — কী ভাগ হয়, Amdahl, threading model, &i বাগ

(সহজ) প্রোগ্রাম আর প্রসেসের পার্থক্য কোন বাক্যে সবচেয়ে সঠিকভাবে বলা হয়েছে?

দুটি একই জিনিসের দুই নাম
প্রোগ্রাম ডিস্কে রাখা নিষ্ক্রিয় নির্দেশের ফাইল; প্রসেস হলো চলমান প্রোগ্রাম — নিজের মেমরি, register, খোলা ফাইল আর PID-সহ
প্রসেস হলো প্রোগ্রামের source code, আর প্রোগ্রাম হলো compile করা ফাইল
একটি প্রোগ্রাম থেকে একবারে একটিই প্রসেস চলতে পারে

(সহজ) পাঁচ অবস্থার process model-এ running → ready transition সাধারণত কোন ঘটনায় ঘটে?

প্রসেস ডিস্ক থেকে পড়ার অনুরোধ করলে
প্রসেসের অপেক্ষার I/O শেষ হলে
প্রসেস exit() ডাকলে
timer interrupt-এ time slice শেষ হলে, বা বেশি অগ্রাধিকারের কেউ ready হলে

(মাঝারি) একটি C ফাংশনের ভেতরে লেখা static int hits = 5; ভ্যারিয়েবলটি প্রসেসের মেমরির কোন অংশে থাকে?

Data
Stack
Heap
BSS

(সহজ) Linux kernel-এ প্রতিটি প্রসেস (আর থ্রেড)-এর PCB কোন কাঠামো দিয়ে রাখা হয়?

struct inode
struct task_struct
struct file
struct page

(মাঝারি) Round Robin-এ quantum q = ১০ ms আর প্রতি context switch-এ s = ০.৫ ms. সব প্রসেস পুরো quantum ব্যবহার করলে CPU efficiency q ÷ (q + s) প্রায় কত?

৪.৮%
৯০.৯%
৯৫.০%
৯৫.২%

(মাঝারি) for (int i = 0; i < 3; i++) fork(); — একটি প্রসেস এই লুপ চালালে, আর কোনো fork ব্যর্থ না হলে, মোট কতটি নতুন প্রসেস তৈরি হয়?

৩
৭
৮
১৬

(কঠিন) নিচের কোড চালালে “x” কতবার ছাপা হবে? (কোনো fork ব্যর্থ হয় না, stdout terminal-এ) if (fork() == 0) fork(); printf("x\n");

(মাঝারি) Linux-এ একটি child exit(256) দিয়ে শেষ হলো। Parent waitpid-এর পর WEXITSTATUS(st)-এ কী পাবে?

০
১
২৫৫
২৫৬

(কঠিন) Zombie প্রসেস নিয়ে নিচের কোন বক্তব্যটি মিথ্যা?

kill -9 দিয়ে zombie-কে সরিয়ে ফেলা যায়
Zombie-র মেমরি ফেরত দেওয়া হয়ে গেছে; থাকে শুধু PID আর exit status-এর ছোট রেকর্ড
ps-এর STAT কলামে zombie-কে Z দেখায়
অনেক zombie জমলে নতুন প্রসেসের জন্য PID ফুরিয়ে যেতে পারে

(মাঝারি) ৮টি CPU-র একটি Linux সার্ভারে uptime দেখাচ্ছে load average 4.00, 4.10, 3.90. সবচেয়ে সঠিক ব্যাখ্যা কোনটি?

CPU ৪০০% ব্যস্ত, সার্ভার মারাত্মক চাপে
৪টি CPU নষ্ট হয়ে গেছে
ঠিক ৪টি প্রসেস চালু আছে, বাকি সব বন্ধ
গড়ে প্রায় ৪টি task চলছিল, CPU-র অপেক্ষায় ছিল বা (Linux-এ) D-অবস্থায় I/O-তে আটকে ছিল — ৮টি CPU-র তুলনায় চাপ কম

(সহজ) একমুখী, নামহীন, আর সাধারণত fork-এর আগে তৈরি হয়ে parent ও child-এর মধ্যে বাইটের স্রোত পাঠায় — কোন IPC?

Named pipe (FIFO)
TCP socket
Anonymous pipe (pipe())
Shared memory

(মাঝারি) Bash-এ একটি foreground প্রোগ্রাম চলার সময় Ctrl+C চাপা হলো; প্রোগ্রামটি SIGINT সামলায় না। এরপর echo $? কী দেখাবে?

২
১২৮
১৩০
১৪৩

(মাঝারি) একটি প্রোগ্রামের ৭৫% কাজ সমান্তরালে চালানো যায়। Amdahl's law অনুযায়ী ৪টি core-এ speedup আর অসীম core-এ সর্বোচ্চ speedup কত?

৪ আর অসীম
৩ আর ৪
প্রায় ২.২৯ আর ৪
প্রায় ২.২৯ আর ১০

(মাঝারি) একটি লুপে pthread_create(&t[i], NULL, worker, &i) দিয়ে চারটি থ্রেড বানানো হলো; worker *(int *)arg পড়ে ছাপে, আর আউটপুটে বারবার একই সংখ্যা আসছে। কোন সমাধানটি সঠিক?

i-কে volatile ঘোষণা করা
প্রতিটি থ্রেডের জন্য আলাদা ঘর রাখা — যেমন ids[i] = i লিখে &ids[i] পাঠানো
প্রতিটি pthread_create-এর পর sleep(1) দেওয়া
worker-এর শুরুতে pthread_detach ডাকা

৪ · মডিউল ৩ — CPU শিডিউলিং (১৩টি প্রশ্ন)

এই মডিউলের অর্ধেক প্রশ্নই Gantt chart থেকে। প্রতিটির আগে রীতি লিখুন (TAT = CT − AT, WT = TAT − BT, RR-এর tie), তারপর খাতায় টুকরো টুকরো chart. অপশনে প্রায় সবসময় থাকে “অন্য নীতির উত্তর” (SJF-এর বদলে SRTF), “অন্য মাপের উত্তর” (WT-এর বদলে TAT) আর “উল্টো tie-নিয়মের উত্তর” — ব্যাখ্যাগুলো ঠিক সেগুলোকে চিহ্নিত করে। শেষ তিনটি প্রশ্ন real-time আর Linux-এর CFS নিয়ে।

যা ঝালিয়ে নেবেন

পর্ব ১৬ · CPU scheduling-এর ভিত্তি — মাপকাঠি, preemptive বনাম non-preemptive
পর্ব ১৭ · FCFS, SJF আর SRTF — convoy effect, exponential averaging, HRRN
পর্ব ১৮ · Priority scheduling আর Round Robin আর পর্ব ১৯ · MLFQ — tie-নিয়ম, aging, স্তর বদল
পর্ব ২০ · Multiprocessor আর real-time scheduling আর পর্ব ২১ · Linux-এর scheduler — RM, EDF, Liu–Layland; vruntime, nice আর weight

(সহজ) CPU scheduling-এর নিচের কোন মাপকাঠিটি কমানো নয়, বাড়ানোই লক্ষ্য?

Waiting time
Turnaround time
Response time
Throughput

(মাঝারি) FCFS-এ চারটি প্রসেস (সময় ms-এ): P1 (AT ০, BT ৫), P2 (AT ১, BT ৩), P3 (AT ২, BT ৮), P4 (AT ৩, BT ৬). গড় waiting time কত?

৫.৭৫ ms
৭.২৫ ms
৭.৬৭ ms
১১.২৫ ms

(মাঝারি) P1 (AT ০, BT ৭), P2 (AT ২, BT ৪), P3 (AT ৪, BT ১), P4 (AT ৫, BT ৪); সময় ms-এ। Non-preemptive SJF-এ (burst সমান হলে আগে আসা আগে) গড় waiting time কত?

৩.০০ ms
৪.০০ ms
৪.৭৫ ms
৭.০০ ms

(কঠিন) Round Robin, q = ২ ms: P1 (AT ০, BT ৫), P2 (AT ১, BT ৩), P3 (AT ২, BT ১). নিয়ম: একই মুহূর্তে নতুন আগমন আর quantum ফুরানো ঘটলে নতুনটি আগে সারিতে ঢোকে। গড় turnaround time কত?

১.০০ ms
৩.৩৩ ms
৬.৩৩ ms
৭.০০ ms

(মাঝারি) Exponential averaging-এ α = ০.৫, প্রথম অনুমান τ₀ = ১০ ms. পরপর দুটি burst মাপা হলো — প্রথমে ৬ ms, তারপর ৪ ms. এর পরের burst-এর অনুমান τ₂ কত?

৪ ms
৫ ms
৬ ms
৮ ms

(মাঝারি) HRRN-এ এই মুহূর্তে তিনটি প্রসেস অপেক্ষায়: A (অপেক্ষা ৮, burst ৪), B (অপেক্ষা ৯, burst ৬), C (অপেক্ষা ৩, burst ১). কে CPU পাবে?

C, কারণ তার response ratio সবচেয়ে বেশি (৪)
B, কারণ সে সবচেয়ে বেশি অপেক্ষা করেছে
A, কারণ তার ratio ৩
তিনজনের ratio সমান, তাই আগে আসা জন

(সহজ) একটি লম্বা CPU-নির্ভর কাজের পেছনে অনেক ছোট কাজ আটকে থাকে, ফলে গড় অপেক্ষা বেড়ে যায় — এই convoy effect কোন নীতির বৈশিষ্ট্য?

SRTF
Round Robin
MLFQ
FCFS

(মাঝারি) Round Robin-এ ready queue-তে ৫টি প্রসেস, quantum ২০ ms, context switch-এর খরচ উপেক্ষা। একটি প্রসেস নিজের এক পালা শেষ করার পর আবার CPU পেতে সবচেয়ে বেশি কত অপেক্ষা করে?

২০ ms
৮০ ms
১০০ ms
১২০ ms

(মাঝারি) Preemptive priority scheduling (ছোট সংখ্যা = বেশি অগ্রাধিকার; সমান হলে আগে আসা আগে): P1 (AT ০, BT ৬, pr ৩), P2 (AT ১, BT ২, pr ১), P3 (AT ২, BT ৪, pr ৪), P4 (AT ৪, BT ৩, pr ২). গড় waiting time কত?

২.২৫ ms
৩.৫০ ms
৪.৫০ ms
৭.২৫ ms

(মাঝারি) একটি MLFQ-তে Q0 = RR (q ৪ ms), Q1 = RR (q ৮ ms), Q2 = FCFS. নতুন প্রসেস Q0-তে ঢোকে, পুরো quantum খেলে এক স্তর নিচে নামে। ২০ ms burst-এর একটি প্রসেস একা এল, আর কেউ আসেনি। সে Q2-তে কত ms চলবে?

০ ms
৪ ms
৮ ms
১২ ms

(কঠিন) তিনটি periodic task, deadline = period, এক CPU: T1 (c = ১, p = ৪), T2 (c = ২, p = ৬), T3 (c = ১, p = ৮). n = ৩-এ Liu–Layland সীমা প্রায় ০.৭৮০. Rate Monotonic সম্পর্কে কোন সিদ্ধান্ত সঠিক?

U < ১ হলেই RM-এ সব deadline রক্ষা হয়, সীমা দেখার দরকার নেই
U ≈ ০.৭০৮ ≤ ০.৭৮০, তাই RM-এ সব deadline নিশ্চিতভাবে রক্ষা হবে
সীমার নিচে হলেও response-time analysis ছাড়া কিছু বলা যায় না
U সীমার কাছাকাছি, তাই T3 deadline হারাবে

(মাঝারি) এক CPU, deadline = period, preemptive scheduling. নিচের কোন বক্তব্যটি সত্য?

RM সবসময় EDF-এর চেয়ে বেশি task-সেট রক্ষা করতে পারে
RM-এ যে task-এর period সবচেয়ে বড়, সে সবচেয়ে উঁচু অগ্রাধিকার পায়
EDF-এ মোট utilisation ≤ ১ হলেই সব deadline রক্ষা হয়
EDF-এ প্রতিটি task-এর অগ্রাধিকার শুরুতে একবারই স্থির হয়ে যায়

(মাঝারি) একটি Linux CPU-তে দুটি সবসময়-ব্যস্ত task, CFS-এর অধীনে: একটি nice 0 (weight 1024), অন্যটি nice 5 (weight 335). দীর্ঘ সময়ে nice 5-এর task মোটামুটি কত শতাংশ CPU পাবে?

প্রায় ২৪.৭%
প্রায় ৩২.৭%
৫০%
প্রায় ৭৫.৩%

৫ · মডিউল ৪ — কনকারেন্সি ও সিনক্রোনাইজেশন (১৩টি প্রশ্ন)

Race condition থেকে deadlock পর্যন্ত। এখানে প্রশ্নগুলো প্রায়ই একটি ছোট interleaving বা একটি সংখ্যার হিসাব চায়: count-এর সম্ভাব্য মান, Peterson-এ কে ঢোকে, semaphore-এর মান, কমপক্ষে কয়টি resource, Banker's-এর safe sequence. দুটি জোড়া আলাদা রাখুন — mutex বনাম semaphore (মালিকানা), আর deadlock বনাম starvation (কেউই এগোয় না বনাম একজন বঞ্চিত)।

যা ঝালিয়ে নেবেন

পর্ব ২২ · Race condition আর critical section আর পর্ব ২৩ · Hardware support — তিন শর্ত, Peterson, TAS বনাম ticket lock
পর্ব ২৪ · Mutex আর semaphore আর পর্ব ২৫ · Condition variable আর monitor — মালিকানা, ঋণাত্মক মান, Mesa বনাম Hoare
পর্ব ২৬ · ক্লাসিক সমস্যা আর পর্ব ২৭ · Deadlock — bounded buffer, চার শর্ত, n(k − ১) + ১
পর্ব ২৮ · Banker's algorithm আর পর্ব ২৯ · কনকারেন্সির বাগ — safe sequence, priority inversion, ABA

(সহজ) Critical-section সমস্যার সমাধানকে যে তিনটি শর্ত মানতে হয়, নিচের কোনটি তার মধ্যে নেই?

No preemption
Mutual exclusion
Progress
Bounded waiting

(মাঝারি) একটি shared ভ্যারিয়েবল count = ১০. একটি থ্রেড count++ আর আরেকটি count-- একসাথে, কোনো lock ছাড়া চালায় (প্রতিটি = load, বদল আর store-এর তিন ধাপ)। শেষে count-এর সম্ভাব্য সব মান কোনগুলো?

শুধু ১০
৯ বা ১১
৯, ১০ বা ১১
৮ থেকে ১২-এর যেকোনো মান

(কঠিন) Peterson-এর সমাধানে প্রসেস i ঢোকার আগে flag[i] = true; turn = j; লিখে while (flag[j] && turn == j);-এ অপেক্ষা করে। P0 আর P1 দুজনই flag true করল; তারপর P1 আগে turn = 0 লিখল, পরে P0 লিখল turn = 1. কে আগে critical section-এ ঢুকবে?

P0
দুজনই একসাথে
কেউ না — deadlock
P1

(মাঝারি) নিচের কোন lock অপেক্ষারত থ্রেডদের আগমনের ক্রমে (FIFO) সুযোগ দেয়, তাই bounded waiting নিশ্চিত করে?

fetch-and-add দিয়ে বানানো ticket lock
test-and-set (TAS) spinlock
test-and-test-and-set (TTAS) spinlock
interrupt বন্ধ করে বানানো lock

(কঠিন) পাঠ্যবইয়ের সংজ্ঞায় (wait মান ১ কমায়, ঋণাত্মক হলে ডাকা প্রসেস ঘুমায়; signal ১ বাড়ায় আর কেউ ঘুমিয়ে থাকলে একজনকে জাগায়) একটি semaphore-এর শুরুর মান ৩. বিভিন্ন প্রসেস মোট ৭টি wait আর ২টি signal করল। এখন semaphore-এর মান আর ঘুমন্ত প্রসেসের সংখ্যা কত?

মান ০, ঘুমন্ত ০
মান −২, ঘুমন্ত ২
মান −২, ঘুমন্ত ০
মান ২, ঘুমন্ত ২

(সহজ) ১০ ঘরের একটি bounded buffer-এর পাঠ্যবইয়ের সমাধানে mutex, empty আর full semaphore-এর শুরুর মান যথাক্রমে কত?

১, ০, ১০
১, ১০, ০
০, ১০, ০
১০, ১, ০

(মাঝারি) Mutex আর binary semaphore-এর পার্থক্য নিয়ে কোন বক্তব্যটি সঠিক?

দুটি হুবহু একই, শুধু নাম আলাদা
binary semaphore সবসময় spin করে, mutex সবসময় ঘুমায়
mutex-এর মালিক আছে — যে lock করেছে শুধু সে-ই unlock করে, তাই priority inheritance সম্ভব; semaphore-এর মালিক নেই, যেকোনো থ্রেড signal দিতে পারে
mutex দিয়ে একাধিক একই রকম সম্পদ (যেমন ৩টি প্রিন্টার) গোনা যায়

(সহজ) pthreads আর Java-র wait/notify-সহ আজকের প্রায় সব সিস্টেমের condition variable কোন semantics মানে, আর তাই wait কোথায় লিখতে হয়?

Hoare semantics — তাই একটি if-ই যথেষ্ট
Mesa semantics — signal শুধু একটি ইঙ্গিত, তাই wait সবসময় while লুপে
Mesa semantics — তাই একটি if-ই যথেষ্ট
Hoare semantics — তাই wait-এর আগে নিজে mutex ছেড়ে দিতে হয়

(মাঝারি) “প্রতিটি প্রসেস কাজ শুরুর আগেই দরকারি সব resource একসাথে চেয়ে নেবে; সব না পেলে কিছুই ধরে রাখবে না” — এই নিয়ম deadlock-এর কোন শর্তটি সরাসরি ভাঙে?

Mutual exclusion
No preemption
Hold and wait
Circular wait

(কঠিন) একটি সিস্টেমে একই ধরনের ৬টি tape drive. প্রতিটি প্রসেসের সর্বোচ্চ ৩টি লাগে, আর drive একটি একটি করে চাওয়া হয়। deadlock কখনো হবে না — এমন নিশ্চয়তা রেখে সর্বোচ্চ কতটি প্রসেস চালানো যায়?

(কঠিন) Banker's algorithm, তিন ধরনের resource (A, B, C). Available = (২, ৩, ১). Max: P0 (৫, ৩, ২), P1 (৩, ২, ২), P2 (৯, ০, ২), P3 (২, ২, ২). Allocation: P0 (১, ১, ০), P1 (২, ০, ০), P2 (৩, ০, ২), P3 (২, ১, ১). Safety algorithm প্রতিবার সবচেয়ে ছোট index-এর যোগ্য প্রসেস বাছলে কোন safe sequence পাওয়া যায়?

P3, P1, P0, P2
P3, P0, P1, P2
P1, P3, P0, P2
কোনো safe sequence নেই — অবস্থা unsafe

(মাঝারি) ১৯৯৭ সালে মঙ্গলের মাটিতে Mars Pathfinder বারবার নিজে থেকে রিসেট হচ্ছিল। কারণ আর প্রতিকার হিসেবে সাধারণত কী বলা হয়?

Deadlock — দুটি task পরস্পরের lock-এর অপেক্ষায়; প্রতিকার lock-ক্রম বদলানো
Memory leak — মেমরি ফুরিয়ে যাচ্ছিল; প্রতিকার garbage collector
Race condition — দুটি task একসাথে একটি counter বদলাচ্ছিল; প্রতিকার volatile
Priority inversion — নিম্ন task-এর ধরা mutex-এর অপেক্ষায় উচ্চ task, আর মাঝারি task নিম্নটিকে CPU পেতে দিচ্ছিল না; প্রতিকার priority inheritance চালু করা

(কঠিন) একটি lock-free stack-এ একটি থ্রেডের CAS(top, A, B) সফল হলো, যদিও মাঝে অন্য থ্রেড A আর B দুটিই pop করে, B-এর মেমরি মুক্ত করে, আবার A push করেছিল। এই সমস্যার নাম আর একটি প্রচলিত প্রতিকার কোনটি?

ABA সমস্যা; pointer-এর সাথে একটি version tag (counter) রেখে CAS করা
Priority inversion; priority inheritance
Deadlock; সব থ্রেড একই ক্রমে lock নেবে
False sharing; ভ্যারিয়েবলগুলো আলাদা cache line-এ রাখা

৬ · মডিউল ৫ — মেমরি ম্যানেজমেন্ট (১৫টি প্রশ্ন)

কোর্সের সবচেয়ে বেশি numerical এই মডিউলে: ঠিকানার অনুবাদ (base-limit, page, segment, two-level), fit কৌশল, EAT (TLB আর page fault — দুটি আলাদা সূত্র), page replacement আর frame allocation. হিসাব শুরুর আগে bit ভাগ করে লিখুন (কত bit page number, কত bit offset), আর hex ঠিকানা hex অঙ্কের সীমায় নয়, bit-এর সীমায় ভাঙুন। internal আর external fragmentation-এর পার্থক্য প্রায় প্রতিটি পরীক্ষায় আসে।

যা ঝালিয়ে নেবেন

পর্ব ৩০ · মেমরির ভিত্তি আর পর্ব ৩১ · Contiguous allocation — binding, base-limit, চার fit, buddy
পর্ব ৩২ · Paging, পর্ব ৩৩ · TLB আর বড় page table আর পর্ব ৩৪ · Segmentation — bit ভাগ, hex অনুবাদ, EAT, ১০/১০/১২
পর্ব ৩৫ · Virtual memory আর পর্ব ৩৬ · Page replacement — page fault-এর EAT, FIFO/OPT/LRU, Belady
পর্ব ৩৭ · Thrashing আর working set আর পর্ব ৩৮ · Linux-এ মেমরি — proportional allocation, RSS বনাম PSS

(সহজ) একটি সরল MMU-তে relocation register = ১২০০০ আর limit = ২০০০. প্রোগ্রাম logical ঠিকানা ২৫০ ব্যবহার করলে কোন physical ঠিকানায় যাবে?

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

(মাঝারি) একটি প্রসেসের base register = ৫০০০ আর limit register = ২০০০. CPU-র তৈরি নিচের কোন ঠিকানায় trap হবে?

৫০০০
৬৫০০
৬৯৯৯
৭০০০

(মাঝারি) কোন সময়ে address binding হলে compiler-কে relocatable code বানাতে হয়, আর প্রোগ্রাম মেমরিতে বসানোর সময় চূড়ান্ত ঠিকানা ঠিক হয় — কিন্তু চলার মাঝে প্রসেসকে সরানো যায় না?

Compile time
Execution time
Load time
যেকোনো সময়ে — কারণ সব binding-এই MMU লাগে

(মাঝারি) ঠিকানার ক্রমে খালি জায়গা (hole): ১০০K, ৫০০K, ২০০K, ৩০০K, ৬০০K. অনুরোধ আসে ক্রমে ২১২K, ৪১৭K, ১১২K, ৪২৬K. First fit-এ কোন অনুরোধটি জায়গা পায় না?

২১২K
৪১৭K
১১২K
৪২৬K

(মাঝারি) Page size ৪ KiB (৪০৯৬ byte). ১০,০০০ byte-এর একটি প্রসেস কয়টি page পাবে, আর কোন ধরনের অপচয় কত হবে?

২টি page; external fragmentation ১৮০৮ byte
৩টি page; internal fragmentation ২২৮৮ byte
৩টি page; external fragmentation ২২৮৮ byte
৩টি page; কোনো অপচয় নেই

(মাঝারি) Logical ঠিকানা ১৬ bit আর page size ১ KiB হলে logical address space-এ কয়টি page, আর offset কত bit?

১৬টি page, ১২-bit offset
৬৪টি page, ৬-bit offset
৬৪টি page, ১০-bit offset
১০২৪টি page, ৬-bit offset

(মাঝারি) Page size ৪ KiB. একটি প্রসেসের page table-এ page ৫ → frame 0x2C. Logical ঠিকানা 0x5ABC-এর physical ঠিকানা কত?

0x2CABC
0x5ABC
0x2C5ABC
0x31ABC

(মাঝারি) Main memory access ১০০ ns, TLB lookup ১০ ns, TLB hit ratio ৯০%, এক স্তরের page table. TLB lookup-এর সময় hit আর miss দুই পথেই গুনলে effective access time কত?

১১০ ns
১১৯ ns
১২০ ns
২১০ ns

(কঠিন) ৩২-bit two-level page table, বিভাজন ১০/১০/১২. Virtual ঠিকানা 0x00C02ABC-এর outer index, inner index আর offset কত?

৩, ২, 0xABC
০, 0xC02, 0xABC
১২, ২, 0xABC
৩, 0xC02, 0xABC

(মাঝারি) Segment table: segment ০ (base ২১৯, limit ৬০০), segment ১ (base ২৩০০, limit ১৪). Logical ঠিকানা ⟨১, ১৪⟩-এর ফল কী?

physical ঠিকানা ২৩১৪
physical ঠিকানা ২৩১৩
trap — offset সীমার বাইরে
physical ঠিকানা ২৩৩

(মাঝারি) Memory access time ২০০ ns, page-fault service time ৮ ms, আর প্রতি ১০০০ access-এ একটি page fault (p = ০.০০১)। Effective access time প্রায় কত?

২০০ ns
২০৭.৮ ns
প্রায় ৮.২ µs
৮ ms

(মাঝারি) Reference string 1, 2, 3, 4, 2, 1, 5, 6, 2, 1, 2, 3, 7, 6, 3, 2, 1, 2, 3, 6; ৩টি frame, শুরুতে খালি। LRU-তে কতটি page fault হবে?

১১
১৪
১৫
১৬

(মাঝারি) frame-সংখ্যা বাড়ালে page fault বেড়ে যাওয়ার ঘটনা (Belady's anomaly) নিচের কোন নীতিতে ঘটতে পারে?

LRU
OPT
LRU আর OPT দুটিতেই, কিন্তু FIFO-তে নয়
FIFO

(মাঝারি) মোট ৬৪টি frame, দুটি প্রসেস — একটি ১৬ page-এর, আরেকটি ১১২ page-এর। Proportional allocation-এ তারা কয়টি করে frame পাবে?

৮ আর ৫৬
৩২ আর ৩২
১৬ আর ৪৮
১৬ আর ১১২

(মাঝারি) ৪টি Linux প্রসেস একটি ৮ MiB shared library ভাগ করে (পুরোটা RAM-এ), আর প্রত্যেকের নিজস্ব ২ MiB মেমরি RAM-এ। একটি প্রসেসের RSS আর PSS কত?

RSS ২ MiB, PSS ২ MiB
RSS ১০ MiB, PSS ৪ MiB
RSS ১০ MiB, PSS ১০ MiB
RSS ৪ MiB, PSS ১০ MiB

নিজে মিলিয়ে দেখুন — page fault আর head movement

এই পাতার numerical-গুলো ছোট প্রোগ্রামে যাচাই করা, আর তার একটি অংশ এখানে চালিয়ে দেখতে পারেন। নিচের কোড মডিউল ৫-এর reference string-এ ৩ আর ৪টি frame দিয়ে FIFO, LRU আর OPT-এর fault গোনে, Belady-র বিখ্যাত string-এ FIFO-র anomaly দেখায়, আর পরের মডিউলের ডিস্ক-প্রশ্নের SSTF ও C-LOOK-এর মোট head movement বের করে। আগে খাতায় উত্তর লিখুন, তারপর চালান।

// Re-check two kinds of MCQ numericals on this page: page faults and disk head movement.
function faults(ref, n, kind) {
  let fr = [], f = 0;
  const last = {};
  ref.forEach((x, t) => {
    if (!fr.includes(x)) {
      f++;
      if (fr.length === n) {
        let v = fr[0];                                        // FIFO: oldest arrival
        if (kind === "LRU") v = fr.reduce((a, b) => (last[a] < last[b] ? a : b));
        if (kind === "OPT") {                                 // farthest next use (never = best)
          const next = y => { const i = ref.indexOf(y, t + 1); return i < 0 ? Infinity : i; };
          v = fr.reduce((a, b) => (next(b) > next(a) ? b : a));
        }
        fr = fr.filter(y => y !== v);
      }
      fr.push(x);
    }
    last[x] = t;
  });
  return f;
}
const R = [1,2,3,4,2,1,5,6,2,1,2,3,7,6,3,2,1,2,3,6];
for (const n of [3, 4]) console.log(n + " frames: FIFO " + faults(R, n, "FIFO") + ", LRU " + faults(R, n, "LRU") + ", OPT " + faults(R, n, "OPT"));
const B = [1,2,3,4,1,2,5,1,2,3,4,5];
console.log("Belady string, FIFO: 3 frames " + faults(B, 3, "FIFO") + ", 4 frames " + faults(B, 4, "FIFO"));
const move = (head, path) => path.reduce((s, c) => { s.t += Math.abs(c - s.h); s.h = c; return s; }, { t: 0, h: head }).t;
console.log("SSTF  50 -> 43 24 16 82 140 170 190 : " + move(50, [43, 24, 16, 82, 140, 170, 190]));
console.log("C-LOOK with jump : " + move(50, [82, 140, 170, 190, 16, 24, 43]) + ", without jump: " + (move(50, [82, 140, 170, 190]) + move(16, [24, 43])));

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

3 frames: FIFO 16, LRU 15, OPT 11
4 frames: FIFO 14, LRU 10, OPT 8
Belady string, FIFO: 3 frames 9, 4 frames 10
SSTF  50 -> 43 24 16 82 140 170 190 : 208
C-LOOK with jump : 341, without jump: 167

প্রথম লাইন মডিউল ৫-এর LRU-প্রশ্নের উত্তর (১৫) আর তার দুটি distractor-এর উৎস — FIFO ১৬, OPT ১১. দ্বিতীয় লাইনে ৪টি frame-এ সব সংখ্যা কমেছে (১৪, ১০, ৮), কিন্তু এটি নিশ্চয়তা নয়: তৃতীয় লাইনে Belady-র string-এ FIFO ৩ frame-এ ৯ আর ৪ frame-এ ১০টি fault দেয় — frame বেড়েছে, fault-ও বেড়েছে। শেষ দুই লাইন মডিউল ৬-এর ডিস্ক-প্রশ্নের: SSTF ২০৮, আর C-LOOK লাফসহ ৩৪১, লাফ বাদে ১৬৭. কোডে reference string বা অনুরোধের সারি বদলে নিজের বইয়ের অঙ্কও মিলিয়ে নিতে পারেন — তবে আগে হাতে করুন, কারণ পরীক্ষার হলে কোড চলে না।

৭ · মডিউল ৬ — I/O, স্টোরেজ ও ফাইল সিস্টেম (১৪টি প্রশ্ন)

Interrupt থেকে RAID পর্যন্ত। ডিস্ক-scheduling-এর প্রশ্নে head-এর দিক আর লাফ গোনার রীতি আগে লিখুন; inode-এর প্রশ্নে প্রথমে বের করুন এক block-এ কয়টি pointer আঁটে। আর file system-এর প্রশ্নে তিনটি জিনিস আলাদা রাখুন — নাম (directory-তে), inode (ফাইলের পরিচয়পত্র) আর খোলা ফাইলের offset (open-file table-এ)। Hard link আর symbolic link-এর পার্থক্য এই কাঠামো থেকেই আসে।

যা ঝালিয়ে নেবেন

পর্ব ৩৯ · I/O system আর পর্ব ৪০ · ডিস্ক আর SSD — polling বনাম interrupt, top/bottom half, rotational latency, SSTF থেকে C-LOOK, write amplification
পর্ব ৪১ · ফাইল আর পর্ব ৪২ · Directory, link আর mounting — তিন স্তরের টেবিল, তিন সময়, link count, hard বনাম soft
পর্ব ৪৩ · File system-এর ভেতর আর পর্ব ৪৪ · Crash consistency — inode-এর সর্বোচ্চ আকার, bitmap, journal replay
পর্ব ৪৫ · RAID — লেভেলভেদে ধারণক্ষমতা, small-write penalty, RAID backup নয়

(মাঝারি) একটি দ্রুত network card-এ প্রতি সেকেন্ডে লাখ লাখ প্যাকেট আসে। প্রতিটি প্যাকেটে একটি করে interrupt দিলে কী সমস্যা হয়, আর Linux-এর প্রচলিত সমাধান কী?

কোনো সমস্যা নেই — interrupt সবসময় polling-এর চেয়ে দক্ষ
interrupt সামলাতেই CPU-র বেশিরভাগ সময় চলে যায়; NAPI ভিড়ের সময় interrupt বন্ধ রেখে polling-এ একসাথে অনেক প্যাকেট তোলে
DMA বন্ধ করে CPU দিয়ে প্রতিটি বাইট কপি করাই সমাধান
প্রতিটি প্যাকেটের জন্য আলাদা thread তৈরি করাই সমাধান

(মাঝারি) নিচের কোন জায়গায় Linux kernel-এর কোড ঘুমাতে পারে (যেমন mutex-এর অপেক্ষায়)?

workqueue-র কাজের ফাংশনে
top half, অর্থাৎ hard IRQ handler-এ
softirq বা tasklet-এ
spinlock ধরে থাকা অবস্থায়

(সহজ) Linux-এ নিচের কোনটি block device?

কিবোর্ড
serial port (/dev/ttyS0)
Ethernet card (eth0)
NVMe SSD (/dev/nvme0n1)

(মাঝারি) ১৫,০০০ RPM-এ ঘোরা একটি হার্ড ডিস্কের গড় rotational latency কত?

১ ms
২ ms
৪ ms
৮.৩৩ ms

(মাঝারি) Cylinder ০–১৯৯-এর ডিস্কে head ৫০-এ। অনুরোধের সারি: ৮২, ১৭০, ৪৩, ১৪০, ২৪, ১৬, ১৯০. SSTF-এ (দূরত্ব সমান হলে ছোট cylinder আগে) মোট head movement কত?

২০৮
৩১৪
৩৩২
৬৪২

(কঠিন) একই সারি (head ৫০; ৮২, ১৭০, ৪৩, ১৪০, ২৪, ১৬, ১৯০; cylinder ০–১৯৯), head বড় cylinder-এর দিকে যাচ্ছে। C-LOOK-এ ফেরার লাফ (১৯০ → ১৬) গুনলে আর না গুনলে মোট head movement কত?

৩৪১ আর ১৬৭
৩৯১ আর ১৯২
৩১৪ আর ১৪০
৩৪১ আর ৩৪১

(মাঝারি) একটি SSD-তে garbage collection-এর সময় victim block-এর গড়ে ৮০% page বৈধ থাকে। সরল মডেল WA = ১ ÷ (১ − u) অনুযায়ী write amplification কত?

০.২
১.২৫
৪
৫

(মাঝারি) একটি প্রসেস একটি ফাইল খুলে fd 3 পেল, তারপর fork করল। child fd 3 দিয়ে ১০০ byte পড়ে শেষ হলো। এরপর parent fd 3 দিয়ে পড়লে ফাইলের কোন offset থেকে পড়বে?

০
১০০
২০০
ঠিক বলা যায় না, প্রতিবার আলাদা

(মাঝারি) Linux-এ echo hi >> notes.txt দিয়ে একটি পুরোনো ফাইলের শেষে লেখা যোগ করা হলো। ফাইলের কোন সময়গুলো বদলাবে?

শুধু mtime
শুধু ctime
mtime আর ctime
atime আর birth time

(সহজ) ext4-এ একটি directory-র ভেতরে ৪টি sub-directory আর ২০টি সাধারণ ফাইল। ওই directory-র link count সাধারণত কত?

২
৬
২৪
২৬

(মাঝারি) Hard link আর symbolic link নিয়ে নিচের কোন বক্তব্যটি মিথ্যা?

আসল নাম মুছলে hard link দিয়ে ডেটা পড়া যায়, কিন্তু symlink ঝুলে যায়
Symbolic link-এর নিজস্ব inode আছে, যার ভেতরে একটি path লেখা থাকে
সাধারণ ব্যবহারে directory-র hard link বানানো যায় না
Hard link অন্য file system-এর একটি ফাইলকেও দেখাতে পারে

(কঠিন) Block ১ KiB, block pointer ৪ byte. Inode-এ ১২টি direct, ১টি single indirect আর ১টি double indirect pointer (triple নেই)। সর্বোচ্চ ফাইল-আকার প্রায় কত?

২৬৮ KiB
প্রায় ৬৪.৩ MiB
প্রায় ১৬ GiB
প্রায় ৪ TiB

(মাঝারি) Journaling file system-এ একটি transaction-এর TxB, বদলানো metadata আর commit block (TxE) journal-এ স্থায়ীভাবে লেখা হয়েছে, কিন্তু checkpoint (আসল জায়গায় লেখা) শেষ হওয়ার আগে বিদ্যুৎ চলে গেল। পরের বুটে recovery কী করবে?

journal থেকে transaction-টি আবার চালাবে (replay), ফলে বদলগুলো আসল জায়গায় পৌঁছাবে
transaction-টি বাদ দেবে, কারণ checkpoint হয়নি
পুরো ডিস্কে fsck চালাতে হবে
কিছুই করবে না; বদলগুলো হারিয়ে যাবে

(মাঝারি) ৬টি ২ TB ডিস্ক দিয়ে RAID 6 অ্যারে বানানো হলো। ব্যবহারযোগ্য ধারণক্ষমতা কত, আর একসাথে কয়টি ডিস্ক নষ্ট হওয়া সয়?

১২ TB, ০টি
১০ TB, ১টি
৮ TB, যেকোনো ২টি
৬ TB, যেকোনো ৩টি

৮ · মডিউল ৭ — সুরক্ষা ও নিরাপত্তা (১২টি প্রশ্ন)

Access matrix থেকে SELinux. Linux permission-এর প্রশ্নে অঙ্কগুলো bit হিসেবে ভাবুন (r = ৪, w = ২, x = ১), umask-কে বিয়োগ নয়, বিট মোছা হিসেবে, আর মনে রাখুন kernel একটিমাত্র শ্রেণি (owner, group বা other) দেখে। নিরাপত্তার প্রশ্নগুলো এখানে প্রতিরক্ষার দিক থেকে — কোন ব্যবস্থা কী থামায়, আর ঝামেলা হলে নিরাপদ সমাধান কোনটি।

যা ঝালিয়ে নেবেন

পর্ব ৪৬ · Protection — domain, access matrix, ACL বনাম capability
পর্ব ৪৭ · Linux-এ user, group আর permission — chmod, umask, setuid, sticky bit
পর্ব ৪৮ · OS নিরাপত্তা — CIA triad, salt আর ধীর hash, ASLR, NX, canary, KPTI
পর্ব ৪৯ · Sandbox আর mandatory access control — Bell–LaPadula বনাম Biba, SELinux-এর denial

(সহজ) Protection আর security-র পার্থক্য কোন বাক্যে সবচেয়ে সঠিক?

দুটি একই জিনিস
Protection হলো ভেতরের mechanism — কোন প্রসেস কোন resource-এ কী করতে পারবে; security হলো হুমকির বিরুদ্ধে পুরো সিস্টেমের সুরক্ষা, authentication আর encryption-সহ
Protection শুধু নেটওয়ার্কের জন্য, security শুধু ফাইলের জন্য
Security hardware-এর কাজ, protection software-এর

(মাঝারি) Access matrix-এর সারি = domain, কলাম = object. Capability list matrix-এর কোন অংশ, আর বাস্তবে তার একটি চেনা উদাহরণ কী?

একটি কলাম; যেমন Unix-এর rwx বিট
একটি ঘর; যেমন /etc/passwd
একটি সারি — একটি domain-এর সব অধিকার; যেমন Unix-এর file descriptor
পুরো matrix; যেমন global table

(সহজ) chmod 754 report.sh-এর পর ls -l-এ অনুমতি কেমন দেখাবে?

-rwxr-xr--
-rwxr--r-x
-rw-r-xr--
-rwxrwxr--

(কঠিন) umask 026 থাকা অবস্থায় mkdir shared চালানো হলো (mkdir mode 0777 চায়)। নতুন directory-র mode কত?

640
750
751
755

(মাঝারি) ফাইল ----rw---- sumi staff; sumi নিজে staff group-এর সদস্য। sumi ফাইলটি পড়তে চাইলে কী হবে?

পড়তে পারবেন, কারণ তিনি group-এর সদস্য আর group-এর r আছে
পড়তে পারবেন, কারণ owner সবসময় সব পারেন
Permission denied — owner মিলে গেলে শুধু owner-এর বিট (---) দেখা হয়
সাধারণ ব্যবহারকারীর ক্ষেত্রে অনুমতি যাচাই হয় না, শুধু root-এর হয়

(মাঝারি) ls -l /usr/bin/passwd দেখায় -rwsr-xr-x root root. owner-এর ঘরের ‘s’ কী বোঝায়?

setuid বিট বসানো (execute-ও আছে) — চালালে প্রসেসের effective UID হয় ফাইলের মালিক root
sticky বিট — শুধু মালিক ফাইলটি মুছতে পারেন
ফাইলটি একটি socket
setgid বিট — চালালে group-এর অধিকার পায়

(মাঝারি) একটি shared ফোল্ডারে সবাই ফাইল রাখতে পারবেন, কিন্তু কেউ অন্যের ফাইল মুছতে পারবেন না — Linux-এ ফোল্ডারটির কোন mode সবচেয়ে উপযুক্ত?

0777
1777
2775
0755

(সহজ) একটি ওয়েবসাইটে লাখ লাখ ভুয়া অনুরোধ পাঠিয়ে (DDoS) সাইটটি বসিয়ে দেওয়া হলো; কোনো তথ্য চুরি বা বদল হয়নি। CIA triad-এর কোন দিক ক্ষতিগ্রস্ত?

Confidentiality
Availability
Integrity
Authentication

(মাঝারি) নতুন একটি সিস্টেমে ব্যবহারকারীর পাসওয়ার্ড সংরক্ষণের সবচেয়ে উপযুক্ত পদ্ধতি কোনটি?

salt ছাড়া SHA-256 hash
AES দিয়ে encrypt করে key একই সার্ভারে রাখা
সরাসরি লেখা রাখা, কিন্তু ফাইলটি শুধু root পড়তে পারবে
প্রতিটি ব্যবহারকারীর আলাদা এলোমেলো salt-সহ Argon2id বা bcrypt-এর মতো ইচ্ছাকৃত ধীর hash

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

NX — stack-এ buffer overflow পুরোপুরি অসম্ভব করে
ASLR — কোড, stack আর library-র ঠিকানা প্রতিবার এলোমেলো করে, তাই আক্রমণকারী আগে থেকে ঠিকানা সহজে জানতে পারে না
Stack canary — heap-এর use-after-free ধরে
KPTI — পাসওয়ার্ড অনুমানের আক্রমণ আটকায়

(মাঝারি) Biba integrity model-এর নিয়ম দুটি কী?

no read down আর no write up
no read up আর no write down
no read up আর no write up
মালিক যা চান, তা-ই

(মাঝারি) একটি Linux সার্ভারে নতুন বসানো ওয়েব অ্যাপ SELinux-এর কারণে একটি ফোল্ডার পড়তে পারছে না, আর audit log-এ AVC denial দেখা যাচ্ছে। সবচেয়ে সঠিক পদক্ষেপ কোনটি?

setenforce 0 দিয়ে SELinux স্থায়ীভাবে বন্ধ রাখা
ফোল্ডারে chmod -R 777 দেওয়া
audit log-এর AVC বার্তা পড়ে ফোল্ডারের label ঠিক করা (যেমন semanage fcontext আর restorecon), বা দরকারি নীতি যোগ করা
অ্যাপটিকে root হিসেবে চালানো

৯ · মডিউল ৮ — ভার্চুয়ালাইজেশন, কনটেইনার ও আধুনিক OS (১৩টি প্রশ্ন)

Hypervisor, container, cloud, distributed system আর মোবাইল OS. এই মডিউলে সবচেয়ে বড় পার্থক্য একটিই — কে কোন kernel ভাগ করছে। VM নিজের guest kernel চালায়; container host-এর kernel ভাগ করে চলা প্রসেস, যাকে namespace আলাদা দৃশ্য দেয় আর cgroup সীমা বেঁধে দেয়। numerical এখানে কম, কিন্তু যা আছে (EPT-র walk, cgroup-এর throttling, DVFS-এর শক্তি) তাতে একটি করে গুণের ফাঁদ।

যা ঝালিয়ে নেবেন

পর্ব ৫০ · Virtual machine আর hypervisor — type 1 বনাম 2, Popek–Goldberg, EPT, live migration
পর্ব ৫১ · Container-এর ভেতর আর পর্ব ৫২ · VM, container, microVM আর serverless — আটটি namespace, cpu.max, Firecracker
পর্ব ৫৩ · Distributed system-এর OS-দিক — Lamport আর vector clock, Ricart–Agrawala
পর্ব ৫৪ · মোবাইল, embedded আর real-time OS — Zygote, Jetsam, DVFS-এর V²

(সহজ) নিচের কোনটি type 1 (bare-metal) hypervisor?

Oracle VirtualBox
VMware Workstation
KVM ছাড়া, শুধু অনুকরণে চলা QEMU
VMware ESXi

(মাঝারি) VT-x/AMD-V আসার আগে x86-কে কেন শুধু trap-and-emulate দিয়ে virtualize করা যেত না?

কিছু sensitive instruction (যেমন POPF) privileged ছিল না — কম ক্ষমতায় চালালে trap না করে চুপচাপ অন্যভাবে চলত
x86-এ কোনো privileged instruction-ই ছিল না
x86-এর মেমরি খুব কম ছিল
x86-এ interrupt-এর ব্যবস্থা ছিল না

(কঠিন) EPT/NPT-সহ একটি VM-এ guest আর host দুটিই চার স্তরের page table ব্যবহার করে। TLB আর page-walk cache খালি থাকলে একটি guest ঠিকানার ডেটা আনতে সবচেয়ে বেশি কতবার মেমরিতে যেতে হয় — ডেটা পড়াসহ?

৫
৮
২৪
২৫

(মাঝারি) Paravirtualization-এর মূল ধারণা কোনটি?

guest OS একদম না বদলে আসল হার্ডওয়্যারের পুরো অনুকরণে চলে
guest OS জানে সে VM-এ চলছে, আর sensitive কাজ বা I/O-র জন্য hypercall বা virtio-র মতো বিশেষ interface দিয়ে সরাসরি hypervisor-কে ডাকে
একাধিক OS একই kernel ভাগ করে চলে
hypervisor guest-এর প্রতিটি instruction অনুবাদ করে চালায়

(মাঝারি) একটি VM-এর ১৬ GB মেমরি ১০ Gbps (প্রায় ১২৫০ MB/s) লিংকে pre-copy live migration-এ সরানো হচ্ছে। কোন অবস্থায় migration কখনো ছোট অবশিষ্টাংশে পৌঁছাবে না?

VM-এর মেমরি ১৬ GB-এর বেশি হলে
VM-এ কোনো প্রোগ্রাম চালু না থাকলে
VM প্রতি সেকেন্ডে লিংকের গতির চেয়ে বেশি মেমরি বদলালে, যেমন ২০০০ MB/s
VM প্রতি সেকেন্ডে ১০০ MB মেমরি বদলালে

(সহজ) Container আর virtual machine-এর মূল পার্থক্য কোনটি?

Container-এর ভেতরে নিজের আলাদা Linux kernel বুট হয়
VM সবসময় container-এর চেয়ে দ্রুত চালু হয়
Container শুধু Windows-এ চলে
Container host-এর kernel ভাগ করে চলা প্রসেস (namespace + cgroup); VM hypervisor-এর ওপর নিজের guest kernel চালায়

(মাঝারি) কোন Linux namespace একটি container-কে নিজের network interface, routing table আর port-এর আলাদা জগৎ দেয়?

(কঠিন) একটি container-এর cgroup v2-এ cpu.max = 50000 100000 (প্রতি ১০০ ms-এ ৫০ ms CPU-কোটা)। ভেতরের প্রোগ্রামের ২টি thread দুটি অলস CPU-তে একটানা ব্যস্ত। প্রতিটি ১০০ ms period-এ কী ঘটবে?

৫০ ms চলবে, তারপর ৫০ ms থামবে
২৫ ms চলবে, তারপর বাকি ৭৫ ms পুরো দল থামানো (throttled) থাকবে
পুরো ১০০ ms চলবে, কারণ CPU দুটি
১২.৫ ms চলবে, ৮৭.৫ ms থামবে

(মাঝারি) AWS Lambda-র মতো serverless প্ল্যাটফর্মে ব্যবহৃত Firecracker কী?

একটি container image-এর ফরম্যাট
একটি microVM monitor — KVM-এর ওপর ন্যূনতম virtual ডিভাইসের হালকা VM, যা খুব দ্রুত চালু হয় আর কম মেমরি নেয়
Linux-এর একটি scheduling class
একটি user-space kernel, যা অ্যাপের syscall ধরে নিজে সামলায়

(মাঝারি) তিন প্রসেসের সিস্টেমে ঘটনা a-র vector clock [১, ২, ০] আর ঘটনা b-র [২, ২, ৩]. সম্পর্ক কী?

b → a
a আর b concurrent
a → b (a, b-র আগে ঘটেছে)
vector clock দিয়ে বলা যায় না, Lamport clock লাগবে

(মাঝারি) Ricart–Agrawala algorithm-এ ৮টি প্রসেস থাকলে একবার critical section-এ ঢুকতে মোট কতটি বার্তা লাগে? আর centralised পদ্ধতিতে?

১৪ আর ৩
১৬ আর ২
৭ আর ৩
১৪ আর ১

(কঠিন) একটি CPU ১.১ V-এ ২ GHz থেকে ০.৯ V-এ ১ GHz-এ নামানো হলো। P = C·V²·f মডেলে একটি নির্দিষ্ট কাজ শেষ করতে dynamic শক্তি আগের তুলনায় প্রায় কত গুণ? (static খরচ উপেক্ষা)

০.৩৩
০.৫০
০.৬৭
০.৮২

(সহজ) Android-এ নতুন অ্যাপের প্রসেস সাধারণত কীভাবে তৈরি হয়?

প্রতিবার নতুন করে পুরো runtime বুট করে
Jetsam নতুন প্রসেস বানায়
Linux kernel সরাসরি APK ফাইল exec করে
আগে থেকে runtime আর সাধারণ class preload করে রাখা Zygote প্রসেস fork করে

১০ · মডিউল ৯ — বাস্তব OS ও ক্যাপস্টোন (১২টি প্রশ্ন)

Linux kernel, Windows NT, পারফরম্যান্সের তদন্ত, xv6 আর ক্যাপস্টোনের allocator. এখানে প্রশ্নগুলো “বাস্তব সিস্টেম” ধাঁচের: কোন OS-এ কোন নিয়ম, কোন টুল কখন, কোন সংখ্যা আসলে কী বোঝায়। Linux আর Windows-এর শব্দ গুলিয়ে ফেলবেন না — fd আর handle, overcommit আর commit limit, eBPF আর ETW আলাদা জগতের।

যা ঝালিয়ে নেবেন

পর্ব ৫৫ · Linux kernel-এর ভেতরে — kernel-কোডের নিয়ম, container_of, eBPF verifier
পর্ব ৫৬ · Windows-এর ভেতর — handle, reserve বনাম commit, WSL1 বনাম WSL2
পর্ব ৫৭ · পারফরম্যান্স আর observability — USE, M/M/1, iowait, প্রথম ৬০ সেকেন্ড
পর্ব ৫৮ · xv6 আর পর্ব ৫৯ · ক্যাপস্টোন — a7, Sv39, buddy-র XOR, boundary tag

(সহজ) Linux kernel-এর ভেতরে কোড লেখার নিয়ম নিয়ে কোনটি সত্য?

kernel-এর stack user প্রোগ্রামের মতো দরকারমতো বড় হয়
kernel-এ সাধারণ C library (printf, malloc) নেই — বদলে printk, kmalloc-এর মতো kernel-এর নিজস্ব ফাংশন
kernel-কোড যেকোনো জায়গায় নির্ভয়ে floating point ব্যবহার করতে পারে
interrupt handler-এর ভেতরে mutex নিয়ে ঘুমানো যায়

(মাঝারি) একটি eBPF প্রোগ্রাম kernel-এ লোড করার আগে verifier মূলত কী নিশ্চিত করে?

প্রোগ্রামটি দ্রুত চলবে
প্রোগ্রামটি user mode-এ চলবে
প্রতিটি সম্ভাব্য পথে মেমরি-প্রবেশ সীমার ভেতরে, pointer-এর NULL-যাচাই আছে, লুপ শেষ হয়, আর শুধু অনুমোদিত helper ডাকা হয়
প্রোগ্রামটির লেখক root

(কঠিন) x86-64-এ struct job { int id; int prio; char name[8]; struct list_head link; }; — list_head-এ দুটি pointer. একটি তালিকায় হাঁটার সময় p = 0x3010, যা একটি job-এর link member-এর ঠিকানা। container_of(p, struct job, link) কী দেবে?

0x3000
0x3008
0x3010
0x3020

(মাঝারি) Windows-এর handle নিয়ে কোন বক্তব্যটি সঠিক?

handle প্রসেস-নিজস্ব একটি সূচক, যা ফাইল ছাড়াও প্রসেস, thread, event, registry key-র মতো যেকোনো kernel object দেখাতে পারে
handle একটি global সংখ্যা — এক প্রসেসের handle অন্য প্রসেসে হুবহু কাজ করে
handle আসলে object-এর kernel-মেমরির ঠিকানা
সব handle বন্ধ হলেই object সঙ্গে সঙ্গে মোছে, kernel-এর reference থাকলেও

(মাঝারি) একটি Windows যন্ত্রে RAM ৮ GiB, pagefile ৪ GiB (স্থির আকার), বর্তমান commit charge ১০ GiB. একটি প্রোগ্রাম VirtualAlloc দিয়ে ৩ GiB MEM_COMMIT চাইলে কী হওয়ার কথা?

সফল — commit শুধু ঠিকানা আটকায়, কোনো হিসাব লাগে না
সফল, আর সঙ্গে সঙ্গে ৩ GiB RAM ভরে যাবে
সফল, কারণ Windows ডিফল্টে Linux-এর মতো overcommit করে
ব্যর্থ — commit limit প্রায় ৮ + ৪ = ১২ GiB, আর ১০ + ৩ = ১৩ তার বেশি

(সহজ) Windows-এ Linux প্রোগ্রাম চালানোর জন্য WSL2 কীভাবে কাজ করে?

Linux syscall-কে NT kernel-এর কাজে অনুবাদ করে (pico process)
একটি হালকা Hyper-V VM-এ আসল Linux kernel চালায়
Linux প্রোগ্রামকে Windows-এর .exe-তে recompile করে
Cygwin-এর মতো একটি POSIX library দিয়ে

(মাঝারি) একটি M/M/1 সারিতে সেবার হার স্থির রেখে ব্যবহার ρ = ০.৬ থেকে ০.৯ করা হলো। গড় response time কত গুণ হবে?

১.৫ গুণ
২.৫ গুণ
৪ গুণ
১০ গুণ

(মাঝারি) একটি Linux সার্ভারে top দেখায় us ৫%, sy ৩%, wa ৭০%, id ২২%. কোন ব্যাখ্যা সবচেয়ে সঠিক?

CPU ৭০% ব্যস্ত, আরও core কিনতে হবে
steal time বেশি, প্রতিবেশী VM CPU নিচ্ছে
kernel-এর কাজ (sy) বাধা
CPU বেশিরভাগ সময় অলস ছিল আর তখন I/O-র অপেক্ষা চলছিল — ডিস্ক বা স্টোরেজ দেখা দরকার, যেমন iostat -xz 1

(মাঝারি) RISC-V-এ চলা xv6-এ user প্রোগ্রাম system call করলে নম্বর কোন register-এ যায়, আর virtual ঠিকানা (Sv39) কয় স্তরের page table-এ অনুবাদ হয়?

a7; তিন স্তর
a0; তিন স্তর
rax; চার স্তর
a7; চার স্তর

(মাঝারি) একটি buddy allocator-এ pool-এর শুরু থেকে offset ৬৪০-এ ১২৮ byte-এর একটি ব্লক মুক্ত হলো। তার buddy কোন offset-এ?

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

(মাঝারি) নিজের allocator-এ প্রতিটি ব্লকে ৮ byte header আর ৮ byte footer, আর ব্লকের মাপ ১৬-এর গুণিতকে তোলা হয়। malloc(40)-এর জন্য ব্লক কত byte?

৪০
৪৮
৫৬
৬৪

(মাঝারি) একটি Linux সার্ভার হঠাৎ ধীর। প্রথম ৬০ সেকেন্ডের চেকলিস্টে নিচের কোনটি সাধারণত সবচেয়ে শেষে, আর সাবধানে ব্যবহার করা উচিত?

strace দিয়ে চলমান প্রোডাকশন প্রসেস trace করা
uptime দিয়ে load average দেখা
dmesg দিয়ে kernel-এর সাম্প্রতিক বার্তা (OOM, ডিস্কের ত্রুটি) দেখা
vmstat 1 দিয়ে run queue, swap আর CPU-র ভাগ দেখা

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

এই পাতার ১১৯টি প্রশ্ন শেষ হলে আরও অনুশীলন চাইবেন, আর AI চ্যাটবট মুহূর্তে শত শত MCQ বানিয়ে দিতে পারে। কিন্তু মনে রাখুন: OS-এর MCQ-তে AI প্রায়ই ভুল উত্তরকে “সঠিক” বলে চিহ্নিত করে, বা একই প্রশ্নে দুটি সঠিক অপশন রেখে দেয়। সবচেয়ে বেশি ভুল ঠিক সেই জায়গাগুলোতে, যেগুলো এই পাতার ফাঁদ: RR-এর tie-নিয়ম না বলেই Gantt chart, page fault-এ একটি ধাপ বাদ, semaphore-এর মান কোন সংজ্ঞায় — তা না বলা, C-SCAN-এ লাফ গোনা হলো কি না চুপ থাকা। আরেকটি সমস্যা পুরোনো বা ভুল-OS-এর তথ্য: “Linux-এর scheduler O(1)” (২০০৭ সাল থেকে CFS, আর ৬.৬ থেকে EEVDF), কিংবা Linux-এর আচরণকে সব OS-এর বলে চালানো।

AI-এর প্রচলিত ভুল	উদাহরণ	কীভাবে ধরবেন
রীতি না বলা	RR-এর Gantt-এ একই মুহূর্তে আগমন আর quantum ফুরানোর tie চুপচাপ এক দিকে মেটানো	প্রশ্নে tie-নিয়ম লেখা চান; দুই নিয়মেই নিজে হিসাব করে দেখুন উত্তর বদলায় কি না
ভুল উত্তর-চাবি	LRU-র fault-সংখ্যা এক ধাপ কম গোনা	frame-এর প্রতিটি অবস্থা খাতায় লিখুন, বা এই পাতার মতো ছোট script চালান
দুটি সঠিক অপশন	“কোনটি safe sequence?” — দুটি বৈধ sequence-ই অপশনে, বাছাইয়ের নিয়ম নেই	প্রতিটি অপশন আলাদা করে সত্য-মিথ্যা যাচাই করুন
পুরোনো তথ্য	“Linux O(1) scheduler ব্যবহার করে”	সংশ্লিষ্ট পর্ব আর kernel-এর ডকুমেন্টেশনের সাথে মেলান
ভুল OS	Windows-এর প্রশ্নে fork, বা Linux-এর প্রশ্নে registry	প্রশ্নে কোন OS আর কোন সংস্করণ, তা লিখতে বলুন
বানানো উৎস	“অমুক পরীক্ষায় এসেছিল”	উৎস দেখাতে না পারলে দাবিটি বাদ দিন

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

আমি অপারেটিং সিস্টেমের MCQ পরীক্ষার প্রস্তুতি নিচ্ছি (বিশ্ববিদ্যালয়, চাকরির লিখিত পরীক্ষা আর ইন্টারভিউ)। বিষয়: [যেমন: Round Robin আর SRTF / page replacement / Banker's algorithm / Linux permission] কঠিনতা: [সহজ / মাঝারি / কঠিন] ১০টি MCQ বানাও। প্রতিটির জন্য: ১. প্রশ্ন আর ঠিক ৪টি অপশন; শুধু একটি সঠিক। প্রশ্ন নিজে সম্পূর্ণ হবে — দরকারি সব সংখ্যা প্রশ্নেই থাকবে। ২. যে রীতি ধরছ, প্রশ্নেই লেখো (RR-এর tie-নিয়ম, priority-তে ছোট সংখ্যা উঁচু কি না, C-SCAN-এ লাফ গোনা হবে কি না, semaphore-এর কোন সংজ্ঞা)। ৩. সঠিক উত্তর, আর প্রতিটি ভুল অপশন কোন ভুল ধারণা বা কোন হিসাবের ভুল থেকে এসেছে — এক লাইনে। ৪. numerical-এ পুরো Gantt chart, frame-এর প্রতিটি অবস্থা বা প্রতিটি ধাপের হিসাব দাও। ৫. বাস্তব সিস্টেমের প্রশ্নে কোন OS আর কোন সংস্করণ, তা লেখো। ৬. কোনো প্রশ্নকে কোনো নির্দিষ্ট পরীক্ষার আসল প্রশ্ন বলে দাবি করবে না।

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

প্রতিটি numerical নিজে খাতায় করেছি, বা এই পাতার মতো ছোট script চালিয়ে মিলিয়েছি; AI-এর উত্তর-চাবির সাথে মিলেছে
প্রশ্নে রীতি লেখা আছে; উল্টো রীতিতে উত্তর বদলালে সেটি প্রশ্নে স্পষ্ট করেছি
চারটি অপশনের মধ্যে ঠিক একটি সত্য — দুটি সত্য হয়ে যাওয়া প্রশ্ন ঠিক করেছি
Linux, Windows বা macOS-এর আচরণের দাবি সংশ্লিষ্ট পর্ব আর ডকুমেন্টেশনের সাথে মিলিয়েছি; সংস্করণ লেখা আছে
নিরাপত্তার প্রশ্নগুলো প্রতিরক্ষার দিক থেকে — কোন ব্যবস্থা কী থামায়, কীভাবে নিরাপদে ঠিক করবেন
“অমুক পরীক্ষায় এসেছিল” ধরনের দাবি বাদ দিয়েছি

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

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

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

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

এক অংশ, পুরো মনোযোগ: একবারে একটি মডিউলের অংশ নিন। প্রতিটি প্রশ্নে চাপার আগে খাতায় নিজের উত্তর আর এক লাইনের কারণ লিখুন — “গ, কারণ কারও Need ≤ Available নয়”. কারণ লিখতে না পারলে আন্দাজটিকে ভুল হিসেবেই গুনুন, ঠিক হলেও।
ভুলের খাতা: প্রতিটি ভুলের জন্য একটি লাইন — কোন নিয়মটি গুলিয়েছিলাম (“exit status-এর শুধু নিচের ৮ bit যায়”)। প্রশ্ন নয়, নিয়মটি লিখুন; পরীক্ষায় একই নিয়ম অন্য সংখ্যায় আসবে।
সংখ্যা বদলে নতুন প্রশ্ন: প্রতিটি numerical-এ একটি সংখ্যা বদলান — RR-এ quantum ২-এর বদলে ৩, Available-এ একটি resource বেশি, frame ৩-এর বদলে ৪ — আর আগে খাতায় নতুন উত্তর বের করুন, তারপর এই পাতার script বা নিজের ছোট প্রোগ্রামে মেলান। মুখস্থ উত্তর এখানে কাজ করে না, তাই এটিই সবচেয়ে শক্তিশালী অনুশীলন।
পর্বে ফিরে যাওয়া: একটি অংশে তিনটির বেশি ভুল হলে সেই অংশের “যা ঝালিয়ে নেবেন” তালিকার পর্বগুলো আবার পড়ুন — বিশেষ করে সেখানকার ধাপে-ধাপে ডায়াগ্রাম আর simulator.
ফিরে আসার সময়সূচি: ভুলের খাতা দেখে ১ দিন, ৩ দিন আর ৭ দিন পরে শুধু ভুল প্রশ্নগুলো আবার করুন। পাতার প্রশ্নের ক্রম একই থাকে, তাই উত্তরের অবস্থান মুখস্থ হয়ে যাওয়ার ঝুঁকি আছে — অপশন পড়ার আগেই নিজের উত্তর বলুন।
সময় ধরে পূর্ণ মহড়া: পরীক্ষার আগে সব অংশ থেকে মিশিয়ে ২৫টি প্রশ্ন ২০ মিনিটে করুন, negative marking ধরে নম্বর গুনুন। কোর্স হোমের মডিউল টেস্টও একই কাজে লাগে।

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

প্র ০২Multiprogramming, multitasking, multiprocessing আর multithreading — চারটি “multi” আসলে কোথায় আলাদা?

চারটি শব্দ চারটি আলাদা প্রশ্নের উত্তর। Multiprogramming উত্তর দেয় “মেমরিতে কয়টি কাজ?”: একাধিক কাজ একসাথে মেমরিতে রাখা, যাতে একটি I/O-র অপেক্ষায় আটকালে CPU আরেকটিকে চালাতে পারে। লক্ষ্য CPU utilisation, আর হিসাবটি সরল — প্রতিটি কাজ সময়ের p অংশ অপেক্ষায় থাকলে n টি কাজে CPU মোটামুটি 1 − pⁿ অংশ ব্যস্ত। ১৯৬০-এর দশকে IBM-এর OS/360-এর মতো সিস্টেম এভাবে দামি mainframe-কে ব্যস্ত রাখত। এখানে কোনো timer-এর পালা বদল বাধ্যতামূলক নয়: একটি কাজ যতক্ষণ নিজে I/O চায় না, ততক্ষণ চলতে পারে।

Multitasking বা time-sharing উত্তর দেয় “মানুষ কত দ্রুত সাড়া পাবে?”: multiprogramming-এর ওপর timer interrupt যোগ করে প্রতিটি কাজকে ছোট time slice দেওয়া, যাতে অনেক মানুষ একসাথে বসেও মনে করেন যন্ত্রটি শুধু তাঁরই। ১৯৬০-এর দশকের শুরুতে MIT-র CTSS এই ধারণার প্রথম দিকের সফল উদাহরণ। লক্ষ্য response time. তাই প্রতিটি multitasking সিস্টেম multiprogramming-ও করে, কিন্তু উল্টোটি নয়।

Multiprocessing হার্ডওয়্যারের কথা: একাধিক CPU বা core, তাই সত্যিকারের একই মুহূর্তে একাধিক নির্দেশ চলে — একে বলে parallelism, সত্যিকারের সমান্তরালতা। এক core-এর multitasking-এ সমান্তরালতা শুধু চোখের ভ্রম — দ্রুত পালা বদল। Multithreading প্রোগ্রামের ভেতরের কথা: এক প্রসেসে একাধিক কাজের ধারা, যারা একই address space ভাগ করে। শব্দটির একটি hardware-অর্থও আছে — একটি core-এ দুটি hardware thread (SMT; Intel ২০০২ সাল থেকে Hyper-Threading নামে বিক্রি করে)। MCQ-তে প্রসঙ্গ দেখে কোন অর্থ, তা বুঝে নিন।

পরীক্ষায় চিনবেন একটি শব্দ খুঁজে: প্রশ্নে timer বা time slice থাকলে multitasking; শুধু “I/O-র ফাঁকে CPU ব্যস্ত” থাকলে multiprogramming; “একাধিক CPU” থাকলে multiprocessing; “এক প্রসেসের ভেতরে” থাকলে multithreading. আর চারটি একসাথে থাকতে পারে — আপনার ফোনে চারটিই চলছে।

মূল উপলব্ধি: multiprogramming = মেমরিতে অনেক কাজ (CPU ব্যস্ত রাখা); multitasking = তার সাথে timer-এর পালা (দ্রুত সাড়া); multiprocessing = অনেক CPU; multithreading = এক প্রসেসে অনেক ধারা।

প্র ০৩Deadlock, starvation আর livelock — তিনটিতেই কাজ এগোয় না। পার্থক্যটা ঠিক কোথায়, আর প্রতিকারও কেন আলাদা?

Deadlock মানে একদল প্রসেস বা থ্রেডের প্রত্যেকে এমন একটি resource-এর অপেক্ষায়, যা ধরে আছে দলেরই আরেকজন — একটি চক্র। Coffman ও সহকর্মীরা ১৯৭১ সালে দেখান, এর জন্য চারটি শর্ত একসাথে লাগে: mutual exclusion, hold and wait, no preemption আর circular wait. deadlock-এর বৈশিষ্ট্য হলো স্থিরতা: দলের কেউ আর কখনো এগোবে না, বাইরে থেকে কেউ হস্তক্ষেপ (প্রসেস বন্ধ করা বা resource কেড়ে নেওয়া) না করলে। সিস্টেমের বাকি অংশ চলতে পারে, কিন্তু চক্রের সদস্যরা চিরতরে ঘুমিয়ে।

Starvation-এ কোনো চক্র নেই, আর সিস্টেম ঠিকই চলছে — শুধু একজন বারবার সুযোগ হারায়, কারণ নিয়মটি সবসময় অন্য কাউকে আগে দেয়। ছোট কাজের স্রোতে SJF-এর লম্বা কাজ, উঁচু অগ্রাধিকারের ভিড়ে নিচের কাজ, reader-দের স্রোতে writer — সবই starvation. এটি নীতির ন্যায্যতার সমস্যা, তাই প্রতিকারও নীতিতে: aging (অপেক্ষার সাথে অগ্রাধিকার বাড়ানো), HRRN-এর ratio, MLFQ-র priority boost, বা ticket lock-এর মতো FIFO ক্রম। লক্ষ্য একটাই — অপেক্ষার একটি ঊর্ধ্বসীমা, অর্থাৎ bounded waiting.

Livelock দুটির মাঝামাঝি অদ্ভুত অবস্থা: সবাই চলছে, অবস্থা বদলাচ্ছে, CPU ব্যস্ত — কিন্তু কেউ অগ্রগতি করছে না। সরু করিডরে মুখোমুখি দুজন, দুজনেই ভদ্রতা করে একসাথে বাঁয়ে সরেন, তারপর একসাথে ডানে। কোডে এটি হয় যখন দুটি থ্রেড lock না পেয়ে ধরা lock ছেড়ে দেয়, আর ঠিক একই তালে আবার চেষ্টা করে। প্রতিকার তাল ভাঙা: এলোমেলো backoff, বা সবাই একই ক্রমে lock নেওয়া।

MCQ-তে চেনার কৌশল: “চক্র”, “একে অপরের অপেক্ষায়”, “কেউই না” — deadlock; “একজন বারবার”, “বাকিরা এগোচ্ছে” — starvation; “CPU ব্যস্ত, কিন্তু কাজ শূন্য”, “ছেড়ে দিয়ে আবার চেষ্টা” — livelock. আর মনে রাখুন, dining philosophers-এর monitor সমাধান deadlock ঠেকায় কিন্তু starvation নয় — দুটি সমস্যা যে আলাদা, তার সবচেয়ে চেনা প্রমাণ।

মূল উপলব্ধি: deadlock = চক্রে চিরস্থায়ী জট, প্রতিকার চার শর্তের একটি ভাঙা বা detection-recovery; starvation = অন্যায্য নীতি, প্রতিকার aging বা FIFO; livelock = তালে-তাল মেলানো ব্যস্ততা, প্রতিকার এলোমেলো backoff.

প্র ০৪Internal আর external fragmentation — কোন ব্যবস্থায় কোনটি হয়, আর paging কেন একটি দূর করে কিন্তু অন্যটি নয়?

দুটিই অপচয়, কিন্তু অপচয়ের জায়গা আলাদা। Internal fragmentation মানে বরাদ্দ করা ব্লকের ভেতরে অব্যবহৃত অংশ: চাওয়া হয়েছিল ১০,০০০ byte, কিন্তু ব্যবস্থা দেয় শুধু ৪ KiB-এর গুণিতকে, তাই শেষ page-এ ২,২৮৮ byte পড়ে থাকে — আর সেটি অন্য কেউ ব্যবহার করতে পারে না, কারণ ব্লকটি একজনের নামে। External fragmentation মানে বরাদ্দের বাইরে খালি জায়গা ছোট ছোট টুকরোয় ছড়ানো: মোট খালি যথেষ্ট, কিন্তু কোনো একটি টানা hole অনুরোধের মাপের নয়।

কোনটি কোথায়, তা নির্ভর করে ব্লকের মাপ স্থির না পরিবর্তনশীল তার ওপর। স্থির মাপ (fixed partition, paging, buddy system, slab) — external প্রায় নেই, কারণ যেকোনো খালি ঘর যেকোনো অনুরোধে চলে; দাম internal. পরিবর্তনশীল মাপ (variable partition, segmentation, file-এর contiguous allocation) — internal নেই, কারণ যত চাই তত দেওয়া হয়; দাম external. buddy system-এ ২-এর ঘাতে গোল করায় internal অপচয় একটি ব্লকে প্রায় অর্ধেক পর্যন্ত যেতে পারে — যেমন ১২৯K চাইলে ২৫৬K দেওয়া হয়।

Paging তাই external fragmentation দূর করে — প্রসেসের page যেকোনো খালি frame-এ বসতে পারে, টানা জায়গার দরকারই নেই — কিন্তু internal রেখে দেয়: গড়ে প্রতিটি প্রসেসের শেষ page-এ প্রায় আধা page. বড় page (যেমন ২ MiB-এর huge page) TLB-র নাগাল বাড়ায়, কিন্তু এই অপচয়ও বাড়ায় — page size-এর দর-কষাকষির মূলে এটিই। external fragmentation কতটা মারাত্মক, তার একটি বিখ্যাত হিসাব Donald Knuth-এর: first fit-এ স্থিত অবস্থায় N টি ব্লকের সাথে প্রায় N/2 টি hole থাকে (৫০-শতাংশ নিয়ম), hole আর ব্লকের গড় আকার সমান ধরলে মেমরির প্রায় এক-তৃতীয়াংশ। প্রতিকার compaction, কিন্তু তার জন্য চলার সময়ে ঠিকানা বদলানো (execution-time binding) লাগে, আর অনেক byte কপি করতে হয়।

MCQ-তে চেনার প্রশ্ন একটাই: “অপচয়টি কার নামে?” কারও বরাদ্দের ভেতরে হলে internal; কারও নয়, শুধু টুকরো হওয়ায় অকেজো হলে external.

মূল উপলব্ধি: স্থির মাপের ব্লক = internal, পরিবর্তনশীল মাপ = external. paging external দূর করে internal-এর দামে; segmentation উল্টো। “অপচয় কার নামে” — এই প্রশ্নেই উত্তর।

প্র ০৫Process আর thread-এর পার্থক্য কী, আর Linux-এ দুটি একই কাঠামো হলে পার্থক্যটা টিকে থাকে কোথায়?

পাঠ্যবইয়ের ভাষায় প্রসেস হলো সম্পদের মালিকানার একক — নিজের address space, খোলা ফাইল, অনুমতি; আর thread হলো scheduling-এর একক — একটি program counter, register-এর সেট আর একটি stack. এক প্রসেসের সব thread code, global data, heap আর খোলা ফাইল ভাগ করে; প্রত্যেকের নিজের শুধু stack, register আর thread-local storage. তাই thread তৈরি আর বদলানো সস্তা (page table বদলায় না, TLB অটুট থাকে), ডেটা ভাগ করা সহজ — কিন্তু সেই সহজতাই বিপদ: একটি thread-এর ভুল লেখা পুরো প্রসেসের মেমরি নষ্ট করতে পারে, আর একটি thread crash করলে সাধারণত পুরো প্রসেস মরে।

Linux-এ ব্যাপারটি আরও মজার। kernel-এর চোখে প্রসেস আর thread দুটিই একটি task_struct — একটি “task”. পার্থক্য তৈরি হয় clone()-এর flag দিয়ে: CLONE_VM দিলে মেমরি ভাগ, CLONE_FILES দিলে fd-টেবিল ভাগ, CLONE_THREAD দিলে একই thread group. fork মানে প্রায় কিছুই ভাগ না করা clone; pthread_create মানে প্রায় সবকিছু ভাগ করা clone. তাই একটি multithreaded প্রসেসের সব thread-এ getpid() একই, কিন্তু gettid() আলাদা। ২০০০-এর দশকের শুরুতে NPTL লাইব্রেরি এই ভিত্তিতে Linux-এর আজকের one-to-one thread মডেল দাঁড় করায়। Windows-এ মডেলটি পাঠ্যবইয়ের কাছাকাছি: প্রসেস একটি পাত্র, আর scheduler চালায় শুধু thread.

বাস্তবে কোনটি বাছবেন, তা নির্ভর করে আলাদা থাকার দাম কতটা। ব্রাউজারের প্রতিটি tab বা site আলাদা প্রসেসে রাখা হয় (Google Chrome ২০০৮ সালে এই নকশা নিয়ে আসে), যাতে একটি ক্ষতিকর বা crash করা পাতা বাকিদের ছুঁতে না পারে। আবার একটি ওয়েব সার্ভার বা ডেটাবেস একই ডেটা-কাঠামোয় হাজারো অনুরোধ সামলাতে thread pool ব্যবহার করে, কারণ ভাগ করা মেমরি দ্রুত।

মূল উপলব্ধি: প্রসেস = আলাদা address space আর সম্পদ (নিরাপদ, দামি); thread = একই address space-এ আলাদা কাজের ধারা (সস্তা, কিন্তু ভাগাভাগির ঝুঁকি)। Linux-এ দুটিই task, পার্থক্য শুধু কী ভাগ হচ্ছে।

প্র ০৬Hard link আর soft (symbolic) link — ভেতরে কী ঘটে, আর কেন একটি অন্য file system-এ যেতে পারে কিন্তু অন্যটি পারে না?

চাবিটি একটি সত্যে: Unix-ধাঁচের file system-এ ফাইলের নাম ফাইলের ভেতরে থাকে না। directory আসলে একটি তালিকা — “নাম → inode নম্বর”. inode-এ থাকে ফাইলের আকার, মালিক, অনুমতি, সময় আর ডেটার block-এর ঠিকানা; নাম নয়। তাই একই inode-এর একাধিক নাম থাকতেই পারে। Hard link ঠিক তাই: আরেকটি directory entry, যা একই inode নম্বর দেখায়। inode-এ একটি link count থাকে; ln a b-এ সেটি বাড়ে, rm-এ কমে, আর শূন্য হলে (এবং কেউ ফাইলটি খুলে না রাখলে) তবেই ডেটা মুছে যায়। কোন নামটি “আসল”, সে প্রশ্নই অর্থহীন — সব নাম সমান।

Symbolic link সম্পূর্ণ আলাদা জিনিস: নিজস্ব inode-এর একটি ছোট ফাইল, যার ভেতরে শুধু একটি path লেখা। kernel path খোঁজার সময় সেটি পেলে লেখা path ধরে আবার খোঁজে। এটি ১৯৮০-এর দশকের শুরুতে BSD Unix-এ যোগ হয়, ঠিক hard link-এর সীমাবদ্ধতা পেরোতে।

দুই সীমাবদ্ধতাই নকশা থেকে আসে। এক, inode নম্বরের অর্থ শুধু একটি file system-এর ভেতরে — আরেকটি partition-এ ১২৩৪৫ নম্বর inode সম্পূর্ণ অন্য ফাইল। তাই hard link অন্য file system-এ যায় না; symlink যায়, কারণ সে নম্বর নয়, একটি path রাখে। দুই, directory-র hard link সাধারণ ব্যবহারে নিষেধ, কারণ cycle তৈরি হলে গাছ-ঘোরা অসীম লুপে পড়ত, reference count কখনো শূন্য হতো না, আর “..”-র মানে অস্পষ্ট হতো; symlink-এর cycle kernel একটি সীমা দিয়ে ধরে আর ELOOP ত্রুটি দেয়। দামও আছে: লক্ষ্য মুছলে symlink “ঝুলে” যায় (dangling), আর একই নামে নতুন ফাইল এলে সে নতুনটিকেই দেখায়; hard link মোছা বা সরানো নামের ওপর নির্ভর করে না।

Windows-এ শব্দগুলো মেলে, কিন্তু হুবহু নয়: NTFS hard link আর symbolic link দুটিই সমর্থন করে (mklink), directory-র জন্য junction আছে; কিন্তু সাধারণ shortcut (.lnk) OS-স্তরের link নয়, Explorer-এর বোঝা একটি সাধারণ ফাইল।

মূল উপলব্ধি: hard link = একই inode-এর আরেকটি নাম (একই file system, directory নয়, লক্ষ্য মুছলেও ডেটা থাকে); symlink = path লেখা আলাদা ফাইল (যেকোনো জায়গায় যায়, কিন্তু লক্ষ্য মুছলে ঝুলে যায়)।

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

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

ক্রমএকটি প্রসেস RAM-এ নেই এমন একটি বৈধ page ছুঁয়েছে, আর কোনো frame খালি নেই। এরপর যা ঘটে, আগে থেকে পরে সাজান (▲▼ চেপে সরান)

MMU invalid entry দেখে trap করে, CPU kernel-এর page-fault handler-এ ঢোকে
kernel যাচাই করে ঠিকানাটি প্রসেসের বৈধ এলাকায় কি না
replacement নীতি দিয়ে একটি victim frame বাছে (dirty হলে আগে ডিস্কে লেখে)
ডিস্ক থেকে দরকারি page-টি frame-এ পড়ে, আর অপেক্ষার সময় অন্য প্রসেস চলে
page table আপডেট করে entry-টি valid করে
যে নির্দেশে fault হয়েছিল, সেটি আবার চালায়

শব্দকোষ

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

মনে রাখুন

বাদ দিন, তারপর যাচাই করুন: প্রতিটি অপশনের পেছনের দাবি একটি নিয়ম বা ছোট হিসাব দিয়ে কাটুন; “মিথ্যা” আর “সবচেয়ে” শব্দে দাগ দিন।
Negative marking-এ হিসাব: k টি অপশন বাকি থাকলে আন্দাজ লাভজনক, যতক্ষণ কাটা নম্বর ১ ÷ (k − ১)-এর কম; −০.২৫-এ দুটিতে নামাতে পারলে এক আন্দাজের গড় লাভ +০.৩৭৫.
Numerical-এ রীতি আগে: TAT = CT − AT, WT = TAT − BT, RR-এর tie, SSTF-এর tie, C-SCAN-এর লাফ, Banker's-এর ছোট index, TLB-র t — খাতার কোণে লিখে তবেই হিসাব।
জোড়াগুলো আলাদা রাখুন: multiprogramming বনাম multitasking, deadlock বনাম starvation, unsafe বনাম deadlock, internal বনাম external, process বনাম thread, hard বনাম soft link, mutex বনাম semaphore.
AI-এর MCQ যাচাই: প্রতিটি numerical নিজে করুন বা script-এ মেলান, রীতি আর OS-এর নাম চেয়ে নিন, আর “অমুক পরীক্ষায় এসেছিল” ধরনের দাবি বাদ দিন।

পরের পর্বে: MCQ-তে চারটি অপশন থাকে; লিখিত পরীক্ষা আর ভাইভায় থাকে না। পর্ব ৬২-তে process, memory, deadlock আর আরও বিষয়ের লিখিত ও মৌখিক প্রশ্ন — কীভাবে গুছিয়ে, যুক্তিসহ উত্তর লিখবেন আর বলবেন।

MCQ প্রশ্নব্যাংক — অপারেটিং সিস্টেম

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

১ · অপারেটিং সিস্টেমের MCQ কীভাবে সামলাবেন — প্রশ্নের ধরন, বাদ দেওয়ার কৌশল আর negative marking

প্রশ্নের সাত ছাঁচ

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

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

কৌশল ৩ · negative marking — কখন আন্দাজ করবেন

সময় ভাগ

দশটি বড় ফাঁদ

২ · মডিউল ১ — অপারেটিং সিস্টেমের ভিত্তি (১৩টি প্রশ্ন)

৩ · মডিউল ২ — প্রসেস ও থ্রেড (১৪টি প্রশ্ন)

৪ · মডিউল ৩ — CPU শিডিউলিং (১৩টি প্রশ্ন)

৫ · মডিউল ৪ — কনকারেন্সি ও সিনক্রোনাইজেশন (১৩টি প্রশ্ন)

৬ · মডিউল ৫ — মেমরি ম্যানেজমেন্ট (১৫টি প্রশ্ন)

নিজে মিলিয়ে দেখুন — page fault আর head movement

৭ · মডিউল ৬ — I/O, স্টোরেজ ও ফাইল সিস্টেম (১৪টি প্রশ্ন)

৮ · মডিউল ৭ — সুরক্ষা ও নিরাপত্তা (১২টি প্রশ্ন)

৯ · মডিউল ৮ — ভার্চুয়ালাইজেশন, কনটেইনার ও আধুনিক OS (১৩টি প্রশ্ন)

১০ · মডিউল ৯ — বাস্তব OS ও ক্যাপস্টোন (১২টি প্রশ্ন)

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

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

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

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

শব্দকোষ

মনে রাখুন

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