fix: apply domain fixes from contributor PRs #1782, #1784

B200/NVL72 TFLOP constants (2x correction per NVIDIA Blackwell
datasheet): B200 FP16 dense 2250 → 4500 TFLOPS, NVL72 FP16
162 → 324 PFLOPS, and all derived precision values. Applied to
hardware/registry.py (the current location, not the old
constants.py that the original PR targeted).

Kits hardware spec corrections: Pi Zero 2W is quad-core (not
single-core), Pi power specs use proper voltage/amperage format,
Nicla Vision memory corrected to 1MB SRAM + 2MB Flash + 16MB
external QSPI Flash.

Labs fixes: 404.qmd dark-mode selectors (body.quarto-dark),
lab_11 FlashAttention MathPeek speedup formula (N/B not M/d),
lab_06 tau_opt consistency (MTBF 50 hrs for 1,000 GPUs matches
the reveal text and Young-Daly formula).

Based on contributions by Shashank-Tripat in PRs #1782 and #1784.

Author: profvjreddi

book/tests/test_units.py

@@ -346,7 +346,7 @@ def test_extended_gpu_specs():
     ok &= check("V100 TDP", V100_TDP.to(watt).magnitude, 300.0)
 
     # B200
-    ok &= check("B200 FP16", B200_FLOPS_FP16_TENSOR.to(TFLOPs / second).magnitude, 2250.0)
+    ok &= check("B200 FP16", B200_FLOPS_FP16_TENSOR.to(TFLOPs / second).magnitude, 4500.0)
     ok &= check("B200 BW", B200_MEM_BW.to(TB / second).magnitude, 8.0)
     ok &= check("B200 Mem", B200_MEM_CAPACITY.to(GiB).magnitude, 192.0)
 

book/tools/audit/audit_mlsysim_drift.py

@@ -41,8 +41,8 @@
     ("h100_fp8",       1979,  0.02, 'Hardware.Cloud.H100.compute.precision_flops["fp8"]'),
     ("h100_tf32",      494,   0.02, 'Hardware.Cloud.H100.compute.precision_flops["tf32"]'),
     ("h100_int8",      1979,  0.02, 'Hardware.Cloud.H100.compute.precision_flops["int8"]'),
-    ("b200_fp16",      2250,  0.02, "Hardware.Cloud.B200.compute.peak_flops"),
-    ("b200_fp8",       4500,  0.02, 'Hardware.Cloud.B200.compute.precision_flops["fp8"]'),
+    ("b200_fp16",      4500,  0.02, "Hardware.Cloud.B200.compute.peak_flops"),
+    ("b200_fp8",       9000,  0.02, 'Hardware.Cloud.B200.compute.precision_flops["fp8"]'),
     ("mi300x_fp16",    1307,  0.02, "Hardware.Cloud.MI300X.compute.peak_flops"),
 
     # GPU memory (GiB, GB/s, TB/s)

kits/contents/platforms.qmd

@@ -131,7 +131,7 @@ The Nicla Vision exemplifies professional-grade embedded vision systems built ar
 STM32H747 dual-core ARM Cortex-M7/M4 running at 480MHz
 
 **Memory Hierarchy:**
-2MB integrated RAM and 16MB Flash storage
+1MB integrated SRAM and 2MB Flash storage, plus 16MB external QSPI Flash
 
 **Integrated Sensors:**
 GC2145 camera sensor, MP34DT05 digital microphone, 6-axis IMU

kits/contents/raspi/raspi.qmd

@@ -20,8 +20,9 @@ Camera modules, power adapters, and SD cards are available from the same reselle
 
 - **Raspberry Pi**: Ensure you have at least one of the boards: the Raspberry Pi Zero 2 W, Raspberry Pi 4 or 5 for the Vision Labs, and the Raspberry 5 for the GenAi labs.
 - **Power Adapter**: To Power on the boards.
-    - Raspberry Pi Zero 2-W: 2.5 W with a Micro-USB adapter
-    - Raspberry Pi 4 or 5: 3.5 W with a USB-C adapter
+    - Raspberry Pi Zero 2-W: 5V / 2.5A via Micro-USB adapter
+    - Raspberry Pi 4: 5V / 3A via USB-C adapter
+    - Raspberry Pi 5: 5V / 5A via USB-C adapter
 
 - **Network**: With internet access for downloading the necessary software and controlling the boards remotely.
 - **SD Card (32 GB minimum) and an SD card Adapter**: For the Raspberry Pi OS.

kits/contents/raspi/setup/setup.qmd

@@ -28,7 +28,7 @@ The Raspberry Pi is a powerful and versatile single-board computer that has beco
 
 1. **Raspberry Pi Zero 2 W** (*Raspi-Zero*):
    - Ideal for: Compact embedded systems
-   - Key specs: 1 GHz single-core CPU (ARM Cortex-A53), 512 MB RAM, minimal power consumption
+   - Key specs: 1 GHz quad-core CPU (ARM Cortex-A53), 512 MB RAM, minimal power consumption
 
 2. **Raspberry Pi 5** (*Raspi-5*):
    - Ideal for: More demanding applications such as edge computing, computer vision, and edgeAI applications, including LLMs.

labs/404.qmd

