CPU কীভাবে কাজ করে — fetch-decode-execute, ক্লক আর কোর

১ · CPU-র আসল কাজ — আনা, বোঝা, করা, আবার আনা

পর্ব ০৩-এ আপনি CPU-কে “কম্পিউটারের মস্তিষ্ক” হিসেবে চিনেছেন, আর তার তিন অংশের নাম জেনেছেন। কিন্তু মস্তিষ্ক শব্দটি একটু বিভ্রান্তিকর। CPU আমাদের মতো চিন্তা করে না। সে শুধু অল্প কয়েক রকমের সরল কাজ জানে — যোগ, তুলনা, এক জায়গা থেকে আরেক জায়গায় সংখ্যা সরানো, আর “অমুক ঠিকানার নির্দেশে লাফ দাও”।

তাহলে ভিডিও চালানো বা bKash-এ টাকা পাঠানোর মতো বড় কাজ কীভাবে হয়? উত্তর একটি চক্রে। CPU মেমরি থেকে একটি নির্দেশ আনে, সেটি কী বলছে বোঝে, কাজটি করে, ফল রাখে — তারপর পরের নির্দেশ আনতে যায়। একে বলে fetch-decode-execute চক্র (instruction cycle বা machine cycle). আজকের ল্যাপটপের CPU এই চক্র সেকেন্ডে শতকোটি বার ঘোরায়।

von Neumann নকশা — প্রোগ্রাম আর ডেটা একই মেমরিতে

প্রায় সব আধুনিক কম্পিউটার যে নকশায় তৈরি, তার নাম von Neumann architecture — পর্ব ০২-এ ইতিহাস হিসেবে নামটি দেখেছেন। এই নকশায় চারটি অংশ: CPU, মেমরি, ইনপুট-আউটপুট (I/O), আর এদের জোড়ার তার, অর্থাৎ বাস. সবচেয়ে গুরুত্বপূর্ণ ভাবনাটি হলো stored-program: প্রোগ্রামের নির্দেশও আসলে সংখ্যা, তাই সেগুলো ডেটার সাথে একই মেমরিতে রাখা যায়। নতুন প্রোগ্রাম চালাতে শুধু মেমরিতে অন্য সংখ্যা লিখলেই হয়।

এই নকশার একটি দুর্বলতাও আছে। নির্দেশ আর ডেটা দুটোকেই একই সরু রাস্তা (বাস) দিয়ে আসতে হয়, আর মেমরি CPU-র তুলনায় অনেক ধীর। ফলে CPU-কে প্রায়ই অপেক্ষা করতে হয়। একে বলে von Neumann bottleneck — ব্যস্ত সেতুর মুখের জটের মতো — গাড়ি যত দ্রুতই হোক। এর বড় সমাধান cache — পর্ব ২৫-এ আসছে।

২ · CPU-র ভেতরের দল — ALU, কন্ট্রোল ইউনিট আর রেজিস্টার

এবার তিনটি অংশ ঠিক কী করে, একটু গভীরে দেখা যাক।

• ALU (Arithmetic Logic Unit): হিসাবের যন্ত্র। পর্ব ২১-এর full adder দিয়ে বানানো যোগের সার্কিট, তুলনার সার্কিট (comparator), আর AND, OR, XOR-এর গেট — সব এখানে। ALU নিজে কিছু মনে রাখে না; দুটি ইনপুট পায়, কন্ট্রোল ইউনিট বলে দেয় কোন কাজ, আর সে ফল দেয়।
• কন্ট্রোল ইউনিট (CU): পরিচালক। নির্দেশের কোড পড়ে (পর্ব ২১-এর decoder দিয়ে) বোঝে কোন কাজ, তারপর ঠিক সময়ে ঠিক তারে সংকেত পাঠায় — “মেমরি, এখন পড়ো”, “ALU, যোগ করো”, “ফলটি ACC-তে রাখো”। নিজে কোনো হিসাব করে না, কিন্তু সবাইকে তালে তালে চালায়।
• রেজিস্টার: CPU-র ভেতরের হাতে-গোনা কয়েকটি অতি দ্রুত ঘর। পর্ব ২২-এ দেখেছেন, রেজিস্টার আসলে কয়েকটি flip-flop পাশাপাশি — প্রতিটি ক্লক-টিকে নতুন মান নিতে পারে। রেজিস্টার পড়তে সময় লাগে মাত্র একটি ক্লক চক্র বা তারও কম, যেখানে RAM থেকে আনতে লাগতে পারে কয়েকশো চক্র।

