Timing আর clock — propagation delay, setup-hold, critical path আর metastability

১ · কেন synchronous নকশা — একটি সাধারণ ছন্দের শক্তি

পর্ব ০৮-এ (Logic gate আর transistor) দেখেছেন, প্রতিটি gate-এর output বদলাতে সময় লাগে — propagation delay. পর্ব ১০-এ (আরও সরলীকরণ) দেখেছেন, বিভিন্ন পথের delay আলাদা বলে output-এ ক্ষণিকের ভুল মান — glitch বা static hazard — দেখা দিতে পারে। এখন ভাবুন একটি CPU-র কথা, যেখানে কোটি কোটি gate, আর প্রতিটি সংকেত ভিন্ন সময়ে পৌঁছায়। কোন মুহূর্তে কোন তারের মান “সঠিক”, তা বলবেন কীভাবে?

উত্তর হলো synchronous নকশা। Circuit-কে দুই ধরনের অংশে ভাগ করা হয়: স্মৃতি রাখার flip-flop (বা register), আর তাদের মাঝের combinational logic. সব flip-flop একটিই সাধারণ সংকেত শোনে — clock. Clock-এর প্রতিটি উঠন্ত ধারে (rising edge) সব flip-flop একসাথে তাদের ইনপুটের মান তুলে নেয়, আর পরের ধার পর্যন্ত সেটি ধরে রাখে। দুই ধারের মাঝখানে combinational logic যা খুশি করুক — glitch হোক, মান দশবার উল্টাক — কিছু যায় আসে না, যদি পরের ধারের একটু আগে সব স্থির হয়ে যায়।

এর বিকল্প asynchronous নকশা — যেখানে কোনো সাধারণ clock নেই, প্রতিটি অংশ “কাজ শেষ” সংকেত দিয়ে পরের অংশকে জাগায়। এটি সম্ভব, আর কিছু জায়গায় ব্যবহারও হয় (ভাবনার প্রশ্ন ০১), কিন্তু প্রতিটি glitch সেখানে সত্যিকারের ঘটনা, তাই নকশা আর যাচাই অনেক কঠিন। এজন্য প্রায় সব CPU, GPU আর microcontroller synchronous. পর্ব ১৫-এ (Latch আর flip-flop) flip-flop-এর ভেতরের গঠন, পর্ব ১৬-এ register ও counter, আর পর্ব ১৭-এ finite state machine — সবই এই একটি ধারণার ওপর দাঁড়িয়ে। এই পর্বে প্রশ্ন: clock কত দ্রুত চালানো যায়, আর কোথায় এই নিখুঁত ছবি ভেঙে পড়ে?

Clock সংকেত — period, frequency, duty cycle আর edge

Clock হলো নিয়মিত ছন্দে 0 আর 1-এর মধ্যে ওঠানামা করা একটি বর্গাকার তরঙ্গ। এর চারটি মাপ জানলেই চলে:

• Period T_c (clock cycle time) — এক উঠন্ত ধার থেকে পরের উঠন্ত ধার পর্যন্ত সময়।
• Frequency f = ১ / T_c (clock rate) — প্রতি সেকেন্ডে কতগুলো cycle. T_c = ১ ns হলে f = ১ GHz; T_c = ২৫০ ps হলে f = ৪ GHz.
• Duty cycle — একটি period-এর কত অংশ clock 1 থাকে। বেশিরভাগ clock ৫০%, অর্থাৎ অর্ধেক সময় 1, অর্ধেক সময় 0.
• Edge — 0 থেকে 1-এ ওঠা হলো rising edge, 1 থেকে 0-তে নামা falling edge. এই পর্বের সব flip-flop rising-edge-triggered — অর্থাৎ শুধু উঠন্ত ধারেই মান নেয়।

পর্ব ০৩-এ (পারফরম্যান্স মাপা) CPU time = instruction count × CPI × T_c সূত্রে clock rate একটি গুণক হিসেবে এসেছিল — বলা হয়েছিল, clock দ্রুত হলে প্রোগ্রাম দ্রুত চলে। কিন্তু T_c কে ঠিক করে? মার্কেটিং বিভাগ নয় — circuit-এর ভেতরের সবচেয়ে ধীর পথ। সেটিই এখন হিসাব করব। (Clock সংকেত আসে একটি স্ফটিক বা crystal oscillator আর chip-এর ভেতরের PLL থেকে — অংশ ৭-এ।)

২ · ছয়টি timing সংখ্যা — flip-flop আর logic-এর delay

Flip-flop আদর্শ যন্ত্র নয়। উঠন্ত ধারে “ছবি তোলার” জন্য তার ইনপুট D-কে ধারের একটু আগে থেকে একটু পর পর্যন্ত স্থির থাকতে হয় — ক্যামেরার সামনে নড়াচড়া করলে যেমন ছবি ঝাপসা হয়। আবার ছবি তোলার পর output Q-তে নতুন মান দেখাতেও একটু সময় লাগে। এই কোর্সে Harris & Harris-এর বই (Digital Design and Computer Architecture)-এর লেখার নিয়ম ব্যবহার করা হচ্ছে, যা পাঠ্যবই আর ইন্টারভিউতে বহুল প্রচলিত:

শেষ দুটি পর্ব ০৮-এর পুরোনো বন্ধু; প্রথম চারটি flip-flop-এর datasheet বা standard-cell library থেকে আসে। প্রথম দুটি একসাথে edge-এর চারপাশে একটি “নিষিদ্ধ জানালা” তৈরি করে — aperture (t_setup + t_hold চওড়া), যার ভেতরে D বদলানো চলবে না। t_pcq আর t_ccq-কে একসাথে clock-to-Q delay বলে। মনে রাখার কৌশল: “p” মানে propagation = সবচেয়ে দেরি (setup-এর হিসাবে লাগে), “c” মানে contamination = সবচেয়ে আগে (hold-এর হিসাবে লাগে)। কখনো কখনো hold time ০ বা ঋণাত্মকও হয় — মানে edge-এর ঠিক পরেই D বদলালেও সমস্যা নেই।

৩ · Setup-এর শর্ত — clock সর্বোচ্চ কত দ্রুত চলতে পারে

সবচেয়ে সাধারণ ছবিটি নিন: একটি register R1, তার পরে কিছু combinational logic, তারপর আরেকটি register R2. দুটিই একই clock পায়। R1 একটি edge-এ নতুন মান ছাড়ে (launch); সেই মান logic পেরিয়ে R2-র D-তে পৌঁছায়, আর R2 পরের edge-এ সেটি ধরে (capture).

