From d29f0ef7212c3ebac0c61533d37ba092da3a29bd Mon Sep 17 00:00:00 2001
From: qazal <77887910+Qazalin@users.noreply.github.com>
Date: Tue, 7 Apr 2026 17:07:09 +0300
Subject: [PATCH 01/21] viz: speed up profiler first render (#15632)

* viz: speed up profiler first render

* better comment
---
 tinygrad/viz/js/index.js | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/tinygrad/viz/js/index.js b/tinygrad/viz/js/index.js
index 4ca5f10105..781bac1a6f 100644
--- a/tinygrad/viz/js/index.js
+++ b/tinygrad/viz/js/index.js
@@ -408,8 +408,8 @@ async function renderProfiler(path, opts) {
   canvas.addEventListener("wheel", e => (e.stopPropagation(), e.preventDefault()), { passive:false });
   const ctx = canvas.getContext("2d");
   const canvasTop = rect(canvas).top;
-  // color by key (name/device)
-  const colorMap = new Map();
+  // map event name to shape and label colors
+  const colorMap = new Map(), coloredNames = new Map();
   // map shapes by event key
   const shapeMap = new Map();
   const heightScale = d3.scaleLinear().domain([0, tracePeak]).range([4,maxheight=100]);
@@ -448,11 +448,14 @@ async function renderProfiler(path, opts) {
           colorMap.set(colorKey, d3.rgb(color));
         }
         const fillColor = colorMap.get(colorKey).brighter(0.3*depth).toString();
-        const label = parseColors(e.name).flatMap(({ color, st }) => {
-          const parts = [];
-          for (let i=0; i<st.length; i+=4) { const part = st.slice(i, i+4); parts.push({ color, st:part, width:ctx.measureText(part).width }); }
-          return parts;
-        });
+        let label = coloredNames.get(e.name);
+        if (label == null) {
+          label = parseColors(e.name).flatMap(({ color, st }) => {
+            const parts = [];
+            for (let i=0; i<st.length; i+=4) { const part = st.slice(i, i+4); parts.push({ color, st:part, width:ctx.measureText(part).width }); }
+            return parts;
+          }); coloredNames.set(e.name, label);
+        }
         let shapeRef = e.ref;
         if (shapeRef != null) { ref = {ctx:e.ref, step:0}; shapeRef = ref; }
         else if (ref != null) {

From b78b384d58f65d9aae1c92724c55d6f6e316cdeb Mon Sep 17 00:00:00 2001
From: nimlgen <138685161+nimlgen@users.noreply.github.com>
Date: Tue, 7 Apr 2026 19:43:51 +0300
Subject: [PATCH 02/21] mlx: graph (#15621)

* Dx

* Dx

* simpler

* mypy

* x

* f

* Dx

* x

* c

* x
---
 tinygrad/helpers.py                    |   2 +
 tinygrad/runtime/graph/hcq.py          | 152 ++++++++++++++++++-------
 tinygrad/runtime/ops_rdma.py           |   2 +-
 tinygrad/runtime/support/mlx/mlxdev.py |   4 +-
 4 files changed, 117 insertions(+), 43 deletions(-)

diff --git a/tinygrad/helpers.py b/tinygrad/helpers.py
index 16947a686a..22f2213835 100644
--- a/tinygrad/helpers.py
+++ b/tinygrad/helpers.py
@@ -61,6 +61,8 @@ def lo32(x:Any) -> Any: return x & 0xFFFFFFFF # Any is sint
 def hi32(x:Any) -> Any: return x >> 32 # Any is sint
 def data64(data:Any) -> tuple[Any, Any]: return (data >> 32, data & 0xFFFFFFFF) # Any is sint
 def data64_le(data:Any) -> tuple[Any, Any]: return (data & 0xFFFFFFFF, data >> 32) # Any is sint
+def to_be32(val:Any) -> Any: return ((val & 0xFF) << 24) | (((val >> 8) & 0xFF) << 16) | (((val >> 16) & 0xFF) << 8) | ((val >> 24) & 0xFF)
+def to_be64(val:Any) -> Any: return to_be32(val >> 32) | (to_be32(val & 0xFFFFFFFF) << 32)
 def getbits(value: int, start: int, end: int): return (value >> start) & ((1 << (end - start + 1)) - 1)
 def i2u(bits: int, value: int): return value if value >= 0 else (1<<bits)+value
 def is_numpy_ndarray(x) -> bool: return str(type(x)) == "<class 'numpy.ndarray'>"
diff --git a/tinygrad/runtime/graph/hcq.py b/tinygrad/runtime/graph/hcq.py
index 28473c2e24..ea343dcce9 100644
--- a/tinygrad/runtime/graph/hcq.py
+++ b/tinygrad/runtime/graph/hcq.py
@@ -7,6 +7,7 @@ from tinygrad.dtype import dtypes
 from tinygrad.uop.ops import UOp, Ops, Variable
 from tinygrad.engine.realize import BufferXfer, CompiledRunner, BufferCopy
 from tinygrad.engine.jit import GraphRunner, MultiGraphRunner
+from tinygrad.runtime.ops_rdma import RDMACopyQueue
 
 class HCQGraph(MultiGraphRunner):
   def __init__(self, *args, **kwargs):
@@ -50,10 +51,21 @@ class HCQGraph(MultiGraphRunner):
 
     self.comp_queues: dict[HCQCompiled, HWQueue] = {dev: unwrap(dev.hw_compute_queue_t)() for dev in self.devices}
     self.copy_queues: dict[tuple[HCQCompiled, int], HWQueue] = {} # lazy allocation, keyed by (device, queue_idx)
+    self.rdma_queues: dict[tuple[HCQCompiled, HCQCompiled], RDMACopyQueue] = {} # lazy allocation, keyed by device pair
     self.num_copy_queues: int = getenv("HCQ_NUM_SDMA", min(len(self.devices), 8) if ALL2ALL >= 1 else 1)
+    self.num_rdma_ops: dict[tuple[HCQCompiled, HCQCompiled], int] = collections.defaultdict(int)
 
+    self.rdma_vars: dict[tuple[HCQCompiled, HCQCompiled], tuple[Variable, Any]] = {} # value is variable and src_qp
+    self.rdma_deps: dict[int, tuple[HWQueue, list[tuple[HCQSignal, int]], HCQSignal, int]] = {}
+    self.rdma_last_dest: dict[int, tuple[HWQueue, int]] = {} # per QP id: last (queue, signal_value) for dbell ordering
+
+    # Per-peer-group representative device for signal allocation. For cpu, use devices[0].
+    self.pg_dev: dict[Any, HCQCompiled] = {dev.peer_group: self.devices[0] for dev in self.devices if dev._is_cpu()} \
+                                        |  {dev.peer_group: dev for dev in self.devices if not dev._is_cpu()}
+
+    self.kick_signals: dict[Any, HCQSignal] = {pg: pg_dev.new_signal(value=0) for pg, pg_dev in self.pg_dev.items()}
     self.signals: dict[Any, HCQSignal] = {**{dev: dev.new_signal(value=0) for dev in self.devices if not dev._is_cpu()},
-      **{"KICK": self.devices[0].new_signal(value=0)}, **{dev: self.devices[0].new_signal(value=0) for dev in self.devices if dev._is_cpu()}}
+      **{dev: self.pg_dev[dev.peer_group].new_signal(value=0) for dev in self.devices if dev._is_cpu()}}
     self.kickoff_value: int = 0
     self.kickoff_var = UOp.variable("kickoff_var", 0, 0xffffffff, dtype=dtypes.uint32)
 
@@ -63,19 +75,22 @@ class HCQGraph(MultiGraphRunner):
     self.prof_graph_deps: list[list[int]] = []
     self.prof_graph_entries: list[ProfileGraphEntry] = []
 
-    last_j: dict[HWQueue, int|None] = collections.defaultdict(lambda: None)
-    queue_access: dict[HWQueue, dict[HWQueue, int|None]] = collections.defaultdict(lambda: collections.defaultdict(lambda: None))
-    dev_access: dict[HWQueue, set[HCQCompiled]] = collections.defaultdict(set)
+    self.last_j: dict[HWQueue, int|None] = collections.defaultdict(lambda: None)
+    self.queue_access: dict[HWQueue, dict[HWQueue, int|None]] = collections.defaultdict(lambda: collections.defaultdict(lambda: None))
+    self.dev_access: dict[HWQueue, set[HCQCompiled]] = collections.defaultdict(set)
 
-    for dev, queue in self.comp_queues.items(): dev_access[queue].add(dev)
+    for dev, queue in self.comp_queues.items(): self.dev_access[queue].add(dev)
 
     self.input_replace_map: dict[HCQCompiled, set[int]] = collections.defaultdict(set)
     self.device_vars: dict[HCQCompiled, dict[str, int]] = {}
 
     for j,ji in enumerate(self.jit_cache):
+      ji_devs = [cast(HCQCompiled, Device[cast(Buffer, b).device]) for b in ji.bufs] if isinstance(ji.prg, BufferXfer) else []
+      is_rdma = len(ji_devs) > 0 and not any(d._is_cpu() for d in ji_devs) and len(set(d.peer_group for d in ji_devs)) > 1
+
       if is_exec_prg:=isinstance(ji.prg, CompiledRunner): enqueue_dev: HCQCompiled = ji.prg.dev
       else:
-        # For copy ops prioritize enqeueuing on the dest device, so reverse the buffers.
+        # For copy ops prioritize enqeueuing on the src device, so reverse the buffers.
         for b in cast(list[Buffer], ji.bufs[::-1]):
           if (enqueue_dev:=cast(HCQCompiled, Device[b.device])).hw_copy_queue_t is not None: break
 
@@ -85,47 +100,39 @@ class HCQGraph(MultiGraphRunner):
 
       if is_exec_prg:
         enqueue_queue = self.comp_queues[enqueue_dev]
+      elif is_rdma:
+        enqueue_queue = self.comp_queues[enqueue_dev]
+        rdma_key = (cast(HCQCompiled, Device[cast(Buffer, ji.bufs[0]).device]).rdma_dev(), enqueue_dev.rdma_dev())
+        self.rdma_queues.setdefault(rdma_key, RDMACopyQueue(enqueue_dev.rdma_dev()))
       else:
         assert (enqueue_dev.hw_copy_queue_t is not None), "device must implement a copy queue"
         queue_idx = self.devices.index(cast(HCQCompiled, Device[cast(Buffer, ji.bufs[0]).device])) % self.num_copy_queues
         enqueue_queue = self.copy_queues.setdefault((enqueue_dev, queue_idx),
-                                                    enqueue_dev.hw_copy_queue_t(queue_idx=queue_idx).wait(self.signals['KICK'], self.kickoff_var))
+          enqueue_dev.hw_copy_queue_t(queue_idx=queue_idx).wait(self.kick_signals[enqueue_dev.peer_group], self.kickoff_var))
 
-      out_signal = self.signals.setdefault(enqueue_queue, self.devices[0].new_signal(value=0))
+      out_signal = self.signals.setdefault(enqueue_queue, self.pg_dev[enqueue_dev.peer_group].new_signal(value=0))
 
       # Get dependencies based on input and output buffers.
-      rdeps = self._access_resources(ji.bufs, ji.prg.p.outs if is_exec_prg else [0], (enqueue_queue, j + 1)) #type:ignore
+      if is_rdma:
+        src_qp, dest_qp = rdma_key[1].iface.connect(rdma_key[0])[:2]
+        sync_signals, opt_deps, rdeps = self._resolve_deps(ji.bufs[1:], [], enqueue_queue, enqueue_dev, out_signal, j,
+                                                           is_copy=isinstance(ji.prg, BufferXfer), rdma_qp=src_qp)
+        peer_queue = self.comp_queues[peer_dev:=cast(HCQCompiled, Device[cast(Buffer, ji.bufs[0]).device])]
+        peer_out_signal = self.signals.setdefault(peer_queue, self.pg_dev[peer_dev.peer_group].new_signal(value=0))
+        peer_sync_signals, peer_opt_deps, peer_rdeps = self._resolve_deps(ji.bufs[:1], [0], peer_queue, peer_dev, peer_out_signal, j,
+                                                                          is_copy=isinstance(ji.prg, BufferXfer), rdma_qp=dest_qp)
+        self.rdma_deps[j] = (peer_queue, peer_sync_signals + peer_opt_deps, peer_out_signal, j + 1)
+        self.last_j[peer_queue] = j
+      else:
+        sync_signals, opt_deps, rdeps = self._resolve_deps(ji.bufs, cast(CompiledRunner, ji.prg).p.outs if is_exec_prg else [0], enqueue_queue,
+          enqueue_dev, out_signal, j, is_copy=isinstance(ji.prg, BufferXfer))
 
-      # Update dependencies to include previous kernel in queue. This is required for timeline signals.
-      opt_deps, deps = [], rdeps + ([(enqueue_queue, prev_ji + 1)] if (prev_ji:=last_j[enqueue_queue]) is not None else [])
-
-      # Optimize dependencies by removing redundant ones. Remove waiting for the value of the queue which is known to be already
-      # synced with the current queue.
-      for dep_queue, dep_val in sorted(deps, key=lambda x: x[1], reverse=True):
-        if (qa:=queue_access[enqueue_queue][dep_queue]) is None or qa < dep_val:
-          opt_deps.append((self.signals[dep_queue], dep_val))
-          queue_access[enqueue_queue][dep_queue] = dep_val
-          dev_access[enqueue_queue].update(dev_access[dep_queue])
-
-      # Ensure device is ready for use in current context: the graph has initialized the device and it's safe to operate on it within this graph.
-      sync_signals = [(self.signals[d], self.kickoff_var) for b in ji.bufs if (d:=Device[cast(Buffer, b).device]) not in dev_access[enqueue_queue]]
-      dev_access[enqueue_queue].update(cast(HCQCompiled, Device[cast(Buffer, b).device]) for b in ji.bufs)
-
-      # Remove self-dependency for compute and copy queues.
-      # For compute, in case of NV, optimize when only 1 same-queue dependency exists, since NV chains 2+ executions in this case,
-      # eliminating dependency need.
-      dname = enqueue_dev.device.split(":", 1)[0]
-      can_opt = dname in {"AMD", "QCOM"} or (dname == "NV" and len(sync_signals) == 0 and len(opt_deps) == 1 and id(opt_deps[0][0]) == id(out_signal))
-      if can_opt or isinstance(ji.prg, BufferXfer): opt_deps = [x for x in opt_deps if id(x[0]) != id(out_signal)]
-
-      # Enable necessary signals in the schedule by setting the signal value.
-      for sig, val in opt_deps: self.ji_schedule[val - 1] = self.ji_schedule[val - 1][:5] + (val,)
       self.ji_schedule[j] = (enqueue_dev, enqueue_queue, sync_signals, opt_deps[::-1], out_signal, None if is_exec_prg else (j + 1))
 
       # Collect profile information if profiling is enabled.
       if PROFILE:
         # When execution are chained, we can reuse the end timestamp from the previous command as the start timestamp for the current command.
-        sig_st = prev_ji * 2 + 1 if len(opt_deps) == 0 and (prev_ji:=last_j[enqueue_queue]) is not None else j * 2
+        sig_st = prev_ji * 2 + 1 if len(opt_deps) == 0 and (prev_ji:=self.last_j[enqueue_queue]) is not None else j * 2
 
         # Description based on the command.
         prof_ji_desc = ji.prg._prg.name if is_exec_prg else TracingKey(f"{ji.bufs[1].device} -> {ji.bufs[0].device}", ret=ji.bufs[0].nbytes) # type: ignore
@@ -134,7 +141,7 @@ class HCQGraph(MultiGraphRunner):
         self.prof_graph_entries.append(ProfileGraphEntry(prof_name, prof_ji_desc, sig_st, j * 2 + 1))
         self.prof_graph_deps.append([d - 1 for _, d in rdeps])
 
-      last_j[enqueue_queue] = j
+      self.last_j[enqueue_queue] = j
 
     # Check which signals are used in the profile graph.
     self.prof_signal_is_used = [any(ent.st_id == j or ent.en_id == j for ent in self.prof_graph_entries) for j in range(len(self.jit_cache) * 2)]
@@ -149,7 +156,7 @@ class HCQGraph(MultiGraphRunner):
 
     for dev in self.devices:
       self.comp_queues[dev].memory_barrier().wait(self.virt_timeline_signals[dev], self.virt_timeline_vals[dev]) \
-                           .wait(self.signals['KICK'], self.kickoff_var).signal(self.signals[dev], self.kickoff_var)
+                           .wait(self.kick_signals[dev.peer_group], self.kickoff_var).signal(self.signals[dev], self.kickoff_var)
 
     for j,ji in enumerate(self.jit_cache):
       enqueue_dev, enqueue_queue, sync_signals, deps, signal, signal_val = self.ji_schedule[j]
@@ -165,6 +172,28 @@ class HCQGraph(MultiGraphRunner):
       # Encode main commands based on ji type.
       if isinstance(ji.prg, CompiledRunner):
         enqueue_queue.exec(ji.prg._prg, self.ji_args[j], tuple(ji.prg.p.global_size or (1,1,1)), tuple(ji.prg.p.local_size or (1,1,1)))
+      elif isinstance(ji.prg, BufferXfer) and len(set(cast(HCQCompiled, Device[cast(Buffer, b).device]).peer_group for b in ji.bufs)) > 1:
+        dest_queue, dest_deps, dest_out_signal, dest_out_val = self.rdma_deps[j]
+        for sig, val in dest_deps: dest_queue.wait(sig, val)
+
+        dest, src = [cast(Buffer, x) for x in ji.bufs[0:2]]
+        dest_dev, src_dev = cast(HCQCompiled, Device[dest.device]), cast(HCQCompiled, Device[src.device])
+        dest_rdma, src_rdma = dest_dev.rdma_dev(), src_dev.rdma_dev()
+
+        # get qp info
+        src_qp, dest_qp, src_cq_buf, dest_cq_buf = src_rdma.iface.connect(dest_rdma)
+
+        # use var for head
+        head_var = self.rdma_vars.setdefault((dest_rdma, src_rdma), (UOp.variable(f"rdma_var_{j}", 0, 0xffffffff, dtype=dtypes.uint32), src_qp))[0]
+        next_head = self.num_rdma_ops[(dest_rdma, src_rdma)]
+
+        rdma_queue = self.rdma_queues[(dest_rdma, src_rdma)]
+        rdma_queue.copy(self.hcq_bufs[j][0], self.hcq_bufs[j][1], dest.nbytes) \
+                  .encode_ring(enqueue_queue, src_dev, src_rdma.iface, src_qp, src_cq_buf, head_var + next_head, ring_uar=True) \
+                  .encode_ring(self.comp_queues[dest_dev], dest_dev, dest_rdma.iface, dest_qp, dest_cq_buf, head_var + next_head)
+
+        dest_queue.signal(dest_out_signal, dest_out_val)
+        self.num_rdma_ops[(dest_rdma, src_rdma)] += 1
       elif isinstance(ji.prg, (BufferXfer, BufferCopy)):
         dest, src = [cast(Buffer, x) for x in ji.bufs[0:2]]
         for bufid, src in enumerate(cast(list[Buffer], ji.bufs)):
@@ -181,7 +210,7 @@ class HCQGraph(MultiGraphRunner):
     for dev in self.devices:
       for dep_dev in list(self.copy_to_devs[dev]) + [dev]:
         for copy_q in self._dev_copy_queues(dep_dev):
-          if copy_q in self.signals: self.comp_queues[dev].wait(self.signals[copy_q], cast(int, last_j[copy_q]) + 1)
+          if copy_q in self.signals: self.comp_queues[dev].wait(self.signals[copy_q], cast(int, self.last_j[copy_q]) + 1)
 
       self.comp_queues[dev].signal(self.virt_timeline_signals[dev], self.virt_timeline_vals[dev] + 1).bind(dev)
       for copy_q in self._dev_copy_queues(dev): copy_q.bind(dev)
@@ -189,6 +218,44 @@ class HCQGraph(MultiGraphRunner):
     self.last_timeline: dict[HCQCompiled, tuple[HCQSignal, int]] = {dev: (dev.timeline_signal, 0) for dev in self.devices}
     self.queue_signals_to_reset = [self.signals[q] for q in list(self.comp_queues.values()) + list(self.copy_queues.values()) if q in self.signals]
 
+  def _resolve_deps(self, bufs, outs, enqueue_queue, enqueue_dev, out_signal, j, is_copy, rdma_qp=None):
+    rdeps = self._access_resources(bufs, outs, (enqueue_queue, j + 1)) #type:ignore
+
+    # Order shared QP doorbell record writes across different compute queues (head+1 must complete before head+2).
+    if rdma_qp is not None and (prev:=self.rdma_last_dest.get(id(rdma_qp))) is not None and prev[0] is not enqueue_queue:
+      rdeps = rdeps + [(prev[0], prev[1])]
+    if rdma_qp is not None: self.rdma_last_dest[id(rdma_qp)] = (enqueue_queue, j + 1)
+
+    # Update dependencies to include previous kernel in queue. This is required for timeline signals.
+    opt_deps, deps = [], rdeps + ([(enqueue_queue, prev_ji + 1)] if (prev_ji:=self.last_j[enqueue_queue]) is not None else [])
+
+    # Optimize dependencies by removing redundant ones. Remove waiting for the value of the queue which is known to be already
+    # synced with the current queue.
+    for dep_queue, dep_val in sorted(deps, key=lambda x: x[1], reverse=True):
+      if (qa:=self.queue_access[enqueue_queue][dep_queue]) is None or qa < dep_val:
+        opt_deps.append((self.signals[dep_queue], dep_val))
+        self.queue_access[enqueue_queue][dep_queue] = dep_val
+        self.dev_access[enqueue_queue].update(self.dev_access[dep_queue])
+
+    # Ensure device is ready for use in current context: the graph has initialized the device and it's safe to operate on it within this graph.
+    # Only sync with same-peer-group devices; cross-peer-group sync is handled by RDMA.
+    sync_signals = [(self.signals[d], self.kickoff_var) for b in bufs
+      if (d:=cast(HCQCompiled, Device[cast(Buffer, b).device])) not in self.dev_access[enqueue_queue]
+      and (d.peer_group == enqueue_dev.peer_group or rdma_qp is None)]
+    self.dev_access[enqueue_queue].update(cast(HCQCompiled, Device[cast(Buffer, b).device]) for b in bufs)
+
+    # Remove self-dependency for compute and copy queues.
+    # For compute, in case of NV, optimize when only 1 same-queue dependency exists, since NV chains 2+ executions in this case,
+    # eliminating dependency need. For RDMA, keep self-dependency to flush cache.
+    dname = enqueue_dev.device.split(":", 1)[0]
+    can_opt = dname in {"AMD", "QCOM"} or (dname == "NV" and len(sync_signals) == 0 and len(opt_deps) == 1 and id(opt_deps[0][0]) == id(out_signal))
+    if (can_opt or is_copy) and rdma_qp is None: opt_deps = [x for x in opt_deps if id(x[0]) != id(out_signal)]
+
+    # Enable necessary signals in the schedule by setting the signal value.
+    for sig, val in opt_deps: self.ji_schedule[val - 1] = self.ji_schedule[val - 1][:5] + (val,)
+
+    return sync_signals, opt_deps, rdeps
+
   def _dev_copy_queues(self, dev): return [q for (d, _), q in self.copy_queues.items() if d == dev]
 
   def __call__(self, input_buffers: list[Buffer], var_vals: dict[str, int], wait=False) -> float|None:
@@ -209,6 +276,9 @@ class HCQGraph(MultiGraphRunner):
     for (j,i),input_idx in self.input_replace.items():
       hcq_var_vals[self.input_replace_to_var[(j,i)].expr] = input_buffers[input_idx]._buf.va_addr
 
+    for (var, qp) in self.rdma_vars.values(): hcq_var_vals[var.expr] = qp.head
+    for q in self.rdma_queues.values(): q.submit(q.dev, hcq_var_vals)
+
     for dev in self.devices:
       self.comp_queues[dev].submit(dev, hcq_var_vals_local:=hcq_var_vals|self.device_vars.get(dev, {}))
       for copy_queue in self._dev_copy_queues(dev): copy_queue.submit(dev, hcq_var_vals_local)
@@ -216,7 +286,7 @@ class HCQGraph(MultiGraphRunner):
 
     # Launch graph
     for sig in self.queue_signals_to_reset: sig.value = 0
-    self.signals['KICK'].value = self.kickoff_value
+    for sig in self.kick_signals.values(): sig.value = self.kickoff_value
 
     if wait:
       st = time.perf_counter()
@@ -247,8 +317,10 @@ class HCQGraph(MultiGraphRunner):
     # If all of devices are mapped into CPU address space, can use CPU inside the peer group.
     cpu_support = all(type(d.timeline_signal.base_buf.view) is MMIOInterface for d in all_devs)
 
-    # Check if all devices are within the same peer group. If CPU is supported, don't count it as a separate peer group.
-    if len(set(d.peer_group for d in all_devs if not (cpu_support and d._is_cpu()))) > 1: return False
+    # Check if all devices are within the same peer group. Allow cross-peer-group if all peer groups have RDMA devices.
+    if len(set(d.peer_group for d in all_devs if not (cpu_support and d._is_cpu()))) > 1:
+      try: [d.rdma_dev() for d in all_devs if not d._is_cpu()]
+      except RuntimeError: return False
 
     if new_call.src[0].op is Ops.COPY:
       # MOCKGPU is not supported, since it can't execute commands in parallel
diff --git a/tinygrad/runtime/ops_rdma.py b/tinygrad/runtime/ops_rdma.py
index b4a09e7572..15069a354a 100644
--- a/tinygrad/runtime/ops_rdma.py
+++ b/tinygrad/runtime/ops_rdma.py
@@ -21,7 +21,7 @@ class RDMACopyQueue(HWQueue):
     for buf in [iface.dbr_buf, cq_buf] + ([iface.uar_buf] if ring_uar else []): cast(HCQAllocator, dev.allocator).map(buf)
     hwq.write(iface.dbr_buf.offset(qp.qp_dbr + (4 if ring_uar else 0)), to_be('I', head + 1))
     if ring_uar: hwq.write(iface.uar_buf.offset(0x800), to_be('Q', ((head << 8) | 0x0a) << 32 | ((qp.qp_info['qpn'] << 8) | 2)), b64=True)
-    hwq.poll_bit(cq_buf.offset((head & (qp.cq_size - 1)) * 64 + 60, 4), ((head >> 7) & 1) << 24, mask=0x01000000)
+    hwq.poll_bit(cq_buf.offset((head & (qp.cq_size - 1)) * 64 + 60, 4), ((head >> (qp.cq_size.bit_length() - 1)) & 1) << 24, mask=0x01000000)
     hwq.write(iface.dbr_buf.offset(qp.cq_dbr), to_be('I', (head + 1) & 0xFFFFFF))
     return self
 
diff --git a/tinygrad/runtime/support/mlx/mlxdev.py b/tinygrad/runtime/support/mlx/mlxdev.py
index 739c34f687..ff84e8e463 100644
--- a/tinygrad/runtime/support/mlx/mlxdev.py
+++ b/tinygrad/runtime/support/mlx/mlxdev.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 import struct, random, socket, ctypes, functools, itertools
-from tinygrad.helpers import getenv, wait_cond, round_up, next_power2, ceildiv, DEBUG, hi32, lo32
+from tinygrad.helpers import getenv, wait_cond, round_up, next_power2, ceildiv, DEBUG, hi32, lo32, to_be32, to_be64
 from tinygrad.runtime.support.memory import BumpAllocator
 from tinygrad.runtime.support.system import PCIDevice
 from tinygrad.runtime.autogen import mlx5, pci
@@ -11,7 +11,7 @@ MLX5_CMD_STRUCTS = {v: (getattr(mlx5, f"struct_mlx5_ifc_{n[12:].lower()}_in_bits
   getattr(mlx5, f"struct_mlx5_ifc_{n[12:].lower()}_out_bits", None)) for n, v in mlx5.__dict__.items() if n.startswith("MLX5_CMD_OP_")}
 MLX5_CMD_STRUCTS[mlx5.MLX5_CMD_OP_ACCESS_REG] = (mlx5.struct_mlx5_ifc_access_register_in_bits, mlx5.struct_mlx5_ifc_access_register_out_bits)
 
-def to_be(fmt, val): return struct.unpack('<'+fmt, struct.pack('>'+fmt, val))[0]
+def to_be(fmt, val): return to_be32(val) if fmt == 'I' else to_be64(val)
 def ipv4_to_gid(ip): return bytes(10) + b'\xff\xff' + socket.inet_aton(ip)
 
 def udp_sport(lqpn, rqpn):

From 890286e8d6e22dc199fcac4b6b5f0aa06c9a94ac Mon Sep 17 00:00:00 2001
From: qazal <77887910+Qazalin@users.noreply.github.com>
Date: Tue, 7 Apr 2026 21:18:45 +0300
Subject: [PATCH 03/21] update llama profile.sh (#15633)

* update llama profile.sh

* BENCHMARK 5
---
 .../llama8b/implementations/tinybox_8xMI350X/dev_beam.sh        | 2 +-
 .../llama8b/implementations/tinybox_8xMI350X/profile.sh         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama8b/implementations/tinybox_8xMI350X/dev_beam.sh b/examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama8b/implementations/tinybox_8xMI350X/dev_beam.sh
index c345538f6f..6dfbf57089 100755
--- a/examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama8b/implementations/tinybox_8xMI350X/dev_beam.sh
+++ b/examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama8b/implementations/tinybox_8xMI350X/dev_beam.sh
@@ -36,7 +36,7 @@ export DATA_SEED=${DATA_SEED:-5760}
 export JITBEAM=${JITBEAM:-3}
 export BEAM_UOPS_MAX=6000 BEAM_UPCAST_MAX=256 BEAM_LOCAL_MAX=1024 BEAM_MIN_PROGRESS=5 BEAM_PADTO=1
 
-export FAKEDATA=1 BENCHMARK=10
+export FAKEDATA=1 BENCHMARK=${BENCHMARK:-10}
 if [ -z "$FULL_LAYERS" ]; then
   export LLAMA_LAYERS=2
 fi
diff --git a/examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama8b/implementations/tinybox_8xMI350X/profile.sh b/examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama8b/implementations/tinybox_8xMI350X/profile.sh
index cfddfa2601..e8fed36b18 100755
--- a/examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama8b/implementations/tinybox_8xMI350X/profile.sh
+++ b/examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama8b/implementations/tinybox_8xMI350X/profile.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
 export BENCHMARK=5
 export EVAL_BS=0
-VIZ=${VIZ:--1} examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama8b/implementations/tinybox_8xMI350X/dev_run.sh
+VIZ=${VIZ:--1} FULL_LAYERS=1 DEBUG=0 examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama8b/implementations/tinybox_8xMI350X/dev_beam.sh
 extra/viz/cli.py --profile -s "${DEV:-AMD}"

From 9c6e925b56e108e7f793a1998ec41e020fdf30f1 Mon Sep 17 00:00:00 2001
From: chenyu <chenyu@fastmail.com>
Date: Tue, 7 Apr 2026 15:13:00 -0400
Subject: [PATCH 04/21] move lerp to mixin (#15634)

last function of math function section
---
 tinygrad/mixin/elementwise.py | 13 +++++++++++++
 tinygrad/tensor.py            | 15 ---------------
 2 files changed, 13 insertions(+), 15 deletions(-)

diff --git a/tinygrad/mixin/elementwise.py b/tinygrad/mixin/elementwise.py
index c1cb59cd82..8a4129c495 100644
--- a/tinygrad/mixin/elementwise.py
+++ b/tinygrad/mixin/elementwise.py
@@ -974,3 +974,16 @@ class ElementwiseMixin(DTypeMixin, CreationMixin):
     """
     if self.dtype != dtypes.bool and not dtypes.is_int(self.dtype): raise RuntimeError(f"{self.dtype} is not supported")
     return self.logical_not() if self.dtype == dtypes.bool else self ^ -1
+
+  def lerp(self, end: Self, weight: Self | ConstType) -> Self:
+    """
+    Linearly interpolates between `self` and `end` by `weight`.
+
+    ```python exec="true" source="above" session="tensor" result="python"
+    print(Tensor([1., 2., 3.]).lerp(Tensor([4., 5., 6.]), 0.5).numpy())
+    ```
+    """
+    if self.dtype == dtypes.uint8 and isinstance(weight, ElementwiseMixin):
+      w_i = (weight * (1<<(W_PREC:=7)) + 0.5).cast(dtypes.int16)
+      return (self+(((end - self).cast(dtypes.int8) * w_i + (1<<W_PREC-1)).cast(dtypes.uint16) >> W_PREC)).cast(dtypes.uint8)
+    return self + (end - self) * weight
diff --git a/tinygrad/tensor.py b/tinygrad/tensor.py
index 2f42f83da7..45c45d62ce 100644
--- a/tinygrad/tensor.py
+++ b/tinygrad/tensor.py
@@ -2385,21 +2385,6 @@ class Tensor(OpMixin):
     """
     return self._apply_uop(UOp.contiguous_backward)
 
-  # ***** math functions *****
-
-  def lerp(self, end:Tensor, weight:Tensor|float) -> Tensor:
-    """
-    Linearly interpolates between `self` and `end` by `weight`.
-
-    ```python exec="true" source="above" session="tensor" result="python"
-    print(Tensor([1., 2., 3.]).lerp(Tensor([4., 5., 6.]), 0.5).numpy())
-    ```
-    """
-    if self.dtype == dtypes.uint8 and isinstance(weight, Tensor):
-      w_i = (weight * (1<<(W_PREC:=7)) + 0.5).cast(dtypes.int16)
-      return (self+(((end - self).cast(dtypes.int8) * w_i + (1<<W_PREC-1)).cast(dtypes.uint16) >> W_PREC)).cast(dtypes.uint8)
-    return self + (end - self) * weight
-
   # ***** broadcasted elementwise ops *****
 
   def ufix(self, x) -> Tensor:

From a508b8fd2a7b5666278a0a6c2b127e74ed6a4416 Mon Sep 17 00:00:00 2001
From: qazal <77887910+Qazalin@users.noreply.github.com>
Date: Wed, 8 Apr 2026 01:18:04 +0300
Subject: [PATCH 05/21] viz: delete redundant things (#15637)

* delete that

* remove

* delete graph config
---
 extra/viz/cli.py         |  1 -
 tinygrad/viz/js/index.js | 18 +++++++-----------
 2 files changed, 7 insertions(+), 12 deletions(-)

diff --git a/extra/viz/cli.py b/extra/viz/cli.py
index 2fa1459372..25806400d2 100755
--- a/extra/viz/cli.py
+++ b/extra/viz/cli.py
@@ -59,7 +59,6 @@ def main(args) -> None:
     events:list = viz.load_pickle(args.profile_path, default=[])
     if (profile_bytes:=viz.get_profile(events)) is None: raise RuntimeError(f"empty profile in {args.profile_path}")
     profile = decode_profile(profile_bytes)
-    viz.load_amd_counters(viz.ctxs, events)
     profile["layout"].update([(f'{c["name"]} {s["name"]}', s["data"]) for c in viz.ctxs if c["name"].startswith("SQTT") for s in c["steps"]
                               if "PKTS" in s["name"]])
     if args.src is None:
diff --git a/tinygrad/viz/js/index.js b/tinygrad/viz/js/index.js
index 781bac1a6f..24f8419030 100644
--- a/tinygrad/viz/js/index.js
+++ b/tinygrad/viz/js/index.js
@@ -16,7 +16,6 @@ const darkenHex = (h, p = 0) =>
 
 const ANSI_COLORS = ["#b3b3b3", "#ff6666", "#66b366", "#ffff66", "#6666ff", "#ff66ff", "#66ffff", "#ffffff"];
 const ANSI_COLORS_LIGHT = ["#d9d9d9","#ff9999","#99cc99","#ffff99","#9999ff","#ff99ff","#ccffff","#ffffff"];
-const colorsCache = new Map();
 const parseColors = (name, defaultColor="#ffffff") => Array.from(name.matchAll(/(?:\u001b\[(\d+)m([\s\S]*?)\u001b\[0m)|([^\u001b]+)/g),
   ([_, code, colored_st, st]) => ({ st: colored_st ?? st, color: code != null ? (code>=90 ? ANSI_COLORS_LIGHT : ANSI_COLORS)[(parseInt(code)-30+60)%60] : defaultColor }));
 
@@ -375,7 +374,6 @@ function setFocus(key) {
 }
 
 const EventTypes = { EXEC:0, BUF:1 };
-const GraphConfig = [{ pcolor:"#c9a8ff", unit:"B", fillColor:"#2B1B72"}, { pcolor:"#4fa3cc", unit:"Hz", fillColor:"#4fa3cc"}];
 
 async function renderProfiler(path, opts) {
   displaySelection("#profiler");
@@ -487,7 +485,6 @@ async function renderProfiler(path, opts) {
       div.style("height", levelHeight*levels.length+padding+"px").style("pointerEvents", "none");
     } else {
       const linear = u8(), peak = u64();
-      const config = GraphConfig[linear];
       const timestamps = [], valueMap = new Map();
       // start by unpacking the raw events
       const memEvents = [];
@@ -516,7 +513,7 @@ async function renderProfiler(path, opts) {
       const yscale = d3.scaleLinear().domain([0, peak]).range([height, 0]);
       // generic polygon merger
       const base0 = yscale(0);
-      const sum = {x:[], y0:[], y1:[], fillColor:config.fillColor};
+      const sum = {x:[], y0:[], y1:[], fillColor:linear ? null : "#2b1b72"};
       for (let i=0; i<timestamps.length-1; i++) {
         const yv = yscale(valueMap.get(timestamps[i]));
         sum.x.push(timestamps[i], timestamps[i+1]); sum.y1.push(yv, yv); sum.y0.push(base0, base0);
@@ -555,8 +552,8 @@ async function renderProfiler(path, opts) {
         return bufShapes;
       };
       if (timestamps.length > 0) data.first = data.first == null ? timestamps[0] : Math.min(data.first, timestamps[0]);
-      data.tracks.set(k, { shapes:[sum], eventType, linear, visible, offsetY, pcolor:config.pcolor, height, peak, scaleFactor:maxheight*4/height,
-                           get views() { return [[sum], linear ? null : buildBufShapes()]; }, valueMap, rowBorderColor });
+      data.tracks.set(k, { shapes:[sum], eventType, linear, visible, offsetY, pcolor:linear ? "#4fa3cc" : "#c9a8ff", height, peak, scaleFactor:maxheight*4/height,
+                           get views() { return [[sum], linear ? null : buildBufShapes()]; }, valueMap, rowBorderColor, unit:linear ? "Hz" : "B" });
       div.style("height", height+padding+"px").style("cursor", "pointer").on("click", (e) => {
         if (linear) return;
         const newFocus = e.currentTarget.id === focusedDevice ? null : e.currentTarget.id;
@@ -566,7 +563,7 @@ async function renderProfiler(path, opts) {
           if (tid === newFocus) { track.shapes = track.views[1]; offset += rescaleTrack(track, tid, track.scaleFactor); }
           else if (tid === focusedDevice) { track.shapes = track.views[0]; offset += rescaleTrack(track, tid, 1/track.scaleFactor); }
         }
-        data.axes.y = newFocus != null ? { domain:[0, (t=data.tracks.get(newFocus)).peak], range:[t.offsetY+t.height, t.offsetY], fmt:config.unit } : null;
+        data.axes.y = newFocus != null ? { domain:[0, (t=data.tracks.get(newFocus)).peak], range:[t.offsetY+t.height, t.offsetY], fmt:t.unit } : null;
         toggleCls(document.getElementById(focusedDevice), document.getElementById(newFocus), "expanded");
         focusedDevice = newFocus;
         return resize();
@@ -611,12 +608,11 @@ async function renderProfiler(path, opts) {
     const visibleYStart = profilerEl.scrollTop-canvasTop + rect(profilerEl).top, visibleYEnd = visibleYStart+profilerEl.clientHeight;
     ctx.textBaseline = "middle";
     // draw shapes
-    for (const [k, { shapes, eventType, linear, visible, offsetY, valueMap, pcolor, scolor, rowBorderColor }] of data.tracks) {
+    for (const [k, { shapes, eventType, linear, visible, offsetY, valueMap, pcolor, scolor, unit, rowBorderColor }] of data.tracks) {
       visible.length = 0;
       const trackHeight = rect(document.getElementById(k)).height;
       if (offsetY+trackHeight < visibleYStart || offsetY > visibleYEnd) continue;
       const addBorder = scolor != null ? (w) => { if (w > 10) { ctx.strokeStyle = scolor; ctx.stroke(); } } : null;
-      const config = GraphConfig[linear];
       for (const e of shapes) {
         if (eventType === EventTypes.BUF) { // generic polygon
           if (e.x[0]>et || e.x.at(-1)<st) continue;
@@ -626,10 +622,10 @@ async function renderProfiler(path, opts) {
           for (let i=1; i<x.length; i++) {
             ctx.lineTo(x[i], offsetY+e.y1[i]);
             let arg = e.arg;
-            if (arg == null && valueMap != null) arg = {tooltipText: formatUnit(valueMap.get(e.x[i-1]), config.unit)}
+            if (arg == null && valueMap != null) arg = {tooltipText: formatUnit(valueMap.get(e.x[i-1]), unit)}
             visible.push({ x0:x[i-1], x1:x[i], y0:offsetY+e.y1[i-1], y1:offsetY+e.y0[i], arg });
           }
-          if (linear) { ctx.strokeStyle = e.fillColor; ctx.lineWidth = 2; ctx.stroke(); ctx.lineWidth = 1; }
+          if (linear) { ctx.strokeStyle = pcolor; ctx.lineWidth = 2; ctx.stroke(); ctx.lineWidth = 1; }
           // walk the path back and fill the complete shape
           else { for (let i=x.length-1; i>=0; i--) ctx.lineTo(x[i], offsetY+e.y0[i]); ctx.closePath(); ctx.fillStyle = e.fillColor; ctx.fill(); }
         } else { // contiguous rect

From bf3763526ab5f08f5ef1fe5598c084189ef56ac8 Mon Sep 17 00:00:00 2001
From: b1tg <33436708+b1tg@users.noreply.github.com>
Date: Wed, 8 Apr 2026 10:26:23 +0800
Subject: [PATCH 06/21] llm: buffer SSE chunks to fix parse errors from split
 reads (#15641)

---
 tinygrad/apps/llm.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/tinygrad/apps/llm.py b/tinygrad/apps/llm.py
index 6fe4a19201..9ffa500d4f 100644
--- a/tinygrad/apps/llm.py
+++ b/tinygrad/apps/llm.py
@@ -313,10 +313,14 @@ CHAT_HTML = b'''<!DOCTYPE html><html><head><title>tinygrad chat</title><style>
     const d = document.createElement('div'); d.className = 'msg'; chat.appendChild(d);
     const r = await fetch('/v1/chat/completions', {method: 'POST', headers: {'Content-Type': 'application/json'},
       body: JSON.stringify({model: 'llama', messages: msgs, stream: true, temperature: 0.7})});
+    let buf = '';
     for (const rd = r.body.getReader(), dec = new TextDecoder();;) {
       const {done, value} = await rd.read();
       if (done) break;
-      for (const ln of dec.decode(value).split('\\n'))
+      buf += dec.decode(value, {stream: true});
+      const lines = buf.split('\\n');
+      buf = lines.pop();
+      for (const ln of lines)
         if (ln.startsWith('data: ') && !ln.includes('[DONE]'))
           try { d.textContent += JSON.parse(ln.slice(6)).choices[0]?.delta?.content || '' } catch {}
       chat.scrollTop = chat.scrollHeight;

From f930579b7ac198f7398050dbaaa81196b7a0736a Mon Sep 17 00:00:00 2001
From: George Hotz <geohot@gmail.com>
Date: Wed, 8 Apr 2026 11:25:38 +0800
Subject: [PATCH 07/21] llm: change the default port to 8000 so you can
 remember it (match vLLM)

---
 test/external/external_llm_eval.py | 2 +-
 tinygrad/apps/llm.py               | 5 ++---
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/test/external/external_llm_eval.py b/test/external/external_llm_eval.py
index 3a111b71f3..0841b9740e 100644
--- a/test/external/external_llm_eval.py
+++ b/test/external/external_llm_eval.py
@@ -8,7 +8,7 @@ LABEL = ["A", "B", "C", "D"]
 
 if __name__ == "__main__":
   parser = argparse.ArgumentParser()
-  parser.add_argument("--port", "-p", type=int, default=11434)
+  parser.add_argument("--port", "-p", type=int, default=8000)
   parser.add_argument("--limit", "-L", type=int, default=None)
   parser.add_argument("--max_tokens", "-T", type=int, default=4096)
   parser.add_argument("--offset", "-O", type=int, default=0)
diff --git a/tinygrad/apps/llm.py b/tinygrad/apps/llm.py
index 9ffa500d4f..5e22fd9b86 100644
--- a/tinygrad/apps/llm.py
+++ b/tinygrad/apps/llm.py
@@ -287,8 +287,7 @@ models = {
   "olmoe": "https://huggingface.co/allenai/OLMoE-1B-7B-0924-Instruct-GGUF/resolve/main/olmoe-1b-7b-0924-instruct-q4_k_m.gguf",
 }
 
-# *** simple OpenAI compatible server on 11434 to match ollama ***
-# OPENAI_BASE_URL=http://localhost:11434/v1 OPENAI_API_KEY=ollama uvx --from gpt-command-line gpt
+# *** simple OpenAI API compatible server with web interface on http://localhost:8000/ ***
 
 CHAT_HTML = b'''<!DOCTYPE html><html><head><title>tinygrad chat</title><style>
   * { margin: 0 }
@@ -397,7 +396,7 @@ if __name__ == "__main__":
   parser = argparse.ArgumentParser()
   parser.add_argument("--model", "-m", default=list(models.keys())[0], help=f"Model choice ({', '.join(models.keys())}) or path to a local GGUF file")
   parser.add_argument("--max_context", type=int, default=4096, help="Max Context Length")
-  parser.add_argument("--serve", nargs='?', type=int, const=11434, metavar="PORT", help="Run OpenAI compatible API (optional port, default 11434)")
+  parser.add_argument("--serve", nargs='?', type=int, const=8000, metavar="PORT", help="Run OpenAI compatible API (optional port, default 8000)")
   parser.add_argument("--warmup", action="store_true", help="warmup the JIT")
   parser.add_argument("--benchmark", nargs='?', type=int, const=20, metavar="COUNT", help="Benchmark tok/s (optional count, default 20)")
   args = parser.parse_args()

From bcf6931a4f42337da79ad169bbfe180ede18ee83 Mon Sep 17 00:00:00 2001
From: Christopher Milan <chrismilan@ucla.edu>
Date: Tue, 7 Apr 2026 20:57:03 -0700
Subject: [PATCH 08/21] fix: comma 4 does not have pcie (#15642)

---
 tinygrad/runtime/support/system.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/tinygrad/runtime/support/system.py b/tinygrad/runtime/support/system.py
index e7858a5b73..eaa3445dff 100644
--- a/tinygrad/runtime/support/system.py
+++ b/tinygrad/runtime/support/system.py
@@ -66,7 +66,9 @@ class _System:
       iokit.IOServiceGetMatchingServices(0, iokit.IOServiceMatching(b"IOPCIDevice"), ctypes.byref(iterator:=ctypes.c_uint()))
       while svc:=iokit.IOIteratorNext(iterator): all_devs.append((v:=read_prop(svc, "vendor-id"), d:=read_prop(svc, "device-id"), f"{v:x}:{d:x}"))
     else:
-      for pcibus in FileIOInterface("/sys/bus/pci/devices").listdir():
+      try: devs = FileIOInterface("/sys/bus/pci/devices")
+      except FileNotFoundError: raise RuntimeError("no pcie")
+      for pcibus in devs.listdir():
         if base_class is not None and int(FileIOInterface(f"/sys/bus/pci/devices/{pcibus}/class").read(), 16) >> 16 != base_class: continue
         all_devs.append((int(FileIOInterface(f"/sys/bus/pci/devices/{pcibus}/vendor").read(), 16),
                          int(FileIOInterface(f"/sys/bus/pci/devices/{pcibus}/device").read(), 16), pcibus))

From 70dbd35023e3c892e4d9ae41fdc346959b80c200 Mon Sep 17 00:00:00 2001
From: wozeparrot <wozeparrot@gmail.com>
Date: Wed, 8 Apr 2026 15:19:14 +0800
Subject: [PATCH 09/21] llama: move custom_kernel into flat_llama (#15643)

---
 examples/mlperf/model_train.py       |  5 +-
 examples/mlperf/models/flat_llama.py | 14 +++--
 examples/mlperf/models/llama.py      | 80 ----------------------------
 extra/gemm/cdna_asm_gemm.py          |  7 ++-
 test/backend/test_asm_gemm.py        |  4 +-
 tinygrad/tensor.py                   | 13 +----
 6 files changed, 22 insertions(+), 101 deletions(-)
 delete mode 100644 examples/mlperf/models/llama.py

diff --git a/examples/mlperf/model_train.py b/examples/mlperf/model_train.py
index de6b8e9f5c..8ac1dbd4fa 100644
--- a/examples/mlperf/model_train.py
+++ b/examples/mlperf/model_train.py
@@ -1544,7 +1544,7 @@ def train_llama3():
 
       mem_gb = GlobalCounters.mem_used / 1e9
       gflops = GlobalCounters.global_ops / 1e9 / dev_time
-      mfu = ((6 * num_params * SEQLEN * GBS) / (dev_time * device_count * 2.3e15)) * 100
+      mfu = ((6 * num_params * SEQLEN * GBS) / (dev_time * device_count * (4.6e15 if FP8 else 2.3e15))) * 100
       tqdm.write(
           f"{i:5} {step_time:.3f} s step, {gbs_time:.3f} s gbs, {optim_time:.3f} s optim, {data_time:.3f} s data, {loss:.4f} loss, " \
           f"{lr:.12f} LR, {grad_norm:.6f} grad_norm, {mem_gb:.2f} GB used, {gflops:9.2f} GFLOPS, {mfu:5.2f}% MFU")
@@ -1578,7 +1578,8 @@ def train_llama3():
 
       if i == BENCHMARK:
         median_step_time = sorted(step_times)[(BENCHMARK + 1) // 2]
-        estimated_total_minutes = int(median_step_time * (SAMPLES // GBS) / 60)
+        estimated_steps = 200_000 // GBS if getenv("LLAMA3_SIZE", "8B") == "8B" else MAX_STEPS
+        estimated_total_minutes = int(median_step_time * estimated_steps / 60)
         print(f"Estimated training time: {estimated_total_minutes // 60}h{estimated_total_minutes % 60}m")
         print(f"epoch global_ops: {GlobalCounters.global_ops:_}, "
               f"epoch global_mem: {GlobalCounters.global_mem:_}")
diff --git a/examples/mlperf/models/flat_llama.py b/examples/mlperf/models/flat_llama.py
index 91f2eac2da..fd6aa1e812 100644
--- a/examples/mlperf/models/flat_llama.py
+++ b/examples/mlperf/models/flat_llama.py
@@ -35,8 +35,12 @@ def quantize_fp8(x:Tensor, amax_state:Tensor|None=None):
   return x_clamped.cast(FP8_DTYPE), scale.float().reciprocal()
 
 def matmul(x:Tensor, w:Tensor, fp8=FP8, amax_x:Tensor|None=None, amax_w:Tensor|None=None) -> Tensor:
-  if not fp8: return x @ w.T
   from tinygrad.helpers import ASM_GEMM
+  if not fp8:
+    if ASM_GEMM:
+      from extra.gemm.cdna_asm_gemm import can_use_asm_gemm, asm_gemm
+      if can_use_asm_gemm(x, w.T): return asm_gemm(x, w.T)
+    return x @ w.T
   x_fp8, x_scale = quantize_fp8(x, amax_state=amax_x)
   w_fp8, w_scale = quantize_fp8(w, amax_state=amax_w)
   combined_scale = x_scale * w_scale
@@ -122,7 +126,11 @@ class FlatTransformer:
     xq, xk = apply_rotary_emb(xq, xk, freqs_cis)
     if FP8: xq, xk, xv = xq.cast(dtypes.bfloat16), xk.cast(dtypes.bfloat16), xv.cast(dtypes.bfloat16)
     xq, xk, xv = xq.transpose(1, 2), xk.transpose(1, 2), xv.transpose(1, 2)
-    attn = xq.scaled_dot_product_attention(xk, xv, is_causal=True, enable_gqa=True).transpose(1, 2)
+    if getenv("HK_FLASH_ATTENTION"):
+      from extra.thunder.amd.fa import flash_attention
+      attn = flash_attention(xq, xk, xv, is_causal=True)
+    else:
+      attn = xq.scaled_dot_product_attention(xk, xv, is_causal=True, enable_gqa=True).transpose(1, 2)
     attn = attn.reshape(bsz, seqlen, -1)
     return matmul(attn, wo, amax_x=amax_xo, amax_w=amax_wo)
 
@@ -193,7 +201,7 @@ class FlatTransformer:
                          self.attention_norm[i], self.wo[i],
                          self.ffn_norm[i], self.w1[i], self.w2[i], self.w3[i],
                          **attn_kwargs, **amax_attn, **amax_layer)
-    logits = (self.norm(h).contiguous().contiguous_backward() @ self.output[0].T).contiguous_backward()
+    logits = matmul(self.norm(h).contiguous().contiguous_backward(), self.output[0], fp8=False).contiguous_backward()
     return logits
 
 def _get_pads(uop:UOp) -> list[UOp]:
diff --git a/examples/mlperf/models/llama.py b/examples/mlperf/models/llama.py
deleted file mode 100644
index 0ae17fd93c..0000000000
--- a/examples/mlperf/models/llama.py
+++ /dev/null
@@ -1,80 +0,0 @@
-from tinygrad import Tensor, nn
-from tinygrad.helpers import getenv
-from extra.models.llama import apply_rotary_emb, precompute_freqs_cis
-
-class Attention:
-  def __init__(self, dim:int, n_heads:int, n_kv_heads:int|None=None, linear=nn.Linear):
-    self.n_heads = n_heads
-    self.n_kv_heads = n_kv_heads if n_kv_heads is not None else n_heads # n_kv_heads != n_heads implies MQA [arxiv/2307.09288, A.2.1]
-    self.head_dim = dim // n_heads
-    self.n_rep = self.n_heads // self.n_kv_heads
-
-    if getenv("WQKV"):
-      self.wqkv = linear(dim, self.n_heads * self.head_dim + self.n_kv_heads * self.head_dim * 2, bias=False)
-    else:
-      self.wq = linear(dim, self.n_heads * self.head_dim, bias=False)
-      self.wk = linear(dim, self.n_kv_heads * self.head_dim, bias=False)
-      self.wv = linear(dim, self.n_kv_heads * self.head_dim, bias=False)
-
-    self.wo = linear(self.n_heads * self.head_dim, dim, bias=False)
-
-  def __call__(self, x:Tensor, freqs_cis:Tensor) -> Tensor:
-    if getenv("WQKV"):
-      xqkv = self.wqkv(x)
-      xqkv = xqkv.reshape(xqkv.shape[0], xqkv.shape[1], self.n_kv_heads, self.n_rep + 2, self.head_dim)
-      xq = xqkv[:, :, :, :self.n_rep].reshape(xqkv.shape[0], xqkv.shape[1], -1)
-      xk = xqkv[:, :, :, self.n_rep:self.n_rep+1].reshape(xqkv.shape[0], xqkv.shape[1], -1)
-      xv = xqkv[:, :, :, self.n_rep+1:self.n_rep+2].reshape(xqkv.shape[0], xqkv.shape[1], -1)
-    else:
-      xq, xk, xv = self.wq(x), self.wk(x), self.wv(x)
-
-    xq = xq.reshape(xq.shape[0], xq.shape[1], self.n_heads, self.head_dim)
-    xk = xk.reshape(xk.shape[0], xk.shape[1], self.n_kv_heads, self.head_dim)
-    xv = xv.reshape(xv.shape[0], xv.shape[1], self.n_kv_heads, self.head_dim)
-
-    xq, xk = apply_rotary_emb(xq, xk, freqs_cis)
-    bsz, seqlen, _, _ = xq.shape
-
-    xq, xk, xv = xq.transpose(1, 2), xk.transpose(1, 2), xv.transpose(1, 2)
-    attn = xq.scaled_dot_product_attention(xk, xv, is_causal=True, enable_gqa=True).transpose(1, 2)
-
-    attn = attn.reshape(bsz, seqlen, -1)
-    return self.wo(attn)
-
-class FeedForward:
-  def __init__(self, dim:int, hidden_dim:int, linear=nn.Linear):
-    self.w1 = linear(dim, hidden_dim, bias=False)
-    self.w2 = linear(hidden_dim, dim, bias=False)
-    self.w3 = linear(dim, hidden_dim, bias=False) # the gate in Gated Linear Unit
-
-  def __call__(self, x:Tensor) -> Tensor:
-    w1 = self.w1(x).silu()
-    w3 = self.w3(x)
-    return self.w2(w1 * w3)
-
-class TransformerBlock:
-  def __init__(self, dim:int, hidden_dim:int, n_heads:int, n_kv_heads:int|None, norm_eps:float, linear=nn.Linear):
-    self.attention = Attention(dim, n_heads, n_kv_heads, linear)
-    self.feed_forward = FeedForward(dim, hidden_dim, linear)
-    self.attention_norm = nn.RMSNorm(dim, norm_eps)
-    self.ffn_norm = nn.RMSNorm(dim, norm_eps)
-
-  def __call__(self, x:Tensor, freqs_cis:Tensor):
-    h = x + self.attention(self.attention_norm(x), freqs_cis)
-    return h + self.feed_forward(self.ffn_norm(h))
-
-class Transformer:
-  def __init__(self, dim:int, hidden_dim:int, n_heads:int, n_layers:int, norm_eps:float, vocab_size:int, n_kv_heads:int|None=None,
-               rope_theta:int=10000, max_context:int=1024, linear=nn.Linear, embedding=nn.Embedding):
-    self.layers = [TransformerBlock(dim, hidden_dim, n_heads, n_kv_heads, norm_eps, linear) for _ in range(n_layers)]
-    self.norm = nn.RMSNorm(dim, norm_eps)
-    self.tok_embeddings = embedding(vocab_size, dim)
-    self.output = nn.Linear(dim, vocab_size, bias=False) if embedding == nn.Embedding else linear(dim, vocab_size, bias=False)
-    self.freqs_cis = precompute_freqs_cis(dim // n_heads, max_context * 2, rope_theta).contiguous().requires_grad_(False)
-
-  def __call__(self, tokens:Tensor):
-    h = self.tok_embeddings(tokens)
-    freqs_cis = self.freqs_cis.cast(h.dtype)[:, :tokens.shape[1], :, :, :]
-    for layer in self.layers: h = layer(h, freqs_cis)
-    logits = self.output(self.norm(h))
-    return logits
diff --git a/extra/gemm/cdna_asm_gemm.py b/extra/gemm/cdna_asm_gemm.py
index 42524183d4..cbeb8995df 100644
--- a/extra/gemm/cdna_asm_gemm.py
+++ b/extra/gemm/cdna_asm_gemm.py
@@ -2716,8 +2716,11 @@ def custom_gemm_bw(gradient:UOp, kernel:UOp):
     assert all_same([gradient.device, a.device, b.device, out.device])
     a_t, b_t, g_t = Tensor(a, device=a.device), Tensor(b, device=a.device), Tensor(gradient, device=a.device)
     g_t = g_t[:a.shape[0]]
-    grad_a = (g_t @ b_t.T).uop
-    grad_b = (a_t.permute(2, 0, 1).reshape(a_t.shape[2], -1) @ g_t.reshape(-1, g_t.shape[-1])).uop
+    if can_use_asm_gemm(g_t, b_t.T): grad_a = asm_gemm(g_t, b_t.T).uop
+    else: grad_a = (g_t @ b_t.T).uop
+    a_t_flat, g_t_flat = a_t.permute(2, 0, 1).reshape(a_t.shape[2], -1), g_t.reshape(-1, g_t.shape[-1])
+    if can_use_asm_gemm(a_t_flat, g_t_flat): grad_b = asm_gemm(a_t_flat, g_t_flat).uop
+    else: grad_b = (a_t_flat @ g_t_flat).uop
     return (None, grad_a, grad_b)
 
 # ** main gemm function
diff --git a/test/backend/test_asm_gemm.py b/test/backend/test_asm_gemm.py
index b3f825caf2..3567360109 100644
--- a/test/backend/test_asm_gemm.py
+++ b/test/backend/test_asm_gemm.py
@@ -137,13 +137,13 @@ class TestGemmLlama(unittest.TestCase):
       self.skipTest("very slow on non mi350x")
 
   @Context(ASM_GEMM=1)
-  def test_empty(self): (Tensor.empty(N:=getenv("N", 4096), N, dtype=self.dtype)@Tensor.empty(N, N, dtype=self.dtype)).realize()
+  def test_empty(self): asm_gemm(Tensor.empty(N:=getenv("N", 4096), N, dtype=self.dtype), Tensor.empty(N, N, dtype=self.dtype)).realize()
 
   @Context(ASM_GEMM=1)
   def test_empty_bw(self):
     x = Tensor.empty(1, N:=getenv("N", 4096), N, dtype=self.dtype, requires_grad=True)
     y = Tensor.empty((N, N), dtype=self.dtype, requires_grad=True)
-    z = x @ y
+    z = asm_gemm(x, y)
     z.sum().backward()
     Tensor.realize(z, x.grad, y.grad)
     # FP8 forward output is bf16, gradients use fp8e5m2 (aka bf8)
diff --git a/tinygrad/tensor.py b/tinygrad/tensor.py
index 45c45d62ce..456b2902f0 100644
--- a/tinygrad/tensor.py
+++ b/tinygrad/tensor.py
@@ -7,7 +7,7 @@ if TYPE_CHECKING: import numpy
 from tinygrad.dtype import DType, DTypeLike, dtypes, ConstType, least_upper_float, least_upper_dtype, to_dtype, truncate
 from tinygrad.dtype import _from_np_dtype, _to_np_dtype, PyConst, Invalid, InvalidType
 from tinygrad.helpers import argfix, make_tuple, flatten, prod, all_int, round_up, merge_dicts, argsort, getenv, all_same, fully_flatten
-from tinygrad.helpers import IMAGE, FLOAT16, WINO, Metadata, TRACEMETA, ASM_GEMM, ceildiv, fetch, is_numpy_ndarray, TracingKey, cpu_profile
+from tinygrad.helpers import IMAGE, FLOAT16, WINO, Metadata, TRACEMETA, ceildiv, fetch, is_numpy_ndarray, TracingKey, cpu_profile
 from tinygrad.helpers import suppress_finalizing, disable_gc
 from tinygrad.gradient import compute_gradient
 from tinygrad.mixin import OpMixin
@@ -2032,9 +2032,6 @@ class Tensor(OpMixin):
 
   def dot(self, w:Tensor, dtype:DTypeLike|None=None) -> Tensor:
     if IMAGE: return self.image_dot(w, dtype)
-    if ASM_GEMM:
-      from extra.gemm.cdna_asm_gemm import can_use_asm_gemm, asm_gemm
-      if can_use_asm_gemm(self, w): return asm_gemm(self, w)
     return super().dot(w, dtype=dtype)
 
   def _cumalu(self, axis:int, op:Ops, _include_initial=False) -> Tensor:
@@ -2629,14 +2626,6 @@ class Tensor(OpMixin):
     print(q.scaled_dot_product_attention(k, v).numpy())
     ```
     """
-    if getenv("FLASH_ATTENTION"):
-      from extra.thunder.tiny.fa import flash_attention
-      return flash_attention(self, key, value, attn_mask=attn_mask, is_causal=is_causal)
-
-    if getenv("HK_FLASH_ATTENTION"):
-      from extra.thunder.amd.fa import flash_attention
-      return flash_attention(self, key, value, attn_mask=attn_mask, is_causal=is_causal)
-
     # GQA: https://docs.pytorch.org/docs/stable/generated/torch.nn.functional.scaled_dot_product_attention.html
     if enable_gqa:
       key = key.repeat_interleave(int(self.shape[-3] // key.shape[-3]), dim=-3)

From dc6a51e44d97ba72b150c937c78d4f14ca18b471 Mon Sep 17 00:00:00 2001
From: qazal <77887910+Qazalin@users.noreply.github.com>
Date: Wed, 8 Apr 2026 11:43:37 +0300
Subject: [PATCH 10/21] viz: add # of bytes to sdma (#15639)

* viz: add # of bytes to sdma

* update test_viz
---
 test/null/test_viz.py | 4 ++--
 tinygrad/viz/serve.py | 3 ++-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/test/null/test_viz.py b/test/null/test_viz.py
index 05a0eb8140..9a1fd425b4 100644
--- a/test/null/test_viz.py
+++ b/test/null/test_viz.py
@@ -470,7 +470,7 @@ class TestVizProfiler(unittest.TestCase):
     j = load_profile(prof)
     event = j['layout']['NV:SDMA:0']['events'][0]
     gbs = sz/(dur*1e-6)*1e-9
-    self.assertEqual(event['fmt'], f"{gbs:.0f} GB/s")
+    self.assertEqual(event['fmt'], f"{gbs:.0f} GB/s\n{sz/1e6:.0f} MB")
 
   def test_graph(self):
     prof = [ProfileDeviceEvent(device='NV', tdiff=decimal.Decimal(-1000)),
@@ -512,7 +512,7 @@ class TestVizProfiler(unittest.TestCase):
     j = load_profile(prof)
     sdma_events = j['layout']['NV:1:SDMA:0']['events']
     gbs = sz/(dur*1e-6)*1e-9
-    self.assertEqual(sdma_events[0]['fmt'], f"{gbs:.0f} GB/s")
+    self.assertEqual(sdma_events[0]["fmt"], f"{gbs:.0f} GB/s\n{sz/1e6:.0f} MB")
 
   def test_block_ordering(self):
     prof = [ProfileDeviceEvent(device='NV', tdiff=decimal.Decimal(-1000)),
diff --git a/tinygrad/viz/serve.py b/tinygrad/viz/serve.py
index ca7146afd7..32f6ba4c36 100755
--- a/tinygrad/viz/serve.py
+++ b/tinygrad/viz/serve.py
@@ -225,8 +225,9 @@ def timeline_layout(dev_events:list[tuple[int, int, float, DevEvent]], start_ts:
       ref = next((v for k in e.name.keys if (v:=ref_map.get(k)) is not None), None)
       if isinstance(e.name.ret, str): fmt.append(e.name.ret)
       elif isinstance(e.name.ret, int):
-        membw = e.name.ret / (dur * 1e-6)
+        membw = (nbytes:=e.name.ret) / (dur * 1e-6)
         fmt.append(f"{membw*1e-9:.0f} GB/s" if membw < 1e13 else f"{membw*1e-12:.0f} TB/s")
+        fmt.append(next((f"{nbytes/s:.0f} {u}" for s,u in ((1e9,"GB"),(1e6,"MB"),(1e3,"KB")) if nbytes>=s), f"{nbytes:.0f} B"))
       elif e.name.tb: fmt.append("TB:"+json.dumps(e.name.tb))
     events.append(struct.pack("<IIIIfI", enum_str(name, scache), option(ref), option(key), rel_ts(st,start_ts, f"'{name}' on {e.device}"),
                               dur, enum_str("\n".join(fmt),scache)))

From 39a029ec55a67e39cd6ccfca17bc78fe79f3b5ae Mon Sep 17 00:00:00 2001
From: qazal <77887910+Qazalin@users.noreply.github.com>
Date: Wed, 8 Apr 2026 12:02:40 +0300
Subject: [PATCH 11/21] remove ASM_GEMM context var (#15645)

---
 examples/mlperf/models/flat_llama.py |  5 ++---
 test/backend/test_asm_gemm.py        | 12 ++++--------
 tinygrad/helpers.py                  |  2 --
 3 files changed, 6 insertions(+), 13 deletions(-)

diff --git a/examples/mlperf/models/flat_llama.py b/examples/mlperf/models/flat_llama.py
index fd6aa1e812..6373888088 100644
--- a/examples/mlperf/models/flat_llama.py
+++ b/examples/mlperf/models/flat_llama.py
@@ -35,16 +35,15 @@ def quantize_fp8(x:Tensor, amax_state:Tensor|None=None):
   return x_clamped.cast(FP8_DTYPE), scale.float().reciprocal()
 
 def matmul(x:Tensor, w:Tensor, fp8=FP8, amax_x:Tensor|None=None, amax_w:Tensor|None=None) -> Tensor:
-  from tinygrad.helpers import ASM_GEMM
   if not fp8:
-    if ASM_GEMM:
+    if getenv("ASM_GEMM"):
       from extra.gemm.cdna_asm_gemm import can_use_asm_gemm, asm_gemm
       if can_use_asm_gemm(x, w.T): return asm_gemm(x, w.T)
     return x @ w.T
   x_fp8, x_scale = quantize_fp8(x, amax_state=amax_x)
   w_fp8, w_scale = quantize_fp8(w, amax_state=amax_w)
   combined_scale = x_scale * w_scale
-  if ASM_GEMM:
+  if getenv("ASM_GEMM"):
     from extra.gemm.cdna_asm_gemm import can_use_asm_gemm, asm_gemm
     if can_use_asm_gemm(x_fp8, w_fp8.T): return asm_gemm(x_fp8, w_fp8.T, combined_scale=combined_scale)
   return x_fp8.dot(w_fp8.T, dtype=dtypes.float) * combined_scale
diff --git a/test/backend/test_asm_gemm.py b/test/backend/test_asm_gemm.py
index 3567360109..ab91dc37e0 100644
--- a/test/backend/test_asm_gemm.py
+++ b/test/backend/test_asm_gemm.py
@@ -21,9 +21,8 @@ def run_asm_gemm(a_shape, b_shape, dtype=dtypes.float16, a_shard=None, b_shard=N
 
   a, b = a_rand.clone().requires_grad_(), b_rand.clone().requires_grad_()
   if multi: a, b = a.shard(devs, axis=a_shard), b.shard(devs, axis=b_shard)
-  with Context(ASM_GEMM=1):
-    tst = asm_gemm(a, b)
-    tst.sum().backward()
+  tst = asm_gemm(a, b)
+  tst.sum().backward()
   Tensor.realize(tst, a.grad, b.grad)
 
   a_ref, b_ref = a_rand.clone().requires_grad_(), b_rand.clone().requires_grad_()
@@ -32,9 +31,8 @@ def run_asm_gemm(a_shape, b_shape, dtype=dtypes.float16, a_shard=None, b_shard=N
     a_ref = a_ref.cast(dtypes.bfloat16)
     b_ref = b_ref.cast(dtypes.bfloat16)
   if multi: a_ref, b_ref = a_ref.shard(devs, axis=a_shard), b_ref.shard(devs, axis=b_shard)
-  with Context(ASM_GEMM=0):
-    ref = asm_gemm(a_ref, b_ref)
-    ref.sum().backward()
+  ref = a_ref @ b_ref
+  ref.sum().backward()
   Tensor.realize(ref, a_ref.grad, b_ref.grad)
 
   # no validation on the NULL device
@@ -136,10 +134,8 @@ class TestGemmLlama(unittest.TestCase):
     if not is_cdna4() or getenv("MOCKGPU"):
       self.skipTest("very slow on non mi350x")
 
-  @Context(ASM_GEMM=1)
   def test_empty(self): asm_gemm(Tensor.empty(N:=getenv("N", 4096), N, dtype=self.dtype), Tensor.empty(N, N, dtype=self.dtype)).realize()
 
-  @Context(ASM_GEMM=1)
   def test_empty_bw(self):
     x = Tensor.empty(1, N:=getenv("N", 4096), N, dtype=self.dtype, requires_grad=True)
     y = Tensor.empty((N, N), dtype=self.dtype, requires_grad=True)
diff --git a/tinygrad/helpers.py b/tinygrad/helpers.py
index 22f2213835..ab09e1c6ad 100644
--- a/tinygrad/helpers.py
+++ b/tinygrad/helpers.py
@@ -251,8 +251,6 @@ ALLOW_TF32 = ContextVar("ALLOW_TF32", 0)
 SCACHE = ContextVar("SCACHE", 1)
 # allow use of atomics for embedding backward
 USE_ATOMICS = ContextVar("USE_ATOMICS", 0)
-# allow use of assembly for gemm
-ASM_GEMM = ContextVar("ASM_GEMM", 0)
 
 @dataclass(frozen=True)
 class Metadata:

From 35e3983840ebf9d95a1dd412ff9ddb8e39f69997 Mon Sep 17 00:00:00 2001
From: George Hotz <72895+geohot@users.noreply.github.com>
Date: Wed, 8 Apr 2026 17:16:19 +0800
Subject: [PATCH 12/21] Add Q5_0, Q5_1, and bfloat16 GGUF types (#15644)

---
 test/unit/test_gguf.py | 33 ++++++++++++++++++++++-----------
 tinygrad/nn/state.py   | 23 +++++++++++++++++++----
 2 files changed, 41 insertions(+), 15 deletions(-)

diff --git a/test/unit/test_gguf.py b/test/unit/test_gguf.py
index 5b7f2f4de5..ee042b72e4 100644
--- a/test/unit/test_gguf.py
+++ b/test/unit/test_gguf.py
@@ -30,11 +30,15 @@ class TestGGUF(unittest.TestCase):
 
   def test_dequantization_q4_0(self): self._test_dequantization(GGMLQuantizationType.Q4_0)
   def test_dequantization_q4_1(self): self._test_dequantization(GGMLQuantizationType.Q4_1)
+  def test_dequantization_q5_0(self): self._test_dequantization(GGMLQuantizationType.Q5_0)
+  def test_dequantization_q5_1(self): self._test_dequantization(GGMLQuantizationType.Q5_1)
   def test_dequantization_q8_0(self): self._test_dequantization(GGMLQuantizationType.Q8_0)
   def test_dequantization_q4_k(self): self._test_dequantization(GGMLQuantizationType.Q4_K)
   def test_dequantization_q5_k(self): self._test_dequantization(GGMLQuantizationType.Q5_K)
   def test_dequantization_q6_k(self): self._test_dequantization(GGMLQuantizationType.Q6_K)
   def test_dequantization_mxfp4(self): self._test_dequantization(GGMLQuantizationType.MXFP4)
+  @unittest.skipUnless(is_dtype_supported(dtypes.bfloat16), "Backend must support bfloat16")
+  def test_dequantization_bf16(self): self._test_dequantization(GGMLQuantizationType.BF16)
   def test_dequantization_mxfp4_old(self):
     def encode(nibbles, E):
       packed = [(low & 0xF) | ((high & 0xF) << 4) for low, high in zip(nibbles[:16], nibbles[16:])]
@@ -120,17 +124,21 @@ class TestGGUF(unittest.TestCase):
 class TestGGUFGEMV(unittest.TestCase):
   def _test_gguf_gemv(self, qtype: GGMLQuantizationType):
     block_size, type_size = GGML_QUANT_SIZES[qtype]
-    rows, cols = 8192, 2048
+    rows, cols = (1024, 512) if qtype == GGMLQuantizationType.BF16 else (8192, 2048)
     n_blocks = rows * cols // block_size
     rng = np.random.default_rng(42)
-    # generate random quantized blocks with valid fp16 scale fields (random bytes can produce NaN scales)
-    q_data = rng.integers(0, 256, size=n_blocks * type_size, dtype=np.uint8).reshape(n_blocks, type_size)
-    scales = np.float16(rng.standard_normal(n_blocks * 4)).view(np.uint8).reshape(n_blocks, -1)
-    if qtype == GGMLQuantizationType.Q8_0: q_data[:, :2] = scales[:, :2]                    # d at offset 0
-    elif qtype in (GGMLQuantizationType.Q4_K, GGMLQuantizationType.Q5_K): q_data[:, :4] = scales[:, :4] # d, dmin at offset 0
-    elif qtype == GGMLQuantizationType.Q6_K: q_data[:, -2:] = scales[:, :2]                 # d at end
-    elif qtype == GGMLQuantizationType.MXFP4: q_data[:, 0] = rng.integers(120, 136, size=n_blocks, dtype=np.uint8) # constrain byte0
-    q_data = q_data.flatten()
+    if qtype == GGMLQuantizationType.BF16:
+      q_data = (rng.standard_normal(rows * cols).astype(np.float32).view(np.uint32) >> 16).astype(np.uint16).view(np.uint8)
+    else:
+      # generate random quantized blocks with valid fp16 scale fields (random bytes can produce NaN scales)
+      q_data = rng.integers(0, 256, size=n_blocks * type_size, dtype=np.uint8).reshape(n_blocks, type_size)
+      scales = np.float16(rng.standard_normal(n_blocks * 4)).view(np.uint8).reshape(n_blocks, -1)
+      if qtype in (GGMLQuantizationType.Q5_0, GGMLQuantizationType.Q8_0): q_data[:, :2] = scales[:, :2]  # d at offset 0
+      elif qtype in (GGMLQuantizationType.Q5_1, GGMLQuantizationType.Q4_K, GGMLQuantizationType.Q5_K):
+        q_data[:, :4] = scales[:, :4]  # d, m/dmin at offset 0
+      elif qtype == GGMLQuantizationType.Q6_K: q_data[:, -2:] = scales[:, :2]               # d at end
+      elif qtype == GGMLQuantizationType.MXFP4: q_data[:, 0] = rng.integers(120, 136, size=n_blocks, dtype=np.uint8) # constrain byte0
+      q_data = q_data.flatten()
     ref = dequantize(q_data, qtype).reshape(rows, cols)
 
     # build a minimal gguf in memory: header + 1 tensor info + aligned data
@@ -148,15 +156,18 @@ class TestGGUFGEMV(unittest.TestCase):
 
     x = rng.standard_normal(cols).astype(np.float32)
     np.testing.assert_allclose((tensors["weight"] @ Tensor(x)).numpy(), ref @ x, atol=1e-2, rtol=1e-2)
-    # can only expect the weights to be identical if we really support float16 (ie. not decompositions)
-    if is_dtype_supported(dtypes.half): np.testing.assert_equal(tensors["weight"].numpy(), ref)
+    if qtype == GGMLQuantizationType.BF16 or is_dtype_supported(dtypes.half): np.testing.assert_equal(tensors["weight"].numpy(), ref)
     assert np.isfinite(ref).all() and np.isfinite(tensors["weight"].numpy()).all(), f"{qtype.name} has NaN/Inf"
 
   def test_gguf_gemv_q8_0(self): self._test_gguf_gemv(GGMLQuantizationType.Q8_0)
+  def test_gguf_gemv_q5_0(self): self._test_gguf_gemv(GGMLQuantizationType.Q5_0)
+  def test_gguf_gemv_q5_1(self): self._test_gguf_gemv(GGMLQuantizationType.Q5_1)
   def test_gguf_gemv_q4_k(self): self._test_gguf_gemv(GGMLQuantizationType.Q4_K)
   def test_gguf_gemv_q5_k(self): self._test_gguf_gemv(GGMLQuantizationType.Q5_K)
   def test_gguf_gemv_q6_k(self): self._test_gguf_gemv(GGMLQuantizationType.Q6_K)
   def test_gguf_gemv_mxfp4(self): self._test_gguf_gemv(GGMLQuantizationType.MXFP4)
+  @unittest.skipUnless(is_dtype_supported(dtypes.bfloat16), "Backend must support bfloat16")
+  def test_gguf_gemv_bf16(self): self._test_gguf_gemv(GGMLQuantizationType.BF16)
 
 if __name__ == '__main__':
   unittest.main()
diff --git a/tinygrad/nn/state.py b/tinygrad/nn/state.py
index 5c83d6c3e7..fe8736c117 100644
--- a/tinygrad/nn/state.py
+++ b/tinygrad/nn/state.py
@@ -297,13 +297,19 @@ def ggml_data_to_tensor(t: Tensor, n: int, ggml_type: int) -> Tensor:
   """
   Converts ggml tensor data to a tinygrad tensor.
 
-  Supported native types: float32 (id: 0), float16 (id: 1), int8 (id: 16), int16 (id: 17), int32 (id: 18)
-  Supported quantized types: Q4_0 (id: 2), Q4_1 (id: 3), Q8_0 (id: 8), Q4_K (id: 12), Q5_K (id: 13), Q6_K (id: 14), MXFP4 (id: 39)
+  Supported native types: float32 (id: 0), float16 (id: 1), bfloat16 (id: 30),
+  int8 (id: 16), int16 (id: 17), int32 (id: 18)
+  Supported quantized types: Q4_0 (id: 2), Q4_1 (id: 3), Q5_0 (id: 6),
+  Q5_1 (id: 7), Q8_0 (id: 8), Q4_K (id: 12), Q5_K (id: 13),
+  Q6_K (id: 14), MXFP4 (id: 39)
   """
   # https://github.com/ggerganov/ggml/blob/323951f1bdcdfbd5b5ff3a9a7c3770e63b1a560e/include/ggml.h#L356
 
   # native types
-  if (dtype := { 0: dtypes.float32, 1: dtypes.float16, 16: dtypes.int8, 17: dtypes.int16, 18: dtypes.int32 }.get(ggml_type)) is not None:
+  if (dtype := {
+    0: dtypes.float32, 1: dtypes.float16, 16: dtypes.int8,
+    17: dtypes.int16, 18: dtypes.int32, 30: dtypes.bfloat16,
+  }.get(ggml_type)) is not None:
     return t[:dtype.itemsize * n].contiguous().bitcast(dtype)
 
   def q_to_uint8(t: Tensor, b: int) -> Tensor:
@@ -312,12 +318,21 @@ def ggml_data_to_tensor(t: Tensor, n: int, ggml_type: int) -> Tensor:
     return t.unsqueeze(-1).expand((*t.shape,8//b)).idiv(shift_tensor).bitwise_and(bitmask).transpose(-1, -2).flatten(-2)
 
   # map to (number of elements, number of bytes)
-  if (nelements_nbytes := { 2:(32,18), 3:(32,20), 8:(32,34), 12:(256,144), 13:(256,176), 14:(256,210), 39:(32,17) }.get(ggml_type)) is not None:
+  if (nelements_nbytes := {
+    2:(32,18), 3:(32,20), 6:(32,22), 7:(32,24), 8:(32,34),
+    12:(256,144), 13:(256,176), 14:(256,210), 39:(32,17),
+  }.get(ggml_type)) is not None:
     blocks = t[:(n//nelements_nbytes[0])*nelements_nbytes[1]].reshape((-1, nelements_nbytes[1])).contiguous()
     if ggml_type == 2: return (q_to_uint8(blocks[:,2:], 4).bitcast(dtypes.int8) - 8) * blocks[:,:2].bitcast(dtypes.float16).cast(dtypes.float32)
     if ggml_type == 3:
       d, m = (blocks[:,s:s+2].bitcast(dtypes.float16).cast(dtypes.float32) for s in [ 0, 2 ])
       return q_to_uint8(blocks[:,4:], 4).bitcast(dtypes.int8) * d + m
+    if ggml_type in (6, 7):
+      d = blocks[:,:2].bitcast(dtypes.float16).cast(dtypes.float32)
+      qh_off = 2 if ggml_type == 6 else 4
+      qh = q_to_uint8(blocks[:,qh_off:qh_off+4], 1).reshape((-1, 8, 4)).transpose(-1, -2).flatten(-2).bitcast(dtypes.int8)
+      q = q_to_uint8(blocks[:,qh_off+4:], 4).bitcast(dtypes.int8) + qh * 16
+      return q * d + (blocks[:,2:4].bitcast(dtypes.float16).cast(dtypes.float32) if ggml_type == 7 else -16 * d)
     if ggml_type == 8: return blocks[:,:2].bitcast(dtypes.float16).cast(dtypes.float32) * blocks[:,2:].bitcast(dtypes.int8)
      # Q4_K: 256 elements per 144-byte block (d:2, dmin:2, scales:12, qs:128)
      # Q5_K: 256 elements per 176-byte block (d:2, dmin:2, scales:12, qh:32, qs:128)

From 3ac16b3bea62c08ea125d883a1940ff7b257b78f Mon Sep 17 00:00:00 2001
From: qazal <77887910+Qazalin@users.noreply.github.com>
Date: Wed, 8 Apr 2026 14:24:23 +0300
Subject: [PATCH 13/21] viz: add wmma row, update exec duration logic (#15646)

* viz: split wmma to its own row, fix duration logic

* regs

* decrease number of loops, add pickle

* assert overlaps
---
 extra/sqtt/examples/generate_examples.py        |   3 ++-
 .../gfx1200/profile_handwritten_run_0.pkl       | Bin 0 -> 72208 bytes
 .../gfx1200/profile_handwritten_run_1.pkl       | Bin 0 -> 72172 bytes
 test/amd/test_custom_kernel.py                  |   9 +++++----
 test/amd/test_sqttmap.py                        |  13 ++++++++++++-
 tinygrad/viz/serve.py                           |   8 ++++----
 6 files changed, 23 insertions(+), 10 deletions(-)
 create mode 100644 extra/sqtt/examples/gfx1200/profile_handwritten_run_0.pkl
 create mode 100644 extra/sqtt/examples/gfx1200/profile_handwritten_run_1.pkl

diff --git a/extra/sqtt/examples/generate_examples.py b/extra/sqtt/examples/generate_examples.py
index 63eab22d7f..55ea70e4c4 100644
--- a/extra/sqtt/examples/generate_examples.py
+++ b/extra/sqtt/examples/generate_examples.py
@@ -10,6 +10,7 @@ EXAMPLES = {
   "plus":"test/test_tiny.py TestTiny.test_plus",
   "gemm":"-c \"from tinygrad import Tensor; (Tensor.empty(N:=32, N)@Tensor.empty(N, N)).realize()\"",
   "sync":"test/amd/test_custom_kernel.py TestCustomKernel.test_lds_sync",
+  "handwritten":"test/amd/test_custom_kernel.py TestCustomKernel.test_handwritten",
 }
 
 if __name__ == "__main__":
@@ -21,6 +22,6 @@ if __name__ == "__main__":
     for i in range(2):
       # AM_RESET=1 gets a clear trace, does not work on mi300 machines
       subprocess.run([sys.executable, *shlex.split(test)], cwd=EXAMPLES_DIR.parent.parent.parent,
-                     env={**os.environ, "AMD":"1", "AM_RESET":"1" if not arch.startswith("gfx9") else "0", "VIZ":"-2", "PYTHONPATH":"."})
+                     env={**os.environ, "DEV":"AMD", "AM_RESET":"1" if not arch.startswith("gfx9") else "0", "VIZ":"-2", "PYTHONPATH":"."})
       PROFILE_PATH.rename(dest:=EXAMPLES_DIR/arch/f"profile_{name}_run_{i}.pkl")
       print(f"saved SQTT trace to {dest}")
diff --git a/extra/sqtt/examples/gfx1200/profile_handwritten_run_0.pkl b/extra/sqtt/examples/gfx1200/profile_handwritten_run_0.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..f0c862b6b901ac3c61f60a13552bfd7522570714
GIT binary patch
literal 72208
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

literal 0
HcmV?d00001

diff --git a/extra/sqtt/examples/gfx1200/profile_handwritten_run_1.pkl b/extra/sqtt/examples/gfx1200/profile_handwritten_run_1.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..8f8dc9f1145bd1328b7e9a039c42fd8c49abfa14
GIT binary patch
literal 72172
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
S2p^x@(cJ3cl^5F=aQuIX3)b)e

literal 0
HcmV?d00001

diff --git a/test/amd/test_custom_kernel.py b/test/amd/test_custom_kernel.py
index 47c37b8068..ac4dad03d8 100644
--- a/test/amd/test_custom_kernel.py
+++ b/test/amd/test_custom_kernel.py
@@ -104,20 +104,21 @@ def custom_handwritten(A:UOp, arch:str) -> UOp:
   lds = UOp(Ops.DEFINE_LOCAL, dtypes.uint8.ptr(size=512, addrspace=AddrSpace.LOCAL), (), 'lds')  # 128 * 4 bytes
   k = Kernel(arch)
   k.emit(r4.s_nop(0))
-  k.emit(r4.v_mov_b32_e32(v[1], 10))
+  k.emit(r4.v_mov_b32_e32(v[1], 4))
   def emit_alt():
-    for i in range(4):
+    for i in range(2):
       k.emit(r4.v_mov_b32_e32(v[20+i], 4.0))
       k.emit(r4.v_rcp_f32_e32(v[22+i], v[20+i]))
       k.emit(r4.s_mov_b32(s[20+i], i))
+      k.emit(r4.s_mul_i32(s[14+i], s[12+i], 32))
   def emit_wmma():
-    for _ in range(4):
+    for _ in range(2):
       k.emit(r4.v_wmma_f32_16x16x16_f16(v[0:7], v[8:11], v[8:11], 1))
   k.label("start")
   k.emit(s_mov_b32(s[1], 10))
   k.label("loop")
   # wmma should've overlapped here if it was a different unit?
-  for _ in range(4):
+  for _ in range(2):
     emit_wmma()
     emit_alt()
   for _ in range(8): k.emit(s_nop(1))
diff --git a/test/amd/test_sqttmap.py b/test/amd/test_sqttmap.py
index 99ea7bcb5a..2828234054 100644
--- a/test/amd/test_sqttmap.py
+++ b/test/amd/test_sqttmap.py
@@ -131,7 +131,18 @@ class TestSQTTMapBase(unittest.TestCase):
 
 class TestSQTTMapRDNA3(TestSQTTMapBase): target = "gfx1100"
 
-class TestSQTTMapRDNA4(TestSQTTMapBase): target = "gfx1200"
+class TestSQTTMapRDNA4(TestSQTTMapBase):
+  target = "gfx1200"
+
+  @unittest.expectedFailure
+  def test_rdna4_wmma(self):
+    events, kernels, target = self.examples["profile_handwritten_run_0"]
+    row_ends = {}
+    for e in sqtt_timeline(events[0].blob, list(kernels.values())[0].lib, target):
+      if type(e).__name__ != "ProfileRangeEvent": continue
+      if (et:=row_ends.get(e.device)) is not None and e.st < et:
+        raise RuntimeError(f"overlap in {e.device}: {e.st} {et}.")
+      row_ends[e.device] = e.en
 
 class TestSQTTMapCDNA(TestSQTTMapBase):
   target = "gfx950"
diff --git a/tinygrad/viz/serve.py b/tinygrad/viz/serve.py
index 32f6ba4c36..3b23bf3292 100755
--- a/tinygrad/viz/serve.py
+++ b/tinygrad/viz/serve.py
@@ -366,11 +366,11 @@ def sqtt_timeline(data:bytes, lib:bytes, target:str) -> Generator[ProfileEvent,
       dispatch_id, op_type = exec_pending[name].pop(0)
       # get the number of cycles from the op type
       duration = int(dur_match.group(1)) if (dur_match:=re.match(r".*_(\d+)$", op_type)) else 1
-      # for execs, timestamp is the completion time
-      start_time, end_time = p._time-duration, p._time
+      # for execs, extend end time by the duration
+      start_time, end_time = p._time, p._time+duration
       link = f"LINK:{dispatch_id}"
-      # add wmma in the exec name for coloring
-      if op_type.startswith("WMMA"): name += "_WMMA"
+      # wmma exec gets its own row and color
+      if op_type.startswith("WMMA"): name, row = name+"_WMMA", "ALUEXEC:0 WMMA"
     # queue inst dispatches
     idx = next(row_counts.setdefault(row, itertools.count(0)))
     if isinstance(p, (VALUINST, INST, INST_RDNA4)) and (exec_type:=dispatch_to_exec.get(name.replace("OTHER_", "").split("_")[0])) is not None:

From b1e52ba0c2553abab18840c1986aa09eeacca548 Mon Sep 17 00:00:00 2001
From: nimlgen <138685161+nimlgen@users.noreply.github.com>
Date: Wed, 8 Apr 2026 15:53:52 +0300
Subject: [PATCH 14/21] the slowest line in hcq graph (#15635)

* the slowest line in hcq graph

* x
---
 tinygrad/runtime/graph/hcq.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tinygrad/runtime/graph/hcq.py b/tinygrad/runtime/graph/hcq.py
index ea343dcce9..687d8735ca 100644
--- a/tinygrad/runtime/graph/hcq.py
+++ b/tinygrad/runtime/graph/hcq.py
@@ -144,7 +144,7 @@ class HCQGraph(MultiGraphRunner):
       self.last_j[enqueue_queue] = j
 
     # Check which signals are used in the profile graph.
-    self.prof_signal_is_used = [any(ent.st_id == j or ent.en_id == j for ent in self.prof_graph_entries) for j in range(len(self.jit_cache) * 2)]
+    self.prof_signal_is_used: set[int] = {sid for ent in self.prof_graph_entries for sid in (ent.st_id, ent.en_id)}
 
     # Build hardware queues.
     self.copy_to_devs: dict[HCQCompiled, set[HCQCompiled]] = {dev: set() for dev in self.devices}
@@ -167,7 +167,7 @@ class HCQGraph(MultiGraphRunner):
       for sig, val in sync_signals + deps: enqueue_queue.wait(sig, val)
 
       # Encode waits and start profile timestamp (if needed).
-      if PROFILE and self.prof_signal_is_used[j * 2]: enqueue_queue.timestamp(self.prof_signals[j * 2])
+      if PROFILE and j * 2 in self.prof_signal_is_used: enqueue_queue.timestamp(self.prof_signals[j * 2])
 
       # Encode main commands based on ji type.
       if isinstance(ji.prg, CompiledRunner):
@@ -203,7 +203,7 @@ class HCQGraph(MultiGraphRunner):
         self.copy_to_devs[cast(HCQCompiled, Device[dest.device])].add(cast(HCQCompiled, Device[src.device]))
 
       # Encode finish profile timestamp (if needed).
-      if PROFILE and self.prof_signal_is_used[j * 2 + 1]: enqueue_queue.timestamp(self.prof_signals[j * 2 + 1])
+      if PROFILE and j * 2 + 1 in self.prof_signal_is_used: enqueue_queue.timestamp(self.prof_signals[j * 2 + 1])
 
       if signal_val is not None: enqueue_queue.signal(signal, signal_val)
 

From 1ebeb52e59751b3485b63fe182b9dcdd1a3cde24 Mon Sep 17 00:00:00 2001
From: George Hotz <72895+geohot@users.noreply.github.com>
Date: Wed, 8 Apr 2026 21:26:44 +0800
Subject: [PATCH 15/21] RDNA4 asm gemm (#15427)

* sqtt: rdna4 decoder work

* diff cleanup

* more diff

* test

* 125

* r4

---------

Co-authored-by: qazal <qazal.software@gmail.com>
Co-authored-by: qazal <77887910+Qazalin@users.noreply.github.com>
---
 extra/gemm/rdna4_asm_matmul.py | 245 +++++++++++++++++++++++++++++++++
 1 file changed, 245 insertions(+)
 create mode 100644 extra/gemm/rdna4_asm_matmul.py

diff --git a/extra/gemm/rdna4_asm_matmul.py b/extra/gemm/rdna4_asm_matmul.py
new file mode 100644
index 0000000000..04ed8ce908
--- /dev/null
+++ b/extra/gemm/rdna4_asm_matmul.py
@@ -0,0 +1,245 @@
+# RDNA4 128x128 GEMM using WMMA — optimized DS scheduling
+import numpy as np
+from tinygrad import Tensor, Device, Context, GlobalCounters
+from tinygrad.uop.ops import UOp, Ops, KernelInfo
+from tinygrad.helpers import getenv, colored
+from tinygrad.dtype import dtypes, AddrSpace
+from tinygrad.engine.realize import Estimates
+from tinygrad.renderer.amd.dsl import s, v, VCC_LO, NULL, src, ttmp
+from tinygrad.runtime.autogen.amd.rdna4.ins import *
+
+BLOCK_M, BLOCK_N, BLOCK_K = 128, 128, 16
+TILES_M, TILES_N = 4, 4
+THREADS, ELEM = 128, 2
+LDS_A_ROW = BLOCK_K*ELEM   # 32
+LDS_B_ROW = BLOCK_N*ELEM  # 256
+LDS_A_SIZE = BLOCK_M * LDS_A_ROW  # 4096
+LDS_B_SIZE = BLOCK_K * LDS_B_ROW  # 4096
+LDS_SIZE = LDS_A_SIZE + LDS_B_SIZE  # 8192
+LDS_B_OFF = LDS_A_SIZE
+ACC, DA, DB, FA, FB, ET = 60, 188, 196, 204, 44, 10
+
+def build_kernel(N, arch='gfx1200'):
+  assert N % BLOCK_M == 0 and N >= 256
+  NO_ALU, NO_DS, NO_GLOBAL = getenv("NO_ALU", 0), getenv("NO_DS", 0), getenv("NO_GLOBAL", 0)
+  I, L, B = [], {}, []
+  def e(i): I.append(i); return i
+  def label(n): L[n] = sum(i.size() for i in I)
+  def br(i, t): B.append((len(I)-1, t))
+
+  e(s_load_b128(sdata=s[4:7], sbase=s[0:1], ioffset=0, soffset=NULL))
+  e(s_load_b64(sdata=s[8:9], sbase=s[0:1], ioffset=0x10, soffset=NULL))
+  e(s_wait_kmcnt(simm16=0))
+  e(s_mov_b32(s[10], ttmp[9])); e(s_and_b32(s[11], ttmp[7], 0xFFFF))
+  e(s_lshl_b32(s[10], s[10], 7)); e(s_lshl_b32(s[11], s[11], 7))
+  e(s_mov_b32(s[12], N)); e(s_lshl_b32(s[13], s[12], 1))
+  e(s_mul_i32(s[14], s[12], BLOCK_K*ELEM))
+  e(s_add_co_i32(s[17], s[12], -2*BLOCK_K))  # loop bound
+
+  e(v_and_b32_e32(v[1], 31, v[0])); e(v_lshrrev_b32_e32(v[2], 5, v[0]))
+  e(v_and_b32_e32(v[3], 1, v[2])); e(v_lshrrev_b32_e32(v[2], 1, v[2]))
+
+  e(v_lshlrev_b32_e32(v[4], 5, v[0]))
+  # B store: transposed layout for stride-32 reads. addr = LDS_B_OFF + (tid%8)*512 + (tid/8)*32
+  e(v_and_b32_e32(v[48], 7, v[0])); e(v_lshlrev_b32_e32(v[5], 9, v[48]))   # (tid%8)*512
+  e(v_lshrrev_b32_e32(v[48], 3, v[0])); e(v_lshlrev_b32_e32(v[48], 5, v[48]))  # (tid/8)*32
+  e(v_add_nc_u32_e32(v[5], v[5], v[48])); e(v_add_nc_u32_e32(v[5], LDS_B_OFF, v[5]))
+
+  e(v_add_nc_u32_e32(v[48], s[11], v[0]))
+  e(v_mul_lo_u32(v[6], v[48], N*ELEM)); e(v_mov_b32_e32(v[7], 0))
+  e(v_lshrrev_b32_e32(v[48], 3, v[0])); e(v_mul_lo_u32(v[8], v[48], N*ELEM))
+  e(v_and_b32_e32(v[48], 7, v[0])); e(v_lshlrev_b32_e32(v[48], 5, v[48]))
+  e(v_add_nc_u32_e32(v[8], v[8], v[48]))
+  e(s_mul_i32(s[15], s[10], ELEM)); e(v_add_nc_u32_e32(v[8], s[15], v[8]))
+  e(v_mov_b32_e32(v[9], 0))
+
+  # LDS read addrs with padded strides (eliminates bank conflicts)
+  # A: (lane%16)*LDS_A_ROW + (lane/16)*16 + wave_m*64*LDS_A_ROW
+  # B: (lane%16)*LDS_B_ROW + (lane/16)*16 + wave_n*64*ELEM + LDS_B_OFF
+  LLA, LLB = 40, 43
+  e(v_and_b32_e32(v[50], 15, v[1])); e(v_lshrrev_b32_e32(v[51], 4, v[1]))
+  e(v_lshlrev_b32_e32(v[LLA], 5, v[50]))        # (lane%16) * 32
+  e(v_lshlrev_b32_e32(v[51], 4, v[51]))        # (lane/16) * 16
+  e(v_add_nc_u32_e32(v[LLA], v[LLA], v[51]))
+  e(v_lshlrev_b32_e32(v[52], 11, v[2]))         # wave_m * 2048
+  e(v_add_nc_u32_e32(v[LLA], v[LLA], v[52]))
+  # B read: transposed layout. addr = LDS_B_OFF + (lane%16)*32 + (lane/16)*16 + wave_n*2*512
+  # wave_n selects column panels: wave_n*2 panels (each panel=16 cols, wave_n covers 64 cols = 4 panels)
+  # But wave_n*2*512 = wave_n*1024. Hmm, wave_n covers cols [wave_n*64 : (wave_n+1)*64].
+  # Each panel = 16 cols = 512 bytes. wave_n*64/16 = wave_n*4 panels. Offset = wave_n*4*512 = wave_n*2048.
+  e(v_lshlrev_b32_e32(v[LLB], 5, v[50]))         # (lane%16) * 32 (stride 32!)
+  e(v_add_nc_u32_e32(v[LLB], v[LLB], v[51]))     # + (lane/16)*16
+  e(v_lshlrev_b32_e32(v[52], 11, v[3]))           # wave_n * 2048
+  e(v_add_nc_u32_e32(v[LLB], v[LLB], v[52]))
+  e(v_add_nc_u32_e32(v[LLB], LDS_B_OFF, v[LLB]))
+
+  for i in range(0, 128, 2):
+    e(VOPD(VOPDOp.V_DUAL_MOV_B32, VOPDOp.V_DUAL_MOV_B32, vdstx=v[ACC+i], vdsty=v[ACC+i+1], srcx0=0, srcy0=0))
+  e(s_mov_b32(s[16], 0))
+
+  if not NO_GLOBAL:
+    for i in range(2): e(global_load_b128(vdst=v[DA+i*4:DA+i*4+3], vaddr=v[6:7], saddr=s[4:5], ioffset=i*16))
+    for i in range(2): e(global_load_b128(vdst=v[DB+i*4:DB+i*4+3], vaddr=v[8:9], saddr=s[6:7], ioffset=i*16))
+    e(s_wait_loadcnt(simm16=0))
+  if not NO_DS:
+    for i in range(2): e(ds_store_b128(addr=v[4], data0=v[DA+i*4:DA+i*4+3], offset0=(i*16)&0xFF, offset1=(i*16)>>8))
+    for i in range(2): e(ds_store_b128(addr=v[5], data0=v[DB+i*4:DB+i*4+3], offset0=(i*16)&0xFF, offset1=(i*16)>>8))
+  if not NO_GLOBAL:
+    e(v_add_nc_u32_e32(v[6], BLOCK_K*ELEM, v[6]))
+    e(v_add_nc_u32_e32(v[8], s[14], v[8]))
+
+  # =============================================================================
+  def emit_iter_body(load_set='AB'):
+    if not NO_DS:
+      e(s_wait_dscnt(simm16=0))
+      e(s_barrier_signal(ssrc0=src[193])); e(s_barrier_wait(simm16=0xFFFF))
+    if not NO_GLOBAL:
+      if 'A' in load_set:
+        for i in range(2): e(global_load_b128(vdst=v[DA+i*4:DA+i*4+3], vaddr=v[6:7], saddr=s[4:5], ioffset=i*16))
+        e(v_add_nc_u32_e32(v[6], BLOCK_K*ELEM, v[6]))
+      if 'B' in load_set:
+        for i in range(2): e(global_load_b128(vdst=v[DB+i*4:DB+i*4+3], vaddr=v[8:9], saddr=s[6:7], ioffset=i*16))
+        e(v_add_nc_u32_e32(v[8], s[14], v[8]))
+    if not NO_DS:
+      # Issue 6 loads: A[0:3] + B[0] + B[1]. B[2:3] interleaved with WMMAs.
+      for tm in range(TILES_M):
+        aoff = tm * 16 * LDS_A_ROW
+        e(ds_load_b128(vdst=v[FA+tm*4:FA+tm*4+3], addr=v[LLA], offset0=aoff&0xFF, offset1=aoff>>8))
+      e(ds_load_b128(vdst=v[FB:FB+3], addr=v[LLB], offset0=0, offset1=0))
+      e(ds_load_b128(vdst=v[FB+4:FB+7], addr=v[LLB], offset0=0, offset1=2))
+      e(s_wait_dscnt(simm16=0))  # wait for 6 loads (no stall!)
+    if not NO_ALU:
+      # B[0] WMMAs — issue B[2] during compute
+      if not NO_DS: e(ds_load_b128(vdst=v[FB+8:FB+11], addr=v[LLB], offset0=0, offset1=4))
+      for tm in range(TILES_M):
+        ac = ACC + (tm*TILES_N+0)*8
+        e(v_wmma_f32_16x16x16_f16(vdst=v[ac:ac+7], src0=v[FA+tm*4:FA+tm*4+3], src1=v[FB:FB+3], src2=v[ac:ac+7]))
+      # B[1] WMMAs — issue B[3] during compute
+      if not NO_DS:
+        e(ds_load_b128(vdst=v[FB+12:FB+15], addr=v[LLB], offset0=0, offset1=6))
+      for tm in range(TILES_M):
+        ac = ACC + (tm*TILES_N+1)*8
+        e(v_wmma_f32_16x16x16_f16(vdst=v[ac:ac+7], src0=v[FA+tm*4:FA+tm*4+3], src1=v[FB+4:FB+7], src2=v[ac:ac+7]))
+      # B[2] WMMAs — B[2] loaded during B[0] WMMAs (~100 cycles ago)
+      if not NO_DS: e(s_wait_dscnt(simm16=1))  # B[2] done, B[3] may still be loading
+      for tm in range(TILES_M):
+        ac = ACC + (tm*TILES_N+2)*8
+        e(v_wmma_f32_16x16x16_f16(vdst=v[ac:ac+7], src0=v[FA+tm*4:FA+tm*4+3], src1=v[FB+8:FB+11], src2=v[ac:ac+7]))
+      # B[3] WMMAs
+      if not NO_DS: e(s_wait_dscnt(simm16=0))
+      for tm in range(TILES_M):
+        ac = ACC + (tm*TILES_N+3)*8
+        e(v_wmma_f32_16x16x16_f16(vdst=v[ac:ac+7], src0=v[FA+tm*4:FA+tm*4+3], src1=v[FB+12:FB+15], src2=v[ac:ac+7]))
+    if not NO_GLOBAL and not NO_DS: e(s_wait_loadcnt(simm16=0))
+    if not NO_DS:
+      for i in range(2): e(ds_store_b128(addr=v[4], data0=v[DA+i*4:DA+i*4+3], offset0=(i*16)&0xFF, offset1=(i*16)>>8))
+      for i in range(2): e(ds_store_b128(addr=v[5], data0=v[DB+i*4:DB+i*4+3], offset0=(i*16)&0xFF, offset1=(i*16)>>8))
+    e(s_add_co_i32(s[16], s[16], BLOCK_K))
+
+  label('LOOP')
+  emit_iter_body(load_set='A')
+  emit_iter_body(load_set='B')
+  e(s_cmp_lt_i32(s[16], s[17])); e(s_cbranch_scc1(simm16=0)); br(I[-1], 'LOOP')
+
+  emit_iter_body(load_set='AB')  # tail with prefetch
+
+  # Final iteration: no prefetch, no ds_store needed
+  if not NO_DS:
+    e(s_wait_dscnt(simm16=0))
+    e(s_barrier_signal(ssrc0=src[193])); e(s_barrier_wait(simm16=0xFFFF))
+  if not NO_DS:
+    for tm in range(TILES_M):
+      aoff = tm * 16 * LDS_A_ROW
+      e(ds_load_b128(vdst=v[FA+tm*4:FA+tm*4+3], addr=v[LLA], offset0=aoff&0xFF, offset1=aoff>>8))
+    e(ds_load_b128(vdst=v[FB:FB+3], addr=v[LLB], offset0=0, offset1=0))
+    e(ds_load_b128(vdst=v[FB+4:FB+7], addr=v[LLB], offset0=0, offset1=2))
+    e(s_wait_dscnt(simm16=0))
+  if not NO_ALU:
+    if not NO_DS: e(ds_load_b128(vdst=v[FB+8:FB+11], addr=v[LLB], offset0=0, offset1=4))
+    for tm in range(TILES_M):
+      ac = ACC + (tm*TILES_N+0)*8
+      e(v_wmma_f32_16x16x16_f16(vdst=v[ac:ac+7], src0=v[FA+tm*4:FA+tm*4+3], src1=v[FB:FB+3], src2=v[ac:ac+7]))
+    if not NO_DS: e(ds_load_b128(vdst=v[FB+12:FB+15], addr=v[LLB], offset0=0, offset1=6))
+    for tm in range(TILES_M):
+      ac = ACC + (tm*TILES_N+1)*8
+      e(v_wmma_f32_16x16x16_f16(vdst=v[ac:ac+7], src0=v[FA+tm*4:FA+tm*4+3], src1=v[FB+4:FB+7], src2=v[ac:ac+7]))
+    if not NO_DS: e(s_wait_dscnt(simm16=1))
+    for tm in range(TILES_M):
+      ac = ACC + (tm*TILES_N+2)*8
+      e(v_wmma_f32_16x16x16_f16(vdst=v[ac:ac+7], src0=v[FA+tm*4:FA+tm*4+3], src1=v[FB+8:FB+11], src2=v[ac:ac+7]))
+    if not NO_DS: e(s_wait_dscnt(simm16=0))
+    for tm in range(TILES_M):
+      ac = ACC + (tm*TILES_N+3)*8
+      e(v_wmma_f32_16x16x16_f16(vdst=v[ac:ac+7], src0=v[FA+tm*4:FA+tm*4+3], src1=v[FB+12:FB+15], src2=v[ac:ac+7]))
+
+  label('EPILOGUE')
+  e(v_and_b32_e32(v[ET], 15, v[1]))
+  e(v_lshrrev_b32_e32(v[ET+1], 4, v[1])); e(v_lshlrev_b32_e32(v[ET+1], 3, v[ET+1]))
+  e(v_lshlrev_b32_e32(v[ET+2], 6, v[2])); e(v_add_nc_u32_e32(v[ET+2], s[11], v[ET+2]))
+  e(v_lshlrev_b32_e32(v[ET+3], 6, v[3])); e(v_add_nc_u32_e32(v[ET+3], s[10], v[ET+3]))
+  e(v_add_nc_u32_e32(v[ET+3], v[ET+3], v[ET])); e(v_mov_b32_e32(v[ET+5], 0))
+
+  for tm in range(TILES_M):
+    for tn in range(TILES_N):
+      ac = ACC + (tm*TILES_N+tn)*8; r_off, c_off = tm*16, tn*16
+      e(v_add_nc_u32_e32(v[ET+6], r_off, v[ET+2])); e(v_add_nc_u32_e32(v[ET+6], v[ET+1], v[ET+6]))
+      e(v_mul_lo_u32(v[ET+4], v[ET+6], s[12])); e(v_add_nc_u32_e32(v[ET+4], v[ET+4], v[ET+3]))
+      if c_off: e(v_add_nc_u32_e32(v[ET+4], c_off, v[ET+4]))
+      e(v_lshlrev_b32_e32(v[ET+4], 1, v[ET+4]))
+      for elem in range(8):
+        e(v_cvt_f16_f32_e32(v[ET+7], v[ac+elem]))
+        e(global_store_b16(vaddr=v[ET+4:ET+5], vsrc=v[ET+7], saddr=s[8:9]))
+        if elem < 7: e(v_add_nc_u32_e32(v[ET+4], s[13], v[ET+4]))
+
+  e(s_wait_storecnt(simm16=0)); e(s_sendmsg(simm16=3)); e(s_endpgm())
+
+  for idx, target in B:
+    off = (L[target] - sum(i.size() for i in I[:idx+1])) // 4
+    assert -32768 <= off <= 32767; I[idx].simm16 = off
+  return I
+
+N = getenv("N", 4096)
+
+def test_matmul():
+  dev = Device[Device.DEFAULT]
+  arch = getattr(dev.renderer, 'arch', 'gfx1200')
+  print(f"Device arch: {arch}")
+  insts = build_kernel(N, arch)
+
+  rng = np.random.default_rng(42)
+  a = Tensor(rng.random((N, N), dtype=np.float32).astype(np.float16))
+  b = Tensor(rng.random((N, N), dtype=np.float32).astype(np.float16))
+  c = Tensor.empty(N, N, dtype=dtypes.half)
+  Tensor.realize(a, b, c)
+
+  grid, local = (N//BLOCK_N, N//BLOCK_M, 1), (THREADS, 1, 1)
+  print(f"Grid: {grid}, Local: {local}")
+
+  dname = Device.DEFAULT
+  def asm_kernel(A, B, C):
+    gidxs = [UOp.special(n, f"gidx{i}") for i,n in enumerate(grid)]
+    lidxs = [UOp.special(THREADS, "lidx0")]
+    lds = UOp(Ops.DEFINE_LOCAL, dtypes.uint8.ptr(size=max(LDS_SIZE, 65536//getenv("LIMIT_OCC",2)), addrspace=AddrSpace.LOCAL), (), 'lds')
+    sink = UOp.sink(A.base, B.base, C.base, lds, *gidxs, *lidxs,
+                    arg=KernelInfo(name=colored("kernel","cyan"), estimates=Estimates(ops=N*N*N*2, mem=N*N*2*3)))
+    return UOp(Ops.PROGRAM, src=(sink, UOp(Ops.DEVICE, arg=dname), UOp(Ops.LINEAR, src=tuple([UOp(Ops.INS, arg=x) for x in insts]))))
+
+  c = Tensor.custom_kernel(a, b, c, fxn=asm_kernel)[2]
+  ei = c.schedule()[0].lower()
+
+  ets = []
+  with Context(DEBUG=2):
+    for _ in range(getenv("CNT", 5)): ets.append(ei.run(wait=True))
+  print(f"REAL TFLOPS {N*N*N*2 / min(ets) * 1e-12:.2f}")
+
+  if getenv("VERIFY", 1):
+    GlobalCounters.reset()
+    c_np = c.float().numpy()
+    a_np, b_np = a.float().numpy(), b.float().numpy()
+    ref = a_np @ b_np
+    err = np.sqrt(np.mean((c_np - ref)**2)) / np.sqrt(np.mean(ref**2))
+    print(f"relative RMSE {err:.6f}")
+    if err != err or err > 0.05: raise RuntimeError(f"matmul is wrong! RMSE={err}")
+
+if __name__ == "__main__":
+  test_matmul()

From dae9dea903ad01a06f19bd7affd0e5aa7c6519f0 Mon Sep 17 00:00:00 2001
From: chenyu <chenyu@fastmail.com>
Date: Wed, 8 Apr 2026 09:44:37 -0400
Subject: [PATCH 16/21] clean up tensor random functions (#15648)

* clean up tensor random functions

* revert that
---
 tinygrad/tensor.py | 23 +++++++++--------------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/tinygrad/tensor.py b/tinygrad/tensor.py
index 456b2902f0..596e72aae6 100644
--- a/tinygrad/tensor.py
+++ b/tinygrad/tensor.py
@@ -832,7 +832,7 @@ class Tensor(OpMixin):
     if isinstance(self.device, tuple): return self._multi_like(Tensor.rand, **kwargs)
     return Tensor.rand(*self.shape, device=kwargs.pop("device", self.device), dtype=kwargs.pop("dtype", self.dtype), **kwargs)
 
-  # ***** rng hlops *****
+  # ***** random functions *****
 
   def randn_like(self, dtype:DTypeLike|None=None, requires_grad:bool|None=None, **kwargs) -> Tensor:
     """
@@ -880,9 +880,8 @@ class Tensor(OpMixin):
     print(Tensor.randint(2, 3, low=5, high=10).numpy())
     ```
     """
-    if not isinstance(low, int) or not isinstance(high, int): raise TypeError(f"{low=} and {high=} must be integers")
-    dtype = to_dtype(dtype)
-    if not dtypes.is_int(dtype): raise TypeError(f"{dtype=} must be int")
+    if not all_int([low, high]): raise TypeError(f"{low=} and {high=} must be integers")
+    if not dtypes.is_int(dtype := to_dtype(dtype)): raise TypeError(f"{dtype=} must be int")
     return Tensor.uniform(*shape, low=low, high=high, dtype=dtype, **kwargs)
 
   @staticmethod
@@ -898,7 +897,7 @@ class Tensor(OpMixin):
     print(Tensor.normal(2, 3, mean=10, std=2).numpy())
     ```
     """
-    return ((std * Tensor.randn(*shape, **kwargs)) + mean).requires_grad_(requires_grad)
+    return (std * Tensor.randn(*shape, **kwargs) + mean).requires_grad_(requires_grad)
 
   @staticmethod
   def uniform(*shape, low=0.0, high=1.0, dtype:DTypeLike|None=None, requires_grad:bool|None=None, **kwargs) -> Tensor:
@@ -931,7 +930,6 @@ class Tensor(OpMixin):
     """
     return Tensor.uniform(*shape, low=-1.0, high=1.0, **kwargs).mul(prod(argfix(*shape))**-0.5)
 
-  # https://www.tensorflow.org/api_docs/python/tf/keras/initializers/GlorotUniform
   @staticmethod
   def glorot_uniform(*shape, **kwargs) -> Tensor:
     """
@@ -945,9 +943,9 @@ class Tensor(OpMixin):
     print(Tensor.glorot_uniform(2, 3).numpy())
     ```
     """
-    return Tensor.uniform(*shape, low=-1.0, high=1.0, **kwargs).mul((6/(argfix(*shape)[0]+prod(argfix(*shape)[1:])))**0.5)
+    bound = (6 / (argfix(*shape)[0]+prod(argfix(*shape)[1:]))) ** 0.5
+    return Tensor.uniform(*shape, low=-bound, high=bound, **kwargs)
 
-  # https://pytorch.org/docs/stable/_modules/torch/nn/init.html#kaiming_uniform_
   @staticmethod
   def kaiming_uniform(*shape, a:float = 0.01, **kwargs) -> Tensor:
     """
@@ -961,10 +959,9 @@ class Tensor(OpMixin):
     print(Tensor.kaiming_uniform(2, 3).numpy())
     ```
     """
-    bound = math.sqrt(3.0) * math.sqrt(2.0 / (1 + a ** 2)) / math.sqrt(prod(argfix(*shape)[1:]))
+    bound = (6 / (1 + a ** 2) / prod(argfix(*shape)[1:])) ** 0.5
     return Tensor.uniform(*shape, low=-bound, high=bound, **kwargs)
 
-  # https://pytorch.org/docs/stable/_modules/torch/nn/init.html#kaiming_normal_
   @staticmethod
   def kaiming_normal(*shape, a:float = 0.01, **kwargs) -> Tensor:
     """
@@ -978,7 +975,7 @@ class Tensor(OpMixin):
     print(Tensor.kaiming_normal(2, 3).numpy())
     ```
     """
-    std = math.sqrt(2.0 / (1 + a ** 2)) / math.sqrt(prod(argfix(*shape)[1:]))
+    std = (2 / (1 + a ** 2) / prod(argfix(*shape)[1:])) ** 0.5
     return Tensor.normal(*shape, mean=0.0, std=std, **kwargs)
 
   @staticmethod
@@ -1059,7 +1056,7 @@ class Tensor(OpMixin):
       else: t.grad.assign(t.grad + g.to(t.grad.device))
     return self
 
-  # ***** movement low level ops *****
+  # ***** movement ops *****
 
   def _mop(self, op:Ops, arg) -> Tensor: return self._apply_uop(UOp._mop, extra_args=(op,), arg=arg)
   def _rop(self, op:Ops, axis:tuple[int, ...]) -> Tensor: return self._apply_uop(UOp._rop, op=op, axis=axis)
@@ -1137,8 +1134,6 @@ class Tensor(OpMixin):
     if mode in {"reflect", "replicate"}: return self._pad_reflect_replicate(pX, mode)
     raise NotImplementedError(f"{mode=} is not supported")
 
-  # ***** movement high level ops *****
-
   def _getitem(self, indices, v: Tensor|None = None) -> Tensor:
     # wrap single index into a list
     if (isinstance(indices, list) and all_int(indices)) or not isinstance(indices, (tuple, list)): indices = [indices]

From 839d37b7bc33154379db38097cb8443d2aaa6665 Mon Sep 17 00:00:00 2001
From: chenyu <chenyu@fastmail.com>
Date: Wed, 8 Apr 2026 09:53:59 -0400
Subject: [PATCH 17/21] update median_step_time in model_train.py (#15649)

BENCHMARK=5 used to pick the 4th largest, not the middle one
---
 examples/mlperf/model_train.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/examples/mlperf/model_train.py b/examples/mlperf/model_train.py
index 8ac1dbd4fa..29c0f73b1e 100644
--- a/examples/mlperf/model_train.py
+++ b/examples/mlperf/model_train.py
@@ -246,7 +246,7 @@ def train_resnet():
 
       if i == BENCHMARK:
         assert not math.isnan(loss)
-        median_step_time = sorted(step_times)[(BENCHMARK + 1) // 2]  # in seconds
+        median_step_time = sorted(step_times)[BENCHMARK // 2]  # in seconds
         estimated_total_minutes = int(median_step_time * steps_in_train_epoch * epochs / 60)
         print(f"Estimated training time: {estimated_total_minutes // 60}h{estimated_total_minutes % 60}m")
         print(f"epoch global_ops: {steps_in_train_epoch * GlobalCounters.global_ops:_}, "
@@ -593,7 +593,7 @@ def train_retinanet():
 
       if i == BENCHMARK:
         assert not math.isnan(loss)
-        median_step_time = sorted(step_times)[(BENCHMARK + 1) // 2]  # in seconds
+        median_step_time = sorted(step_times)[BENCHMARK // 2]  # in seconds
         estimated_total_minutes = int(median_step_time * steps_in_train_epoch * EPOCHS / 60)
         print(f"Estimated training time: {estimated_total_minutes // 60}h{estimated_total_minutes % 60}m")
         print(f"epoch global_ops: {steps_in_train_epoch * GlobalCounters.global_ops:_}, "
@@ -868,7 +868,7 @@ def train_unet3d():
         i += 1
 
         if i == BENCHMARK:
-          median_step_time = sorted(step_times)[(BENCHMARK + 1) // 2]  # in seconds
+          median_step_time = sorted(step_times)[BENCHMARK // 2]  # in seconds
           estimated_total_minutes = int(median_step_time * SAMPLES_PER_EPOCH * NUM_EPOCHS / 60)
           print(f"Estimated training time: {estimated_total_minutes // 60}h{estimated_total_minutes % 60}m")
           if (TRAIN_BEAM or EVAL_BEAM) and epoch == start_epoch: break
@@ -1167,7 +1167,7 @@ def train_bert():
       i += 1
 
       if i == BENCHMARK:
-        median_step_time = sorted(step_times)[(BENCHMARK + 1) // 2]  # in seconds
+        median_step_time = sorted(step_times)[BENCHMARK // 2]  # in seconds
         estimated_total_minutes = int(median_step_time * train_steps / 60)
         print(f"Estimated training time: {estimated_total_minutes // 60}h{estimated_total_minutes % 60}m")
         print(f"epoch global_ops: {train_steps * GlobalCounters.global_ops:_}, "
@@ -1577,7 +1577,7 @@ def train_llama3():
         safe_save(get_state_dict(scheduler), fn)
 
       if i == BENCHMARK:
-        median_step_time = sorted(step_times)[(BENCHMARK + 1) // 2]
+        median_step_time = sorted(step_times)[BENCHMARK // 2]
         estimated_steps = 200_000 // GBS if getenv("LLAMA3_SIZE", "8B") == "8B" else MAX_STEPS
         estimated_total_minutes = int(median_step_time * estimated_steps / 60)
         print(f"Estimated training time: {estimated_total_minutes // 60}h{estimated_total_minutes % 60}m")

From 71c83cc3f65eabcee7d6980be839348e2a2f0fb7 Mon Sep 17 00:00:00 2001
From: qazal <77887910+Qazalin@users.noreply.github.com>
Date: Wed, 8 Apr 2026 17:13:44 +0300
Subject: [PATCH 18/21] viz: put OTHER_ on the wave row (#15650)

* viz: put OTHER_ on the wave row

* update tests

* cleanup cli
---
 extra/viz/cli.py         | 2 +-
 test/amd/test_sqttmap.py | 8 +++-----
 tinygrad/viz/serve.py    | 7 +------
 3 files changed, 5 insertions(+), 12 deletions(-)

diff --git a/extra/viz/cli.py b/extra/viz/cli.py
index 25806400d2..4077976ffd 100755
--- a/extra/viz/cli.py
+++ b/extra/viz/cli.py
@@ -87,7 +87,7 @@ def main(args) -> None:
         op_str = hex_colored(op_name, color) if color and not args.no_color else op_name
         phase, delay = None, 0
         idx = next(pkt_idxs.setdefault(e.device, itertools.count()))
-        if e.device.startswith("WAVE") or e.device == "OTHER_SIMD":
+        if e.device.startswith("WAVE"):
           inst = f"0x{(pc:=int(info.replace('PC:', ''))):05x} {pc_map[pc]}" if info else f"{'':7} {op_name}"
           dispatch_to_inst[f"{e.device}-{idx}"] = (inst, int(e.st))
           phase = "DISPATCH"
diff --git a/test/amd/test_sqttmap.py b/test/amd/test_sqttmap.py
index 2828234054..d6225e61fa 100644
--- a/test/amd/test_sqttmap.py
+++ b/test/amd/test_sqttmap.py
@@ -100,9 +100,7 @@ class TestSQTTMapBase(unittest.TestCase):
             elif "WAVE" in e.device:
               # sopk/immediates don't get ALU/MEM EXEC
               if e.name.display_name not in {"IMMEDIATE", "IMMEDIATE_MASK", "JUMP", "JUMP_NO", "MESSAGE", "BARRIER", "BARRIER_SIGNAL",
-                                             "WAVEEND", "WAVERDY"}: insts += 1
-            # OTHER_ is its own stream, it's the INST from other SIMDs that share the same EXEC.
-            elif e.device.startswith("OTHER"): continue
+                                             "WAVEEND", "WAVERDY"} and not e.name.display_name.startswith("OTHER_"): insts += 1
             else: raise Exception(f"timeline row must be INST or EXEC, got {e.device}")
           self.assertEqual(execs, insts)
 
@@ -139,9 +137,9 @@ class TestSQTTMapRDNA4(TestSQTTMapBase):
     events, kernels, target = self.examples["profile_handwritten_run_0"]
     row_ends = {}
     for e in sqtt_timeline(events[0].blob, list(kernels.values())[0].lib, target):
-      if type(e).__name__ != "ProfileRangeEvent": continue
+      if type(e).__name__ != "ProfileRangeEvent" or e.device != "ALUEXEC:0 WMMA": continue
       if (et:=row_ends.get(e.device)) is not None and e.st < et:
-        raise RuntimeError(f"overlap in {e.device}: {e.st} {et}.")
+        raise RuntimeError(f"WMMA exec overlaps in {e.device}: {e.st} {et}.")
       row_ends[e.device] = e.en
 
 class TestSQTTMapCDNA(TestSQTTMapBase):
diff --git a/tinygrad/viz/serve.py b/tinygrad/viz/serve.py
index 3b23bf3292..92a34a2949 100755
--- a/tinygrad/viz/serve.py
+++ b/tinygrad/viz/serve.py
@@ -352,12 +352,10 @@ def sqtt_timeline(data:bytes, lib:bytes, target:str) -> Generator[ProfileEvent,
   row_counts:dict[str, itertools.count] = {}
   curr_barrier:dict[int, ProfileRangeEvent] = {}
   exec_pending:dict[str, list[tuple[str, str]]] = {}
-  is_cdna = target.startswith("gfx9")
   dispatch_to_exec = {"WMMA":"VALU", "VALU":"VALU", "VALU1":"VALU", "VALUT":"VALU", "VALUB":"VALU", "VALUINST":"VALU", "VINTERP":"VALU",
                       "SGMEM":"VMEM", "FLAT":"VMEM", "LDS":"LDS", "SALU":"SALU", "SMEM":"SALU", "VMEM":"VMEM"}
   def add(name:str, p:PacketType, wave:int|None=None, info:InstructionInfo|None=None) -> Generator[ProfileEvent, None, None]:
-    row = "OTHER_SIMD" if name.startswith("OTHER_") else f"WAVE:{wave}" if (wave:=getattr(p, "wave", wave)) is not None \
-        else f"{p.__class__.__name__}:0 {name.replace('_ALT', '')}"
+    row = f"WAVE:{wave}" if (wave:=getattr(p, "wave", wave)) is not None else f"{p.__class__.__name__}:0 {name.replace('_ALT', '')}"
     # by default we extend the packet to one cycle after timestamp
     start_time, end_time = p._time, p._time+1
     # exec links to dispatch, dispatch links to PC
@@ -382,9 +380,6 @@ def sqtt_timeline(data:bytes, lib:bytes, target:str) -> Generator[ProfileEvent,
     # construct and yield the event for this packet
     if row not in row_ends: yield ProfilePointEvent(row, "JSON", "pcMap", pc_map, ts=Decimal(0))
     yield (e:=ProfileRangeEvent(row, TracingKey(name, ret=link), Decimal(start_time), Decimal(end_time)))
-    # allow CDNA packets to overlap, NOT allowed on RDNA.
-    if (et:=row_ends.get(row)) is not None and e.st < et and not is_cdna and not isinstance(p, (ALUEXEC, VMEMEXEC)):
-      RuntimeError(f"packet {row}-{idx} overlaps: {e.st} {et}.")
     row_ends[row] = unwrap(e.en)
     # barrier on this wave extends to fill the time it was waiting
     if wave is not None:

From 1b44cb2ac634121a7d7220bfff5c4d29cb8aec5a Mon Sep 17 00:00:00 2001
From: nimlgen <138685161+nimlgen@users.noreply.github.com>
Date: Wed, 8 Apr 2026 20:07:12 +0300
Subject: [PATCH 19/21] split update stat from execitem (#15654)

---
 tinygrad/engine/realize.py | 38 ++++++++++++++++++++++----------------
 1 file changed, 22 insertions(+), 16 deletions(-)

diff --git a/tinygrad/engine/realize.py b/tinygrad/engine/realize.py
index cb4af7beb4..a2d387a0e3 100644
--- a/tinygrad/engine/realize.py
+++ b/tinygrad/engine/realize.py
@@ -9,6 +9,27 @@ from tinygrad.device import Device, Buffer
 from tinygrad.renderer import ProgramSpec, Estimates
 from tinygrad.codegen import get_program
 
+# **************** Stat ****************
+
+def update_stats(display_name:str, device:str, estimates:Estimates, var_vals:dict[str, int], et:float|None, buf_count:int,
+                 jit=False, metadata:tuple[Metadata, ...]=(), first_run=False):
+  GlobalCounters.kernel_count += 1
+  GlobalCounters.global_ops += (op_est:=sym_infer(estimates.ops, var_vals))
+  GlobalCounters.global_mem += (mem_est:=sym_infer(estimates.mem, var_vals))
+  if et is not None: GlobalCounters.time_sum_s += et
+  if DEBUG >= 2:
+    lds_est = sym_infer(estimates.lds, var_vals)
+    header_color = 'magenta' if jit else ('green' if first_run else None)
+    ptm = colored(time_to_str(et, w=9), "yellow" if et > 0.01 else None) if et is not None else ""
+    flops, membw, ldsbw = op_est/(et or 1e-20), mem_est/(et or 1e-20), lds_est/(et or 1e-20)
+    flops_str = f"{flops*1e-9:7.0f} GFLOPS" if flops < 1e14 else colored(f"{flops*1e-12:7.0f} TFLOPS", 'green')
+    mem_str = f"{membw*1e-9:4.0f}|{ldsbw*1e-9:<6.0f} GB/s" if membw < 1e13 and ldsbw < 1e15 else \
+      colored(f"{membw*1e-12:4.0f}|{ldsbw*1e-12:<6.0f} TB/s", 'green')
+    print(f"{colored(f'*** {device[:7]:7s} {GlobalCounters.kernel_count:4d}', header_color)}"+
+      f" {display_name+' '*(46-ansilen(display_name))} arg {buf_count:2d} mem {GlobalCounters.mem_used/1e9:6.2f} GB"+
+      ("" if et is None else f" tm {ptm}/{GlobalCounters.time_sum_s*1e3:9.2f}ms ({flops_str} {mem_str})")+
+      f" {[repr(m) if TRACEMETA >= 2 else str(m) for m in metadata] if metadata else ''}")
+
 # **************** Runners ****************
 
 class Runner:
@@ -166,22 +187,7 @@ class ExecItem:
       cpu_events.append(ProfilePointEvent(self.prg.device, "exec", len(cpu_events), payload))
     et = self.prg(bufs, var_vals, wait=wait or DEBUG >= 2)
     if do_update_stats:
-      GlobalCounters.kernel_count += 1
-      GlobalCounters.global_ops += (op_est:=sym_infer(self.prg.estimates.ops, var_vals))
-      GlobalCounters.global_mem += (mem_est:=sym_infer(self.prg.estimates.mem, var_vals))
-      if et is not None: GlobalCounters.time_sum_s += et
-      if DEBUG >= 2:
-        lds_est = sym_infer(self.prg.estimates.lds, var_vals)
-        header_color = 'magenta' if jit else ('green' if self.prg.first_run else None)
-        ptm = colored(time_to_str(et, w=9), "yellow" if et > 0.01 else None) if et is not None else ""
-        flops, membw, ldsbw = op_est/(et or 1e-20), mem_est/(et or 1e-20), lds_est/(et or 1e-20)
-        flops_str = f"{flops*1e-9:7.0f} GFLOPS" if flops < 1e14 else colored(f"{flops*1e-12:7.0f} TFLOPS", 'green')
-        mem_str = f"{membw*1e-9:4.0f}|{ldsbw*1e-9:<6.0f} GB/s" if membw < 1e13 and ldsbw < 1e15 else \
-          colored(f"{membw*1e-12:4.0f}|{ldsbw*1e-12:<6.0f} TB/s", 'green')
-        print(f"{colored(f'*** {self.prg.device[:7]:7s} {GlobalCounters.kernel_count:4d}', header_color)}"+
-          f" {self.prg.display_name+' '*(46-ansilen(self.prg.display_name))} arg {len(bufs):2d} mem {GlobalCounters.mem_used/1e9:6.2f} GB"+
-          ("" if et is None else f" tm {ptm}/{GlobalCounters.time_sum_s*1e3:9.2f}ms ({flops_str} {mem_str})")+
-          f" {[repr(m) if TRACEMETA >= 2 else str(m) for m in self.metadata] if self.metadata else ''}")
+      update_stats(self.prg.display_name, self.prg.device, self.prg.estimates, var_vals, et, len(bufs), jit, self.metadata, self.prg.first_run)
       self.prg.first_run = False
     return et
 

From 28b14b0e3857313dacdf3c52d19b09f9669ce289 Mon Sep 17 00:00:00 2001
From: nimlgen <138685161+nimlgen@users.noreply.github.com>
Date: Wed, 8 Apr 2026 20:07:28 +0300
Subject: [PATCH 20/21] mlx: remove to_be, use helpers (#15655)

---
 extra/mlx_driver/loopback.py           |  9 +++++----
 tinygrad/runtime/ops_rdma.py           | 14 +++++++-------
 tinygrad/runtime/support/mlx/mlxdev.py | 11 +++++------
 3 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/extra/mlx_driver/loopback.py b/extra/mlx_driver/loopback.py
index 2013263f9f..31a017f061 100644
--- a/extra/mlx_driver/loopback.py
+++ b/extra/mlx_driver/loopback.py
@@ -6,7 +6,8 @@ from tinygrad.device import Device, BufferSpec
 from tinygrad.runtime.support.system import PCIDevice
 from tinygrad.runtime.support.memory import AddrSpace
 from tinygrad.runtime.ops_amd import AMDComputeQueue
-from extra.mlx_driver.mlxdev import MLXDev, MLXQP, to_be
+from tinygrad.helpers import to_be32, to_be64
+from extra.mlx_driver.mlxdev import MLXDev, MLXQP
 
 BUF_SIZE = 0x1000
 MLX_PCI = getenv("MLX_PCI", "0000:41:00.0")
@@ -49,7 +50,7 @@ rq_wqe = qp.qp_buf.view((qp.rq_head & rq_mask) * 16, 16)
 rq_wqe[:] = struct.pack('>IIQ', len(test_msg), dev.mkey, dst_paddr)
 qp.rq_head += 1
 # ring recv doorbell from CPU (DBR offset 0 = recv counter)
-dev.dbr[qp.qp_dbr // 4] = to_be('I', qp.rq_head)
+dev.dbr[qp.qp_dbr // 4] = to_be32(qp.rq_head)
 
 # build send WQE in SQ from CPU (opcode 0x0a = SEND, ds_count=2)
 sq_head = qp.sq_head
@@ -60,7 +61,7 @@ wqe[0:8] = struct.pack('>II', (sq_head << 8) | 0x0a, (qp.qp_info['qpn'] << 8) |
 wqe[11] = 0x08  # CE: signal completion
 wqe[16:32] = struct.pack('>IIQ', len(test_msg), dev.mkey, src_paddr)
 qp.sq_head += 1
-doorbell_val = to_be('Q', int.from_bytes(bytes(wqe[0:8]), 'big'))
+doorbell_val = to_be64(int.from_bytes(bytes(wqe[0:8]), 'big'))
 
 # map MLX5 UAR and DBR into GPU VA
 uar_paddr = dev.pci_dev.bar_info(0)[0] + dev.uar * 0x1000
@@ -72,7 +73,7 @@ print(f"UAR gpu_va=0x{uar_gpu_va:x} DBR gpu_va=0x{dbr_gpu_va:x}")
 q = AMDComputeQueue(gpu)
 q.wait(gpu.timeline_signal, gpu.timeline_value - 1)
 # write DBR (32-bit sq_head) - send doorbell at qp_dbr + 4
-q.release_mem(dbr_gpu_va + qp.qp_dbr + 4, to_be('I', qp.sq_head), q.pm4.data_sel__mec_release_mem__send_32_bit_low,
+q.release_mem(dbr_gpu_va + qp.qp_dbr + 4, to_be32(qp.sq_head), q.pm4.data_sel__mec_release_mem__send_32_bit_low,
               q.pm4.int_sel__mec_release_mem__none)
 # write UAR doorbell (64-bit)
 q.release_mem(uar_gpu_va + 0x800, doorbell_val, q.pm4.data_sel__mec_release_mem__send_64_bit_data,
diff --git a/tinygrad/runtime/ops_rdma.py b/tinygrad/runtime/ops_rdma.py
index 15069a354a..5c6259edf8 100644
--- a/tinygrad/runtime/ops_rdma.py
+++ b/tinygrad/runtime/ops_rdma.py
@@ -5,8 +5,8 @@ from tinygrad.uop.ops import sint
 from tinygrad.runtime.support.hcq import HCQCompiled, HCQAllocatorBase, HCQAllocator, HWQueue, HCQBuffer, FileIOInterface
 from tinygrad.runtime.support.system import System, PCIIfaceBase, PCIAllocationMeta
 from tinygrad.runtime.support.memory import VirtMapping, AddrSpace
-from tinygrad.runtime.support.mlx.mlxdev import MLXDev, MLXQP, to_be
-from tinygrad.helpers import unwrap
+from tinygrad.runtime.support.mlx.mlxdev import MLXDev, MLXQP
+from tinygrad.helpers import unwrap, to_be32, to_be64
 
 class RDMACopyQueue(HWQueue):
   def __init__(self, dev:RDMADevice):
@@ -19,10 +19,10 @@ class RDMACopyQueue(HWQueue):
 
   def encode_ring(self, hwq:HWQueue, dev:HCQCompiled, iface:MLXIface, qp:MLXQP, cq_buf:HCQBuffer, head:sint, ring_uar:bool=False):
     for buf in [iface.dbr_buf, cq_buf] + ([iface.uar_buf] if ring_uar else []): cast(HCQAllocator, dev.allocator).map(buf)
-    hwq.write(iface.dbr_buf.offset(qp.qp_dbr + (4 if ring_uar else 0)), to_be('I', head + 1))
-    if ring_uar: hwq.write(iface.uar_buf.offset(0x800), to_be('Q', ((head << 8) | 0x0a) << 32 | ((qp.qp_info['qpn'] << 8) | 2)), b64=True)
+    hwq.write(iface.dbr_buf.offset(qp.qp_dbr + (4 if ring_uar else 0)), to_be32(head + 1))
+    if ring_uar: hwq.write(iface.uar_buf.offset(0x800), to_be64(((head << 8) | 0x0a) << 32 | ((qp.qp_info['qpn'] << 8) | 2)), b64=True)
     hwq.poll_bit(cq_buf.offset((head & (qp.cq_size - 1)) * 64 + 60, 4), ((head >> (qp.cq_size.bit_length() - 1)) & 1) << 24, mask=0x01000000)
-    hwq.write(iface.dbr_buf.offset(qp.cq_dbr), to_be('I', (head + 1) & 0xFFFFFF))
+    hwq.write(iface.dbr_buf.offset(qp.cq_dbr), to_be32((head + 1) & 0xFFFFFF))
     return self
 
   def copy(self, dest:HCQBuffer, src:HCQBuffer, sz:int):
@@ -39,8 +39,8 @@ class RDMACopyQueue(HWQueue):
   def _submit(self, dev:RDMADevice):
     for remote_nic, sq_wqe, rq_wqe in zip(self._q[0::3], self._q[1::3], self._q[2::3]):
       src_qp, dest_qp, _, _ = dev.iface.connect(remote_nic)
-      assert src_qp.head + 1 - to_be('I', src_qp.dev.dbr[src_qp.qp_dbr // 4 + 1]) <= (1 << src_qp.log_sq_size), "SQ ring full"
-      assert src_qp.head + 1 - to_be('I', dest_qp.dev.dbr[dest_qp.qp_dbr // 4]) <= (1 << dest_qp.log_rq_size), "RQ ring full"
+      assert src_qp.head + 1 - to_be32(src_qp.dev.dbr[src_qp.qp_dbr // 4 + 1]) <= (1 << src_qp.log_sq_size), "SQ ring full"
+      assert src_qp.head + 1 - to_be32(dest_qp.dev.dbr[dest_qp.qp_dbr // 4]) <= (1 << dest_qp.log_rq_size), "RQ ring full"
       dest_qp.qp_buf.view((src_qp.head & ((1 << dest_qp.log_rq_size) - 1)) * 16, 16)[:] = rq_wqe
       sq_view = src_qp.qp_buf.view(src_qp.sq_offset + (src_qp.head & ((1 << src_qp.log_sq_size) - 1)) * 64, 64)
       sq_view[:] = struct.pack('>I', (src_qp.head << 8) | 0x0a) + sq_wqe[4:]
diff --git a/tinygrad/runtime/support/mlx/mlxdev.py b/tinygrad/runtime/support/mlx/mlxdev.py
index ff84e8e463..4db29163df 100644
--- a/tinygrad/runtime/support/mlx/mlxdev.py
+++ b/tinygrad/runtime/support/mlx/mlxdev.py
@@ -11,7 +11,6 @@ MLX5_CMD_STRUCTS = {v: (getattr(mlx5, f"struct_mlx5_ifc_{n[12:].lower()}_in_bits
   getattr(mlx5, f"struct_mlx5_ifc_{n[12:].lower()}_out_bits", None)) for n, v in mlx5.__dict__.items() if n.startswith("MLX5_CMD_OP_")}
 MLX5_CMD_STRUCTS[mlx5.MLX5_CMD_OP_ACCESS_REG] = (mlx5.struct_mlx5_ifc_access_register_in_bits, mlx5.struct_mlx5_ifc_access_register_out_bits)
 
-def to_be(fmt, val): return to_be32(val) if fmt == 'I' else to_be64(val)
 def ipv4_to_gid(ip): return bytes(10) + b'\xff\xff' + socket.inet_aton(ip)
 
 def udp_sport(lqpn, rqpn):
@@ -64,7 +63,7 @@ class MLXCmdQueue:
     for i in range(n):
       off, _ = self.mboxes[base + i]
       blk = mlx5.struct_mlx5_cmd_prot_block(data=list(data[i*chunk_sz:(i+1)*chunk_sz].ljust(chunk_sz, b'\x00')),
-        next=to_be('Q', self.mboxes[base+i+1][1]) if i < n-1 else 0, block_num=to_be('I', i), token=tok)
+        next=to_be64(self.mboxes[base+i+1][1]) if i < n-1 else 0, block_num=to_be32(i), token=tok)
       self.queue[off:off + ctypes.sizeof(mlx5.struct_mlx5_cmd_prot_block)] = bytes(blk)
     return (self.mboxes[base][0], self.mboxes[base][1], n)
 
@@ -81,9 +80,9 @@ class MLXCmdQueue:
     # prepare mailboxes and build command layout
     _, in_ptr, n_in = self.create_mbox_chain(0, tok, inp[16:])
     _, out_ptr, n_out = self.create_mbox_chain(n_in, tok, bytes(out_sz))
-    cmd = mlx5.struct_mlx5_cmd_layout(type=mlx5.MLX5_PCI_CMD_XPORT, inlen=to_be('I', len(inp)), in_ptr=to_be('Q', in_ptr),
+    cmd = mlx5.struct_mlx5_cmd_layout(type=mlx5.MLX5_PCI_CMD_XPORT, inlen=to_be32(len(inp)), in_ptr=to_be64(in_ptr),
       _in=[int.from_bytes(inp[i:i+4], 'little') for i in range(0, 16, 4)],
-      out_ptr=to_be('Q', out_ptr), outlen=to_be('I', 16 + out_sz), token=tok, status_own=mlx5.CMD_OWNER_HW)
+      out_ptr=to_be64(out_ptr), outlen=to_be32(16 + out_sz), token=tok, status_own=mlx5.CMD_OWNER_HW)
     cmd_bytes = bytearray(bytes(cmd))
     cmd_bytes[mlx5.struct_mlx5_cmd_layout.sig.offset] = (~functools.reduce(lambda a, b: a ^ b, cmd_bytes)) & 0xFF  # type: ignore[attr-defined]
 
@@ -115,8 +114,8 @@ class MLXDev:
 
     self.init_hw(ip)
 
-  def rreg(self, off): return to_be('I',self.bar[off // 4])
-  def wreg(self, off, val): self.bar[off // 4] = to_be('I',val)
+  def rreg(self, off): return to_be32(self.bar[off // 4])
+  def wreg(self, off, val): self.bar[off // 4] = to_be32(val)
   def iseg_r(self, field): return self.rreg(getattr(mlx5.struct_mlx5_init_seg, field).offset)
   def iseg_w(self, field, val): self.wreg(getattr(mlx5.struct_mlx5_init_seg, field).offset, val)
 

From cb681da8405b0b3ffe91cdeee3f33dd06ecb7aa4 Mon Sep 17 00:00:00 2001
From: chenyu <chenyu@fastmail.com>
Date: Wed, 8 Apr 2026 13:15:19 -0400
Subject: [PATCH 21/21] move UOp.pad to mixin (#15657)

the same arg works for Tensor.pad
---
 tinygrad/mixin/movement.py |  6 ++++++
 tinygrad/uop/ops.py        | 10 ----------
 2 files changed, 6 insertions(+), 10 deletions(-)

diff --git a/tinygrad/mixin/movement.py b/tinygrad/mixin/movement.py
index 68b64c7b9b..47ca3640e8 100644
--- a/tinygrad/mixin/movement.py
+++ b/tinygrad/mixin/movement.py
@@ -107,6 +107,12 @@ class MovementMixin:
     ret = self._mop(Ops.RESHAPE, arg=new_shape)
     return self if ret.shape == self.shape else ret
 
+  def pad(self, arg:tuple[tuple[sint, sint] | None, ...]) -> Self:
+    if self.ndim != len(arg):
+      raise ValueError(f"{self.ndim=} != {len(arg)=}")
+    ret = self._mop(Ops.PAD, tuple(x if x is not None else (0, 0) for x in arg))
+    return self if ret.shape == self.shape else ret
+
   def shrink(self, arg: tuple[tuple[sint, sint] | None, ...]) -> Self:
     """
     Returns a tensor that shrinks the each axis based on input arg.
diff --git a/tinygrad/uop/ops.py b/tinygrad/uop/ops.py
index c55847a08d..705c78082a 100644
--- a/tinygrad/uop/ops.py
+++ b/tinygrad/uop/ops.py
@@ -650,16 +650,6 @@ class UOp(OpMixin, metaclass=UOpMetaClass):
     if ret.shape == self.shape and same_shape_noop: return self
     return ret
 
-  # in these four, if the shape doesn't change we can return self
-  #def reshape(self, arg:tuple[sint, ...]): return self._mop(Ops.RESHAPE, arg, same_shape_noop=True)
-  #def expand(self, arg:tuple[sint, ...]): return self._mop(Ops.EXPAND, arg, same_shape_noop=True)
-  #def shrink(self, arg:tuple[tuple[sint, sint], ...]): return self._mop(Ops.SHRINK, arg, same_shape_noop=True)
-  def pad(self, arg:tuple[tuple[sint, sint], ...]): return self._mop(Ops.PAD, arg, same_shape_noop=True)
-
-  # in these two, we have custom logic to check if they are a no-op
-  #def permute(self, arg:tuple[int, ...]): return self._mop(Ops.PERMUTE, arg, same_shape_noop=False) if arg != tuple(range(len(self.shape))) else self
-  #def flip(self, arg:tuple[bool, ...]): return self._mop(Ops.FLIP, arg, same_shape_noop=False) if any(arg) and len(arg) == len(self.shape) else self
-
   # *** uop UNIQUE ***
 
   # TODO: use this in Buffer