বিশেষ দায়িত্বের রেজিস্টারগুলো

পরীক্ষায় সবচেয়ে বেশি প্রশ্ন আসে এই রেজিস্টারগুলো নিয়ে:

Flag-গুলোর কথা পর্ব ১৭-এ বাইনারি যোগ-বিয়োগের সময় দেখেছেন: carry বা overflow হলো কি না, ফল শূন্য কি না। এখানে তাদের আসল কাজটি স্পষ্ট হয়। CPU “যদি… তাহলে…” সিদ্ধান্ত নেয় ঠিক এভাবে: প্রথমে একটি তুলনা বা বিয়োগ করে flag সেট করে, তারপর একটি শর্তযুক্ত লাফ-নির্দেশ (যেমন “Zero flag 1 হলে লাফ দাও”) flag দেখে ঠিক করে PC-তে নতুন ঠিকানা বসবে কি না। প্রতিটি if আর লুপ শেষে এই দুই ধাপে ভাঙে।

৩ · বাস — ঠিকানা, তথ্য আর সংকেতের রাস্তা; ৩২-bit বনাম ৬৪-bit

পর্ব ০৩-এ বাসকে শহরের রাস্তার সাথে তুলনা করেছিলাম। এবার প্রশ্ন: রাস্তা কত চওড়া? বাসের প্রতিটি তার একসাথে একটি bit বহন করে। তাই বাসে যতটি তার, একবারে তত bit যায় — একে বলে বাসের প্রস্থ (width).

• অ্যাড্রেস বাস: CPU থেকে মেমরির দিকে, একমুখী। n টি তার থাকলে আলাদা ঠিকানা হয় 2ⁿ টি। তাই অ্যাড্রেস বাসের প্রস্থই ঠিক করে CPU সর্বোচ্চ কত মেমরি চিনতে পারবে।
• ডেটা বাস: দুই দিকে চলে। এর প্রস্থ ঠিক করে একবারে কত bit তথ্য আসা-যাওয়া করবে — ৮-bit বাসে একবারে ১ byte, ৬৪-bit বাসে একবারে ৮ byte.
• কন্ট্রোল বাস: আলাদা আলাদা সংকেতের তার — “পড়ো” (read), “লেখো” (write), ক্লক, “কাজ শেষ”, interrupt ইত্যাদি।

এ কারণেই একসময় ৩২-bit Windows-এ ৮ GB RAM লাগালেও প্রায় ৩–৪ GB-ই ব্যবহার হতো — ঠিকানার নম্বর ফুরিয়ে যেত। ৬৪-bit CPU-তে এই সীমা কার্যত উঠে গেছে। বাস্তবে আজকের চিপ পুরো ৬৪টি ঠিকানা-bit ব্যবহারও করে না, সাধারণত ৪৮ বা ৫৭ bit — তাতেই কয়েকশো TB থেকে আরও অনেক বেশি পর্যন্ত চেনা যায়, যা যেকোনো ল্যাপটপের প্রয়োজনের বহু গুণ।

৪ · নির্দেশ-চক্র ধাপে ধাপে — একটি খেলনা CPU-তে প্রোগ্রাম চালানো