প্রমাণ (derivation). R1-এর launch edge-কে সময় ০ ধরুন। সবচেয়ে খারাপ ক্ষেত্রে R1-এর Q স্থির হয় t_pcq-তে। তারপর ধীরতম পথ দিয়ে খবর পৌঁছাতে আরও t_pd লাগে, তাই R2-র D স্থির হয় t_pcq + t_pd-তে। R2-র capture edge আসে T_c-তে, আর তার দাবি — D স্থির থাকতে হবে T_c − t_setup-এর আগেই। অতএব

t_pcq + t_pd ≤ T_c − t_setup  ⇔  T_c ≥ t_pcq + t_pd + t_setup,   f_max = ১ / T_c,min

এখানে t_pd হলো সব R→R পথের মধ্যে সবচেয়ে বড়টি — critical path. t_pcq + t_setup অংশটিকে বলে sequencing overhead: প্রতিটি cycle-এ register নিজেই যে সময় খেয়ে ফেলে, যা কোনো কাজের হিসাবে যায় না। নিচের stepper-এ পুরো একটি cycle দেখুন — এখানে t_pd = ২৪০ ps, t_cd = ৩০ ps (পর্ব ১১-এর ৩২ বিট বহুস্তর CLA, প্রতি gate ২০ ps ধরে) আর T_c = ৪০০ ps. প্রতিটি অক্ষর ১০ ps; x মানে মান বদলাচ্ছে (অনিশ্চিত), = মানে স্থির; s setup-জানালা, h hold-জানালা।

ps    0    50   100  150  200  250  300  350  400  450
CLK   ‾
Q1    =
D2    =
win

R1 samples its D at t = 0 and will put a NEW value on Q1.
D2 still shows the result of the OLD Q1.

ps    0    50   100  150  200  250  300  350  400  450
CLK   ‾‾‾‾‾‾
Q1    ===xx=
D2    ======
win

Q1 may start changing at tccq = 30 ps,
Q1 is surely new at     tpcq = 50 ps.

ps    0    50   100  150  200  250  300  350  400  450
CLK   ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾__________
Q1    ===xx=========================
D2    ======xxxxxxxxxxxxxxxxxxxxxxx=

D2 may start changing at tccq + tcd = 30 + 30 = 60 ps
D2 is surely stable at   tpcq + tpd = 50 + 240 = 290 ps

ps    0    50   100  150  200  250  300  350  400  450
CLK   ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾____________________
Q1    ===xx===================================
D2    ======xxxxxxxxxxxxxxxxxxxxxxx===========
win                                     ssssss

setup window starts at Tc - tsetup = 400 - 60 = 340 ps
D2 stable at 290 ps  ->  setup slack = 340 - 290 = 50 ps
minimum Tc = 50 + 240 + 60 = 350 ps  ->  fmax = 2.857 GHz

ps    0    50   100  150  200  250  300  350  400  450
CLK   ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾____________________‾‾‾‾‾‾‾‾
Q1    ===xx======================================xx===
D2    ======xxxxxxxxxxxxxxxxxxxxxxx=================xx
win                                     sssssshhhh

R2 captures the stable D2 at 400 ps.  Same edge: R1 launches again.
hold window ends at 400 + thold = 440 ps
D2 next changes at 400 + 30 + 30 = 460 ps -> hold slack = 20 ps

উদাহরণ ১ — ripple বনাম CLA (পর্ব ১১-এর সাথে মিলিয়ে)। ধরুন প্রতিটি gate-এর delay ২০ ps (বোঝানোর জন্য ধরা মান), আর flip-flop-এর t_pcq = ৫০, t_setup = ৬০ ps. পর্ব ১১-এ (Adder) হিসাব করা হয়েছিল ৩২ বিট ripple-carry adder-এর সবচেয়ে খারাপ delay 2n + 1 = ৬৫ gate delay, আর বহুস্তর carry-lookahead-এর ১২ gate delay. দুই register-এর মাঝে adder বসালে:

• Ripple: t_pd = ৬৫ × ২০ = ১,৩০০ ps → T_c ≥ ৫০ + ১,৩০০ + ৬০ = ১,৪১০ ps → f_max ≈ ৭০৯ MHz.
• CLA: t_pd = ১২ × ২০ = ২৪০ ps → T_c ≥ ৩৫০ ps → f_max ≈ ২.৮৬ GHz.

লক্ষ করুন sequencing overhead-এর (১১০ ps) ভাগ: ripple-এর cycle-এ মাত্র ৭.৮%, কিন্তু CLA-র cycle-এ ৩১.৪%. Logic যত দ্রুত হয়, register-এর নিজের খরচ তত বড় হয়ে দেখা দেয় — পর্ব ৩৫-এ (pipelining) ঠিক এই কারণেই pipeline-এর ধাপ অসীম বাড়ানো যায় না।

উদাহরণ ২ — উল্টো প্রশ্ন। ২ GHz-এ চালাতে চাইলে (T_c = ৫০০ ps) দুই register-এর মাঝে সর্বোচ্চ কত logic রাখা যায়? t_pd ≤ ৫০০ − ৫০ − ৬০ = ৩৯০ ps, অর্থাৎ ২০ ps-এর gate হলে সর্বোচ্চ ১৯টি স্তর (৩৯০ / ২০ = ১৯.৫, পূর্ণ স্তর ১৯)। নকশাকারীরা ঠিক এভাবে “logic depth”-এর বাজেট ভাগ করেন।

নিচের calculator একই flip-flop (t_pcq = ৫০, t_ccq = ৩০, t_setup = ৬০, t_hold = ৪০ ps) নিয়ে কয়েকটি পরিস্থিতিতে দুই শর্তই যাচাই করে। এখনই সব সারি না বুঝলেও চলবে — hold আর skew-এর সারিগুলো পরের দুই অংশে ব্যাখ্যা করা হবে।