@@ -27,18 +27,6 @@ title: "Page Not Found"
 .j404-nav a { color: #555 !important; text-decoration: none !important; }
 .j404-nav a:hover { color: #a31f34 !important; }
 @media (max-width: 540px) { .j404-wrap { margin-top: 2.5rem; } .j404-joke { font-size: 1.1rem; } }
-@media (prefers-color-scheme: dark) {
-  .j404-joke { color: #f0f0f0; }
-  .j404-sub { color: #aaa; }
-  .j404-btn-secondary { background: transparent !important; color: #f0f0f0 !important; border-color: #444; }
-  .j404-btn-secondary:hover { border-color: #ff6b80 !important; color: #ff6b80 !important; }
-  .j404-refresh { color: #999; }
-  .j404-refresh:hover { color: #ff6b80 !important; }
-  .j404-meta-sep { color: #555; }
-  .j404-nav { border-top-color: #333; }
-  .j404-nav a { color: #aaa !important; }
-  .j404-nav a:hover { color: #ff6b80 !important; }
-}
 body.quarto-dark .j404-joke { color: #f0f0f0; }
 body.quarto-dark .j404-sub { color: #aaa; }
 body.quarto-dark .j404-btn-secondary { background: transparent !important; color: #f0f0f0 !important; border-color: #444; }

labs/vol1/lab_11_hw_accel.py

@@ -975,7 +975,7 @@ def build_part_e():
 - **$d$**: head dimension
 - **$M$**: SRAM size (on-chip memory per SM)
 
-Speedup $\\approx M / d$, which is 2-4x at typical dimensions. Tiling keeps Q, K, V blocks in SRAM, avoiding the $N^2$ materialization in HBM.
+Speedup $\\approx N / B$ (where $B$ is tile size), reaching ~10x at seq\_len=4096, tile=256. Tiling keeps Q, K, V blocks in SRAM, avoiding the $N^2$ materialization in HBM.
 """)
         }))
         return mo.vstack(items)

labs/vol2/lab_06_fault_tolerance.py

@@ -612,12 +612,12 @@ def build_part_b():
     - 175B parameters x 14 bytes (FP16 weights + FP32 Adam m1 + m2 + master) = **2.45 TB** per checkpoint
     - At NFS 1 GB/s aggregate write: 2,450 seconds = **~41 minutes**
 
-    With MTBF of ~5 hours (1,000 GPUs), the Young-Daly optimal interval is:
-    tau_opt = sqrt(2 * 2450 * 18,000) = sqrt(88,200,000) = ~9,393s = ~2.6 hours
+    With MTBF of ~50 hours (1,000 GPUs, MTTF=50,000 hrs each), the Young-Daly optimal interval is:
+    tau_opt = sqrt(2 * 2450 * 180,000) = sqrt(882,000,000) = ~29,700s = ~8.2 hours
 
-    But wait -- at 1 GB/s NFS, checkpoint write time (41 min) is already a significant
-    fraction of the optimal interval (2.6 hours). With faster storage (100 GB/s NVMe RAID),
-    the same checkpoint takes only 24.5 seconds.
+    At 1 GB/s NFS, checkpoint write time (41 min) is a manageable fraction of the 8.2 hour
+    optimal interval. With faster storage (100 GB/s NVMe RAID), the same checkpoint takes only
+    24.5 seconds.
 
     What happens at a larger cluster (10,000 GPUs) where MTBF drops to ~5 hours?
     """))
@@ -756,9 +756,9 @@ def build_part_b():
             items.append(mo.callout(mo.md(
                 "**Correct.** 175B x 14 bytes = 2.45 TB per checkpoint. At 1 GB/s NFS, that is "
                 "2,450 seconds = ~41 minutes. With MTBF of ~50 hours for a 1,000-GPU cluster, "
-                "the Young-Daly optimal interval is ~2.6 hours, so 41 minutes is within budget. "
-                "But at 10,000 GPUs (MTBF ~5 hours), optimal interval drops to ~27 minutes "
-                "-- now the write time *exceeds* the optimal interval. Checkpoint storm."
+                "the Young-Daly optimal interval is ~8.2 hours, so 41 minutes is well within budget. "
+                "But at 10,000 GPUs (MTBF ~5 hours), optimal interval drops to ~2.6 hours "
+                "-- now the write time (41 min) is a large fraction of the optimal interval."
             ), kind="success"))
         elif partB_prediction.value == "A":
             items.append(mo.callout(mo.md(

mlsysim/mlsysim/hardware/registry.py

@@ -102,7 +102,7 @@ class CloudHardware(Registry):
     B200 = HardwareNode(
         name="NVIDIA B200",
         release_year=2024,
-        compute=ComputeCore(peak_flops=2250 * TFLOPs / second, precision_flops={"fp8": 4500 * TFLOPs / second, "fp4": 9000 * TFLOPs / second, "int4": 9000 * TOPS}),
+        compute=ComputeCore(peak_flops=4500 * TFLOPs / second, precision_flops={"fp8": 9000 * TFLOPs / second, "fp4": 18000 * TFLOPs / second, "int4": 18000 * TOPS}),
         memory=MemoryHierarchy(capacity=192 * GiB, bandwidth=8 * TB / second),
         interconnect=IOInterconnect(name="PCIe Gen5 x16", bandwidth=64 * GB / second),
         nvlink=IOInterconnect(name="NVLink 5.0", bandwidth=1800 * GB / second, latency=LATENCY_NVLINK),
@@ -124,12 +124,12 @@ class CloudHardware(Registry):
         name="NVIDIA GB200 NVL72",
         release_year=2024,
         compute=ComputeCore(
-            peak_flops=162 * PFLOPs / second,
+            peak_flops=324 * PFLOPs / second,
             precision_flops={
-                "fp16": 162 * PFLOPs / second,
-                "bf16": 162 * PFLOPs / second,
-                "fp8": 324 * PFLOPs / second,
-                "fp4": 720 * PFLOPs / second,
+                "fp16": 324 * PFLOPs / second,
+                "bf16": 324 * PFLOPs / second,
+                "fp8": 648 * PFLOPs / second,
+                "fp4": 1440 * PFLOPs / second,
             },
         ),
         memory=MemoryHierarchy(capacity=13.8 * TB, bandwidth=576 * TB / second),