আসল CPU-র নির্দেশ-ভাষা (instruction set বা ISA) হাজারখানেক নির্দেশের, শেখার জন্য বড্ড জটিল। তাই শিক্ষকেরা বহু বছর ধরে খেলনা CPU ব্যবহার করেন — সবচেয়ে বিখ্যাত “Little Man Computer”, যা ১৯৬০-এর দশকে MIT-তে Stuart Madnick শেখানোর জন্য তৈরি করেন। আমরাও একটি খেলনা CPU বানাব: মেমরিতে মাত্র ১৬টি ঘর (ঠিকানা 0 থেকে 15), একটি accumulator, আর ৮টি নির্দেশ।

প্রতিটি নির্দেশ ৮ bit, অর্থাৎ ১ byte. ওপরের ৪ bit হলো opcode — কোন কাজ; নিচের ৪ bit হলো operand — কোন ঘরের সংখ্যা নিয়ে কাজ। ৪ bit দিয়ে 0 থেকে 15 পর্যন্ত ঠিকানা লেখা যায় — ঠিক ১৬টি ঘর।

এখন একটি ছোট প্রোগ্রাম: “5 আর 3 যোগ করে ফলটি ঘর 6-এ রাখা”। Assembly-তে চার লাইন, আর প্রতিটি লাইনের machine code বানানো হয় opcode আর ঠিকানা পাশাপাশি বসিয়ে:

লক্ষ করুন, ঘর 0–3-এ নির্দেশ আর ঘর 4–6-এ ডেটা — একই মেমরিতে, একই চেহারায়, শুধু 0 আর 1. মেমরি নিজে জানে না কোনটি নির্দেশ আর কোনটি সংখ্যা; PC যে ঘরে নিয়ে যায়, CPU সেটিকেই নির্দেশ হিসেবে পড়ে। এবার প্রোগ্রামটি চালান — প্রতিটি ধাপে রেজিস্টারগুলোর মান খেয়াল করুন:

014   LOAD 4125   ADD 5246   STORE 6300   HALT405   (ডেটা: 5)503   (ডেটা: 3)6--   (ফলের ঘর)

লুপ বানানো — লাফ আর শর্ত দিয়ে

লুপের জন্য দরকার দুটি নির্দেশ: JUMP (PC-তে নতুন ঠিকানা বসিয়ে পেছনে ফিরে যাওয়া) আর JZ (শর্ত সত্য হলে তবেই লাফ)। নিচের প্রোগ্রামটি ১ থেকে ৫ পর্যন্ত যোগ করে (৫ + ৪ + ৩ + ২ + ১), আর প্রতিটি নির্দেশের পর PC, IR আর ACC ছাপে:

const NAMES = ['HALT', 'LOAD', 'ADD', 'SUB', 'STORE', 'JUMP', 'JZ', 'OUT'];
const mem = [0x1C, 0x2B, 0x4C, 0x1B, 0x3D, 0x4B, 0x68, 0x50,   // 0-7: লুপ
             0x1C, 0x70, 0x00, 5, 0, 1, 0, 0];                  // 11 = N, 12 = SUM, 13 = ONE
let pc = 0, acc = 0, ir = 0, count = 0, running = true;
const hex = (v) => v.toString(16).toUpperCase().padStart(2, '0');
while (running) {
  ir = mem[pc];                         // FETCH: PC যে ঘর দেখায়, সেখান থেকে IR-এ
  const at = pc;
  pc = pc + 1;                          // PC এগিয়ে গেল পরের ঘরে
  const op = ir >> 4, addr = ir & 15;   // DECODE: উপরের ৪ bit = কাজ, নিচের ৪ bit = ঠিকানা
  if (op === 0) running = false;        // EXECUTE: opcode অনুযায়ী একটি কাজ
  if (op === 1) acc = mem[addr];
  if (op === 2) acc = acc + mem[addr];
  if (op === 3) acc = acc - mem[addr];
  if (op === 4) mem[addr] = acc;
  if (op === 5) pc = addr;
  if (op === 6 && acc === 0) pc = addr;
  count++;
  console.log(`PC=${hex(at)} IR=${hex(ir)} ${NAMES[op].padEnd(5)} ${String(addr).padStart(2)} | ACC=${acc}`);
  if (op === 7) console.log(`   >>> OUTPUT: ${acc}`);
}
console.log(`HALT after ${count} instructions. SUM (cell 12) = ${mem[12]}`);