// Register-to-register timing check (all times in ps).
// Setup: Tc >= tpcq + tpd + tsetup + tskew
// Hold : tccq + tcd >= thold + tskew   (no Tc in it!)
const FF = { tpcq: 50, tccq: 30, tsetup: 60, thold: 40 };
function check(name, tpd, tcd, skew, fGHz) {
  const Tc = 1000 / fGHz;                       // clock period in ps
  const TcMin = FF.tpcq + tpd + FF.tsetup + skew;
  const setupSlack = Tc - TcMin;
  const holdSlack = FF.tccq + tcd - (FF.thold + skew);
  const tag = s => (s >= 0 ? "PASS" : "FAIL");
  console.log(name.padEnd(24) + String(TcMin).padStart(6) +
    (1e6 / TcMin).toFixed(0).padStart(7) + String(Tc.toFixed(0)).padStart(6) +
    `${setupSlack.toFixed(0).padStart(7)} ${tag(setupSlack)}` +
    `${holdSlack.toFixed(0).padStart(6)} ${tag(holdSlack)}`);
}
console.log("scenario                 TcMin   fmax    Tc   setup-slack  hold-slack");
console.log("                          (ps)  (MHz)  (ps)");
check("ripple-32 @1GHz", 1300, 30, 0, 1);    // 65 gates x 20 ps
check("CLA-32 @1GHz", 240, 30, 0, 1);        // 12 gates x 20 ps
check("FF->FF wire @1GHz", 0, 0, 0, 1);       // shift register, no logic
check("FF->buf->FF @1GHz", 25, 15, 0, 1);     // one delay buffer added
check("CLA-32 skew50 @2GHz", 240, 30, 50, 2);
check("CLA-32 skew50 @1GHz", 240, 30, 50, 1); // slower clock: hold still fails
check("CLA-32 skew50 +2buf", 240, 60, 50, 2); // pad only the short paths

scenario                 TcMin   fmax    Tc   setup-slack  hold-slack
                          (ps)  (MHz)  (ps)
ripple-32 @1GHz           1410    709  1000   -410 FAIL    20 PASS
CLA-32 @1GHz               350   2857  1000    650 PASS    20 PASS
FF->FF wire @1GHz          110   9091  1000    890 PASS   -10 FAIL
FF->buf->FF @1GHz          135   7407  1000    865 PASS     5 PASS
CLA-32 skew50 @2GHz        400   2500   500    100 PASS   -30 FAIL
CLA-32 skew50 @1GHz        400   2500  1000    600 PASS   -30 FAIL
CLA-32 skew50 +2buf        400   2500   500    100 PASS     0 PASS

৪ · Hold-এর শর্ত — যখন পথ খুব বেশি দ্রুত

Setup-এর ভয় হলো “দেরিতে পৌঁছানো”। Hold-এর ভয় উল্টো: খুব তাড়াতাড়ি পৌঁছানো। একই edge-এ R1 নতুন মান ছাড়ে আর R2 পুরোনো মান ধরে। R1-এর নতুন মান যদি এত দ্রুত R2-র D-তে চলে আসে যে R2-র hold-জানালা তখনো শেষ হয়নি, তাহলে R2 পুরোনো মানের বদলে নতুনটা ধরে ফেলতে পারে — বা দুইয়ের মাঝামাঝি কোনো অবস্থায় আটকে যেতে পারে (অংশ ৮)।

প্রমাণ। Edge সময় ০-তে। সবচেয়ে আগে R1-এর Q বদলায় t_ccq-তে; দ্রুততম পথ দিয়ে সেই পরিবর্তন R2-র D-তে পৌঁছায় t_ccq + t_cd-তে। R2 চায় D অন্তত t_hold পর্যন্ত না বদলাক। অতএব

t_ccq + t_cd ≥ t_hold  ⇔  t_cd ≥ t_hold − t_ccq

সূত্রে T_c কোথাও নেই! কারণ দুই পক্ষই — R1-এর launch আর R2-র hold-জানালা — একই edge-এর ঘটনা। Clock ধীর বা দ্রুত করলে দুটিই একসাথে সরে। তাই setup violation হলে clock ধীর করে chip চালানো যায় (কম গতিতে বিক্রি করা যায়), কিন্তু hold violation থাকলে chip কোনো গতিতেই নির্ভরযোগ্য নয় — নতুন করে নকশা আর তৈরি করতে হয় (ভাবনার প্রশ্ন ০৩)।

  D1 ──► [R1] ──Q1──────────► [R2] ──► Q2
          ▲     (wire: tpd = tcd = 0)  ▲
  CLK ────┴────────────────────────────┘

before the edge:  D1 = 0,  Q1 = 1,  Q2 = 0
correct result after the edge:  Q1 = 0,  Q2 = 1  (the old Q1)

ps        0    25   50   75   100
CLK       ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
hold(R2)  hhhhhhhh

R2 needs D2 (= Q1) to stay at the OLD value 1
from 0 ps until thold = 40 ps

ps        0    25   50   75   100
CLK       ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
Q1 = D2   ======xxxx==========
hold(R2)  hhhhhhhh

Q1 starts changing at tccq = 30 ps, inside the hold window
hold slack = tccq + tcd - thold = 30 + 0 - 40 = -10 ps

R2 may capture:  1 (correct, by luck)
                 0 (wrong: the bit skipped a stage)
                 or hang in between (metastable)

slower clock (Tc = 10 ns instead of 1 ns)?
-> same 30 ps vs 40 ps race  -> still broken

  [R1] ──Q1──[buf: tcd 15, tpd 25]──► [R2]

ps        0    25   50   75   100
CLK       ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
Q1        ======xxxx==========
D2        =========xxxxxx=====
hold(R2)  hhhhhhhh

D2 starts changing at 30 + 15 = 45 ps > 40 ps
hold slack = +5 ps;  cost: Tc min grows 110 -> 135 ps

বাস্তবে অনেক flip-flop-এ t_ccq ≥ t_hold রাখা হয়, যাতে সরাসরি জোড়া flip-flop-ও নিরাপদ থাকে। কিন্তু পরের অংশে দেখবেন, clock skew এলে সেই নিরাপত্তা আর থাকে না।

৫ · Clock skew আর jitter — একই clock, ভিন্ন সময়ে

এতক্ষণ ধরে নিয়েছি, clock edge সব flip-flop-এ ঠিক একই মুহূর্তে পৌঁছায়। বাস্তবে clock একটি তার — chip-এর এক কোণ থেকে অন্য কোণে যেতে তার-দৈর্ঘ্য আর buffer-এর কারণে সময় লাগে। দুই flip-flop-এ clock পৌঁছানোর সময়ের পার্থক্যকে বলে clock skew. সংজ্ঞা নিন δ = (capture register-এ clock পৌঁছানোর সময়) − (launch register-এ clock পৌঁছানোর সময়)।