৫ · ক্লক, GHz আর IPC — গতি আসলে কোথা থেকে আসে

খেলনা CPU-র প্রতিটি ধাপ কখন হবে, সেটি ঠিক করে দেয় ক্লক সিগন্যাল — পর্ব ২২-এ দেখা সেই নিয়মিত টিক-টিক, যার প্রতিটি ধারে সব রেজিস্টার একসাথে নতুন মান নেয়। দুই টিকের মাঝের সময়কে বলে একটি clock cycle. এই সময়ের মধ্যে সংকেতকে গেটের পর গেট পেরিয়ে (পর্ব ২০-এর propagation delay) পরের রেজিস্টারে পৌঁছাতে হয়।

ক্লক স্পিড মাপা হয় হার্টজে (Hz) — প্রতি সেকেন্ডে কতটি চক্র। ১ MHz = ১০ লাখ, ১ GHz = ১০০ কোটি চক্র প্রতি সেকেন্ডে। ৩ GHz CPU-তে প্রতিটি চক্র প্রায় ০.৩৩ ন্যানোসেকেন্ড। কিন্তু চক্র আর নির্দেশ এক জিনিস নয় — একটি নির্দেশ কয়েক চক্র নিতে পারে, আবার আধুনিক CPU এক চক্রে কয়েকটি নির্দেশও শেষ করতে পারে। গড়ে প্রতি চক্রে কতটি নির্দেশ শেষ হয়, তাকে বলে IPC (Instructions Per Cycle).

সূত্রটি মোটামুটি, নিখুঁত নয়; তবু এটি দেখায়: শুধু GHz দেখে দুটি CPU তুলনা করা যায় না। একটি CPU ৪ GHz-এ গড়ে ২টি নির্দেশ/চক্র চালালে সেকেন্ডে ৮০০ কোটি; আরেকটি ৩ GHz-এ ৪টি চালালে ১,২০০ কোটি — কম GHz, তবু দেড় গুণ দ্রুত। প্রতি প্রজন্মে নির্মাতারা মূলত IPC বাড়ান।

তাহলে GHz বাড়ালেই তো হয় — কেন বাড়ানো হয় না?

২০০৫-এর দিকে GHz-এর দৌড় থেমে যায় (পর্ব ২২-এর ভাবনার প্রশ্নে যার গল্প শুরু; ভাবনার প্রশ্ন ৩-এ আরও)। কারণ মূলত তাপ। চিপের বিদ্যুৎ-খরচ মোটামুটি ক্লক-গতি আর ভোল্টেজের বর্গের গুণফলের সাথে বাড়ে, আর বেশি গতিতে চালাতে ভোল্টেজও বাড়াতে হয়। ফলে গতি একটু বাড়ালে তাপ বাড়ে অনেক বেশি। আগে ট্রানজিস্টর ছোট করলে বিদ্যুৎ-খরচও কমত (Dennard scaling), কিন্তু ২০০৫-এর আশপাশে সেই সুবিধা ফুরিয়ে যায়।

আজকের CPU-তে তাই দুটি ক্লক লেখা থাকে: base clock — যে গতিতে দীর্ঘ সময় নিরাপদে চলতে পারে, আর boost clock — ঠান্ডা থাকলে আর অল্প কোর ব্যস্ত থাকলে কিছুক্ষণের জন্য যে সর্বোচ্চ গতিতে ওঠে। গরম হয়ে গেলে CPU নিজেই গতি কমায় (thermal throttling, পর্ব ০৮)। কাজ না থাকলে ক্লক নামিয়ে বিদ্যুৎ বাঁচায়।

৬ · Pipeline আর branch prediction — একসাথে অনেক নির্দেশ

GHz বাড়ানো বন্ধ হলে IPC বাড়াতে হবে। প্রথম কৌশলটি পরিচিত এক দৃশ্য থেকে বোঝা যায়। ধরুন একটি লন্ড্রিতে চার বস্তা কাপড়: প্রতিটি বস্তাকে ধোয়া, শুকানো, ইস্তিরি আর ভাঁজ — চার ধাপ, প্রতিটি ৩০ মিনিট। এক বস্তা পুরো শেষ করে তবেই পরেরটি ধরলে লাগে ৮ ঘণ্টা। কিন্তু প্রথম বস্তা ওয়াশিং মেশিন থেকে ড্রায়ারে গেলেই দ্বিতীয় বস্তা মেশিনে ঢুকতে পারে! এভাবে সব যন্ত্র একসাথে ব্যস্ত রাখলে চার বস্তা শেষ হয় ৩ ঘণ্টা ৩০ মিনিটে। একে বলে pipelining — garments কারখানার production line-এর মতো।

CPU-তেও নির্দেশ চক্রের ধাপগুলো আলাদা আলাদা সার্কিটে হয়। আমাদের উদাহরণে চার ধাপ: F (fetch), D (decode), E (execute), W (write back). নিচে চারটি নির্দেশ I1–I4 আগে pipeline ছাড়া, তারপর pipeline দিয়ে চালান:

খেয়াল করুন, pipeline একটি নির্দেশকে দ্রুত করে না — প্রতিটি নির্দেশ এখনো ৪ চক্র নেয়। কিন্তু প্রতি চক্রে একটি করে নির্দেশ শেষ হয়, তাই মোট কাজ প্রায় ৪ গুণ দ্রুত। আসল CPU-র pipeline-এ ধাপ আরও বেশি — শিক্ষার ক্লাসিক নকশায় ৫টি, আর আধুনিক চিপে সাধারণত ১০–২০টি; Pentium 4-এর কোনো কোনো সংস্করণে ৩০-এর বেশি ছিল।

বাধা — hazard, আর লাফ দিলে কী হয়

Pipeline সবসময় মসৃণ চলে না। এমন বাধাকে বলে hazard. যেমন, I2 যদি I1-এর ফলের ওপর নির্ভর করে, আর সেই ফল এখনো লেখা না হয়ে থাকে — তাহলে I2-কে এক-দুই চক্র অপেক্ষা করতে হয় (data hazard). সবচেয়ে বড় ঝামেলা লাফ-নির্দেশে: JZ চালিয়ে না দেখা পর্যন্ত CPU জানে না পরের নির্দেশ কোনটি। কিন্তু ততক্ষণে pipeline-এ পরের নির্দেশ ঢোকানোর সময় পেরিয়ে যাচ্ছে! অপেক্ষা করলে সময় নষ্ট। তাই CPU অনুমান করে — একে বলে branch prediction. অনুমান করে আগেভাগে নির্দেশ চালানোকে বলে speculative execution. অনুমান ভুল হলে কী হয়, দেখুন:

আধুনিক branch predictor আগের লাফগুলোর ইতিহাস মনে রেখে অনুমান করে — যেমন “এই লুপ গত ৯৯ বার লাফ দিয়েছে, এবারও দেবে”। অনেক প্রোগ্রামে এদের অনুমান ৯৫ শতাংশেরও বেশি সময় ঠিক হয়। ভুল হলে খরচ অবশ্য বড় — গভীর pipeline-এ একবারে ১৫–২০ চক্র নষ্ট হতে পারে।

৭ · মাল্টিকোর, thread আর Hyper-Threading

এক কোরকে আর দ্রুত করা কঠিন হয়ে যাওয়ায় নির্মাতারা অন্য পথ ধরলেন: এক চিপে কয়েকটি সম্পূর্ণ core বসানো (multicore). প্রতিটি কোরের নিজস্ব ALU, কন্ট্রোল ইউনিট, রেজিস্টার আর pipeline — যেন এক রান্নাঘরে কয়েকজন রাঁধুনি।