• Positive skew (δ > ০) — capture-এর clock দেরিতে আসে। Setup-এর হাতে বাড়তি δ সময়: T_c ≥ t_pcq + t_pd + t_setup − δ. কিন্তু hold-জানালাও δ দেরিতে শেষ হয়: t_ccq + t_cd ≥ t_hold + δ — hold কঠিন হলো।
• Negative skew (δ < ০) — capture-এর clock আগে আসে। Setup কঠিন হয় (|δ| যোগ হয়), hold সহজ হয়।

অর্থাৎ skew একদিকে যা দেয়, অন্যদিকে তা কেড়ে নেয়। আর chip-এ হাজার হাজার পথ; কোন পথে কোন দিকের skew, তা তৈরির বৈচিত্র্য আর তাপমাত্রায় বদলাতে পারে। তাই Harris & Harris নিরাপদ (conservative) রূপটি দেন — skew-এর চিহ্ন অজানা ধরে, |δ| ≤ t_skew হলে দুই শর্তেই সবচেয়ে খারাপটা:

T_c ≥ t_pcq + t_pd + t_setup + t_skew  ·  t_ccq + t_cd ≥ t_hold + t_skew

উদাহরণ ৩ — skew-এর হিসাব। একই CLA পথ (t_pd = ২৪০, t_cd = ৩০) আর একই flip-flop (t_pcq = ৫০, t_ccq = ৩০, t_setup = ৬০, t_hold = ৪০ ps).

• δ = +৫০ ps (জানা, positive): T_c ≥ ৫০ + ২৪০ + ৬০ − ৫০ = ৩০০ ps (setup-এ লাভ)। Hold: ৩০ + ৩০ = ৬০ বনাম ৪০ + ৫০ = ৯০ → slack −৩০ ps — violation.
• δ = −৫০ ps (জানা, negative): T_c ≥ ৪০০ ps; hold: ৬০ ≥ ৪০ − ৫০ = −১০ → slack +৭০ ps — নিরাপদ।
• চিহ্ন অজানা, t_skew = ৫০ ps: দুই খারাপ একসাথে — T_c ≥ ৪০০ ps (f_max ২.৫ GHz) আর hold slack −৩০ ps. অংশ ৩-এর calculator-এর পঞ্চম সারি ঠিক এটিই। সমাধান: ছোট পথে অন্তত ৩০ ps t_cd যোগ — যেমন দুটি ১৫ ps-এর buffer (শেষ সারি, slack ০)।

Clock jitter হলো আরেক রকম অনিশ্চয়তা: একই flip-flop-এ পরপর দুটি edge-এর ব্যবধান ঠিক T_c না হয়ে একটু কমবেশি হওয়া (oscillator আর PLL-এর noise, power supply-র ওঠানামা)। Setup-এর হিসাব দুটি ভিন্ন edge-এর মাঝের সময়ের ওপর নির্ভর করে, তাই jitter সেখান থেকে সময় কেড়ে নেয় — নকশাকারীরা T_c-এর বাজেটে jitter-এর জন্যও একটি অংশ রাখেন। Hold-এর হিসাব একই edge-এর, তাই সাধারণত cycle-থেকে-cycle jitter সেখানে প্রভাব ফেলে না। Tool-এ skew আর jitter প্রায়ই একসাথে “clock uncertainty” নামে একটি বাজেট হিসেবে দেওয়া হয়।

৬ · Critical path আর static timing analysis — tool কী হিসাব করে

একটি আসল chip-এ কোটি কোটি register-থেকে-register পথ। প্রতিটির জন্য simulation চালিয়ে সব ইনপুট পরীক্ষা করা অসম্ভব — ৬৪ বিটের দুই ইনপুটেই ২^১২৮ সমাবেশ। তাই শিল্পে ব্যবহার হয় static timing analysis (STA): ইনপুটের মান না দেখে শুধু circuit-এর গঠন (netlist) আর প্রতিটি gate-এর delay দিয়ে সবচেয়ে খারাপ আর সবচেয়ে ভালো সময় হিসাব করা। “Static” মানে মান নিয়ে simulation নয়, গঠন দেখে হিসাব।

পদ্ধতিটি একটি graph algorithm — gate-গুলো নোড, তার হলো edge, আর graph-এ কোনো চক্র নেই (চক্র থাকলে তা register দিয়ে ভাঙা থাকে)। টপোলজিক্যাল ক্রমে (ইনপুট থেকে output-এর দিকে) প্রতিটি নোডে দুটি সংখ্যা বসান:

• Max arrival time = (ইনপুটগুলোর max arrival-এর বৃহত্তম) + gate-এর t_pd. শুরুতে প্রতিটি launch register-এর output-এ t_pcq.
• Min arrival time = (ইনপুটগুলোর min arrival-এর ক্ষুদ্রতম) + gate-এর t_cd. শুরুতে t_ccq.

তারপর capture register-এ required time-এর সাথে তুলনা: setup-এর জন্য required = T_c − t_setup − t_skew, hold-এর জন্য required = t_hold + t_skew. Slack = required − arrival (setup), বা arrival − required (hold) — ঋণাত্মক slack মানে violation. Critical path পেতে প্রতিটি নোডে “কোন ইনপুট সবচেয়ে দেরিতে এল” মনে রেখে output থেকে পেছনে হাঁটতে হয়। পর্ব ১১-এর ripple adder-এ delay ইনপুট-নির্ভর ছিল; STA ইচ্ছে করেই সেটি উপেক্ষা করে সবচেয়ে খারাপটা ধরে — নিরাপদ, তবে কখনো কখনো একটু বেশি সাবধানী।

নিচের ছোট netlist নিন। Launch register চারটি সংকেত a, b, c, d দেয়; capture register দুটি সংকেত Y আর Z নেয়। Flip-flop আগের মতোই, T_c = ২৯০ ps, t_skew = ১৫ ps. প্রতিটি gate-এর পাশে (t_pd, t_cd) ps-এ:

g1 = NAND(a, b)    (30, 20)
g2 = INV(c)        (15, 10)
g3 = NOR(g1, g2)   (40, 25)
g4 = XOR(g3, d)    (60, 40)
Y  = AND(g4, g2)   (45, 30)   -> capture FF
Z  = AND(c, d)     (45, 20)   -> capture FF

node  max   min
a      50    30
b      50    30
c      50    30
d      50    30

max = tpcq = 50,  min = tccq = 30  (all launched by one edge)

node  max                 min
g1    max(50,50)+30 = 80   min(30,30)+20 = 50
g2    50+15         = 65   30+10         = 40

latest input of g1: a (b ties at 50)

node  max                   min
g3    max(80,65)+40 = 120   min(50,40)+25 = 65
g4    max(120,50)+60 = 180  min(65,30)+40 = 70

g3 waits for g1 (80), not g2 (65)
g4's EARLIEST change comes from d (30), not g3

node  max                   min
Y     max(180,65)+45 = 225  min(70,40)+30 = 70
Z     max(50,50)+45  = 95   min(30,30)+20 = 50

Y  <- g4 (180)  <- g3 (120)  <- g1 (80)  <- a (50)

critical path:  a -> g1 -> g3 -> g4 -> Y
delay = 50 + 30 + 40 + 60 + 45 = 225 ps

setup required = Tc - tsetup - tskew = 290 - 60 - 15 = 215
hold  required = thold + tskew       = 40 + 15       = 55

Y: setup 215 - 225 = -10  VIOLATION   hold 70 - 55 = +15 ok
Z: setup 215 -  95 = +120 ok          hold 50 - 55 = -5  VIOLATION

এই হিসাবটিই কোডে — একটি টপোলজিক্যাল ক্রমের loop, প্রতিটি নোডে max আর min, তারপর পেছনে হাঁটা:

// Mini static timing analysis on a gate netlist (times in ps).
// Launch FFs drive a, b, c, d; capture FFs sample Y and Z.
const FF = { tpcq: 50, tccq: 30, tsetup: 60, thold: 40 };
const Tc = 290, tskew = 15;                  // clock period and skew budget
const net = [ // [name, type, inputs, tpd, tcd]  (listed in topological order)
  ["g1", "NAND", ["a", "b"], 30, 20],
  ["g2", "INV",  ["c"],      15, 10],
  ["g3", "NOR",  ["g1", "g2"], 40, 25],
  ["g4", "XOR",  ["g3", "d"], 60, 40],
  ["Y",  "AND",  ["g4", "g2"], 45, 30],
  ["Z",  "AND",  ["c", "d"],   45, 20],
];
const late = {}, early = {}, from = {};
for (const x of "abcd") { late[x] = FF.tpcq; early[x] = FF.tccq; }
for (const [n, type, ins, tpd, tcd] of net) {
  const worst = ins.reduce((p, q) => (late[q] > late[p] ? q : p));
  late[n] = late[worst] + tpd;                         // latest arrival
  early[n] = Math.min(...ins.map(i => early[i])) + tcd; // earliest arrival
  from[n] = worst;
  console.log(`${n.padEnd(2)} ${type.padEnd(4)} max ${String(late[n]).padStart(3)}` +
    `  min ${String(early[n]).padStart(3)}  (latest input: ${worst})`);
}
for (const out of ["Y", "Z"]) {
  const path = [out];
  while (from[path[0]]) path.unshift(from[path[0]]);
  const setup = (Tc - FF.tsetup - tskew) - late[out]; // required - arrival
  const hold = early[out] - (FF.thold + tskew);       // arrival - required
  console.log(`${out}: path ${path.join(" -> ")} | setup slack ${setup}` +
    ` ${setup < 0 ? "VIOLATION" : "ok"} | hold slack ${hold} ${hold < 0 ? "VIOLATION" : "ok"}`);
}

g1 NAND max  80  min  50  (latest input: a)
g2 INV  max  65  min  40  (latest input: c)
g3 NOR  max 120  min  65  (latest input: g1)
g4 XOR  max 180  min  70  (latest input: g3)
Y  AND  max 225  min  70  (latest input: g4)
Z  AND  max  95  min  50  (latest input: c)
Y: path a -> g1 -> g3 -> g4 -> Y | setup slack -10 VIOLATION | hold slack 15 ok
Z: path c -> Z | setup slack 120 ok | hold slack -5 VIOLATION

৭ · Clock বিতরণ — clock tree, H-tree, PLL আর clock gating

একটি chip-এ clock-কে লক্ষ লক্ষ flip-flop-এ প্রায় একই সময়ে পৌঁছাতে হয়। একটি তারে এত flip-flop জুড়লে fan-out বিশাল, delay বিশাল, আর দূরের flip-flop অনেক দেরিতে clock পায় — বিশাল skew. তাই clock যায় একটি clock tree দিয়ে: মূল থেকে buffer, প্রতিটি buffer আরও কয়েকটি buffer চালায়, শেষে প্রতিটি পাতায় অল্প কয়েকটি flip-flop. লক্ষ্য — মূল থেকে প্রতিটি পাতার পথের delay সমান রাখা।

এর একটি সুন্দর জ্যামিতিক রূপ H-tree: chip-এর কেন্দ্র থেকে একটি “H” আঁকুন; H-এর চার কোণ থেকে আবার ছোট ছোট H, এভাবে বারবার। গঠন অনুযায়ী কেন্দ্র থেকে প্রতিটি কোণের তার-দৈর্ঘ্য সমান, তাই আদর্শ অবস্থায় skew শূন্য। বাস্তবে logic-এর অসমান বিন্যাস, তারের বৈচিত্র্য আর তাপমাত্রার পার্থক্যে কিছু skew থেকেই যায়; উচ্চ-গতির কিছু CPU-তে তাই tree-র শেষ স্তরে তারের একটি জাল (clock mesh) ব্যবহার করা হয়, যা পার্থক্যগুলো গড় করে দেয় — বেশি power-এর বিনিময়ে।

Clock আসে কোথা থেকে? Board-এ একটি crystal oscillator তুলনামূলক কম কিন্তু খুব স্থির frequency দেয় (প্রায়ই কয়েক MHz থেকে ১০০ MHz-এর মতো)। Chip-এর ভেতরে একটি PLL (phase-locked loop) সেটিকে গুণ করে — যেমন ১০০ MHz × ৪০ = ৪ GHz — আর নিজের output-কে reference-এর সাথে phase মিলিয়ে “তালাবদ্ধ” রাখে। অনেক ডেস্কটপ CPU-র “multiplier” কথাটি এখান থেকেই। PLL-এর output-এর ছোট কাঁপুনিই অংশ ৫-এর jitter-এর একটি বড় উৎস।