কিন্তু কোর থাকলেই কাজ ভাগ হয় না। প্রোগ্রামকে নিজের কাজ কয়েকটি স্বাধীন “ধারায়” ভাগ করতে হয় — প্রতিটি ধারাকে বলে thread. অপারেটিং সিস্টেম (পর্ব ২৬) এই thread-গুলোকে আলাদা কোরে বসায়। যে প্রোগ্রাম একটিমাত্র thread-এ লেখা (single-threaded), সে ১৬ কোরের CPU-তেও একটি কোরই ব্যবহার করে — বাকি ১৫টি তার জন্য বসে থাকে। আর যে ধাপ আগের ধাপের ফলের ওপর নির্ভর করে, সেটি ভাগ করাই যায় না।

১৯৬৭ সালে IBM-এর প্রকৌশলী Gene Amdahl এই সীমাটি একটি সহজ হিসাবে দেখান, যা আজ Amdahl’s law নামে পরিচিত: প্রোগ্রামের যে অংশ ভাগ করা যায় না, কোর যত বাড়ান, সেই অংশের সময় কমে না। একটি উদাহরণে দেখুন:

Hyper-Threading — এক কোর, দুই thread

একটি কোর প্রায়ই মেমরির অপেক্ষায় অলস বসে থাকে। এই ফাঁকা সময় কাজে লাগাতে একটি কোরে দুই সেট রেজিস্টার (PC, flag ইত্যাদি) রাখা হয়, যাতে দুটি thread একই ALU-গুলো ভাগ করে চলতে পারে। এর সাধারণ নাম SMT (simultaneous multithreading); Intel একে বলে Hyper-Threading, যা ২০০২ সালে তাদের CPU-তে আসে। AMD-র Ryzen-এও SMT আছে। তাই “৮ কোর, ১৬ থ্রেড” CPU-তে Windows ১৬টি “logical processor” দেখায় — কিন্তু আসলে ALU-র দল ৮টিই। এতে কাজভেদে কিছুটা বাড়তি গতি আসে, দ্বিগুণ কখনোই নয়। Intel ২০২৪ সালের কিছু নতুন চিপে Hyper-Threading বাদও দিয়েছে।

আরেকটি নতুন ধারা hybrid CPU: এক চিপে দুই রকম কোর — শক্তিশালী “performance” কোর (P-core) আর কম বিদ্যুতের “efficiency” কোর (E-core). ফোনের ARM চিপে এটি বহু বছর ধরে চলছে (big.LITTLE), আর এখন ল্যাপটপেও সাধারণ — হালকা কাজ E-core-এ, ভারী কাজ P-core-এ।

৮ · CISC বনাম RISC, আর GPU, NPU ও মাইক্রোকন্ট্রোলার

প্রতিটি CPU পরিবারের নিজস্ব instruction set আছে — x86-এর machine code ARM চিপে চলে না, যেমন বাংলা বই চীনা পাঠকের কাছে অর্থহীন। ISA নকশার দুটি বড় দর্শন:

বাস্তবে সীমারেখা এখন ঝাপসা — আধুনিক x86 CPU ভেতরে জটিল নির্দেশকে ছোট RISC-ধাঁচের অংশে (micro-op) ভেঙে চালায়। তবু বিদ্যুৎ-সাশ্রয়ে ARM-এর সুনাম ঐতিহাসিক: প্রায় সব স্মার্টফোনের চিপ ARM নকশায় তৈরি, ২০২০ সাল থেকে Apple-এর Mac চলে নিজস্ব ARM চিপ (M-সিরিজ) দিয়ে, আর Windows-এর কিছু ল্যাপটপেও এখন ARM চিপ।

CPU ছাড়াও প্রসেসর — কে কোন কাজের ওস্তাদ

একটি তুলনা মজার। জনপ্রিয় Arduino Uno বোর্ডের ATmega328P মাইক্রোকন্ট্রোলার চলে ১৬ MHz-এ, RAM মাত্র ২ KB, প্রোগ্রাম রাখার flash ৩২ KB — একটি ল্যাপটপের তুলনায় হাস্যকর রকম ছোট। অথচ সেচ-পাম্প বা ফ্যান স্বয়ংক্রিয়ভাবে চালাতে এটুকুই যথেষ্ট। এর ভেতরে নির্দেশ আর ডেটার জন্য আলাদা মেমরি — একে বলে Harvard architecture, যা von Neumann bottleneck এড়ানোর একটি পুরোনো কৌশল। ফোনে অবশ্য CPU, GPU, NPU সব একটি চিপেই থাকে — SoC, পর্ব ০৩-এ যার কথা পড়েছেন।

৯ · CPU-র স্পেক পড়া আর Task Manager-এ CPU দেখা

এবার এই পর্বের জ্ঞান দিয়ে একটি ল্যাপটপের CPU স্পেক পড়া যাক (পর্ব ০৮-এ কেনার সময় কোন CPU বেছে নেবেন, তা দেখেছেন)। একটি কাল্পনিক উদাহরণ:

Windows-এ নিজের CPU দেখতে Ctrl + Shift + Esc চেপে Task Manager খুলুন, তারপর Performance ট্যাবে CPU. সেখানে পাবেন: Utilization (কত শতাংশ ব্যস্ত), Speed (এই মুহূর্তের ক্লক — base-এর চেয়ে বেশিও দেখাতে পারে), Base speed, Cores, Logical processors, আর L1, L2, L3 cache-এর মাপ। গ্রাফে ডান-ক্লিক করে Change graph to → Logical processors বেছে নিলে প্রতিটি logical processor-এর আলাদা গ্রাফ দেখবেন। single-threaded ভারী কাজে প্রায়ই মোট Utilization কম, অথচ একটি-দুটি গ্রাফ উঁচু।

কমান্ড দিয়েও দেখা যায়। Windows PowerShell-এ (পর্ব ২৯-এ কমান্ড লাইন বিস্তারিত আসবে):

Get-CimInstance Win32_Processor | Select-Object Name, NumberOfCores, NumberOfLogicalProcessors, MaxClockSpeed

প্রত্যাশিত আউটপুট (আপনার যন্ত্রে নাম আর সংখ্যা আলাদা হবে): CPU-র পুরো নাম, কোরের সংখ্যা, logical processor-এর সংখ্যা, আর MHz-এ একটি ক্লক-মান। Linux-এ একই তথ্য দেয় lscpu, আর শুধু logical processor গুনতে nproc.

১০ · AI-এর যুগে — CPU-র ব্যাখ্যা আর মার্কেটিং-দাবি যাচাই

“CPU কীভাবে কাজ করে” জিজ্ঞেস করলে AI চ্যাটবট সুন্দর, গোছানো উত্তর দেয়। কিন্তু AI শেখে ইন্টারনেটের অতি-সরল আর বিজ্ঞাপনী লেখা থেকেও। তাই তার উত্তরে প্রায়ই core আর thread গুলিয়ে যায়, GHz-কে গতির একমাত্র মাপ ধরা হয়, বা নির্দিষ্ট মডেলের ভুল স্পেক আত্মবিশ্বাসের সাথে বলা হয় — যাকে বলে AI hallucination.

AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট

• কোর, thread আর ক্লকের প্রতিটি সংখ্যা Intel, AMD, Apple বা Qualcomm-এর অফিশিয়াল স্পেক পাতায় মিলিয়েছি
• “থ্রেড” আর “কোর” কোথাও গুলিয়ে যায়নি — thread কোরের দ্বিগুণ হলে সেটি SMT/Hyper-Threading
• গতির দাবিতে শুধু GHz বা কোর-সংখ্যা নয়, একই কাজের benchmark-ফল দেখেছি
• fetch-decode-execute-এর ব্যাখ্যায় PC, IR, MAR, MDR-এর কাজ এই পর্বের খেলনা CPU-র সাথে মিলিয়ে দেখেছি
• নিজের কম্পিউটারের তথ্য Task Manager বা lscpu দিয়ে নিজে দেখে নিয়েছি