Clock gating — power বাঁচানো। পর্ব ০২-এর সূত্র মনে করুন: dynamic power ≈ α·C·V^২·f, যেখানে α (activity factor) হলো প্রতি cycle-এ গড়ে কতটুকু capacitance পুরো একবার charge আর discharge হয়। সাধারণ data-তারে α প্রায়ই অনেক কম, কিন্তু clock-তার প্রতিটি cycle-এ একবার ওঠে আর একবার নামে — α = ১, সর্বোচ্চ, আর তার-জালও বিশাল। তাই chip-এর dynamic power-এর একটি বড় অংশ clock network-এই খরচ হতে পারে। যে block এই মুহূর্তে কাজ করছে না (যেমন floating-point unit, যখন প্রোগ্রাম শুধু integer হিসাব করছে), তার clock বন্ধ রাখলে বড় সাশ্রয় হয় — একে বলে clock gating.

সহজ বুদ্ধি: gclk = clk AND enable. কিন্তু এটি বিপজ্জনক! clk = 1 থাকাকালীন enable বদলালে gclk-এ একটি ছোট্ট বাড়তি pulse (glitch) বা কাটা pulse তৈরি হয় — আর flip-flop-এর কাছে clock-এর glitch মানে একটি বাড়তি, ভুল edge. তার ওপর AND gate-এর delay clock-পথে skew যোগ করে। সমাধান হলো integrated clock-gating cell (ICG): ভেতরে একটি latch, যা clk = 0 থাকাকালীন enable-এর মান নেয় আর clk = 1 থাকাকালীন সেটি আটকে রাখে; তারপর AND. ফলে enable শুধু clock-এর নিচু অংশে বদলাতে পারে, আর gated clock-এ সবসময় পূর্ণ, পরিষ্কার pulse. Synthesis tool আর standard-cell library এই cell সরবরাহ করে; হাতে লেখা “AND দিয়ে clock বন্ধ” প্রায় সব নকশা-নিয়মে নিষিদ্ধ।

৮ · Metastability — যখন setup-hold মানা অসম্ভব

এতক্ষণের সব হিসাব ধরে নিয়েছে, D কখন বদলাবে তা আমরা জানি — কারণ সব কিছু একই clock থেকে আসে। কিন্তু পৃথিবী clock মানে না। একজন মানুষ যেকোনো মুহূর্তে বোতাম চাপেন; network-এর তার, sensor, বা অন্য clock-এ চলা আরেকটি chip যেকোনো সময় সংকেত পাঠায়। এমন asynchronous input-এর ক্ষেত্রে কোনো না কোনো সময় D ঠিক setup-hold জানালার ভেতরে বদলাবেই — এড়ানোর উপায় নেই।

তখন flip-flop-এর ভেতরে কী হয়? পর্ব ১৫-এ দেখেছেন, flip-flop-এর মূলে দুটি inverter একে অপরকে চালায় — একটি bistable circuit, যার দুটি স্থির অবস্থা (0 আর 1). জানালার ভেতরে D বদলালে circuit এই দুইয়ের মাঝখানের একটি অস্থির সাম্য-বিন্দুর কাছে পড়ে যেতে পারে, যেখানে output-এর voltage না 0, না 1. এই অবস্থার নাম metastability.

গণিতে এই “গড়িয়ে পড়া” প্রায় সূচকীয় (exponential): metastable অবস্থা থেকে বের হতে t-এর বেশি সময় লাগার সম্ভাবনা প্রায় (T₀ / T_c) · e^−t/τ. এখানে τ (tau) হলো flip-flop-এর resolution time constant — তার ভেতরের inverter-জোড়া কত দ্রুত পার্থক্য বাড়ায় — আর T₀ একটি জানালা-সংক্রান্ত ধ্রুবক; দুটিই মেপে বের করা হয়। প্রতি সেকেন্ডে f_data বার ইনপুট বদলালে ব্যর্থতার হার = f_data × সেই সম্ভাবনা, আর তার উল্টো হলো গড় ব্যর্থতা-বিরতি, MTBF (mean time between failures). Harris & Harris-এর রূপে, T_c = ১ / f_clk বসিয়ে:

MTBF = e^{t_r / τ} / (T₀ · f_clk · f_data)

t_r হলো flip-flop-কে স্থির হওয়ার জন্য কত সময় দেওয়া হলো (resolution time). মূল কথা: t_r সূচকে বসে। t_r একটু বাড়ালেই MTBF বহুগুণ বাড়ে। একটি flip-flop-এর output সরাসরি logic-এ গেলে t_r = T_c − t_pd − t_setup — অল্প। সমাধান: প্রথম flip-flop-এর পরে আরেকটি flip-flop বসান, আর মাঝে কোনো logic রাখবেন না। প্রথমটি metastable হলেও তার হাতে প্রায় পুরো একটি cycle (t_r ≈ T_c − t_setup) থাকে স্থির হওয়ার জন্য; দ্বিতীয়টি তখন একটি পরিষ্কার মান ধরে। এই জোড়ার নাম two-flip-flop synchronizer.

  button ──► [FF1] ──meta──► [FF2] ──sync──► logic
  (async)      ▲                ▲
  clk ─────────┴────────────────┘     Tc = 2000 ps (500 MHz)

before edge 1:  async = 0,  meta = 0,  sync = 0

edge 1 at t = 0;  async goes 0 -> 1 at t = -10 ps
(inside FF1's setup window: the last 100 ps before the edge)

async = 1
meta  = M  (about VDD/2, neither 0 nor 1)
sync  = 0   (FF2 sampled the clean old meta = 0)

t =    0 ps   meta = M
t =  300 ps   meta = 1  (resolved; could have been 0)
t = 1900 ps   FF2 setup window opens: meta is long stable

time allowed: tr = Tc - tsetup = 2000 - 100 = 1900 ps
logic sees sync = 0 the whole cycle (clean)

edge 2 at t = 2000 ps
FF2 samples meta = 1 (stable)   -> sync = 1
FF1 samples async = 1           -> meta = 1

logic sees a clean 0 -> 1, one or two cycles late

if meta had resolved to 0 at 300 ps:
edge 2:  FF2 gets 0 -> sync = 0,   FF1 gets async = 1 -> meta = 1
edge 3:  FF2 gets 1 -> sync = 1

either way: sync is always a clean 0 or 1;
the only cost is one extra cycle of delay

failure = meta still undecided after tr = 1900 ps
-> FF2 may go metastable too

P(still metastable) = (T0 / Tc) * e^(-tr / tau)
with tau = 50 ps:  e^(-1900/50) = e^(-38) ~ 3e-17
-> this rare event is exactly what MTBF counts

সংখ্যা দিয়ে দেখা যাক। ধরুন τ = ৫০ ps, T₀ = ১০০ ps, t_setup = ১০০ ps, আর asynchronous ইনপুট প্রতি সেকেন্ডে ১ কোটিবার (১০ MHz) বদলায় (মানগুলো বোঝানোর জন্য ধরা; আসল মান প্রতিটি process আর cell-এর জন্য মেপে datasheet-এ দেওয়া থাকে):

// Synchroniser MTBF:  MTBF = e^(tr / tau) / (T0 * fclk * fdata)
// tr = time the (possibly metastable) flip-flop is allowed to settle.
const tau = 50e-12, T0 = 100e-12;            // flip-flop constants
const fdata = 10e6;                          // async input changes 10 M/s
const tsetup = 100e-12, tlogic = 1500e-12;   // capture setup, logic delay
function human(s) {
  const units = [["years", 3.156e7], ["days", 86400], ["hours", 3600],
                 ["min", 60], ["s", 1], ["ms", 1e-3], ["us", 1e-6]];
  for (const [u, k] of units)
    if (s >= k) return (s / k >= 1000 ? (s / k).toFixed(0) : (s / k).toPrecision(3)) + " " + u;
  return s.toExponential(2) + " s";
}
function mtbf(label, fclk, tr) {
  const m = Math.exp(tr / tau) / (T0 * fclk * fdata);
  console.log(label.padEnd(26) + `tr = ${(tr * 1e12).toFixed(0).padStart(4)} ps` +
    `  MTBF = ${m.toExponential(2).padStart(8)} s = ${human(m)}`);
}
const T500 = 1 / 500e6, T1G = 1 / 1e9;
// one flip-flop: its output goes straight into 1500 ps of logic
mtbf("500 MHz, 1 FF + logic", 500e6, T500 - tlogic - tsetup);
// two flip-flops: the first one gets (almost) a whole cycle to settle
mtbf("500 MHz, 2 FF", 500e6, T500 - tsetup);
// same synchroniser, clock doubled: much less time to settle
mtbf("1 GHz,   2 FF", 1e9, T1G - tsetup);
// three flip-flops: roughly two settling windows in a row
mtbf("1 GHz,   3 FF", 1e9, 2 * (T1G - tsetup));

500 MHz, 1 FF + logic     tr =  400 ps  MTBF =  5.96e-3 s = 5.96 ms
500 MHz, 2 FF             tr = 1900 ps  MTBF = 6.37e+10 s = 2019 years
1 GHz,   2 FF             tr =  900 ps  MTBF =  6.57e+1 s = 1.09 min
1 GHz,   3 FF             tr = 1800 ps  MTBF =  4.31e+9 s = 137 years

Verilog-এ two-flip-flop synchronizer দেখতে খুবই সাধারণ — কিন্তু নিয়মগুলো কঠোর: মাঝের তারে (meta) কোনো logic নয়, দুটি flip-flop chip-এ পাশাপাশি বসানো, আর tool-কে জানানো যে এটি synchronizer (কিছু FPGA tool-এ, যেমন AMD/Xilinx Vivado-তে, ASYNC_REG নামের attribute দিয়ে; নির্মাতার নির্দেশিকায় শিকলের প্রতিটি flip-flop-এ এটি দেওয়ার কথা বলা হয়, নিচে ছোট রাখতে শুধু প্রথমটিতে দেখানো হলো):

// Two-flip-flop synchronizer for ONE asynchronous bit
module sync2 (input  wire clk,
              input  wire rst_n,      // active-low reset
              input  wire async_in,   // from a button or another clock domain
              output reg  sync_out);
  (* ASYNC_REG = "TRUE" *) reg meta; // stage 1: may go metastable
  always @(posedge clk or negedge rst_n)
    if (!rst_n) begin
      meta     <= 1'b0;
      sync_out <= 1'b0;
    end else begin
      meta     <= async_in;  // never use 'meta' anywhere else
      sync_out <= meta;      // stage 2: clean 0 or 1 (almost always)
    end
endmodule

Clock domain crossing — এক clock থেকে আরেক clock-এ

আধুনিক SoC-তে একাধিক clock থাকে — CPU core, মেমরি controller, USB, display — প্রত্যেকের নিজস্ব frequency. একই clock-এ চলা অংশগুলোকে বলে একটি clock domain, আর এক domain থেকে আরেক domain-এ সংকেত পাঠানোকে clock domain crossing (CDC). গ্রহণকারী domain-এর কাছে প্রেরকের সংকেত asynchronous, তাই প্রতিটি crossing-এ synchronizer লাগে। কিন্তু সাবধান:

• এক বিট: two-flip-flop synchronizer যথেষ্ট — শর্ত, সংকেতটি গ্রহণকারী clock-এর অন্তত কয়েক cycle স্থির থাকে, নইলে ছোট pulse হারিয়ে যেতে পারে।
• অনেক বিট একসাথে (যেমন ৮ বিটের counter): প্রতিটি বিটে আলাদা synchronizer বসালে বিপদ। 0111 থেকে 1000-এ যাওয়ার সময় চারটি বিটই বদলায়; কোনো বিট পুরোনো, কোনোটি নতুন মান ধরলে গ্রহণকারী পেতে পারে 1111 বা 0000 — দুটি মানই সম্পূর্ণ ভুল।
• সমাধান ১ — handshake: ডেটা স্থির রেখে একটি এক-বিটের “req” সংকেত synchronize করে পাঠানো; গ্রহণকারী ডেটা নিয়ে “ack” ফেরত পাঠায়। ধীর, কিন্তু নিরাপদ।
• সমাধান ২ — asynchronous FIFO: দুই domain-এর মাঝে একটি ছোট মেমরি-সারি; লেখার pointer আর পড়ার pointer অন্য domain-এ পাঠানো হয় Gray code-এ (পর্ব ০৪, সংখ্যা পদ্ধতি)। Gray code-এ পরপর দুই মানে ঠিক একটি বিট বদলায়, তাই synchronizer হয় পুরোনো মান পায়, নয় নতুন মান — মাঝামাঝি আবর্জনা কখনো নয়। পুরোনো মান পেলে FIFO শুধু একটু সাবধানী (“প্রায় ভরা”) আচরণ করে, ভুল নয়।

Switch debouncing — বোতাম একবার চাপলে কেন দশবার পড়ে

একটি যান্ত্রিক সুইচ বা বোতামের ভেতরে দুটি ধাতব পাত। চাপ দিলে পাত দুটি ঠোকাঠুকি করে কয়েক মিলিসেকেন্ড লাফায় — সংযোগ হয়, ছেঁড়ে, আবার হয় — তারপর স্থির হয়। একে বলে switch bounce. মানুষের কাছে এটি একবার চাপ; কিন্তু ১০০ MHz-এর circuit-এর কাছে প্রতিটি লাফ আলাদা চাপ। লিফটের বোতাম একবার চাপলে যদি counter ৫ বাড়ে, তা-ই এই সমস্যা। (বোতাম asynchronous-ও, তাই প্রথমে synchronizer, তারপর debouncer.)

সমাধান debouncing: ইনপুট নতুন মান দেখালেই বিশ্বাস না করে অপেক্ষা করা, যতক্ষণ না পরপর N টি নমুনায় একই নতুন মান আসে। Hardware-এ এটি একটি counter (পর্ব ১৬, Register, shift register আর counter) বা একটি shift register, যার সব বিট সমান কি না দেখা হয়। নিচের simulator প্রতি ৫ ms-এ একটি নমুনা নেয়, আর N = ৪ (অর্থাৎ ২০ ms স্থিরতা) চায়:

// Counter debouncer: the clean output changes only after the raw
// (bouncy) input has shown the same new value for N samples in a row.
const N = 4;                       // e.g. 4 samples x 5 ms = 20 ms stable
const raw = "0000101101111111111110100100000000";  // one sample per 5 ms
let clean = 0, count = 0, out = "", events = [];
for (let i = 0; i < raw.length; i++) {
  const x = +raw[i];
  if (x === clean) count = 0;      // same as output: nothing to do
  else if (++count === N) {        // new value held N samples: accept it
    clean = x; count = 0;
    events.push(`t=${i * 5} ms -> ${x}`);
  }
  out += clean;
}
let naive = 0;                      // edges a plain counter would see
for (let i = 1; i < raw.length; i++) if (raw[i - 1] === "0" && raw[i] === "1") naive++;
console.log("raw   " + raw);
console.log("clean " + out);
console.log("rising edges in raw: " + naive + ", in clean: " +
  (out.match(/01/g) || []).length);
console.log("accepted changes: " + events.join(", "));

raw   0000101101111111111110100100000000
clean 0000000000001111111111111111100000
rising edges in raw: 5, in clean: 1
accepted changes: t=60 ms -> 1, t=145 ms -> 0

৯ · Clock আরও দ্রুত হয় না কেন — power, pipeline আর বাস্তবতা

সূত্রটি আবার দেখুন: T_c ≥ t_pcq + t_pd + t_setup + t_skew. Clock দ্রুত করার দুটি পথ — gate দ্রুত করা (প্রযুক্তি), আর প্রতিটি cycle-এ logic কম রাখা (নকশা)। দ্বিতীয় পথের নাম pipelining: একটি লম্বা critical path-কে register দিয়ে কয়েক টুকরো করা, যাতে প্রতিটি টুকরোর t_pd ছোট হয় (পর্ব ৩৫, pipelining-এ বিস্তারিত)। কিন্তু দুই পথই দেয়ালে ঠেকে:

• Sequencing overhead কমে না। Logic-কে k টুকরো করলে প্রতিটি টুকরো t_pd/k, কিন্তু প্রতিটির সাথে পুরো t_pcq + t_setup + t_skew যোগ হয়। উদাহরণ ১-এর CLA-তেই overhead ছিল cycle-এর ৩১%; আরও ভাগ করলে প্রায় পুরো cycle register-এর খরচে যায়।
• Power. Dynamic power f-এর সমানুপাতিক, আর বেশি f-এর জন্য প্রায়ই voltage-ও বাড়াতে হয় — V^২ দিয়ে। পর্ব ০২-এ (ইতিহাস আর প্রবণতা) দেখেছেন, ২০০০-এর দশকের মাঝামাঝি এই power wall-এ ধাক্কা খেয়ে ডেস্কটপ CPU-র clock কয়েক GHz-এ প্রায় থেমে যায়, আর শিল্প multicore-এর দিকে মোড় নেয়।
• গভীর pipeline-এর অন্য দাম। বেশি ধাপ মানে branch ভুল অনুমান হলে বেশি কাজ ফেলে দেওয়া (পর্ব ৩৭) আর বেশি hazard (পর্ব ৩৬)। তাই উচ্চ clock-এর লাভ প্রায়ই CPI বেড়ে গিয়ে কিছুটা হারিয়ে যায় — পর্ব ০৩-এর CPU-time সূত্রে দুটি গুণকই দেখতে হয়।
• Skew আর jitter স্থির খরচ। Clock tree যত বড়, skew-এর বাজেট তত; ২৫০ ps-এর cycle-এ ২০–৩০ ps-এর অনিশ্চয়তাও বড় অংশ।

১০ · AI-এর যুগে timing-এর হিসাব

AI টুল setup-hold-এর সংজ্ঞা ঠিকঠাক বলতে পারে, কিন্তু সংখ্যার হিসাবে প্রায়ই ভুল করে — বিশেষ করে কোন delay max আর কোনটি min, skew-এর চিহ্ন, আর hold-এ clock-এর ভূমিকা নিয়ে। নিচের ভুলগুলো চোখে পড়ার মতো ঘন ঘন দেখা যায়:

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

• Setup-এর সূত্রে শুধু “p” (সবচেয়ে দেরি) আর hold-এর সূত্রে শুধু “c” (সবচেয়ে আগে) সংখ্যা আছে
• Hold-এর সূত্রে T_c নেই — উত্তর “clock ধীর করুন” হলে তা ভুল
• Skew-এর চিহ্ন আর সংজ্ঞা (capture − launch) স্পষ্ট লেখা আছে
• সব সংখ্যা এক এককে (ps), আর f_max = ১ / T_c-এর একক রূপান্তর (ps → GHz) নিজে মিলিয়েছি
• দেওয়া script চালিয়েছি, আর হাতের হিসাবের সাথে প্রতিটি সংখ্যা মিলেছে
• Synchronizer বা CDC-র Verilog simulator-এ চালিয়েছি; মাঝের তারে কোনো logic নেই, multi-bit সংকেতে Gray code বা handshake আছে