fix assign copy

.github/workflows/benchmark.yml

@@ -21,9 +21,6 @@ jobs:
   # the 3 minute timeout should not be raised
   testmacpytest:
     name: Mac pytest
-    env:
-      CI: ""
-      CAPTURE_PROCESS_REPLAY: "0"
     runs-on: [self-hosted, macOS]
     timeout-minutes: 3
     defaults:
@@ -44,14 +41,22 @@ jobs:
       run: |
         echo "CACHEDB=/tmp/pytest-db-ci.db" >> $GITHUB_ENV
         rm -f /tmp/pytest-db-ci*
+    # TODO: remove this step once all old caches are migrated
+    - name: Migrate old huggingface cache (symlinks break onnxruntime 1.24+)
+      run: |
+        cd ~/Library/Caches/tinygrad/downloads/models 2>/dev/null || exit 0
+        for old_dir in models--*; do
+          [ -d "$old_dir" ] || continue
+          repo_id=$(echo "$old_dir" | sed 's/models--//; s/--/\//g')
+          snapshot=$(ls -1 "$old_dir/snapshots" 2>/dev/null | head -1)
+          [ -n "$snapshot" ] || continue
+          mkdir -p "$repo_id"
+          cp -RLn "$old_dir/snapshots/$snapshot/"* "$repo_id/" 2>/dev/null || true
+        done
     - name: Run pytest -nauto
       run: |
         source /tmp/tinygrad_pytest_ci/bin/activate
         pytest -nauto --durations=20
-    - name: openpilot compile3 0.10.1 driving_vision
-      run: FLOAT16=1 CL=1 IMAGE=2 python3.11 examples/openpilot/compile3.py https://github.com/commaai/openpilot/raw/720392c9a5b986981fdbed1bb8c47a6c5573a50e/selfdrive/modeld/models/driving_vision.onnx
-    - name: IMAGE=1 openpilot compile3 0.10.1 driving_vision
-      run: FLOAT16=1 CL=1 IMAGE=1 python3.11 examples/openpilot/compile3.py https://github.com/commaai/openpilot/raw/720392c9a5b986981fdbed1bb8c47a6c5573a50e/selfdrive/modeld/models/driving_vision.onnx
 
   testmacbenchmark:
     name: Mac Benchmark
@@ -338,7 +343,7 @@ jobs:
     - name: Run 10 CIFAR training steps
       run: BENCHMARK_LOG=cifar_10steps ASSERT_MIN_STEP_TIME=120 NV=1 STEPS=10 python3 examples/hlb_cifar10.py
     - name: Run 10 CIFAR training steps w HALF
-      run: BENCHMARK_LOG=cifar_10steps_half ASSERT_MIN_STEP_TIME=120 NV=1 STEPS=10 DEFAULT_FLOAT=HALF python3 examples/hlb_cifar10.py
+      run: BENCHMARK_LOG=cifar_10steps_half ASSERT_MIN_STEP_TIME=110 NV=1 STEPS=10 DEFAULT_FLOAT=HALF python3 examples/hlb_cifar10.py
     - name: Run 10 CIFAR training steps w BF16
       run: BENCHMARK_LOG=cifar_10steps_bf16 ASSERT_MIN_STEP_TIME=120 NV=1 STEPS=10 DEFAULT_FLOAT=BFLOAT16 python3 examples/hlb_cifar10.py
     # - name: Run 10 CIFAR training steps w winograd
@@ -510,7 +515,7 @@ jobs:
     - name: Run 10 CIFAR training steps
       run: BENCHMARK_LOG=cifar_10steps ASSERT_MIN_STEP_TIME=200 AMD=1 STEPS=10 python3 examples/hlb_cifar10.py
     - name: Run 10 CIFAR training steps w HALF
-      run: BENCHMARK_LOG=cifar_10steps_half ASSERT_MIN_STEP_TIME=230 AMD=1 STEPS=10 DEFAULT_FLOAT=HALF python3 examples/hlb_cifar10.py
+      run: BENCHMARK_LOG=cifar_10steps_half ASSERT_MIN_STEP_TIME=200 AMD=1 STEPS=10 DEFAULT_FLOAT=HALF python3 examples/hlb_cifar10.py
     # - name: Run 10 CIFAR training steps w BF16
     #   run: BENCHMARK_LOG=cifar_10steps_bf16 ASSERT_MIN_STEP_TIME=288 AMD=1 STEPS=10 DEFAULT_FLOAT=BFLOAT16 python3 examples/hlb_cifar10.py
     # TODO: too slow
@@ -520,9 +525,8 @@ jobs:
       run: time BENCHMARK_LOG=cifar AMD=1 DEFAULT_FLOAT=HALF STEPS=1000 TARGET_EVAL_ACC_PCT=93.0 python3 examples/hlb_cifar10.py
     - name: Run full CIFAR training steps w 6 GPUS
       run: time BENCHMARK_LOG=cifar_6gpu AMD=1 DEFAULT_FLOAT=HALF STEPS=350 BS=1536 GPUS=6 TARGET_EVAL_ACC_PCT=93.0 python3 examples/hlb_cifar10.py
-    # this needs to be mocked and testable on a local machine
-    #- name: Test full tinyfs load
-    #  run: TINYFS_ENDPOINT=10.0.52.11:6767 PYTHONPATH=. python extra/tinyfs/fetch_file.py --hash d734f5e3be9f1e9d863bfaa4fc6c1ef2 --len 175866113 --dest mapping.json --check
+    - name: Test full tinyfs load
+      run: TINYFS_ENDPOINT=10.0.52.11:6767 PYTHONPATH=. python extra/tinyfs/fetch_file.py --hash d734f5e3be9f1e9d863bfaa4fc6c1ef2 --len 175866113 --dest mapping.json --check
     - name: Run process replay tests
       run: cp test/external/process_replay/process_replay.py ./process_replay.py && git fetch origin master && git -c advice.detachedHead=false checkout origin/master && PYTHONPATH=. python3 process_replay.py
 

.github/workflows/test.yml

@@ -1,7 +1,7 @@
 name: Unit Tests
 env:
   # increment this when downloads substantially change to avoid the internet
-  CACHE_VERSION: '17'
+  CACHE_VERSION: '16'
   CAPTURE_PROCESS_REPLAY: 1
   GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
   PYTHONPATH: ${{ github.workspace }}
@@ -649,8 +649,10 @@ jobs:
         run: AMD_LLVM=0 python -m pytest -n=auto test/amd/ --durations 20
       - name: Run AMD renderer tests (AMD_LLVM=1)
         run: AMD_LLVM=1 python -m pytest -n=auto test/amd/ --durations 20
-      - name: Run SQTT profiling tests
-        run: PROFILE=1 SQTT=1 python3 -m pytest -n=auto test/amd/test_sqtt_profiler.py
+      - name: Run TestOps.test_add with SQTT
+        run: |
+          VIZ=-2 DEBUG=5 python3 test/backend/test_ops.py TestOps.test_add
+          extra/sqtt/rgptool.py create "/tmp/profile.pkl.$USER" -o /tmp/gpu0.rgp
       - name: Run AMD emulated tests on NULL backend
         env:
           AMD: 0
@@ -662,30 +664,6 @@ jobs:
       - name: Run LLVM test
         run: AMD_LLVM=1 python test/device/test_amd_llvm.py
 
-  testmockam:
-    name: Linux (am)
-    runs-on: ubuntu-24.04
-    timeout-minutes: 15
-    env:
-      AMD: 1
-      MOCKGPU: 1
-      AMD_IFACE: PCI
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v4
-      - name: Setup Environment
-        uses: ./.github/actions/setup-tinygrad
-        with:
-          key: mockam
-          deps: testing_unit
-          amd: 'true'
-      - name: Run test_tiny on MOCKAM
-        run: python test/test_tiny.py
-      - name: Run test_tiny on MOCKAM USB
-        run: AMD_IFACE=USB python test/test_tiny.py
-      - name: Run test_hcq on MOCKAM
-        run: python -m pytest test/device/test_hcq.py
-
   testamd:
     strategy:
       fail-fast: false
@@ -824,8 +802,6 @@ jobs:
       run: METAL=1 DEBUG=3 python test/backend/test_ops.py TestOps.test_big_gemm
     - name: Test Beam Search
       run: METAL=1 IGNORE_BEAM_CACHE=1 python3 -m pytest extra/optimization/test_beam_search.py
-    - name: Test Device Specific
-      run: METAL=1 python3 -m pytest test/device/test_metal.py
     #- name: Fuzz Test linearizer
     #  run: METAL=1 DEPTH=4 FUZZ_N=50 FUZZ_MAX_SIZE=1000000 python test/external/fuzz_linearizer.py
     - name: Run TRANSCENDENTAL math

.gitignore

@@ -66,5 +66,3 @@ target
 .mypy_cache
 mutants
 .mutmut-cache
-dagre/
-graphlib/

docs/developer/layout.md

@@ -10,7 +10,7 @@ Directories are listed in order of how they are processed.
 
 Group UOps into kernels.
 
-::: tinygrad.schedule.rangeify.get_kernel_graph
+::: tinygrad.schedule.rangeify.get_rangeify_map
     options:
         members: false
         show_labels: false

examples/hlb_cifar10.py

@@ -19,8 +19,8 @@ cifar_std = [0.24703225141799082, 0.24348516474564, 0.26158783926049628]
 BS, STEPS = getenv("BS", 512), getenv("STEPS", 1000)
 EVAL_BS = getenv("EVAL_BS", BS)
 GPUS = [f'{Device.DEFAULT}:{i}' for i in range(getenv("GPUS", 1))]
-assert BS % len(GPUS) == 0, f"{BS=} is not a multiple of {len(GPUS)=}"
-assert EVAL_BS % len(GPUS) == 0, f"{EVAL_BS=} is not a multiple of {len(GPUS)=}"
+assert BS % len(GPUS) == 0, f"{BS=} is not a multiple of {len(GPUS)=}, uneven multi GPU is slow"
+assert EVAL_BS % len(GPUS) == 0, f"{EVAL_BS=} is not a multiple of {len(GPUS)=}, uneven multi GPU is slow"
 
 class UnsyncedBatchNorm:
   def __init__(self, sz:int, eps=1e-5, affine=True, track_running_stats=True, momentum=0.1, num_devices=len(GPUS)):

examples/mlperf/dataloader.py

@@ -65,7 +65,17 @@ def loader_process(q_in, q_out, X:Tensor, seed):
       else:
         # pad data with training mean
         img = np.tile(np.array([[[123.68, 116.78, 103.94]]], dtype=np.uint8), (224, 224, 1))
-      X[idx].flatten().assign(img.tobytes())
+
+      # broken out
+      #img_tensor = Tensor(img.tobytes(), device='CPU')
+      #storage_tensor = X[idx].contiguous().realize().lazydata.base.realized
+      #storage_tensor._copyin(img_tensor.numpy())
+
+      # faster
+      X[idx].contiguous().realize().uop.base.realized.as_memoryview(force_zero_copy=True)[:] = img.tobytes()
+
+      # ideal
+      #X[idx].assign(img.tobytes())   # NOTE: this is slow!
       q_out.put(idx)
     q_out.put(None)
 
@@ -254,8 +264,8 @@ def load_unet3d_data(preprocessed_dataset_dir, seed, queue_in, queue_out, X:Tens
       x = random_brightness_augmentation(x)
       x = gaussian_noise(x)
 
-    X[idx].flatten().assign(x.tobytes())
-    Y[idx].flatten().assign(y.tobytes())
+    X[idx].contiguous().realize().uop.base.realized.as_memoryview(force_zero_copy=True)[:] = x.tobytes()
+    Y[idx].contiguous().realize().uop.base.realized.as_memoryview(force_zero_copy=True)[:] = y.tobytes()
 
     queue_out.put(idx)
   queue_out.put(None)
@@ -369,12 +379,12 @@ def load_retinanet_data(base_dir:Path, val:bool, queue_in:Queue, queue_out:Queue
       clipped_match_idxs = np.clip(match_idxs, 0, None)
       clipped_boxes, clipped_labels = tgt["boxes"][clipped_match_idxs], tgt["labels"][clipped_match_idxs]
 
-      boxes[idx].flatten().assign(clipped_boxes.tobytes())
-      labels[idx].flatten().assign(clipped_labels.tobytes())
-      matches[idx].flatten().assign(match_idxs.tobytes())
-      anchors[idx].flatten().assign(anchor.tobytes())
+      boxes[idx].contiguous().realize().uop.base.realized.as_memoryview(force_zero_copy=True)[:] = clipped_boxes.tobytes()
+      labels[idx].contiguous().realize().uop.base.realized.as_memoryview(force_zero_copy=True)[:] = clipped_labels.tobytes()
+      matches[idx].contiguous().realize().uop.base.realized.as_memoryview(force_zero_copy=True)[:] = match_idxs.tobytes()
+      anchors[idx].contiguous().realize().uop.base.realized.as_memoryview(force_zero_copy=True)[:] = anchor.tobytes()
 
-    imgs[idx].flatten().assign(img.tobytes())
+    imgs[idx].contiguous().realize().uop.base.realized.as_memoryview(force_zero_copy=True)[:] = img.tobytes()
 
     queue_out.put(idx)
   queue_out.put(None)

examples/mlperf/model_train.py

@@ -1371,9 +1371,8 @@ def train_llama3():
       # prevents memory spike on device 0
       v.realize()
 
-  optim_device = "CPU" if getenv("OFFLOAD_OPTIM") else None
-  optim = GradAccClipAdamW(get_parameters(model), lr=0.0, b1=opt_adamw_beta_1, b2=opt_adamw_beta_2,
-                           eps=opt_adamw_epsilon, weight_decay=opt_adamw_weight_decay, grad_acc=grad_acc, device=optim_device)
+  optim = GradAccClipAdamW(get_parameters(model), lr=0.0,
+                b1=opt_adamw_beta_1, b2=opt_adamw_beta_2, eps=opt_adamw_epsilon, weight_decay=opt_adamw_weight_decay, grad_acc=grad_acc)
 
   # init grads
   for p in optim.params:

examples/mlperf/optim.py

@@ -1,21 +1,14 @@
 from tinygrad.tensor import Tensor
 from tinygrad.dtype import dtypes
-from tinygrad.nn.optim import Optimizer
+from tinygrad.nn.optim import LAMB
 from tinygrad.helpers import FUSE_OPTIM
 
-class GradAccClipAdamW(Optimizer):
-  def __init__(self, params:list[Tensor], lr=0.001, b1=0.9, b2=0.999, eps=1e-6, weight_decay=0.0, grad_acc=1, clip_norm=1.0, device=None, fused=FUSE_OPTIM):
-    super().__init__(params, lr, device, fused)
-    self.b1, self.b2, self.eps, self.wd = b1, b2, eps, weight_decay
-    self.b1_t, self.b2_t = (Tensor.ones((1,), dtype=dtypes.float32, device=self.device, requires_grad=False).contiguous() for _ in [b1, b2])
-    self.m = self._new_optim_param()
-    self.v = self._new_optim_param()
+class GradAccClipAdamW(LAMB):
+  def __init__(self, params:list[Tensor], lr=0.001, b1=0.9, b2=0.999, eps=1e-6, weight_decay=0.0, grad_acc=1, clip_norm=1.0, fused=FUSE_OPTIM):
+    super().__init__(params, lr, b1, b2, eps, weight_decay, adam=True, fused=FUSE_OPTIM)
     self.grad_acc, self.clip_norm = grad_acc, clip_norm
 
   def _step(self, params:list[Tensor], grads:list[Tensor]) -> tuple[list[Tensor], list[Tensor]]:
-    for i in range(len(grads)):
-      if grads[i].device != self.m[i].device: grads[i] = grads[i].to(self.m[i].device)
-
     if self.fused:
       grads[0] = grads[0] / self.grad_acc
       total_norm = grads[0].float().square().sum().sqrt()
@@ -28,19 +21,4 @@ class GradAccClipAdamW(Optimizer):
       for i in range(len(grads)):
         grads[i] = grads[i] / self.grad_acc
         grads[i] = (grads[i] * (self.clip_norm / (total_norm + 1e-6)).clamp(max_=1.0)).cast(grads[i].dtype)
-
-    ret = []
-    self.b1_t *= self.b1
-    self.b2_t *= self.b2
-    for i, (t, g) in enumerate(zip(params, grads)):
-      self.m[i].assign((self.b1 * self.m[i] + (1.0 - self.b1) * g).cast(self.m[i].dtype))
-      self.v[i].assign((self.b2 * self.v[i] + (1.0 - self.b2) * (g * g)).cast(self.v[i].dtype))
-      m_hat = self.m[i] / (1.0 - self.b1_t)
-      v_hat = self.v[i] / (1.0 - self.b2_t)
-      up = m_hat / (v_hat.sqrt() + self.eps)
-      ret.append((self.lr * up).cast(t.dtype))
-    return ret, [self.b1_t, self.b2_t] + self.m + self.v
-
-  def _apply_update(self, t:Tensor, up:Tensor) -> Tensor:
-    up = up.shard_like(t) + self.lr.to(t.device) * self.wd * t.detach()
-    return t.detach() - up.cast(t.dtype)
+    return super()._step(params, grads)

examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama8b/implementations/tinybox_8xMI350X/dev_beam.sh

@@ -11,7 +11,6 @@ export HK_FLASH_ATTENTION=${HK_FLASH_ATTENTION:-1}
 export ALL2ALL=${ALL2ALL:-1}
 export USE_ATOMICS=${USE_ATOMICS:-1}
 export ASM_GEMM=${ASM_GEMM:-1}
-export WQKV=${WQKV:-0}
 
 export DEFAULT_FLOAT="bfloat16" OPTIM_DTYPE="bfloat16"
 export DP=${DP:-8} BS=${BS:-8} EVAL_BS=${EVAL_BS:-8} GRADIENT_ACC_STEPS=${GRADIENT_ACC_STEPS:-2}

examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama8b/implementations/tinybox_8xMI350X/dev_run.sh

@@ -11,7 +11,6 @@ export HK_FLASH_ATTENTION=${HK_FLASH_ATTENTION:-1}
 export ALL2ALL=${ALL2ALL:-1}
 export USE_ATOMICS=${USE_ATOMICS:-1}
 export ASM_GEMM=${ASM_GEMM:-1}
-export WQKV=${WQKV:-0}
 
 export DEFAULT_FLOAT="bfloat16" OPTIM_DTYPE="bfloat16"
 export DP=${DP:-8} BS=${BS:-8} EVAL_BS=${EVAL_BS:-8} GRADIENT_ACC_STEPS=${GRADIENT_ACC_STEPS:-2}

extra/amdpci/am_smi.py

@@ -236,6 +236,8 @@ class SMICtx:
       case _: return metrics.SmuMetrics.AverageSocketPower, metrics.SmuMetrics.dGPU_W_MAX
 
   def get_mem_usage(self, dev):
+    return 0
+
     usage = 0
     pt_stack = [dev.mm.root_page_table]
     while len(pt_stack) > 0:
@@ -244,8 +246,8 @@ class SMICtx:
         entry = pt.entries[i]
 
         if (entry & am.AMDGPU_PTE_VALID) == 0: continue
-        if pt.lv < am.AMDGPU_VM_PDB0 and not dev.gmc.is_pte_huge_page(pt.lv, entry):
-          pt_stack.append(AMPageTableEntry(dev, dev.xgmi2paddr(entry & 0x0000FFFFFFFFF000), lv=pt.lv+1))
+        if pt.lv!=am.AMDGPU_VM_PTB and not dev.gmc.is_pte_huge_page(pt.lv, entry):
+          pt_stack.append(AMPageTableEntry(dev, entry & 0x0000FFFFFFFFF000, lv=pt.lv+1))
           continue
         if (entry & am.AMDGPU_PTE_SYSTEM) != 0: continue
         usage += (1 << ((9 * (3-pt.lv)) + 12))

extra/models/llama.py

@@ -41,13 +41,9 @@ class Attention:
     self.n_rep = self.n_heads // self.n_kv_heads
     self.max_context = max_context
 
-    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.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)
 
     self.q_norm = nn.RMSNorm(dim, qk_norm) if qk_norm is not None else None
@@ -55,8 +51,9 @@ class Attention:
 
   def __call__(self, x:Tensor, start_pos:Union[Variable,int], freqs_cis:Tensor, mask:Optional[Tensor]=None) -> Tensor:
     if getenv("WQKV"):
-      xqkv = self.wqkv(x)
-      xq, xk, xv = xqkv.split([self.n_heads * self.head_dim, self.n_kv_heads * self.head_dim, self.n_kv_heads * self.head_dim], dim=2)
+      if not hasattr(self, 'wqkv'): self.wqkv = Tensor.cat(self.wq.weight, self.wk.weight, self.wv.weight)
+      xqkv = x @ self.wqkv.T
+      xq, xk, xv = xqkv.split([self.wq.weight.shape[0], self.wk.weight.shape[0], self.wv.weight.shape[0]], dim=2)
     else:
       xq, xk, xv = self.wq(x), self.wk(x.contiguous_backward()), self.wv(x)
 

extra/sqtt/examples/generate_examples.py

@@ -1,4 +1,4 @@
-import os, subprocess, sys
+import os, subprocess
 from pathlib import Path
 from tinygrad.helpers import temp
 
@@ -6,9 +6,9 @@ EXAMPLES_DIR = Path(__file__).parent
 PROFILE_PATH = Path(temp("profile.pkl", append_user=True))
 
 EXAMPLES = [
-  "test/backend/test_custom_kernel.py TestCustomKernel.test_empty",
-  "test/test_tiny.py TestTiny.test_plus",
-  "test/test_tiny.py TestTiny.test_gemm",
+  "test.backend.test_custom_kernel.TestCustomKernel.test_empty",
+  "test.test_tiny.TestTiny.test_plus",
+  "test.test_tiny.TestTiny.test_gemm",
 ]
 
 if __name__ == "__main__":
@@ -17,8 +17,7 @@ if __name__ == "__main__":
   (EXAMPLES_DIR/arch).mkdir(exist_ok=True)
   for test in EXAMPLES:
     for i in range(2):
-      # AM_RESET=1 gets a clear trace, does not work on mi300 machines
-      subprocess.run([sys.executable, *test.split()], cwd=EXAMPLES_DIR.parent.parent.parent,
-                     env={**os.environ, "AMD":"1", "AM_RESET":"1" if not arch.startswith("gfx9") else "0", "VIZ":"-2", "PYTHONPATH":"."})
+      subprocess.run(["python", "-m", "unittest", test], cwd=EXAMPLES_DIR.parent.parent.parent,
+                     env={**os.environ, "AMD":"1", "SQTT_LIMIT_SE":"-1", "VIZ":"-2"}, check=True)
       PROFILE_PATH.rename(dest:=EXAMPLES_DIR/arch/f"profile_{test.split('.')[-1].replace('test_', '')}_run_{i}.pkl")
       print(f"saved SQTT trace to {dest}")

extra/sqtt/roc.py

@@ -4,8 +4,6 @@ from typing import Generator
 from tinygrad.helpers import temp, unwrap, DEBUG
 from tinygrad.runtime.ops_amd import ProfileSQTTEvent
 from tinygrad.runtime.autogen import rocprof
-from tinygrad.renderer.amd.dsl import Inst
-from test.amd.disasm import disasm
 
 @dataclasses.dataclass(frozen=True)
 class InstExec:
@@ -46,8 +44,8 @@ class OccEvent(WaveSlot):
 RunKey = tuple[str, int]
 
 class _ROCParseCtx:
-  def __init__(self, sqtt_evs:list[ProfileSQTTEvent], disasms:dict[str, dict[int, Inst]]):
-    self.sqtt_evs, self.disasms = iter(sqtt_evs), {k:{k2:(disasm(v2), v2.size()) for k2,v2 in v.items()} for k,v in disasms.items()}
+  def __init__(self, sqtt_evs:list[ProfileSQTTEvent], disasms:dict[str, dict[int, tuple[str, int]]]):
+    self.sqtt_evs, self.disasms = iter(sqtt_evs), disasms
     self.inst_execs:dict[RunKey, list[WaveExec]] = {}
     self.occ_events:dict[RunKey, list[OccEvent]] = {}
 
@@ -73,7 +71,7 @@ class _ROCParseCtx:
     self.inst_execs.setdefault(unwrap(self.active_run), []).append(WaveExec(ev.wave_id, ev.cu, ev.simd, unwrap(self.active_se), ev.begin_time,
                                                                              ev.end_time, insts_blob))
 
-def decode(sqtt_evs:list[ProfileSQTTEvent], disasms:dict[str, dict[int, Inst]]) -> _ROCParseCtx:
+def decode(sqtt_evs:list[ProfileSQTTEvent], disasms:dict[str, dict[int, tuple[str, int]]]) -> _ROCParseCtx:
   ROCParseCtx = _ROCParseCtx(sqtt_evs, disasms)
 
   @rocprof.rocprof_trace_decoder_se_data_callback_t

extra/thunder/amd/fa.py

@@ -11,8 +11,7 @@ from tinygrad.uop.ops import UOp, Ops, KernelInfo
 def _sharded_empty(shape:Tensor, ref:Tensor, axis:int|None, dtype:DTypeLike|None=None) -> Tensor:
   dtype = dtype or ref.dtype
   if not isinstance(ref.device, tuple): return Tensor.empty(*shape, dtype=dtype, device=ref.device)
-  shard_axis = ref.uop.axis if axis is None else axis
-  shape = tuple(s // len(ref.device) if i == shard_axis else s for i, s in enumerate(shape))
+  shape = tuple(s // len(ref.device) if i == ref.uop.axis else s for i, s in enumerate(shape))
   axis = ref.uop.axis if axis is None else axis
   return Tensor(Tensor.empty(*shape, dtype=dtype, device=ref.device).uop.multi(axis), dtype=dtype, device=ref.device)
 
@@ -30,45 +29,42 @@ def flash_attention(xq, xk, xv, attn_mask:Tensor|None=None, is_causal:bool=False
   assert D == 128, "only D=128 supported"
 
   num_devices = len(xq.device) if isinstance(xq.device, tuple) else 1
-  is_dp = xq.uop.axis == 0
-  is_mp = xq.uop.axis == 2
-  B_local = B // num_devices if is_dp else B
-  H_local = H // num_devices if is_mp else H
-  H_KV_local = H_KV // num_devices if is_mp else H_KV
-  shard_axis = 0 if is_dp else 2 if is_mp else None
-  shard_axis_t = 0 if is_dp else 1 if is_mp else None
-  if DEBUG >= 2: print(f"Flash Attention {B=} {B_local=} {N=} {H=} {H_local=} {H_KV=} {H_KV_local=} {D=} on {num_devices} devices, {'DP' if is_dp else 'MP' if is_mp else 'no sharding'}")
+  B_local = B // num_devices
+  if DEBUG >= 2: print(f"Flash Attention {B=} {B_local=} {N=} {H=} {H_KV=} {D=}")
 
   single_device = xq.device[0] if isinstance(xq.device, tuple) else xq.device
   arch = Device[single_device].renderer.arch
 
-  attn = _sharded_empty_like(xq, axis=shard_axis)
-  l_vec = _sharded_empty((B, H, 1, N), xq, dtype=dtypes.float32, axis=shard_axis_t)
+  attn = _sharded_empty_like(xq, axis=0)
+  l_vec = _sharded_empty((B, H, 1, N), xq, axis=0, dtype=dtypes.float32)
 
   def grad(dou:UOp, _) -> tuple[None, None, UOp, UOp, UOp]:
     do = Tensor(dou, device=dou.device)
-    dq_in = _sharded_empty((B, H, N, D), xq, axis=shard_axis_t)
-    dq = _sharded_empty_like(xq, axis=shard_axis)
-    dk = _sharded_empty_like(xk, axis=shard_axis)
-    dv = _sharded_empty_like(xv, axis=shard_axis)
+    dq_in = _sharded_empty((B, H, N, D), xq, axis=0)
+    dq = _sharded_empty_like(xq, axis=0)
+    dk = _sharded_empty_like(xk, axis=0)
+    dv = _sharded_empty_like(xv, axis=0)
 
     # delta_vec = (do * attn).sum(-1, dtype=dtypes.float32).transpose(1, 2).unsqueeze(-2).detach()
-    delta_vec = _sharded_empty((B, H, 1, N), xq, dtype=dtypes.float32, axis=shard_axis_t)
-    delta_vec, dq_in = Tensor.custom_kernel(delta_vec, dq_in, attn, do, fxn=functools.partial(custom_fa_backward_pre, device=single_device, arch=arch, B=B_local, N=N, H=H_local, H_KV=H_KV_local, D=D))[:2]
+    delta_vec = _sharded_empty((B, H, 1, N), xq, axis=0, dtype=dtypes.float32)
+    delta_vec, dq_in = Tensor.custom_kernel(delta_vec, dq_in, attn, do, fxn=functools.partial(custom_fa_backward_pre, device=single_device, arch=arch))[:2]
 
-    dq_in, dk, dv = Tensor.custom_kernel(dq_in, dk, dv, do, xq, xk, xv, l_vec, delta_vec, fxn=functools.partial(custom_fa_backward, device=single_device, arch=arch, B=B_local, N=N, H=H_local, H_KV=H_KV_local, D=D))[:3]
+    dq_in, dk, dv = Tensor.custom_kernel(dq_in, dk, dv, do, xq, xk, xv, l_vec, delta_vec, fxn=functools.partial(custom_fa_backward, device=single_device, arch=arch))[:3]
 
     # unshuffle dq
-    dq = Tensor.custom_kernel(dq, dq_in, fxn=functools.partial(custom_fa_backward_post, device=single_device, arch=arch, B=B_local, N=N, H=H_local, H_KV=H_KV_local, D=D))[0]
+    dq = Tensor.custom_kernel(dq, dq_in, fxn=functools.partial(custom_fa_backward_post, device=single_device, arch=arch))[0]
 
     return None, None, dq.uop, dk.uop, dv.uop
 
-  attn, l_vec = Tensor.custom_kernel(attn, l_vec, xq, xk, xv, fxn=functools.partial(custom_fa_forward, device=single_device, arch=arch, B=B_local, N=N, H=H_local, H_KV=H_KV_local, D=D), grad_fxn=grad)[:2]
+  attn, l_vec = Tensor.custom_kernel(attn, l_vec, xq, xk, xv, fxn=functools.partial(custom_fa_forward, device=single_device, arch=arch), grad_fxn=grad)[:2]
 
   return attn.transpose(1, 2)
 
 @functools.cache
-def custom_fa_forward(o:UOp, l_vec:UOp, q:UOp, k:UOp, v:UOp, device:str, arch:str, B:int, N:int, H:int, H_KV:int, D:int):
+def custom_fa_forward(o:UOp, l_vec:UOp, q:UOp, k:UOp, v:UOp, device:str, arch:str):
+  B, N, H, D = q.shape
+  H_KV = k.shape[2]
+
   code = (pathlib.Path(__file__).parent / "fa_fwd_causal.cpp").read_text()
   compile_args = [f"-I{(pathlib.Path(__file__).parent / 'include').as_posix()}", "-std=c++20", "-DKITTENS_CDNA4", "-DHIP_ENABLE_WARP_SYNC_BUILTINS", "-ffast-math",
                   f"-DATTN_B={B}", f"-DATTN_N={N}", f"-DATTN_H={H}", f"-DATTN_H_KV={H_KV}"]
@@ -99,7 +95,9 @@ def custom_fa_forward(o:UOp, l_vec:UOp, q:UOp, k:UOp, v:UOp, device:str, arch:st
              src=(sink, UOp(Ops.DEVICE, arg=device), UOp(Ops.LINEAR, src=(*sink.src, sink)), UOp(Ops.SOURCE, arg=code), UOp(Ops.BINARY, arg=lib)))
 
 @functools.cache
-def custom_fa_backward_pre(delta_vec:UOp, dq:UOp, o:UOp, do:UOp, device:str, arch:str, B:int, N:int, H:int, H_KV:int, D:int):
+def custom_fa_backward_pre(delta_vec:UOp, dq:UOp, o:UOp, do:UOp, device:str, arch:str):
+  B, N, H, D = o.shape
+
   code = (pathlib.Path(__file__).parent / "fa_bwd_pre.cpp").read_text()
   compile_args = [f"-I{(pathlib.Path(__file__).parent / 'include').as_posix()}", "-std=c++20", "-DKITTENS_CDNA4", "-DHIP_ENABLE_WARP_SYNC_BUILTINS", "-ffast-math",
                   f"-DATTN_B={B}", f"-DATTN_N={N}", f"-DATTN_H={H}"]
@@ -130,7 +128,10 @@ def custom_fa_backward_pre(delta_vec:UOp, dq:UOp, o:UOp, do:UOp, device:str, arc
              src=(sink, UOp(Ops.DEVICE, arg=device), UOp(Ops.LINEAR, src=(*sink.src, sink)), UOp(Ops.SOURCE, arg=code), UOp(Ops.BINARY, arg=lib)))
 
 @functools.cache
-def custom_fa_backward(dq:UOp, dk:UOp, dv:UOp, do:UOp, q:UOp, k:UOp, v:UOp, l_vec:UOp, delta_vec:UOp, device:str, arch:str, B:int, N:int, H:int, H_KV:int, D:int):
+def custom_fa_backward(dq:UOp, dk:UOp, dv:UOp, do:UOp, q:UOp, k:UOp, v:UOp, l_vec:UOp, delta_vec:UOp, device:str, arch:str):
+  B, N, H, D = q.shape
+  H_KV = k.shape[2]
+
   code = (pathlib.Path(__file__).parent / "fa_bwd_causal.cpp").read_text()
   compile_args = [f"-I{(pathlib.Path(__file__).parent / 'include').as_posix()}", "-std=c++20", "-DKITTENS_CDNA4", "-DHIP_ENABLE_WARP_SYNC_BUILTINS", "-ffast-math",
                   f"-DATTN_B={B}", f"-DATTN_N={N}", f"-DATTN_H={H}", f"-DATTN_H_KV={H_KV}"]
@@ -161,7 +162,9 @@ def custom_fa_backward(dq:UOp, dk:UOp, dv:UOp, do:UOp, q:UOp, k:UOp, v:UOp, l_ve
              src=(sink, UOp(Ops.DEVICE, arg=device), UOp(Ops.LINEAR, src=(*sink.src, sink)), UOp(Ops.SOURCE, arg=code), UOp(Ops.BINARY, arg=lib)))
 
 @functools.cache
-def custom_fa_backward_post(dq_out:UOp, dq_in:UOp, device:str, arch:str, B:int, N:int, H:int, H_KV:int, D:int):
+def custom_fa_backward_post(dq_out:UOp, dq_in:UOp, device:str, arch:str):
+  B, N, H, D = dq_out.shape
+
   code = (pathlib.Path(__file__).parent / "fa_bwd_post.cpp").read_text()
   compile_args = [f"-I{(pathlib.Path(__file__).parent / 'include').as_posix()}", "-std=c++20", "-DKITTENS_CDNA4", "-DHIP_ENABLE_WARP_SYNC_BUILTINS", "-ffast-math",
                   f"-DATTN_B={B}", f"-DATTN_N={N}", f"-DATTN_H={H}"]

extra/torch_backend/example.py

@@ -23,8 +23,7 @@ if __name__ == "__main__":
 
   kernel_count = GlobalCounters.kernel_count
   assert kernel_count > 0, "No kernels, test failed"
-  # NOTE: this is 124 on torch 2.10.0
-  expected_kernels = 332
+  expected_kernels = 228
   expectation = f"ResNet18 kernels are {kernel_count} vs {expected_kernels} expected."
   if kernel_count < expected_kernels: warnings.warn(f"{expectation} Expectation can be lowered.", UserWarning)
   assert kernel_count <= expected_kernels, f"{expectation}"

extra/torch_backend/test_kernel_fusion.py

@@ -26,7 +26,7 @@ class TestKernelFusionRegression(unittest.TestCase):
     def fn():
       x = torch.randn(128, 128, device=device)
       return (x + 1.0) * 2.0 - 0.5
-    self._check_kernel_count(fn, 5)
+    self._check_kernel_count(fn, 6)
 
   def test_relu_fusion(self):
     def fn():
@@ -50,14 +50,14 @@ class TestKernelFusionRegression(unittest.TestCase):
     def fn():
       x = torch.randn(64, 64, device=device)
       return (x * 2.0).sum()
-    self._check_kernel_count(fn, 5)
+    self._check_kernel_count(fn, 7)
 
   def test_matmul_elementwise_fusion(self):
     def fn():
       x = torch.randn(32, 32, device=device)
       w = torch.randn(32, 32, device=device)
       return torch.nn.functional.relu(x @ w + 1.0)
-    self._check_kernel_count(fn, 7)
+    self._check_kernel_count(fn, 6)
 
   def test_pooling_fusion(self):
     def fn():
@@ -71,7 +71,7 @@ class TestKernelFusionRegression(unittest.TestCase):
       identity = torch.randn(1, 8, 16, 16, device=device)
       out = x + identity
       return torch.nn.functional.relu(out)
-    self._check_kernel_count(fn, 7)
+    self._check_kernel_count(fn, 6)
 
   def test_inplace_add_relu_fusion(self):
     def fn():
@@ -79,7 +79,7 @@ class TestKernelFusionRegression(unittest.TestCase):
       y = torch.randn(1, 16, 32, 32, device=device)
       x += y
       return torch.nn.functional.relu(x)
-    self._check_kernel_count(fn, 7)
+    self._check_kernel_count(fn, 6)
 
   def test_conv_bn_add_relu_fusion(self):
     def fn():
@@ -92,7 +92,7 @@ class TestKernelFusionRegression(unittest.TestCase):
         out = bn(conv(x))
         out += identity
         return torch.nn.functional.relu(out)
-    self._check_kernel_count(fn, 17)
+    self._check_kernel_count(fn, 16)
 
   def test_multiple_inplace_ops_fusion(self):
     def fn():
@@ -138,7 +138,7 @@ class TestKernelFusionRegression(unittest.TestCase):
       loss.backward()
       optimizer.step()
       return loss
-    self._check_kernel_count(fn, 28)
+    self._check_kernel_count(fn, 33)
 
 if __name__ == "__main__":
   unittest.main()

pyproject.toml

@@ -74,7 +74,7 @@ testing_minimal = [
   "hypothesis>=6.148.9",
   "z3-solver<4.15.4",  # 4.15.4 has a segfault when creating many z3.Context()
 ]
-testing_unit = ["tinygrad[testing_minimal]", "tqdm", "safetensors", "tabulate", "openai", "gguf"]
+testing_unit = ["tinygrad[testing_minimal]", "tqdm", "safetensors", "tabulate", "openai", "ggml-python"]
 testing = [
   "tinygrad[testing_unit]",
   "pillow",

test/amd/helpers.py

@@ -1,9 +1,19 @@
 """Shared test helpers for AMD tests."""
 import ctypes
+from dataclasses import dataclass
 from tinygrad.helpers import unwrap
 from tinygrad.runtime.autogen import llvm
 from tinygrad.runtime.support.elf import elf_loader
 
+@dataclass
+class KernelInfo:
+  code: bytes
+  src: str
+  global_size: tuple[int, int, int]
+  local_size: tuple[int, int, int]
+  buf_idxs: list[int]  # indices into shared buffer pool
+  buf_sizes: list[int]  # sizes for each buffer index
+
 ARCH_TO_TARGET:dict[str, list[str]] = {
   "rdna3":["gfx1100"],
   "rdna4":["gfx1200"],

test/amd/test_compare_emulators.py

@@ -6,6 +6,7 @@ from tinygrad import Device
 
 from test.mockgpu.amd.emu import WaveState, _decode_at, WAVE_SIZE, VCC_LO, EXEC_LO, SCC
 from tinygrad.renderer.amd import decode_inst
+from test.amd.helpers import KernelInfo
 import tinygrad
 REMU_PATH = Path(tinygrad.__file__).parent.parent / "extra/remu/target/release/libremu.so"
 if not REMU_PATH.exists(): REMU_PATH = Path(tinygrad.__file__).parent.parent / "extra/remu/target/release/libremu.dylib"
@@ -21,15 +22,6 @@ def _vals_equal(a: int, b: int) -> bool:
   if a == b: return True
   return _is_f32_nan(a) and _is_f32_nan(b)
 
-@dataclass
-class KernelSnapshot:
-  code: bytes
-  src: str
-  global_size: tuple[int, int, int]
-  local_size: tuple[int, int, int]
-  buf_idxs: list[int]  # indices into shared buffer pool
-  buf_sizes: list[int]  # sizes for each buffer index
-
 @dataclass
 class StateSnapshot:
   pc: int
@@ -293,7 +285,7 @@ def run_single_kernel(kernel: bytes, n_lanes: int, args_ptr: int, global_size: t
 
   return True, f"Completed {gx*gy*gz} workgroups", total_steps
 
-def compare_emulators_multi_kernel(kernels: list[KernelSnapshot], buf_pool: dict[int, int], max_steps: int = 1000,
+def compare_emulators_multi_kernel(kernels: list[KernelInfo], buf_pool: dict[int, int], max_steps: int = 1000,
                                     debug: bool = False, trace_len: int = 10, buf_data: dict[int, bytes] | None = None) -> tuple[bool, str]:
   """Run all kernels through both emulators with shared buffer pool."""
   if buf_data is None: buf_data = {}
@@ -357,7 +349,7 @@ def compare_emulators_with_memory(kernel: bytes, n_lanes: int, buf_sizes: list,
   ok, msg, _ = run_single_kernel(kernel, n_lanes, args_ptr, global_size, (n_lanes, 1, 1), max_steps, debug, trace_len)
   return ok, msg
 
-def get_kernels_from_tinygrad(op_fn) -> tuple[list[KernelSnapshot], dict[int, int], dict[int, bytes]]:
+def get_kernels_from_tinygrad(op_fn) -> tuple[list[KernelInfo], dict[int, int], dict[int, bytes]]:
   """Compile a tinygrad operation and extract all kernels with their buffer mappings."""
   from tinygrad import Tensor
   from tinygrad.runtime.support.elf import elf_loader
@@ -395,7 +387,7 @@ def get_kernels_from_tinygrad(op_fn) -> tuple[list[KernelSnapshot], dict[int, in
                 buf_pool[buf_id] = b.nbytes
               buf_idxs.append(buf_id)
               buf_sizes.append(b.nbytes)
-            kernels.append(KernelSnapshot(
+            kernels.append(KernelInfo(
               code=bytes(sec.content),
               src=lowered.prg.p.src,
               global_size=tuple(lowered.prg.p.global_size),

test/amd/test_sqtt_examples.py

@@ -21,7 +21,7 @@ OTHER_SIMD_OPS = {InstOp.OTHER_LDS_LOAD, InstOp.OTHER_LDS_STORE, InstOp.OTHER_LD
                   InstOp.OTHER_FLAT_STORE_128, InstOp.OTHER_GLOBAL_LOAD, InstOp.OTHER_GLOBAL_LOAD_VADDR,
                   InstOp.OTHER_GLOBAL_STORE_64, InstOp.OTHER_GLOBAL_STORE_96, InstOp.OTHER_GLOBAL_STORE_128,
                   InstOp.OTHER_GLOBAL_STORE_VADDR_128}
-OTHER_SIMD_OPS_RDNA4 = {InstOpRDNA4.OTHER_VMEM, InstOpRDNA4.OTHER_VMEM_STORE}
+OTHER_SIMD_OPS_RDNA4 = {InstOpRDNA4.OTHER_VMEM, InstOpRDNA4.UNK_60}
 
 # ═══════════════════════════════════════════════════════════════════════════════
 # ROCPROF DECODER
@@ -208,12 +208,12 @@ class SQTTExamplesTestBase(unittest.TestCase):
 class TestSQTTExamplesRDNA3(SQTTExamplesTestBase):
   target = "gfx1100"
   expected = {
-    "profile_empty_run_0": [1744, 1801, 1854, 1890, 1917, 1822],
-    "profile_empty_run_1": [1744, 1801, 1854, 1886, 1921, 1906],
-    "profile_gemm_run_0": [1800, 1867, 1899, 1898, 1914, 1895, 1694, 1779, 1819, 1872, 1877, 1858, 1750, 1834, 1866, 1834, 1911, 1796],
-    "profile_gemm_run_1": [1806, 1874, 1837, 1885, 1907, 1906, 1694, 1778, 1810, 1873, 1885, 1867, 1750, 1834, 1866, 1856, 1903, 1897],
-    "profile_plus_run_0": [1744, 1878, 1854, 1890, 1878, 1910],
-    "profile_plus_run_1": [1744, 1878, 1854, 1886, 1921, 1909],
+    "profile_empty_run_0": [1844, 1885, 1905, 1956, 1983, 1889],
+    "profile_empty_run_1": [1780, 1885, 1905, 1956, 1983, 1889],
+    "profile_gemm_run_0": [2656, 2025, 2045, 2096, 2123, 2029, 3183, 2019, 2039, 2090, 2117, 2023, 19119, 2013, 2033, 2084, 2111, 2017],
+    "profile_gemm_run_1": [2662, 2025, 2045, 2096, 2123, 2029, 3179, 2019, 2039, 2090, 2117, 2023, 19113, 2071, 2091, 2142, 2169, 2075],
+    "profile_plus_run_0": [1886, 2013, 2033, 2084, 2111, 2017],
+    "profile_plus_run_1": [1988, 2071, 2091, 2142, 2169, 2075],
   }
 
 class TestSQTTExamplesRDNA4(SQTTExamplesTestBase): target = "gfx1200"

test/amd/test_sqtt_profiler.py

@@ -1,94 +0,0 @@
-import unittest, contextlib
-from tinygrad import Device, Tensor, Context, TinyJit
-from tinygrad.device import Compiled, ProfileProgramEvent, ProfileDeviceEvent
-from tinygrad.viz.serve import load_amd_counters
-
-@contextlib.contextmanager
-def save_sqtt():
-  yield (ret:=[])
-  Device[Device.DEFAULT].synchronize()
-  Device[Device.DEFAULT]._at_profile_finalize()
-  load_amd_counters(ret, Compiled.profile_events)
-  ret[:] = [r for r in ret if r["name"].startswith("Exec")]
-
-@unittest.skipUnless(Device.DEFAULT == "AMD", "only runs on AMD")
-class TestSQTTProfiler(unittest.TestCase):
-  # TODO: can we enable SQTT profiling in context?
-  @classmethod
-  def setUpClass(cls):
-    if not Device[Device.DEFAULT].sqtt_enabled: raise unittest.SkipTest("device must be in SQTT profiling mode")
-
-  def setUp(self):
-    Device[Device.DEFAULT].synchronize()
-    Compiled.profile_events[:] = [e for e in Compiled.profile_events if isinstance(e, (ProfileProgramEvent, ProfileDeviceEvent))]
-
-  def test_simple(self):
-    t = Tensor.empty(1) + 1
-    with save_sqtt() as sqtt:
-      ei = t.schedule()[0].lower()
-      ei.run()
-    self.assertEqual(len(sqtt), 1)
-    self.assertEqual(sqtt[0]["name"], f"Exec {ei.prg.p.function_name}")
-
-  def test_multiple_runs(self):
-    t = Tensor.empty(1) + 1
-    with save_sqtt() as sqtt:
-      ei = t.schedule()[0].lower()
-      for _ in range(N:=3):
-        ei.run()
-    self.assertEqual(len(sqtt), N)
-    for i in range(1, N):
-      self.assertEqual(sqtt[i]["name"], f"Exec {ei.prg.p.function_name} n{i+1}")
-
-  def test_multiple_kernels(self):
-    t = ((Tensor.empty(1) + 1).contiguous() + 2)
-    sched = t.schedule()
-    with save_sqtt() as sqtt:
-      for si in sched: si.lower().run()
-    self.assertEqual(len(sqtt), len(sched))
-    for i,k in enumerate(sched):
-      self.assertEqual(sqtt[i]["name"], f"Exec {k.lower().prg.p.function_name}")
-
-  def test_multiple_kernels_lower(self):
-    t = ((Tensor.empty(1) + 1).contiguous() + 2)
-    sched = t.schedule()
-    with save_sqtt() as sqtt:
-      prgs = [si.lower() for si in sched]
-      for p in prgs: p.run()
-    self.assertEqual(len(sqtt), len(sched))
-    for i,ei in enumerate(prgs):
-      self.assertEqual(sqtt[i]["name"], f"Exec {ei.prg.p.function_name}")
-
-  def test_jit(self):
-    @TinyJit
-    def f(a): return a + 1
-    t = Tensor.empty(1)
-    with save_sqtt() as sqtt:
-      for _ in range(N:=5):
-        f(t).realize()
-    self.assertEqual(len(sqtt), N)
-    kernel_name = sqtt[0]["name"]
-    for i,s in enumerate(sqtt[1:], start=1): self.assertEqual(s["name"], f"{kernel_name} n{i+1}")
-
-  # TODO: can we trace SQTT for graphed kernels?
-  def test_jit_graph(self, kernel_count=3*2):
-    @TinyJit
-    def f(a): return ((a + 1).contiguous() + 2).contiguous().sum()
-    t = Tensor.empty(32)
-    with save_sqtt() as sqtt:
-      for _ in range(5):
-        f(t).realize()
-    names = [s["name"] for s in sqtt]
-    k0, k1, k2 = names[:3]
-    for i in range(3, len(sqtt), 3):
-      n = (i // 3)+1
-      self.assertEqual(names[i], f"{k0} n{n}")
-      self.assertEqual(names[i+1], f"{k1} n{n}")
-      self.assertEqual(names[i+2], f"{k2} n{n}")
-    self.assertEqual(len(sqtt), kernel_count)
-
-  @Context(JIT=2)
-  def test_jit_multiple_kernels(self): self.test_jit_graph(kernel_count=3*5)
-
-if __name__ == "__main__":
-  unittest.main()

test/amd/test_sqttmap.py

@@ -14,7 +14,7 @@ def rocprof_inst_traces_match(sqtt, prg, target):
   from tinygrad.viz.serve import amd_decode
   from extra.sqtt.roc import decode as roc_decode, InstExec
   addr_table = amd_decode(prg.lib, target)
-  disasm_map = {addr+prg.base:inst for addr,inst in addr_table.items()}
+  disasm_map = {addr+prg.base:(disasm(inst), inst.size()) for addr,inst in addr_table.items()}
   rctx = roc_decode([sqtt], {prg.tag:disasm_map})
   rwaves = rctx.inst_execs.get((sqtt.kern, sqtt.exec_tag), [])
   rwaves_iter:dict[int, list[Iterator[InstExec]]] = {} # wave unit (0-15) -> list of inst trace iterators for all executions on that unit
@@ -30,7 +30,7 @@ def rocprof_inst_traces_match(sqtt, prg, target):
     rocprof_inst = next(rwaves_iter[info.wave][0])
     ref_pc = rocprof_inst.pc-prg.base
     # always check pc matches
-    assert ref_pc == info.pc, f"pc mismatch {ref_pc}:{disasm_map[rocprof_inst.pc]} != {info.pc}:{disasm(info.inst)}"
+    assert ref_pc == info.pc, f"pc mismatch {ref_pc}:{disasm_map[rocprof_inst.pc][0]} != {info.pc}:{disasm(info.inst)}"
     # special handling for s_endpgm, it marks the wave completion.
     if info.inst == s_endpgm():
       completed_wave = list(rwaves_iter[info.wave].pop(0))
@@ -72,6 +72,7 @@ class TestSQTTMapBase(unittest.TestCase):
 
 class TestSQTTMapRDNA3(TestSQTTMapBase): target = "gfx1100"
 
+@unittest.skip("this doesn't work")
 class TestSQTTMapRDNA4(TestSQTTMapBase): target = "gfx1200"
 
 if __name__ == "__main__":

test/backend/test_asm_gemm.py

@@ -67,7 +67,6 @@ class TestGemmLarge(unittest.TestCase):
     if not is_cdna4():
       self.skipTest("very slow on non mi350x")
 
-  def test_tiny(self): verify_asm_gemm(1, 256, 256, 64)
   def test_simple(self): verify_asm_gemm(1, N:=getenv("N", 4096), N, N, dtype=dtypes.half)
   def test_gemm(self): verify_asm_gemm(1, 8192, 4096, 14336)
   def test_gemm_batched(self): verify_asm_gemm(2, 8192, 4096, 4096)

test/backend/test_const_folding.py

@@ -10,9 +10,7 @@ def _check_ast_count(desired_count:int, t:Tensor):
   # NOTE: this has side effect because everything can be scheduled only once
   schedule = t.schedule()
   asts = [s for s in schedule if s.ast.op is Ops.SINK]
-  len(asts)
-  # NOT SUPPORTED ANYMORE
-  #assert len(asts) == desired_count, f"{len(asts)} != {desired_count}"
+  assert len(asts) == desired_count, f"{len(asts)} != {desired_count}"
 
 class TestMovedConstFolding(unittest.TestCase):
   def test_add_shrunk_zero(self):

test/backend/test_custom_kernel.py

@@ -265,6 +265,8 @@ class TestCustomKernel(unittest.TestCase):
     Expected schedule order: [A2, B2, E, custom_addmul, final_sum]
     The custom_addmul kernel should be at index 3.
     """
+    from tinygrad.engine.schedule import create_schedule
+    from tinygrad.schedule.rangeify import get_rangeify_map
 
     A, B = Tensor.empty(4, 4), Tensor.empty(4, 4)
     A2 = (A + 1).contiguous()                      # kernel 0: depends on A
@@ -273,7 +275,11 @@ class TestCustomKernel(unittest.TestCase):
     C, D, _, _ = Tensor.custom_kernel(C, D, A2, B2, fxn=custom_elementwise_addmul_kernel)  # depends on A2 AND B2
     E = (A2 * 3).contiguous()                      # kernel 2: depends only on A2
     result = (C + D + E).sum()                     # kernel 3: custom_addmul, then kernel 4: sum
-    schedule = result.schedule()
+
+    big_sink = result.uop.sink()
+    tensor_map = get_rangeify_map(big_sink)
+    sched_sink = big_sink.substitute(tensor_map)
+    schedule, _ = create_schedule(sched_sink)
 
     # Find the custom_addmul kernel position
     custom_idx = next((i for i, item in enumerate(schedule)

test/backend/test_dtype.py

@@ -150,16 +150,28 @@ class TestFp8sConversions(unittest.TestCase):
     np.testing.assert_equal(float_to_fp8(x, dtypes.fp8e4m3), torch.tensor(x, dtype=torch.float8_e4m3fn).view(torch.uint8).item())
 
   def test_float_to_fp8e4m3_extreme_values(self):
-    for x in [FP8E4M3_MAX, FP8E4M3_MAX*1.01, -FP8E4M3_MAX, -FP8E4M3_MAX*1.01, math.inf, -math.inf, math.nan, -math.nan]:
-      np.testing.assert_equal(float_to_fp8(x, dtypes.fp8e4m3), torch.tensor(x, dtype=torch.float8_e4m3fn).view(torch.uint8).item())
+    np.testing.assert_equal(float_to_fp8(FP8E4M3_MAX, dtypes.fp8e4m3), 126)
+    np.testing.assert_equal(float_to_fp8(FP8E4M3_MAX*1.01, dtypes.fp8e4m3), 126)
+    np.testing.assert_equal(float_to_fp8(math.inf, dtypes.fp8e4m3), 127)
+    np.testing.assert_equal(float_to_fp8(-FP8E4M3_MAX, dtypes.fp8e4m3), 254)
+    np.testing.assert_equal(float_to_fp8(-FP8E4M3_MAX*1.01, dtypes.fp8e4m3), 254)
+    np.testing.assert_equal(float_to_fp8(-math.inf, dtypes.fp8e4m3), 255)
+    np.testing.assert_equal(float_to_fp8(math.nan, dtypes.fp8e4m3), 127)
+    np.testing.assert_equal(float_to_fp8(-math.nan, dtypes.fp8e4m3), 255)
 
   @given(strat.floats(width=32, allow_subnormal=True, allow_nan=False, allow_infinity=False, min_value=-FP8E5M2_MAX, max_value=FP8E5M2_MAX))
   def test_float_to_fp8e5m2(self, x):
     np.testing.assert_equal(float_to_fp8(x, dtypes.fp8e5m2), torch.tensor(x, dtype=torch.float8_e5m2).view(torch.uint8).item())
 
   def test_float_to_fp8e5m2_extreme_values(self):
-    for x in [FP8E5M2_MAX, FP8E5M2_MAX*1.01, -FP8E5M2_MAX, -FP8E5M2_MAX*1.01, math.inf, -math.inf, math.nan, -math.nan]:
-      np.testing.assert_equal(float_to_fp8(x, dtypes.fp8e5m2), torch.tensor(x, dtype=torch.float8_e5m2).view(torch.uint8).item())
+    np.testing.assert_equal(float_to_fp8(FP8E5M2_MAX, dtypes.fp8e5m2), 123)
+    np.testing.assert_equal(float_to_fp8(FP8E5M2_MAX*1.01, dtypes.fp8e5m2), 123)
+    np.testing.assert_equal(float_to_fp8(math.inf, dtypes.fp8e5m2), 124)
+    np.testing.assert_equal(float_to_fp8(-FP8E5M2_MAX, dtypes.fp8e5m2), 251)
+    np.testing.assert_equal(float_to_fp8(-FP8E5M2_MAX*1.01, dtypes.fp8e5m2), 251)
+    np.testing.assert_equal(float_to_fp8(-math.inf, dtypes.fp8e5m2), 252)
+    np.testing.assert_equal(float_to_fp8(math.nan, dtypes.fp8e5m2), 126)
+    np.testing.assert_equal(float_to_fp8(-math.nan, dtypes.fp8e5m2), 254)
 
   @given(strat.integers(min_value=0, max_value=255))
   def test_fp8e4m3_to_float(self, x):

test/backend/test_image_dtype.py

@@ -115,7 +115,7 @@ class TestImageDType(unittest.TestCase):
     tst = data.numpy()
     it = data.cast(dtypes.imagef((9,27,4))).realize()
     # the underlying UOp is identical
-    #self.assertIs(it.uop.base.realized, data.uop.base.realized)
+    self.assertIs(it.uop.base.realized, data.uop.base.realized)
     np.testing.assert_equal(tst, it.numpy())
 
   def test_image_and_back_wrong_shape(self):

test/backend/test_jit.py

@@ -332,6 +332,7 @@ class TestJit(unittest.TestCase):
     assert len(res3) == 10, "All values should be different, rand works in jit."
     assert res3 != res2, "Jit rand is diff with diff seeds"
 
+  #@unittest.expectedFailure # requires contiguous folding
   def test_jit_random_after_unrealized_random(self):
     @TinyJit
     def f(): return Tensor.rand()
@@ -475,7 +476,7 @@ class TestJit(unittest.TestCase):
     b = f(Tensor([2.0]))
     assert abs((a - b).item()) > 0.5
 
-  def test_jit_init_empty(self):
+  def test_jit_init_with_empty_different_size(self):
     @TinyJit
     def f(x:Tensor) -> Tensor: return (x + 1).realize()
 
@@ -484,16 +485,9 @@ class TestJit(unittest.TestCase):
     # scalar const input is not allowed
     with self.assertRaises(JitError):
       f(Tensor(2.0)).item()
-    # self.assertEqual(f(Tensor([2.0])).item(), 1.0) # TODO: wrong output, should be 3.0. currently depends on empty value
-
-  def test_jit_init_empty_alt(self):
-    @TinyJit
-    def f(a:Tensor, b:Tensor) -> Tensor: return b.assign(a+1)
-    for i in range(4):
-      a = Tensor([i])
-      b = Tensor.empty_like(a)
-      c = f(a, b)
-      self.assertEqual(c.item(), i+1)
+    # list input has different view structure than empty(1)
+    with self.assertRaises(JitError):
+      f(Tensor([2.0])).item()
 
 @unittest.skip("Pending multioutput implementation #3607")
 class TestMultioutputJit(unittest.TestCase):
@@ -651,8 +645,8 @@ class TestJitFree(unittest.TestCase):
   def test_replan_buffers_memory_layout(self):
     if not hasattr(Device[Device.DEFAULT].allocator, '_offset'): raise unittest.SkipTest("replan_buffers_memory_layout useless")
 
-    ext_tensor = Tensor([1,24,23,45,1]).contiguous()
-    ext_tensor_2 = Tensor([2,2,2,2,2]).contiguous()
+    ext_tensor = Tensor([1,24,23,45,1])
+    ext_tensor_2 = Tensor([2,2,2,2,2])
     @TinyJit
     def fxn(x:Tensor):
       out = (x*ext_tensor_2+ext_tensor).reshape(5,1).expand(5, 100).contiguous()
@@ -660,9 +654,9 @@ class TestJitFree(unittest.TestCase):
     for i in range(5):
       out = fxn(Tensor([i,1,2,3,4]))
       self.assertEqual(out.item(), 11400+200*i)
-    self.assertEqual(len(set([b.base for item in fxn.captured.jit_cache for b in item.bufs if b is not None])), 4)
+    assert len(set([b.base for item in fxn.captured.jit_cache for b in item.bufs if b is not None])) == 4
     fxn.captured.replan_buffers_memory_layout()
-    self.assertEqual(len(set([b.base for item in fxn.captured.jit_cache for b in item.bufs if b is not None])), 2)
+    assert len(set([b.base for item in fxn.captured.jit_cache for b in item.bufs if b is not None])) == 2
 
     out = fxn(Tensor([11,1,2,3,4]))
     self.assertEqual(out.item(), 13600)

test/backend/test_linearizer.py

@@ -3,7 +3,8 @@ import unittest
 from dataclasses import replace
 
 from tinygrad.codegen.opt import Opt, OptOps
-from tinygrad.uop.ops import UOp, Ops, GroupOp, AxisType
+from tinygrad.codegen.gpudims import get_grouped_dims
+from tinygrad.uop.ops import UOp, Ops, GroupOp, AxisType, PatternMatcher, graph_rewrite, UPat
 from tinygrad.device import Device, Buffer, is_dtype_supported
 from tinygrad.tensor import Tensor, _to_np_dtype
 from tinygrad.engine.realize import run_schedule, CompiledRunner, get_program
@@ -252,6 +253,100 @@ class TestLinearizer(unittest.TestCase):
       if any(x.op is Ops.END and x.src[1].op in GroupOp.ALU for x in u.src):
         assert end_range < uops.index(u)
 
+  def test_grouped_dims(self):
+    def _assert_grouped_dims(prefix, dims, max_sizes, reverse_dims, expected_sizes, assert_same_length = True):
+      idxs = get_grouped_dims(prefix, dims, max_sizes, reverse_dims)
+      loop_idxs = dedup(flatten([[y for y in x.toposort() if y.op is Ops.SPECIAL] for x in idxs]))
+      loop_idxs = sorted(loop_idxs, key=lambda uop: uop.arg)
+      sizes = [x.src[0].arg for x in loop_idxs]
+      assert len(idxs) == len(dims), f"expected idxs to have same length as dims {len(dims)}, got {len(idxs)}"
+      if assert_same_length:
+        assert len(loop_idxs) == min(len(sizes), len(dims)), f"expected idxs to have length {min(len(sizes), len(dims))}, got {len(loop_idxs)}"
+      assert sizes == expected_sizes, f"expected sizes={expected_sizes}, got {sizes=}"
+      # TODO: add these back after uop symbolic
+      # for i in range(len(dims)):
+      #   assert idxs[i].max+1 == dims[i], f"idxs[{i}] should have max {dims[i]-1}"
+      # for i in range(len(loop_idxs)):
+      #   assert loop_idxs[i].expr.startswith(prefix), f"loop_idxs[{i}] must start with {prefix}"
+      #   assert loop_idxs[i].max+1 == sizes[i], f"loop_idxs[{i}] should have max {sizes[i]-1}"
+
+    # no-op
+    _assert_grouped_dims("gidx", (2,), (16,16,16), False, [2])
+    _assert_grouped_dims("gidx", (2,3), (16,16,16), False, [2,3])
+
+    # check reverse dims
+    _assert_grouped_dims("gidx", (2,3), (16,16,16), True, [3,2])
+    _assert_grouped_dims("gidx", (2,3,4), (16,16,16), False, [2,3,4])
+
+    # test splitting globals:    len(dims) == len(max)
+    _assert_grouped_dims("gidx", (64,3,4), (16,16,16), False, [16,12,4])
+    _assert_grouped_dims("gidx", (64,3,4), (16,4,16), False, [16,3,16])
+    _assert_grouped_dims("gidx", (64,3,4), (16,16,16), True, [16,3,16])
+    _assert_grouped_dims("gidx", (128,3,4), (16,4,256), False, [16,3,32])
+    _assert_grouped_dims("gidx", (4,4,512), (16,4,256), False, [8,4,256])
+
+    # prefer group_dim strategy when possible
+    _assert_grouped_dims("gidx", (512,4,2), (8192,2,2), False, [2048,2])
+
+    # test splitting globals:    len(dims) < len(max)
+    #                            len(dim)        ->          len(limited)
+    #                              1             ->             2
+    _assert_grouped_dims("gidx", (128,), (16,16,256), False, [16,8], False)
+    #                              1             ->             3
+    _assert_grouped_dims("gidx", (65536,), (16,16,256), False, [16,16,256], False)
+    #                              2             ->             3
+    _assert_grouped_dims("gidx", (128,128), (16,16,256), False, [16,16,64], False)
+    #                              2             ->             2
+    _assert_grouped_dims("gidx", (65536,2), (65535,65535,65535), False, [32768,4], False)
+    # test when the only divisor is the square root of dim
+    _assert_grouped_dims("gidx", (121,), (12,12,12), False, [11,11], False)
+
+    # collapse on onto the left most axis
+    _assert_grouped_dims("gidx", (2,3,4,5), (16,16,16), False, [6,4,5])
+    _assert_grouped_dims("gidx", (2,3,4,5), (32,16,16), True, [20,3,2])
+    # _assert_grouped_dims("gidx", (Variable("start_pos",1,2),3,4,5), (32,16,16), True, [20,3,Variable("start_pos",1,2)])
+
+    # collapse on left-most available axis (the left most is too small)
+    _assert_grouped_dims("gidx", (2,3,4,5), (4,16,16), False, [2,12,5])
+    _assert_grouped_dims("gidx", (2,3,4,5), (16,16,16), True, [5,12,2])
+
+    # _assert_grouped_dims("gidx", (Variable("start_pos",1,2),3,4,5), (16,16,16), False, [Variable("start_pos",1,2)*3,4,5])
+
+    # dim too large and not factorable
+    with self.assertRaises(RuntimeError):
+      get_grouped_dims("gidx", (23,), (16,16,16), False,)
+    with self.assertRaises(RuntimeError):
+      get_grouped_dims("gidx", (128,3,4), (16,2,2), False,)
+
+    # too large for sizes
+    with self.assertRaises(RuntimeError):
+      get_grouped_dims("gidx", (2,3,4,5,6), (16,16,16))
+
+    # TODO: In the above cases we only test if the shape after reshape is correct, never the indices.
+    # We should check if the returned indices are correct, for all cases.
+    # (65536, 2) -> (32768, 4)
+    dims, expected_limited_dims = (65536,2), (32768, 4)
+    idxs = get_grouped_dims("gidx", dims, (65535,65535,65535))
+    def match_div(): raise RuntimeError("match_div")
+    def match_mod(): raise RuntimeError("match_mod")
+    flat_idx_pattern = UPat(Ops.SPECIAL, arg='gidx0')*expected_limited_dims[1]+UPat(Ops.SPECIAL, arg='gidx1')
+    pm = PatternMatcher([
+      (flat_idx_pattern//dims[1], match_div),
+      (flat_idx_pattern%dims[1], match_mod)
+    ])
+
+    with self.assertRaises(RuntimeError) as error:
+      graph_rewrite(idxs[0], pm)
+    self.assertIn("match_div", str(error.exception))
+
+    with self.assertRaises(RuntimeError) as error:
+      graph_rewrite(idxs[1], pm)
+    self.assertIn("match_mod", str(error.exception))
+
+    # # variable too large
+    # with self.assertRaises(AssertionError):
+    #   get_grouped_dims("gidx", (Variable("start_pos",0,16),3,4), (16,16,16), False,)
+
   @unittest.skipUnless(Device[Device.DEFAULT].renderer.has_local, "test requires locals")
   def test_default_global_reversed(self):
     # shrink so that the dims do not collapse

test/backend/test_multitensor.py

@@ -94,7 +94,7 @@ class TestMultiTensor(unittest.TestCase):
   def _test_shard_op(self, op, out, n=4):
     t = Tensor.ones(n).contiguous().realize().shard(devices_2, 0)
     r = op(t).realize()
-    #assert t.uop.is_realized, "shard didn't realize"
+    assert t.uop.is_realized, "shard didn't realize"
     self.assertEqual(r.tolist(), out)
   def test_shard_reshape(self): self._test_shard_op(lambda t:t.reshape(2, 2), [[1.,1.],[1.,1.]])
   def test_shard_elementwise(self): self._test_shard_op(lambda t:(t+t).reshape(2, 2), [[2.,2.],[2.,2.]])
@@ -135,6 +135,34 @@ class TestMultiTensor(unittest.TestCase):
       si.run()
     self.assertEqual(len(set(names)), 1, "function was relinearized")
 
+  @unittest.skip("this doesn't fold because shard_ calls contiguous on all lbs")
+  def test_sharded_memory(self):
+    # Buffer may be stuck in track_cross_buffer
+    for x in (d0, d1, d2, d3, d4): Device[x].synchronize()
+    mem_base = GlobalCounters.mem_used
+
+    X = Tensor.ones(256).contiguous().realize()
+    assert GlobalCounters.mem_used-mem_base== X.dtype.itemsize * 256, GlobalCounters.mem_used-mem_base
+    X.shard_(devices_4).realize()
+    for x in (d0, d1, d2, d3, d4): Device[x].synchronize()
+    assert GlobalCounters.mem_used-mem_base == X.dtype.itemsize * 256 * 4, GlobalCounters.mem_used-mem_base
+
+    X = Tensor.ones(256).contiguous().realize()
+    assert GlobalCounters.mem_used-mem_base == X.dtype.itemsize * 256, GlobalCounters.mem_used-mem_base
+    X.shard_(devices_4, axis=0).realize()
+    for x in (d0, d1, d2, d3, d4): Device[x].synchronize()
+    assert GlobalCounters.mem_used-mem_base == X.dtype.itemsize * 256, GlobalCounters.mem_used-mem_base
+
+    X = Tensor.ones(256).realize()
+    assert GlobalCounters.mem_used-mem_base == 0
+    X.shard_(devices_4).realize()
+    assert GlobalCounters.mem_used-mem_base == 0
+
+    X = Tensor.ones(256).realize()
+    assert GlobalCounters.mem_used-mem_base == 0
+    X.shard_(devices_4, axis=0).realize()
+    assert GlobalCounters.mem_used-mem_base == 0
+
   def test_shard_same_device(self):
     X = Tensor.ones(256).contiguous().realize()
     X.shard_((d1, X.device), 0)
@@ -626,6 +654,54 @@ class TestMultiTensor(unittest.TestCase):
     assert isinstance(jf.jit_cache[4].prg, BufferCopy)
     assert isinstance(jf.jit_cache[5].prg, graph_d1)
 
+  @unittest.skip("no longer supports uneven shard")
+  def test_uneven_shard(self):
+    for N in range(1, 6):
+      X = Tensor.rand(4, 1, 257).contiguous().realize()
+      n = X.numpy()
+      devices = tuple(f"{Device.DEFAULT}:{i}" for i in range(N))
+      X.shard_(devices, 2)
+      np.testing.assert_equal(X.numpy(), n)
+      np.testing.assert_equal(X.reshape(2, 2, 257).numpy(), n.reshape((2, 2, 257)))
+      np.testing.assert_equal(X.shrink(((0,2), (0, 1), (0,257))).numpy(), n[0:2, 0:1, 0:257])
+      np.testing.assert_equal(X.expand((4, 4, 257)).numpy(), np.tile(n, (1, 4, 1)))
+      np.testing.assert_equal(X.permute((0, 2, 1)).numpy(), np.transpose(n, (0, 2, 1)))
+
+  @unittest.skip("no longer supports uneven shard")
+  def test_uneven_multiple_zeros(self):
+    for data in ([1, 2, 3, 4], [1, 2, 3], [1, 2], [1], []):
+      for N in (1, 2, 3, 4):
+        devices = tuple(f"{Device.DEFAULT}:{i}" for i in range(N))
+        # make sure something is computed on each device
+        X = ((Tensor(data).shard(devices, axis=0) + 1).realize() - 1).realize()
+        np.testing.assert_equal(X.numpy(), data)
+
+  @unittest.skip("no longer supports uneven shard")
+  def test_uneven_shard_with_empty(self):
+    N = 4
+    X = Tensor.rand(16, 1, 3).contiguous().realize()
+    np_x = X.numpy()
+    devices = tuple(f"{Device.DEFAULT}:{i}" for i in range(N))
+
+    # test empty shard
+    np.testing.assert_equal(X.shard(devices, 0).numpy(), np_x)
+
+    # test reshape with empty shard
+    np.testing.assert_equal(X.shard(devices, 0).reshape(8, 1, 6).numpy(), np_x.reshape(8, 1, 6))
+
+  @unittest.skip("no longer supports uneven shard")
+  def test_multiple_uneven_shard(self):
+    N = 4
+    X = Tensor.rand(4, 1, 257).contiguous().realize()
+    Y = Tensor.rand(4, 1, 257).contiguous().realize()
+    np_x, np_y = X.numpy(), Y.numpy()
+    devices = tuple(f"{Device.DEFAULT}:{i}" for i in range(N))
+    X.shard_(devices, 2)
+    Y.shard_(devices, 2)
+    np.testing.assert_equal(X.numpy(), np_x)
+    np.testing.assert_equal(Y.numpy(), np_y)
+    np.testing.assert_equal((X + Y).numpy(), np_x + np_y)
+
   def test_bn_ast_on_devices(self):
     t = Tensor.empty((16, 64, 112, 112)).shard(devices_4, axis=0)
     bn = nn.BatchNorm2d(64)
@@ -676,7 +752,34 @@ class TestMultiTensor(unittest.TestCase):
 
     # test no left join
     with self.assertRaises((AssertionError, ValueError)):
-      t0.reshape((26*15,7)).contiguous().schedule()
+      t0.reshape((26*15,7)).schedule()
+
+  @unittest.skip("no longer supports uneven shard")
+  def test_reshape_on_axis_uneven(self):
+    def reshape_helper(t0, t, t_axis):
+      assert t.uop.axis == t_axis
+      np.testing.assert_allclose(t0.reshape(t.shape).numpy(), t.numpy())
+
+    t0 = Tensor.rand((4, 42, 15)).shard(devices_3, axis=1, splits=[14, 7, 21])
+
+    # ok to reshape as long as elements remain on same device
+    reshape_helper(t0, t0.reshape(2, 2, 42, 3, 5), 2)
+    # split to the right
+    reshape_helper(t0, t0.reshape(2, 2, 6, 7, 15), 2)
+    # split off and merge to the right
+    reshape_helper(t0, t0.reshape(4, 6, 105), 1)
+    # really blend the axes together
+    reshape_helper(t0, t0.reshape(4, 30, 21), 1)
+    # split off 1-shape
+    reshape_helper(t0, t0.reshape(4, 1, 42, 15), 2)
+    reshape_helper(t0, t0.reshape(4, 6, 1, 7, 15), 1)
+
+    # assert if cannot maintain shard axis without moving items between devices
+    with self.assertRaises(AssertionError): t0.reshape(4, 7, 6, 15)
+    # assert for degenerate reshape
+    with self.assertRaises(AssertionError): t0.reshape(4, 5, 7, 15)
+    # assert for cannot maintain axis
+    with self.assertRaises(AssertionError): t0.reshape(4, 3, 2, 7, 15)
 
   # it doesn't work like this anymore
   # NOTE: this never failed in assign_multi, it failed tensor spec because MULTI was never pushed in the graph
@@ -746,6 +849,16 @@ class TestMultiTensor(unittest.TestCase):
     self.assertEqual(rab.device, devices_4)
     self.assertEqual(rab.uop.axis, 0)
 
+  @unittest.skip("no longer supports uneven shard")
+  def test_rand_like_uneven_shard(self):
+    t = Tensor.empty((4, 42, 15)).shard(devices_3, axis=1)
+    t2 = Tensor.rand_like(t)
+    self.assertEqual(t.shape, t2.shape)
+    self.assertEqual(t.device, t2.device)
+    self.assertEqual(t.dtype, t2.dtype)
+    self.assertEqual(t.uop.axis, t2.uop.axis)
+    assert all(tlb.shape == t2lb.shape for tlb, t2lb in zip(t.uop.src, t2.uop.src))
+
   def test_rand_like_none_shard(self):
     t = Tensor.empty((16, 16)).shard(devices_2)
     t2 = Tensor.rand_like(t)
@@ -781,14 +894,6 @@ class TestMultiTensor(unittest.TestCase):
     t2.realize()
   def test_full_like_on_shard_axis(self): self.test_full_like_on_shard(0)
 
-  def test_full_like_shrink_on_shard_axis(self):
-    t = Tensor.ones(16, 16, dtype=dtypes.int).shard(devices_2, axis=0)
-    out = Tensor.full_like(t, 2)[:, :8]
-    sched = out.schedule()
-    self.assertEqual(len(sched), 2) # TODO: 0. fix mstack_early_shrink
-    run_schedule(sched)
-    self.assertEqual(out.tolist(), [[2]*8]*16)
-
   def test_dropout_on_shard(self):
     with Tensor.train():
       X = Tensor.ones(256).to(devices_2)
@@ -805,6 +910,15 @@ class TestMultiTensor(unittest.TestCase):
       assert set(unique) == {0, 2}, unique
       assert 200 < counts[0] < 312, counts[0]
 
+  @unittest.skip("no longer supports uneven shard")
+  def test_dropout_on_uneven_shard_axis(self):
+    with Tensor.train():
+      X = Tensor.ones(256).shard(devices_3, axis=0)
+      output = X.dropout(0.5).numpy()
+      unique, counts = np.unique(output, return_counts=True)
+      assert set(unique) == {0, 2}, unique
+      assert 100 < counts[0] < 156, counts[0]
+
   @unittest.skip("TODO: this requires forced_realize to be deleted.")
   def test_shard_memory(self):
     devices = (d0, d1, d2, d3)
@@ -812,15 +926,13 @@ class TestMultiTensor(unittest.TestCase):
     t.shard_(devices, axis=0).realize()
     assert all([lb is lb.base and lb.realized.base.size == 4 * 16 for lb in t.uop.src])
 
+  @unittest.skip("this is unreliable on OSX")
   def test_clone(self):
-    for axis in (None, 0):
-      t = Tensor.arange(16).reshape(4, 4).shard(devices_2, axis=axis).contiguous().realize()
-      t_clone = t.clone().realize()
-      self.assertEqual(t_clone.device, t.device)
-      self.assertEqual(t_clone.uop.axis, axis)
-      self.assertEqual(t_clone.tolist(), t.tolist())
-      t_clone += 1
-      self.assertNotEqual(t_clone.tolist(), t.tolist())
+    t = Tensor.rand(16, 16).shard(devices_2, axis=None)
+    np.testing.assert_allclose(t.numpy(), t.clone().numpy())
+
+    t = Tensor.rand(16, 16).shard(devices_2, axis=0)
+    np.testing.assert_allclose(t.numpy(), t.clone().numpy())
 
   @unittest.skip("RANGEIFY doesn't support multi const folding")
   def test_multi_const_folding(self):
@@ -869,18 +981,18 @@ class TestShrinkMultiTensorShardedAxis(unittest.TestCase):
 
     with self.assertRaises(AssertionError):
       # sharded axis shrink on non-device boundry is not allowed
-      a = t.shrink(((0, 3), (0, 8))).contiguous()
+      a = t.shrink(((0, 3), (0, 8)))
+      a.schedule()
+    with self.assertRaises(AssertionError):
+      # cannot shrink sharded and non-sharded axis at the same time
+      a = t.shrink(((0, 2), (2, 4)))
       a.schedule()
-    a = t.shrink(((0, 2), (2, 4)))
-    assert a.shape == (2, 2)
-    ref = Tensor.arange(64).reshape(8, 8).shrink(((0, 2), (2, 4)))
-    np.testing.assert_equal(a.numpy(), ref.numpy())
 
-    a = t.shrink(((0, 2), (0, 8))).contiguous()
+    a = t.shrink(((0, 2), (0, 8)))
     a.schedule()
     assert a.shape == (2, 8)
 
-    p = a.pad(((0, 6), (0, 0))).contiguous()
+    p = a.pad(((0, 6), (0, 0)))
     p.schedule()
     assert p.shape == (8, 8)
 
@@ -930,6 +1042,24 @@ class TestShrinkMultiTensorShardedAxis(unittest.TestCase):
       np.testing.assert_allclose(a.reshape((2, 1, 8)).expand((2, 5, 8)).numpy(), b.reshape((2, 1, 8)).expand((2, 5, 8)).numpy(), rtol=1e-7, atol=1e-3)
       np.testing.assert_allclose(a.flip(-1).numpy(), b.flip(-1).numpy(), rtol=1e-7, atol=1e-3)
 
+  @unittest.skip("no longer supports uneven shard")
+  def test_uneven(self):
+    t = Tensor.arange(24).reshape(3, 8).contiguous().realize()
+    t.shard_([f"{Device.DEFAULT}:{i}" for i in range(2)], axis=0)
+
+    a = t.shrink(((0, 2), None))
+    b = t.shrink(((2, 3), None))
+    na = t.numpy()[0:2]
+    nb = t.numpy()[2:3]
+    np.testing.assert_equal(a.numpy(), na)
+    np.testing.assert_equal(b.numpy(), nb)
+    np.testing.assert_equal((a+1).numpy(), na+1)
+    np.testing.assert_equal((b+1).numpy(), nb+1)
+    np.testing.assert_equal((1+a).numpy(), 1+na)
+    np.testing.assert_equal((1+b).numpy(), 1+nb)
+    np.testing.assert_equal((a+a).numpy(), na+na)
+    np.testing.assert_equal((b+b).numpy(), nb+nb)
+
   def test_add_two_partitions(self):
     t = Tensor.arange(64).reshape(8, 8).contiguous().realize()
     t.shard_([f"{Device.DEFAULT}:{i}" for i in range(4)], axis=0)

test/backend/test_ops.py

@@ -8,8 +8,7 @@ from tinygrad.tensor import _to_np_dtype
 from tinygrad.device import is_dtype_supported
 from tinygrad.renderer.nir import NIRRenderer
 
-TINY_BACKEND = getenv("TINY_BACKEND")
-if TINY_BACKEND:
+if getenv("TINY_BACKEND"):
   import tinygrad.nn.torch # noqa: F401 # pylint: disable=unused-import
   torch.set_default_device("tiny")
 
@@ -419,6 +418,7 @@ class TestOps(unittest.TestCase):
     helper_test_op(None, lambda x: x.round(), vals=[[1.499, 1.5, 1.501, 1.0, 2.1, 0.0, -5.0, -2.499, -2.5, -2.501]], forward_only=True)
     helper_test_op(None, lambda x: x.round(), vals=[[2.5, -1.5]], forward_only=True)
 
+  @unittest.skipIf(Device.DEFAULT == "WEBGPU" and CI, "isinf check of 'nan' fails on CI software-based vulkan")
   def test_isinf(self):
     val = [float('-inf'), 0., float('inf'), float('nan'), 1.1]
     helper_test_op(None, torch.isinf, Tensor.isinf, vals=[val], forward_only=True)
@@ -640,6 +640,8 @@ class TestOps(unittest.TestCase):
     helper_test_op([(45,65), (45,65)], lambda x,y: x**y)
     helper_test_op([(45,65), (45,65)], lambda x,y: x.pow(y))
 
+  # TODO: WEBGPU NaN handling in pow operations
+  @unittest.skipIf(Device.DEFAULT == "WEBGPU", "WEBGPU NaN handling differs")
   def test_pow(self):
     helper_test_op([(45,65)], lambda x: x**0)
     helper_test_op([(45,65)], lambda x: x**1)
@@ -758,7 +760,6 @@ class TestOps(unittest.TestCase):
     data = [[1,-8,1],[32,1,6]]
     tor = torch.tensor(data, dtype=torch.int)
     ten = Tensor(data, dtype=dtypes.int32)
-    # NOTE: this breaks assigns because it's folded to 0!
     helper_test_op([], lambda: tor^tor, lambda: ten^ten, forward_only=True)
     helper_test_op([], lambda: tor^0x1337, lambda: ten^0x1337, forward_only=True)
     helper_test_op([], lambda: 0x1337^tor, lambda: 0x1337^ten, forward_only=True)
@@ -1542,6 +1543,7 @@ class TestOps(unittest.TestCase):
     helper_test_op([(3, 4, 5, 6)], lambda x: x.isclose(x + 1e-9, rtol=0.01), forward_only=True)
     helper_test_op(None, lambda x,y: x.isclose(y), vals=[[1e-7, 1e-8, 1e-9], [0.0, 0.0, 0.0]], forward_only=True)
 
+  @unittest.skipIf(Device.DEFAULT == "WEBGPU" and CI, "isinf check of 'nan' fails on CI software-based vulkan")
   def test_isclose_edge_cases(self):
     for a in [math.inf, -math.inf, math.nan, 0.0]:
       for b in [math.inf, -math.inf, math.nan, 0.0]:

test/backend/test_outerworld.py

@@ -0,0 +1,230 @@
+import unittest
+import numpy as np
+from tinygrad import Tensor, UOp, nn
+from tinygrad.uop.ops import AxisType, Ops
+
+class TestOuterworldReduce(unittest.TestCase):
+  def test_reduce(self):
+    x = Tensor.ones(5, 5).contiguous()
+    a = UOp.range(5, -1, AxisType.REDUCE)
+    out = x[a]
+    # TODO: syntax for this
+    t = Tensor(UOp(Ops.REDUCE, dtype=out.uop.dtype, src=(out.uop, a), arg=Ops.ADD))
+    self.assertListEqual(t.tolist(), [5.,5.,5.,5.,5.])
+
+# TODO: delete test_outerworld_range?
+class TestOuterRange(unittest.TestCase):
+  def test_simple_range(self):
+    a = Tensor.ones(10).contiguous()
+    acc = Tensor.zeros().contiguous()
+    Tensor.realize(a, acc)
+
+    # this is fold
+    i = UOp.range(10, -100, AxisType.OUTER)
+    acc_i = acc.uop.after(i)
+    vi = UOp.variable("i", i.vmin, i.vmax).bind(i)
+    out = Tensor(acc.uop.after(acc_i.store(acc_i + a[vi].uop).end(i)))
+    out.realize()
+    assert out.item() == 10.0
+
+  def test_inner_range(self):
+    a = Tensor.ones(10, 10).contiguous()
+    acc = Tensor.zeros(10).contiguous()
+    Tensor.realize(a, acc)
+
+    # this is fold
+    i = UOp.range(10, -100, AxisType.OUTER)
+    acc_i = acc.uop.after(i)
+    vi = UOp.variable("i", i.vmin, i.vmax).bind(i)
+    out = Tensor(acc.uop.after(acc_i.store(acc_i + a[:, vi].uop).end(i)))
+    out.realize()
+    self.assertEqual(out.tolist(), [10.0]*10)
+
+  def test_range_matmul(self):
+    vec = Tensor.randn(1, 10).realize()
+    mats = Tensor.randn(3, 10, 10).realize()
+
+    # 3 matmuls in "scan"
+    ref = ((vec @ mats[0]) @ mats[1]) @ mats[2]
+    ref.realize()
+
+    # 3 matmuls with outer world range
+    i = UOp.range(3, -100, AxisType.OUTER)
+    vec_i = Tensor(vec.uop.after(i))
+    comp = vec_i.contiguous() @ mats[i]
+    store = vec_i.uop.store(comp.uop).end(i)
+    out = Tensor(vec.uop.after(store))
+    out.realize()
+
+    # TODO: testing allclose
+    assert Tensor.allclose(ref, out, atol=1e-5), f"max diff {(ref-out).abs().max().item()}"
+
+class TestOuterScan(unittest.TestCase):
+  def _test_scan(self):
+    vec = Tensor.randn(1, 10).realize()
+    mats = Tensor.randn(3, 10, 10).realize()
+
+    # 3 matmuls in "scan"
+    vec1 = vec @ mats[0]
+    vec2 = vec1 @ mats[1]
+    vec3 = vec2 @ mats[2]
+    ref = Tensor.stack(vec1, vec2, vec3)
+    ref.realize()
+    return vec, mats, ref
+
+  def test_uop_scan_matmul(self):
+    vec, mats, ref = self._test_scan()
+
+    # 3 matmuls with SCAN
+    i = UOp.range(3, -100, AxisType.OUTER)
+    out = Tensor.empty(3, 1, 10)
+    phi = Tensor(i.eq(0).where(vec.uop, out[(i-1).maximum(0)].uop))
+    comp = phi @ mats[i]
+    store = out[i].uop.store(comp.uop).end(i)
+    out = Tensor(out.uop.after(store))
+    out.realize()
+
+    # TODO: testing allclose
+    assert Tensor.allclose(ref, out, atol=1e-5), f"max diff {(ref-out).abs().max().item()}"
+
+class TestOuterworld(unittest.TestCase):
+  def test_range_plus_1(self):
+    t = Tensor.arange(100).reshape(10,10).realize()
+
+    # passthrough ranges
+    a = UOp.range(10, -1)
+    sel = t[a] + 1
+    assert sel.shape == (10,)
+    cpy = sel.reshape(1, 10).expand(a, 10).contiguous().realize()
+
+    self.assertTrue((t+1==cpy).all().item())
+
+  def test_range_plus_1_transpose(self):
+    t = Tensor.arange(100).reshape(10,10).realize()
+
+    # passthrough ranges
+    a = UOp.range(10, -1)
+    sel = t[a] + 1
+    assert sel.shape == (10,)
+    cpy = sel.reshape(10, 1).expand(10, a).contiguous().realize()
+
+    self.assertTrue(((t+1).T==cpy).all().item())
+
+  def test_flip_range(self):
+    t = Tensor.rand(10, 10).realize()
+
+    # passthrough ranges
+    a = UOp.range(10, -1)
+    sel = t[9-a]
+    cpy = sel.reshape(1, 10).expand(a, 10).contiguous().realize()
+
+    self.assertTrue((t.flip(0)==cpy).all().item())
+
+  def test_vmap(self):
+    def f(x): return x.sum(axis=0)*2
+
+    x = Tensor.ones(3, 10, 2).contiguous()
+
+    # vmap across axis 0
+    a = UOp.range(3, -1)
+    out = f(x[a])
+    out = out.reshape(1, 2).expand(a, 2).contiguous()
+
+    # 3x2 grid of 20
+    out.realize()
+    self.assertTrue((out==20).all().item())
+
+  def test_fancy_vmap(self):
+    def f(x,y): return x+y
+
+    x = Tensor.arange(9).reshape(3,3).contiguous()
+    y = Tensor.arange(9).reshape(3,3).contiguous()
+
+    a = UOp.range(3, -1)
+    out = f(x[:,a], y[a,:])
+    # TODO: this should support flatten
+    out = out.reshape(1, 3).expand(a, 3).contiguous().realize()
+    self.assertListEqual([[0,4,8],[4,8,12],[8,12,16]], out.tolist())
+
+class TestVmap(unittest.TestCase):
+  def test_vmap_inner(self, axis_type=AxisType.LOOP, fuse=False, grad=False):
+    x = Tensor.ones(1, 10).contiguous().requires_grad_()
+    mats = Tensor.ones(3, 10, 10).contiguous().requires_grad_()
+
+    ref = x @ mats
+    if fuse: ref = ref * 2
+
+    # vmap across axis 0
+    a = UOp.range(3, -1, axis_type)
+    out = x @ mats[a]
+    out = out.reshape(1, 10).pad(((a,(3-a)-1), None))
+    out = Tensor(out.uop.reduce(a, arg=Ops.ADD))
+    if fuse: out = out * 2
+    if grad:
+      out.mean().backward()
+      np.testing.assert_allclose(mats.grad.numpy(), (2./30) if fuse else (1./30))
+    out.realize()
+
+    # TODO: testing allclose
+    assert Tensor.allclose(ref, out, atol=1e-6), f"max diff {(ref-out).abs().max().item()}"
+  def test_vmap_inner_fuse(self): self.test_vmap_inner(fuse=True)
+  def test_vmap_outer(self): self.test_vmap_inner(AxisType.OUTER)
+  def test_vmap_outer_fuse(self): self.test_vmap_inner(AxisType.OUTER, fuse=True)
+
+  def test_vmap_inner_grad(self): self.test_vmap_inner(grad=True)
+  def test_vmap_inner_fuse_grad(self): self.test_vmap_inner(fuse=True, grad=True)
+  def test_vmap_outer_grad(self): self.test_vmap_inner(AxisType.OUTER, grad=True)
+
+  def test_vmap_convs(self):
+    layers = [
+      nn.Conv2d(1, 8, 3), Tensor.relu,
+      nn.Conv2d(8, 8, 3), Tensor.relu]
+    img = Tensor.randn(4, 1, 16, 16).realize(*nn.state.get_parameters(layers))
+    a = UOp.range(4, -1, AxisType.OUTER)
+    out = img[a:a+1].sequential(layers)
+    out = out.pad(((a,(4-a)-1), None, None, None))
+    out = Tensor(out.uop.reduce(a, arg=Ops.ADD))
+    out.realize()
+    np.testing.assert_allclose(out.numpy(), img.sequential(layers).numpy(), atol=1e-6)
+
+  def test_vmap_gemm(self):
+    layers = [
+      nn.Linear(16, 16, bias=False), Tensor.relu,
+      nn.Linear(16, 16, bias=False), Tensor.relu]
+    img = Tensor.randn(4, 16).realize(*nn.state.get_parameters(layers))
+    a = UOp.range(4, -1, AxisType.OUTER)
+    out = img[a:a+1].sequential(layers)
+    out = out.pad(((a,(4-a)-1), None))
+    out = Tensor(out.uop.reduce(a, arg=Ops.ADD))
+    out.realize()
+    np.testing.assert_allclose(out.numpy(), img.sequential(layers).numpy(), atol=1e-6)
+
+  @unittest.skip("this is broken, we need to lower the outer reduce in the outer graph")
+  def test_vmap_gemm_grad(self):
+    layers = [
+      nn.Linear(16, 16, bias=False), Tensor.relu,
+      nn.Linear(16, 16, bias=False), Tensor.relu]
+    layer_tensors = nn.state.get_parameters(layers)
+    img = Tensor.randn(4, 16).realize(*layer_tensors)
+    for l in layer_tensors: l.requires_grad_()
+    a = UOp.range(4, -1, AxisType.OUTER)
+    out = img[a:a+1].sequential(layers)
+    out = out.pad(((a,(4-a)-1), None))
+    out = Tensor(out.uop.reduce(a, arg=Ops.ADD))
+    out.mean().backward()
+    grads = [l.grad for l in layer_tensors]
+    out.realize(*grads)
+    out_grads = [x.numpy() for x in grads]
+
+    # compute reference grads
+    for l in layer_tensors: l.grad = None
+    img.sequential(layers).mean().backward()
+    grads = [l.grad for l in layer_tensors]
+    out.realize(*grads)
+    ref_grads = [x.numpy() for x in grads]
+
+    # compare
+    for o,r in zip(out_grads, ref_grads): np.testing.assert_allclose(o, r, atol=1e-6)
+
+if __name__ == '__main__':
+  unittest.main()

test/backend/test_outerworld_call.py

@@ -0,0 +1,19 @@
+import unittest
+from tinygrad import Tensor
+
+class TestOuterCall(unittest.TestCase):
+  def test_outer_call_assign(self):
+    a = Tensor.zeros(10,10).contiguous()
+    b = Tensor.ones(10,10).contiguous()
+    Tensor.realize(a,b)
+
+    pa = a.as_param(0)
+    pb = b.as_param(1)
+    out = Tensor.call(a, b, fxn=pa.assign(pa+pb))
+    out.realize()
+
+    print(a.numpy())
+    assert (a == 1).all().item()
+
+if __name__ == '__main__':
+  unittest.main()

test/backend/test_outerworld_range.py

@@ -0,0 +1,148 @@
+import unittest
+from tinygrad import Tensor, nn, Variable, UOp
+
+# outerworld range should support three things
+# 1. full optimizer steps (test_model_bound_range)
+# 2. gradient accumulation (you want to end the range before running the optimizer)
+# 3. stacked linear layers
+
+class Model:
+  def __init__(self): self.w = nn.Linear(64, 8, bias=False)
+  def __call__(self, x:Tensor) -> Tensor: return self.w(x)
+
+def get_model_and_opt():
+  Tensor.manual_seed(1337)
+  m = Model()
+  opt = nn.optim.SGD(nn.state.get_parameters(m), lr=0.1, weight_decay=0)
+  return m, opt
+
+class TestOuterworldRange(unittest.TestCase):
+  STEPS = 5
+  BS = 20
+
+  @classmethod
+  def setUpClass(cls):
+    Tensor.manual_seed(1338)
+    # it learns to compute mean
+    cls.X = Tensor.randn(cls.STEPS, cls.BS, 64).contiguous().realize()
+    cls.Y = cls.X.reshape(cls.STEPS, cls.BS, 8, 8).mean(axis=-1).contiguous().realize()
+    cls.losses = cls._get_model_baseline()
+
+  def _compare(self, losses):
+    for i,(x,y) in enumerate(zip(self.losses, losses)):
+      self.assertAlmostEqual(x, y, places=5, msg=f"mismatch at {i} in {self.losses} vs {losses}")
+
+  @classmethod
+  @Tensor.train()
+  def _get_model_baseline(self):
+    m, opt = get_model_and_opt()
+    losses = []
+    for i in range(self.STEPS):
+      opt.zero_grad()
+      loss = (m(self.X[i]) - self.Y[i]).square().mean()
+      loss.backward()
+      loss.realize(*opt.schedule_step())
+      losses.append(loss.item())
+    return losses
+
+  @Tensor.train()
+  def test_model_grad_acc(self):
+    m, opt = get_model_and_opt()
+    losses = []
+    for i in range(self.STEPS):
+      opt.zero_grad()
+      sub_batch_size = self.BS//2
+      loss = 0
+      scaling_factor = self.BS//sub_batch_size
+      for j in range(0, self.BS, sub_batch_size):
+        sub_loss = (m(self.X[i][j:j+sub_batch_size]) - self.Y[i][j:j+sub_batch_size]).square().mean() / scaling_factor
+        sub_loss.backward()
+        loss += sub_loss
+      loss.realize(*opt.schedule_step())
+      losses.append(loss.item())
+    self._compare(losses)
+
+  @Tensor.train()
+  def test_model_variable(self):
+    m, opt = get_model_and_opt()
+    losses = []
+    vi = Variable('i', 0, self.STEPS-1)
+    for i in range(self.STEPS):
+      vib = vi.bind(i)
+      opt.zero_grad()
+      loss = (m(self.X[vib]) - self.Y[vib]).square().mean()
+      loss.backward()
+      loss.realize(*opt.schedule_step())
+      losses.append(loss.item())
+    self._compare(losses)
+
+  @Tensor.train()
+  def test_model_scheduled(self):
+    m, opt = get_model_and_opt()
+    losses = []
+    for i in range(self.STEPS):
+      opt.zero_grad()
+      loss = (m(self.X[i]) - self.Y[i]).square().mean()
+      loss.backward()
+      opt.schedule_step()
+      losses.append(loss)
+    self._compare(Tensor.stack(*losses).tolist())
+
+  @Tensor.train()
+  def test_model_scheduled_setitem(self):
+    m, opt = get_model_and_opt()
+    losses = Tensor.empty(self.STEPS)
+    for i in range(self.STEPS):
+      opt.zero_grad()
+      loss = (m(self.X[i]) - self.Y[i]).square().mean()
+      loss.backward()
+      opt.schedule_step()
+      # TODO: this shouldn't realize
+      losses[i] = loss.requires_grad_(False)
+    self._compare(losses.tolist())
+
+  @unittest.expectedFailure
+  @Tensor.train()
+  def test_model_scheduled_variable(self):
+    m, opt = get_model_and_opt()
+    losses = []
+    vi = Variable('i', 0, self.STEPS-1)
+    for i in range(self.STEPS):
+      vib = vi.bind(i)
+      opt.zero_grad()
+      loss = (m(self.X[vib]) - self.Y[vib]).square().mean()
+      loss.backward()
+      opt.schedule_step()
+      losses.append(loss)
+    self._compare(Tensor.stack(*losses).tolist())
+
+  @unittest.expectedFailure
+  @Tensor.train()
+  def test_model_scheduled_variable_setitem(self):
+    m, opt = get_model_and_opt()
+    losses = Tensor.empty(self.STEPS)
+    vi = Variable('i', 0, self.STEPS-1)
+    for i in range(self.STEPS):
+      vib = vi.bind(i)
+      opt.zero_grad()
+      loss = (m(self.X[vib]) - self.Y[vib]).square().mean()
+      loss.backward()
+      opt.schedule_step()
+      losses[vib] = loss.requires_grad_(False)
+    self._compare(losses.tolist())
+
+  @unittest.expectedFailure
+  @Tensor.train()
+  def test_model_bound_range(self):
+    m, opt = get_model_and_opt()
+    # TODO: should ranges be unique so you don't have to pass in the -1?
+    rng = UOp.range(self.STEPS, -1)
+    vib = Variable('i', 0, self.STEPS-1).bind(rng)
+    loss = (m(self.X[vib]) - self.Y[vib]).square().mean()
+    loss.backward()
+    losses = Tensor.empty(self.STEPS)
+    losses[vib] = loss
+    losses.realize(*opt.schedule_step())
+
+if __name__ == "__main__":
+  unittest.main()

test/backend/test_profiler.py

@@ -1,4 +1,4 @@
-import unittest, struct, contextlib, statistics, gc
+import unittest, struct, contextlib, statistics, time, gc
 from tinygrad import Device, Tensor, dtypes, TinyJit
 from tinygrad.helpers import CI, getenv, Context, ProfileRangeEvent, cpu_profile, cpu_events, ProfilePointEvent, dedup
 from tinygrad.device import Buffer, BufferSpec, Compiled, ProfileDeviceEvent, ProfileGraphEvent
@@ -20,7 +20,7 @@ def helper_collect_profile(*devs):
   cpu_events.clear()
 
   profile_list = []
-  with Context(PROFILE=1):
+  with Context(VIZ=1, PROFILE=1):
     yield profile_list
     for dev in devs: dev.synchronize()
     for dev in devs: dev._at_profile_finalize()
@@ -170,19 +170,30 @@ class TestProfiler(unittest.TestCase):
     for (i1, d1), (i2, d2) in pairs:
       assert abs(jitter_matrix[i1][i2]) < 0.5, "jitter should be less than 0.5us"
 
+  @unittest.skip("this test is flaky")
   def test_cpu_profile(self):
     def test_fxn(err=False):
+      time.sleep(0.1)
       if err: raise Exception()
+      time.sleep(0.1)
 
     with helper_collect_profile(dev:=TestProfiler.d0) as profile:
-      with cpu_profile("test_1", dev):
+      with cpu_profile("test_1", dev.device):
         test_fxn(err=False)
       with self.assertRaises(Exception):
-        with cpu_profile("test_2", dev):
+        with cpu_profile("test_2", dev.device):
           test_fxn(err=True)
 
-    range_events = [p for p in profile if isinstance(p, ProfileRangeEvent) and p.device == dev]
+    range_events = [p for p in profile if isinstance(p, ProfileRangeEvent)]
     self.assertEqual(len(range_events), 2)
+    # record start/end time up to exit (error or success)
+    for e in range_events:
+      self.assertGreater(e.en, e.st)
+    e1, e2 = range_events
+    self.assertEqual([e1.name, e2.name], ["test_1", "test_2"])
+    # TODO: this is flaky
+    #self.assertLess(e1.st, e2.st)
+    #self.assertGreater(e1.en-e1.st, e2.en-e2.st)
 
   @unittest.skip("this test is flaky")
   @unittest.skipUnless(Device[Device.DEFAULT].graph is not None, "graph support required")

test/backend/test_renderer_failures.py

@@ -78,9 +78,7 @@ class TestCStyleFailures(unittest.TestCase):
   def test_repeat_add(self): self._test_src_strip_paren(Ops.ADD)
   def test_repeat_mul(self): self._test_src_strip_paren(Ops.MUL)
   def test_repeat_xor(self): self._test_src_strip_paren(Ops.XOR)
-  @unittest.skipIf(isinstance(Device[Device.DEFAULT].renderer, WGSLRenderer), "wgsl ends up with '(' * 5")
   def test_repeat_or(self): self._test_src_strip_paren(Ops.OR)
-  @unittest.skipIf(isinstance(Device[Device.DEFAULT].renderer, WGSLRenderer), "wgsl ends up with '(' * 5")
   def test_repeat_and(self): self._test_src_strip_paren(Ops.AND)
   def test_repeat_sub(self): self._test_src_strip_paren(Ops.SUB, should_strip_paren=False)
 

test/backend/test_schedule.py

@@ -2,7 +2,7 @@
 # schedule confirms the right things are capable of fusing
 # NOTE: this has overlap with external_test_opt.py
 
-import gc, unittest, functools
+import unittest, functools
 import numpy as np
 from typing import cast
 from hypothesis import assume, given, settings, strategies as strat
@@ -168,13 +168,13 @@ class TestSchedule(unittest.TestCase):
     a = Tensor.full((4,), 4.0).contiguous().realize()
     b = Tensor.full((4,), 2.0).contiguous().realize()
     expr = (a*b)/b
-    run_schedule(check_schedule(expr, 1))
+    check_schedule(expr, 0)
     np.testing.assert_allclose(expr.numpy(), np.full((4,), 4.0))
 
   def test_div_collapse_const(self):
     a = Tensor.full((4,), 4.0).contiguous().realize()
     expr = a/a
-    run_schedule(check_schedule(expr, 1))
+    check_schedule(expr, 0)
     np.testing.assert_allclose(expr.numpy(), np.full((4,), 1.0))
 
   def test_div_collapse(self):
@@ -747,7 +747,7 @@ class TestSchedule(unittest.TestCase):
     p = P[0]
     p = p.pad(((1, 0), ))
     p = p.repeat([2])
-    run_schedule(check_schedule(p, 4))  # TODO: this is high
+    run_schedule(check_schedule(p, 3))
     tiny_ret = p.numpy()
 
     P = np.ones((3, 3), dtype=np.float32)
@@ -775,12 +775,11 @@ class TestSchedule(unittest.TestCase):
   @unittest.skipIf(Device.DEFAULT == "WEBGPU", "Causes other tests to fail")
   def test_conv2d_fused_half(self): _test_conv2d(4, dtype=dtypes.half)
 
+  @unittest.skip("TODO: this is consistently creating non reproducible failures")
   def test_schedule_mem_used_with_inputs(self):
-    gc.collect()
     base = GlobalCounters.mem_used
     x = Tensor.ones(256).contiguous().realize()
     (x+Tensor.ones(256).contiguous()).schedule()
-    gc.collect()
     self.assertEqual(GlobalCounters.mem_used-base, 1024)
 
   @unittest.skipIf(Device.DEFAULT != "CL", "image only supported on CL")
@@ -841,9 +840,10 @@ class TestSchedule(unittest.TestCase):
   def test_cast_const_view(self):
     a = Tensor.ones((4, 4), dtype=dtypes.float32)
     casted_view = a.cast(dtypes.int32)
-    run_schedule(check_schedule(casted_view, 1))
+    run_schedule(check_schedule(casted_view, 0))
+    self.assertIsNone(casted_view.uop.base.realized)
     realized_const_view = casted_view.contiguous()
-    run_schedule(check_schedule(realized_const_view, 0))
+    run_schedule(check_schedule(realized_const_view, 1))
     self.assertListEqual(realized_const_view.tolist(), [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]])
 
   @given(strat.sampled_from(dtypes.all), strat.sampled_from(dtypes.all))
@@ -1036,7 +1036,7 @@ class TestSchedule(unittest.TestCase):
     idx = Tensor([1,2,5,6], dtype=dtypes.int32)
     flat_base[idx] = Tensor([99,99,99,99])
     base.assign(flat_base.reshape(4, 4))
-    sched = check_schedule(base, 6)  # TODO: this is high
+    sched = check_schedule(base, 2)
     run_schedule(sched)
     expected = list(range(16))
     for i, v in zip([1,2,5,6], [99,99,99,99]): expected[i] = v
@@ -1235,11 +1235,11 @@ class TestView(unittest.TestCase):
     bv = b.pad(((0, 2),))[-2:]
     # this becomes a late a*0
     late_mul = a*bv
-    run_schedule(check_schedule(late_mul, 2))
+    check_schedule(late_mul, 0)
     # the arange doesn't realize
-    #self.assertIsNone(b.uop.base.realized)
+    self.assertIsNone(b.uop.base.realized)
     # mul doesn't realize
-    #self.assertIsNone(late_mul.uop.base.realized)
+    self.assertIsNone(late_mul.uop.base.realized)
     self.assertEqual(late_mul.tolist(), [0, 0])
 
   # SINK has two branches:
@@ -1252,21 +1252,20 @@ class TestView(unittest.TestCase):
     bv = b.pad(((0, 2),))[-2:]
     late_mul = a*bv
     other_child = b+2
-    s = check_schedule([late_mul, other_child], 3)
+    s = check_schedule([late_mul, other_child], 2)
     # the arange becomes a BUFFER
     self.assertIs(b.uop.base.op, Ops.BUFFER)
-    # NOTE: no longer checked
     # mul still collapses
-    #self.assertIs(late_mul.uop.base.op, Ops.CONST)
+    self.assertIs(late_mul.uop.base.op, Ops.CONST)
     run_schedule(s)
     self.assertEqual(other_child.tolist(), [2, 3, 4])
 
 @unittest.skipIf(Device.DEFAULT == "CPU", "tests copy from another device to cpu")
 class TestCopyFolding(unittest.TestCase):
   def test_const_copy_is_free(self):
-    b = Tensor(1).to("CPU") * 4
-    run_schedule(check_schedule(b, 1, filter_sink=False))
-    assert b.item() == 4
+    b = Tensor(1).to("CPU")
+    check_schedule(b, 0, filter_sink=False)
+    assert b.item() == 1
 
   def test_one_hot_with_copy(self):
     y = Tensor([1, 2, 3]).to("CPU")
@@ -1274,16 +1273,16 @@ class TestCopyFolding(unittest.TestCase):
     check_schedule(x, 3, filter_sink=False)
 
   def test_const_copy_multi(self):
-    x = Tensor.ones(1, device="CPU").to_(["CPU", "CPU:1"]) * 2
-    run_schedule(check_schedule(x, 2, filter_sink=False))
-    self.assertEqual(x.item(), 2.0)
+    x = Tensor.ones(1, device="CPU").to_(["CPU", "CPU:1"])
+    check_schedule(x, 0, filter_sink=False)
+    self.assertEqual(x.item(), 1)
 
   def test_late_const_copy_folding(self):
     a = Tensor.arange(3).realize()
     zeros = Tensor.zeros(3).realize()
-    b = (a*zeros).to("CPU") + 1
-    run_schedule(check_schedule(b, 1, filter_sink=False))
-    self.assertListEqual(b.tolist(), [1, 1, 1])
+    b = (a*zeros).to("CPU")
+    run_schedule(check_schedule(b, 0, filter_sink=False))
+    self.assertListEqual(b.tolist(), [0, 0, 0])
     self.assertEqual(b.device, "CPU")
 
   def test_alu_after_copy(self):
@@ -1322,7 +1321,7 @@ class TestCopyFolding(unittest.TestCase):
     a = Tensor.ones(4, 4).contiguous().realize()
     # use copy_to_device to bypass Tensor.to() shortcircuit and force a real same-device COPY in the graph
     a.assign(Tensor(a.uop.copy_to_device(a.device), a.device))
-    run_schedule(check_schedule(a, 2, filter_sink=False))
+    run_schedule(check_schedule(a, 0, filter_sink=False))
     self.assertListEqual(a.tolist(), [[1.]*4]*4)
 
   def test_clone(self):

test/backend/test_symbolic_jit.py

@@ -80,7 +80,7 @@ class TestSymbolicJit(unittest.TestCase):
       symbolic = jf(q, k[:, :vi], v[:, :vi])[:2, :4, :1, :8].numpy()
       expected = f(q, k[:, :i], v[:, :i]).numpy()
       np.testing.assert_allclose(symbolic, expected, atol=1e-6, rtol=1e-6)
-    assert_jit_cache_len(jf, 5)
+    assert_jit_cache_len(jf, 4)
 
   def test_cat_dim0(self):
     def f(a, b): return a.cat(b, dim=0).realize()

test/backend/test_transcendental.py

@@ -84,6 +84,7 @@ class TestFromFuzzer(unittest.TestCase):
     _test_value(np.pi * 2, unit=1.5)
 
   @given(strat.sampled_from(dtypes_float))
+  @unittest.skipIf(Device.DEFAULT == "WEBGPU" and CI, "Nan location mismatch on Vulkan, Metal works")
   def test_log2(self, dtype):
     if not is_dtype_supported(dtype): return
     if dtype == dtypes.float64:

test/backend/test_uops.py

@@ -113,12 +113,6 @@ class TestFloatUOps(TestUOps):
   def test_max(self): self._test_bop_fxn(Ops.MAX, lambda a,b: max(a,b))
   def test_cmplt(self): self._test_bop_fxn(Ops.CMPLT, lambda a,b: a<b)
   def test_cmpne(self): self._test_bop_fxn(Ops.CMPNE, lambda a,b: a!=b)
-  @unittest.skipIf(Device.DEFAULT == "WEBGPU", "WEBGPU doesn't support NaN comparison correctly")
-  def test_cmpne_nan(self):  # NaN != x for any x (IEEE 754)
-    for a, b in [(math.nan, 1.0), (1.0, math.nan), (math.nan, math.nan)]:
-      self.assertTrue(_test_single_value(
-        [dtypes.as_const(a, dtypes.float32), dtypes.as_const(b, dtypes.float32)],
-        Ops.CMPNE, (dtypes.float32, dtypes.float32)))
   # MOD isn't tested on floats
 
   def test_where(self):

test/device/test_hcq.py

@@ -76,7 +76,7 @@ class TestHCQ(unittest.TestCase):
         TestHCQ.d0.timeline_signal.wait(TestHCQ.d0.timeline_value)
         TestHCQ.d0.timeline_value += 1
 
-  @unittest.skipIf(Device.DEFAULT in {"CPU"} or getenv("AMD_IFACE", "") == "PCI", "Can't handle async update on CPU/MOCKAM device")
+  @unittest.skipIf(Device.DEFAULT in {"CPU"}, "Can't handle async update on CPU device")
   def test_wait_late_set(self):
     for queue_type in [TestHCQ.d0.hw_compute_queue_t, TestHCQ.d0.hw_copy_queue_t]:
       if queue_type is None: continue
@@ -538,7 +538,7 @@ class TestHCQ(unittest.TestCase):
 
       np.testing.assert_equal(cpu_buffer.numpy(), local_buf.numpy(), "failed")
 
-  @unittest.skipUnless(MOCKGPU and getenv("AMD_IFACE", "") != "PCI", "Emulate this on MOCKGPU to check the path in CI")
+  @unittest.skipUnless(MOCKGPU, "Emulate this on MOCKGPU to check the path in CI")
   def test_on_device_hang(self):
     if not hasattr(self.d0, 'on_device_hang'): self.skipTest("device does not have on_device_hang")
 

test/device/test_metal.py

@@ -1,5 +1,5 @@
 import unittest
-from tinygrad.device import CompileError, Device, BufferSpec
+from tinygrad.device import CompileError, Device
 if Device.DEFAULT=="METAL":
   from tinygrad.runtime.ops_metal import MetalDevice, MetalCompiler, MetalProgram
 @unittest.skipIf(Device.DEFAULT!="METAL", "Metal support required")
@@ -48,14 +48,4 @@ kernel void r_5(device int* data0, const device int* data1, uint3 gid [[threadgr
 """)
     with self.assertRaises(RuntimeError):
       compiled = compiled[:40] # corrupt the compiled program
-      MetalProgram(device, "r_5", compiled)
-
-  def test_free(self):
-    size = 2**16
-    device = Device['METAL']
-    before = device.sysdevice.currentAllocatedSize()
-
-    buf = device.allocator.alloc(size, BufferSpec(nolru=True))
-    self.assertEqual(curr:=device.sysdevice.currentAllocatedSize(), before+size, msg=f"{curr=} - {before=}")
-    device.allocator.free(buf, buf.size, BufferSpec(nolru=True))
-    self.assertEqual(curr:=device.sysdevice.currentAllocatedSize(), before, msg=f"{curr=} - {before=}")
+      MetalProgram(device, "r_5", compiled)

test/external/external_test_onnx_runner.py

@@ -56,12 +56,10 @@ class TestOnnxRunner(unittest.TestCase):
     output = runner({'inp': Tensor([1, 2, 3, 4])})['output']
     _check_ast_count(0, output)
 
-  @unittest.skip("const folding is removed")
   def test_const_fold_from_disk(self):
     self._test_const_fold_unary_op(True)
     self._test_const_fold_binary_op(True)
 
-  @unittest.skip("const folding is removed")
   def test_const_fold_from_memory(self):
     self._test_const_fold_unary_op(False)
     # TODO: understand this and fix this, bitcast related

test/external/process_replay/process_replay.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # compare kernels created by HEAD against master
-import os, multiprocessing, logging, pickle, sqlite3, difflib, warnings, functools, base64, codecs
+import os, multiprocessing, logging, pickle, sqlite3, difflib, warnings, itertools, functools, base64, codecs
 from dataclasses import replace
 from typing import Callable, Any
 
@@ -8,6 +8,7 @@ ASSERT_DIFF = int((flag:="[pr]") in os.getenv("COMMIT_MESSAGE", flag) or flag in
 if not int(os.getenv("ASSERT_PROCESS_REPLAY", "1")): ASSERT_DIFF = 0
 
 try:
+  from tinygrad.schedule.rangeify import get_rangeify_map
   from tinygrad.renderer import Renderer, ProgramSpec
   from tinygrad.engine.realize import get_program
   from tinygrad.uop.ops import UOp, Ops, KernelInfo
@@ -42,6 +43,14 @@ class ProcessReplayWarning(Warning): pass
 
 # *** replay the function and convert return values to string
 
+def replay_get_rangeify_map(ret:dict[UOp, UOp], big_sink:UOp) -> tuple[str, str, tuple[Any, ...]]:
+  UOp.unique_num = itertools.count(max([u.arg for u in big_sink.toposort() if u.op is Ops.UNIQUE], default=0)+1)
+  new_sink = big_sink.substitute(get_rangeify_map(big_sink))
+  def to_str(ret:UOp) -> str:
+    asts = [repr(u.arg.ast) for u in ret.toposort() if u.op is Ops.CALL]
+    return "\n".join([f"{len(asts)} kernels", *asts])
+  return to_str(new_sink), to_str(big_sink.substitute(ret)), (big_sink,)
+
 def replay_get_program(p:ProgramSpec, ast:UOp, renderer:Renderer, opts:list[Opt]|None=None) -> tuple[str, str, tuple[Any, ...]]:
   # the ast.arg is non None if we are inside of search.py
   sink_arg = ast.arg or KernelInfo()
@@ -59,6 +68,8 @@ def replay_get_program(p:ProgramSpec, ast:UOp, renderer:Renderer, opts:list[Opt]
 
 replayers: dict[str, Callable[..., tuple[str, str, tuple[Any, ...]]]] = {}
 replayers["get_program"] = replay_get_program
+# disable this for speed, does it ever find things?
+#replayers["get_rangeify_map"] = replay_get_rangeify_map
 
 # *** run replayers on captured rows and print diffs
 

test/helpers.py

@@ -39,7 +39,7 @@ def assert_jit_cache_len(fxn, expected_len):
     assert len(fxn.jit_cache) == 1, len(fxn.jit_cache)
     # until we have a better way of typing the prg in ExecItem
     assert type(fxn.jit_cache[0].prg).__name__.endswith('Graph')
-    assert len(fxn.jit_cache[0].prg.jit_cache) == expected_len, f"expected {expected_len}, got {len(fxn.jit_cache[0].prg.jit_cache)}"
+    assert len(fxn.jit_cache[0].prg.jit_cache) == expected_len
 
 def rand_for_dtype(dt:DType, size:int, allow_subnormal=True):
   if dtypes.is_unsigned(dt):

test/mockgpu/am/amdriver.py

@@ -1,127 +0,0 @@
-from __future__ import annotations
-import mmap, functools
-from tinygrad.runtime.autogen import libc
-from test.mockgpu.driver import VirtDriver, VirtFileDesc, TextFileDesc, DirFileDesc, VirtFile
-from test.mockgpu.am.amgpu import MockAMGPU, VRAM_SIZE
-
-DOORBELL_SIZE = 0x2000
-MMIO_SIZE = 2 << 20
-PCIBUS = "mock:am:0"
-
-_empty_bar = "0x0000000000000000 0x0000000000000000 0x0000000000000000"
-_resource_lines = [
-  f"0x0000000000000000 0x{VRAM_SIZE-1:016x} 0x0000000000000000", _empty_bar,
-  f"0x0000000000000000 0x{DOORBELL_SIZE-1:016x} 0x0000000000000000", _empty_bar, _empty_bar,
-  f"0x0000000000000000 0x{MMIO_SIZE-1:016x} 0x0000000000000000", _empty_bar,
-]
-
-class PagemapFileDesc(VirtFileDesc):
-  def __init__(self, fd, gpu):
-    super().__init__(fd)
-    self.gpu = gpu
-  def seek(self, offset): self.off = offset
-  def read_contents(self, size=None):
-    entries = bytearray()
-    for i in range((size or 8) // 8):
-      vaddr = ((self.off // 8) + i) * 0x1000
-      paddr = self.gpu._next_sysmem_paddr
-      self.gpu._next_sysmem_paddr += 0x1000
-      self.gpu._sysmem_map[paddr] = vaddr
-      entries += ((1 << 63) | (paddr // 0x1000)).to_bytes(8, 'little')
-    self.off += len(entries)
-    return bytes(entries)
-
-class PCIBarFileDesc(VirtFileDesc):
-  def __init__(self, fd, memfd, driver=None):
-    super().__init__(fd)
-    self.memfd, self.driver = memfd, driver
-  def mmap(self, start, sz, prot, flags, fd, off):
-    addr = libc.mmap(start, sz, prot, flags, self.memfd, off)
-    if self.driver is not None:
-      self.driver.track_address(addr, addr + sz, lambda mv, idx: None, lambda mv, idx: self.driver._emulate_execute())
-    return addr
-
-class PCIMMIOBarFileDesc(VirtFileDesc):
-  def __init__(self, fd, bar5_addr):
-    super().__init__(fd)
-    self.bar5_addr = bar5_addr
-  def mmap(self, start, sz, prot, flags, fd, off): return self.bar5_addr + off
-
-class PCIConfigFileDesc(VirtFileDesc):
-  def __init__(self, fd):
-    super().__init__(fd)
-    self.data = bytearray(256)
-  def read_contents(self, size=None): return bytes(self.data[self.off:self.off + (size or len(self.data) - self.off)])
-  def write_contents(self, content): self.data[self.off:self.off + len(content)] = content
-  def seek(self, offset): self.off = offset
-
-class PCIEnableFileDesc(VirtFileDesc):
-  def __init__(self, fd): super().__init__(fd)
-  def read_contents(self, size=None): return "1\n"
-  def write_contents(self, content): pass
-
-class AMDriver(VirtDriver):
-  def __init__(self):
-    super().__init__()
-    self.gpus:dict[int, MockAMGPU] = {}
-    self._executing = False
-    self.gpu = MockAMGPU(0)
-    self.gpus[0] = self.gpu
-    self.next_fd = 1 << 30
-
-    self._bar5_addr = libc.mmap(0, MMIO_SIZE, mmap.PROT_READ | mmap.PROT_WRITE, mmap.MAP_SHARED | mmap.MAP_ANONYMOUS, -1, 0)
-    mmio = self.gpu.mmio
-    self.track_address(self._bar5_addr, self._bar5_addr + MMIO_SIZE,
-      lambda mv, idx: _bar5_sync_read(mv, idx, mmio), lambda mv, idx: _bar5_sync_write(mv, idx, mmio))
-
-    p = f"/sys/bus/pci/devices/{PCIBUS}"
-    self.tracked_files += [
-      VirtFile("/proc/sys/vm/compact_unevictable_allowed", functools.partial(TextFileDesc, text="0\n")),
-      VirtFile("/proc/self/pagemap", functools.partial(PagemapFileDesc, gpu=self.gpu)),
-      VirtFile("/sys/bus/pci/devices", functools.partial(DirFileDesc, child_names=[PCIBUS])),
-      VirtFile(f"{p}/vendor", functools.partial(TextFileDesc, text="0x1002\n")),
-      VirtFile(f"{p}/device", functools.partial(TextFileDesc, text="0x74a1\n")),
-      VirtFile(f"{p}/enable", PCIEnableFileDesc),
-      VirtFile(f"{p}/config", PCIConfigFileDesc),
-      VirtFile(f"{p}/resource", functools.partial(TextFileDesc, text="\n".join(_resource_lines) + "\n")),
-      VirtFile(f"{p}/resource0", functools.partial(PCIBarFileDesc, memfd=self.gpu.vram_fd)),
-      VirtFile(f"{p}/resource2", functools.partial(PCIBarFileDesc, memfd=self.gpu.doorbell_fd, driver=self)),
-      VirtFile(f"{p}/resource5", functools.partial(PCIMMIOBarFileDesc, bar5_addr=self._bar5_addr)),
-    ]
-
-  def _alloc_fd(self):
-    fd = self.next_fd
-    self.next_fd += 1
-    return fd
-
-  def open(self, name, flags, mode, virtfile): return virtfile.fdcls(self._alloc_fd())
-
-  def _emulate_execute(self):
-    if self._executing: return
-    self._executing = True
-    try:
-      any_progress = True
-      while any_progress:
-        any_progress = False
-        for gpu in self.gpus.values():
-          for q in gpu.queues:
-            if q.executing: any_progress |= q.execute() > 0
-    finally:
-      self._executing = False
-
-def _bar5_sync_read(mv, idx, mmio):
-  if isinstance(idx, slice):
-    for i in range(idx.start or 0, idx.stop or len(mv), idx.step or 1): mv[i] = mmio[i]
-  else: mv[idx] = mmio[idx]
-
-def _bar5_sync_write(mv, idx, mmio):
-  if isinstance(idx, slice):
-    for i in range(idx.start or 0, idx.stop or len(mv), idx.step or 1): mmio[i] = mv[i]
-  else: mmio[idx] = mv[idx]
-
-class AMUSBDriver(AMDriver):
-  def __init__(self):
-    import test.mockgpu.usb as _musb
-    super().__init__()
-    self.state = _musb.MockASM24State(self.gpu, self, VRAM_SIZE, DOORBELL_SIZE, MMIO_SIZE)
-    _musb._mock_usb_state = self.state

test/mockgpu/am/amgpu.py

@@ -1,314 +0,0 @@
-# mypy: ignore-errors
-from __future__ import annotations
-import ctypes, ctypes.util, struct, functools, os, mmap
-from tinygrad.runtime.autogen.am import am
-from tinygrad.runtime.support.amd import AMDReg, import_asic_regs
-from test.mockgpu.amd.amdgpu import AMDGPU
-
-libc = ctypes.CDLL(ctypes.util.find_library("c"))
-libc.mmap.argtypes = [ctypes.c_void_p, ctypes.c_size_t, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_long]
-libc.mmap.restype = ctypes.c_void_p
-
-VRAM_SIZE = 512 << 20
-
-IP_VERSIONS = {
-  am.GC_HWIP: (12, 0, 0), am.SDMA0_HWIP: (7, 0, 0), am.MMHUB_HWIP: (4, 1, 0), am.NBIO_HWIP: (6, 3, 1),
-  am.MP0_HWIP: (14, 0, 2), am.MP1_HWIP: (14, 0, 2), am.HDP_HWIP: (7, 0, 0), am.OSSSYS_HWIP: (7, 0, 0),
-}
-
-def _pad(t, n=10): return t + (0,) * (n - len(t))
-IP_BASES = {
-  am.GC_HWIP:     _pad((0x00001260, 0x0000A000, 0x0001C000, 0x02402C00)),
-  am.SDMA0_HWIP:  _pad((0x00001260, 0x0000A000, 0x0001C000, 0x02402C00)),
-  am.MMHUB_HWIP:  _pad((0x0001A000, 0x02408800)),
-  am.NBIO_HWIP:   _pad((0x00000000, 0x00000014, 0x00000D20, 0x00010400, 0x0241B000, 0x04040000)),
-  am.MP0_HWIP:    _pad((0x00016000, 0x00DC0000, 0x00E00000, 0x00E40000, 0x0243FC00)),
-  am.MP1_HWIP:    _pad((0x00016000, 0x00DC0000, 0x00E00000, 0x00E40000, 0x0243FC00)),
-  am.HDP_HWIP:    _pad((0x00000F20, 0x0240A400)),
-  am.OSSSYS_HWIP: _pad((0x000010A0, 0x0240A000)),
-}
-
-IP_HWIDS = {hwip: am.hw_id_map[hwip] for hwip in IP_VERSIONS}
-
-GC_INFO = dict(gc_num_se=2, gc_num_cu_per_sh=8, gc_num_sh_per_se=2, gc_num_rb_per_se=4,
-               gc_num_tccs=8, gc_wave_size=32, gc_max_waves_per_simd=16, gc_max_scratch_slots_per_cu=32, gc_lds_size=64)
-
-def _build_ip_regs(prefix, hwip) -> dict[str, AMDReg]:
-  try: return import_asic_regs(prefix, IP_VERSIONS[hwip], cls=functools.partial(AMDReg, bases={0: IP_BASES[hwip]}))
-  except Exception: return {}
-
-class MockMMU:
-  def __init__(self, gpu:MockAMGPU):
-    self.gpu = gpu
-    self.tlb: dict[int, tuple[int, int, bool]] = {}
-
-  def invalidate(self, pt_base:int, va_base:int):
-    new_tlb: dict[int, tuple[int, int, bool]] = {}
-    self._walk(pt_base, 0, 0, new_tlb, va_base)
-    for va, (pa, sz, is_sys) in new_tlb.items():
-      old = self.tlb.get(va)
-      if not is_sys and (old is None or old[0] != pa): self.gpu.map_vram_at(va, pa, sz)
-      if old is None: self.gpu.map_range(va, sz)
-    self.tlb = new_tlb
-
-  def _walk(self, pt_paddr:int, level:int, va_acc:int, out:dict, va_base:int):
-    shift = [39, 30, 21, 12][level]
-    for i in range(512):
-      pte = struct.unpack_from('<Q', self.gpu.vram, pt_paddr + i * 8)[0]
-      if not (pte & am.AMDGPU_PTE_VALID): continue
-      va, pa = va_acc | (i << shift), pte & 0x0000FFFFFFFFF000
-      if level == 3 or (pte & am.AMDGPU_PDE_PTE_GFX12):
-        out[va_base + va] = (pa, 1 << shift, bool(pte & am.AMDGPU_PTE_SYSTEM))
-      else:
-        self._walk(pa, level + 1, va, out, va_base)
-
-  def paddr_to_host(self, paddr:int) -> int:
-    page, off = paddr & ~0xFFF, paddr & 0xFFF
-    if page in self.gpu._sysmem_map: return self.gpu._sysmem_map[page] + off
-    if paddr < VRAM_SIZE: return self.gpu.vram_addr + paddr
-    raise ValueError(f"paddr {paddr:#x} not found in sysmem_map or VRAM")
-
-  def addr_to_host(self, addr:int) -> int:
-    gmc = self.gpu.mmio.gmc
-    sys_lo = self.gpu.mmio.regs.get(gmc.reg('regMMMC_VM_SYSTEM_APERTURE_LOW_ADDR') or 0, 0) << 18
-    sys_hi = self.gpu.mmio.regs.get(gmc.reg('regMMMC_VM_SYSTEM_APERTURE_HIGH_ADDR') or 0, 0) << 18
-    if sys_lo <= addr < sys_hi: return self.paddr_to_host(addr - self.gpu.mc_base)
-    for tva, (pa, sz, is_sys) in self.tlb.items():
-      if tva <= addr < tva + sz:
-        paddr = pa + (addr - tva)
-        if not is_sys: return self.gpu.vram_addr + paddr
-        return self.paddr_to_host(paddr)
-    raise ValueError(f"addr {addr:#x} not mapped (sys_aperture=[{sys_lo:#x}, {sys_hi:#x}])")
-
-class MockIPBlock:
-  def __init__(self, gpu:MockAMGPU, mmio:MockMMIOInterface, regs:dict[str, AMDReg]):
-    self.gpu, self.mmio, self._regs = gpu, mmio, regs
-    self._n2a = {n: r.addr[0] for n, r in regs.items()}
-    self._a2n = {a: n for n, a in self._n2a.items()}
-    self.addrs = set(self._n2a.values())
-  def reg(self, name) -> int|None: return self._n2a.get(name)
-  def decode(self, name) -> dict: return self._regs[name].decode(self.mmio.regs.get(self._n2a[name], 0))
-  def read(self, reg:int) -> int: return self.mmio.regs.get(reg, 0)
-  def write(self, reg:int, val:int): self.mmio.regs[reg] = val
-  def _read_pair(self, pair) -> int:
-    if pair[0] is None: return 0
-    return self.mmio.regs.get(pair[0], 0) | (self.mmio.regs.get(pair[1], 0) << 32)
-
-class MockPSP(MockIPBlock):
-  def __init__(self, gpu, mmio):
-    super().__init__(gpu, mmio, _build_ip_regs('mp', am.MP0_HWIP))
-    self._sos_alive, self._ring_wptr = False, 0
-    pref = "regMPASP_SMN_C2PMSG" if IP_VERSIONS[am.MP0_HWIP] >= (14,0,0) else "regMP0_SMN_C2PMSG"
-    def r(n): return self.reg(f"{pref}_{n}")
-    self._c2pmsg_35, self._c2pmsg_64, self._c2pmsg_67 = r(35), r(64), r(67)
-    self._c2pmsg_69, self._c2pmsg_70, self._c2pmsg_81 = r(69), r(70), r(81)
-
-  def read(self, reg:int) -> int:
-    if reg == self._c2pmsg_35: return 0x80000000
-    if reg == self._c2pmsg_81: return 0x1 if self._sos_alive else 0x0
-    if reg == self._c2pmsg_64: return 0x80000000 if self._sos_alive else 0x0
-    if reg == self._c2pmsg_67: return self._ring_wptr
-    return super().read(reg)
-
-  def write(self, reg:int, val:int):
-    super().write(reg, val)
-    if reg == self._c2pmsg_35 and val == am.PSP_BL__LOAD_SOSDRV: self._sos_alive = True
-    if reg == self._c2pmsg_67: self._ring_submit(val)
-
-  def _ring_submit(self, new_wptr:int):
-    old_wptr = self._ring_wptr
-    self._ring_wptr = new_wptr
-    lo, hi = self._c2pmsg_69, self._c2pmsg_70
-    if lo is None or hi is None: return
-    ring_mc = self.mmio.regs.get(lo, 0) | (self.mmio.regs.get(hi, 0) << 32)
-    ring_paddr = ring_mc - self.gpu.mc_base
-    frame_off = ring_paddr + old_wptr * 4
-    frame = am.struct_psp_gfx_rb_frame.from_buffer_copy(bytes(self.gpu.vram[frame_off:frame_off + ctypes.sizeof(am.struct_psp_gfx_rb_frame)]))
-    fence_paddr = ((frame.fence_addr_hi << 32) | frame.fence_addr_lo) - self.gpu.mc_base
-    if 0 <= fence_paddr < len(self.gpu.vram):
-      struct.pack_into('<I', self.gpu.vram, fence_paddr, frame.fence_value)
-    cmd_paddr = ((frame.cmd_buf_addr_hi << 32) | frame.cmd_buf_addr_lo) - self.gpu.mc_base
-    if 0 <= cmd_paddr < len(self.gpu.vram):
-      struct.pack_into('<I', self.gpu.vram, cmd_paddr + 864, 0)
-
-class MockSMU(MockIPBlock):
-  def __init__(self, gpu, mmio):
-    try: regs = import_asic_regs('mp', (11, 0), cls=functools.partial(AMDReg, bases={0: IP_BASES[am.MP1_HWIP]}))
-    except Exception: regs = {}
-    super().__init__(gpu, mmio, regs)
-    self._msg_pending = False
-    def r(n): return self.reg(f"mmMP1_SMN_C2PMSG_{n}")
-    self._c2pmsg_53, self._c2pmsg_54, self._c2pmsg_66 = r(53), r(54), r(66)
-    self._c2pmsg_75, self._c2pmsg_82, self._c2pmsg_90 = r(75), r(82), r(90)
-
-  def read(self, reg:int) -> int:
-    if reg == self._c2pmsg_90 or reg == self._c2pmsg_54: return 0x1 if self._msg_pending else super().read(reg)
-    if reg == self._c2pmsg_82: return self.mmio.regs.get(reg, 3)
-    return super().read(reg)
-
-  def write(self, reg:int, val:int):
-    super().write(reg, val)
-    if reg == self._c2pmsg_66 or reg == self._c2pmsg_75: self._msg_pending = True
-    if (reg == self._c2pmsg_90 or reg == self._c2pmsg_54) and val == 0: self._msg_pending = False
-
-class MockSDMA(MockIPBlock):
-  def __init__(self, gpu, mmio):
-    all_gc = _build_ip_regs('gc', am.GC_HWIP)
-    super().__init__(gpu, mmio, {n: r for n, r in all_gc.items() if 'SDMA' in n})
-
-  def write(self, reg:int, val:int):
-    super().write(reg, val)
-    name = self._a2n.get(reg, '')
-    if name.endswith('_RB_CNTL') and self._regs[name].decode(val).get('rb_enable', 0):
-      self._activate_queue(name.rsplit('_RB_CNTL', 1)[0])
-
-  def _activate_queue(self, prefix:str):
-    ring_addr = self._read_pair((self.reg(f'{prefix}_RB_BASE'), self.reg(f'{prefix}_RB_BASE_HI'))) << 8
-    rptr_addr = self._read_pair((self.reg(f'{prefix}_RB_RPTR_ADDR_LO'), self.reg(f'{prefix}_RB_RPTR_ADDR_HI')))
-    wptr_addr = self._read_pair((self.reg(f'{prefix}_RB_WPTR_POLL_ADDR_LO'), self.reg(f'{prefix}_RB_WPTR_POLL_ADDR_HI')))
-    rb_size = self.decode(f'{prefix}_RB_CNTL')['rb_size']
-    self.gpu.add_sdma_queue(self.gpu.mmu.addr_to_host(ring_addr), 4 << rb_size,
-                            self.gpu.mmu.addr_to_host(rptr_addr), self.gpu.mmu.addr_to_host(wptr_addr))
-
-class MockGFX(MockIPBlock):
-  def __init__(self, gpu, mmio):
-    super().__init__(gpu, mmio, _build_ip_regs('gc', am.GC_HWIP))
-    self._pt_base = (self.reg('regGCVM_CONTEXT0_PAGE_TABLE_BASE_ADDR_LO32'), self.reg('regGCVM_CONTEXT0_PAGE_TABLE_BASE_ADDR_HI32'))
-    self._pt_start = (self.reg('regGCVM_CONTEXT0_PAGE_TABLE_START_ADDR_LO32'), self.reg('regGCVM_CONTEXT0_PAGE_TABLE_START_ADDR_HI32'))
-    self._gc_inv_ack = self.reg('regGCVM_INVALIDATE_ENG17_ACK')
-    self._gc_inv_req = self.reg('regGCVM_INVALIDATE_ENG17_REQ')
-    self._hqd_active = self.reg('regCP_HQD_ACTIVE')
-
-  def read(self, reg:int) -> int:
-    if reg == self.reg('regCP_STAT') or reg == self.reg('regRLC_SAFE_MODE'): return 0
-    if reg == self.reg('regRLC_RLCS_BOOTLOAD_STATUS'): return 0x2
-    if reg == self._gc_inv_ack: return 0x1
-    return super().read(reg)
-
-  def write(self, reg:int, val:int):
-    super().write(reg, val)
-    if reg == self.reg('regCP_HQD_DEQUEUE_REQUEST'):
-      if self._hqd_active is not None: self.mmio.regs[self._hqd_active] = 0
-    if reg == self._hqd_active and val == 1: self._activate_pm4_queue()
-    if reg == self._gc_inv_req: self.gpu.mmu.invalidate(self.get_pt_base(), self.get_va_base())
-
-  def _activate_pm4_queue(self):
-    ring_addr = self._read_pair((self.reg('regCP_HQD_PQ_BASE'), self.reg('regCP_HQD_PQ_BASE_HI'))) << 8
-    rptr_addr = self._read_pair((self.reg('regCP_HQD_PQ_RPTR_REPORT_ADDR'), self.reg('regCP_HQD_PQ_RPTR_REPORT_ADDR_HI')))
-    wptr_addr = self._read_pair((self.reg('regCP_HQD_PQ_WPTR_POLL_ADDR'), self.reg('regCP_HQD_PQ_WPTR_POLL_ADDR_HI')))
-    queue_size = self.decode('regCP_HQD_PQ_CONTROL')['queue_size']
-    self.gpu.add_pm4_queue(self.gpu.mmu.addr_to_host(ring_addr), 4 << (queue_size + 1),
-                           self.gpu.mmu.addr_to_host(rptr_addr), self.gpu.mmu.addr_to_host(wptr_addr))
-
-  def get_pt_base(self) -> int: return self._read_pair(self._pt_base) & 0x0000FFFFFFFFF000
-  def get_va_base(self) -> int: return self._read_pair(self._pt_start) << 12
-
-class MockGMC(MockIPBlock):
-  def __init__(self, gpu, mmio, gfx:MockGFX):
-    super().__init__(gpu, mmio, _build_ip_regs('mmhub', am.MMHUB_HWIP))
-    self._gfx = gfx
-    self._inv_ack = self.reg('regMMVM_INVALIDATE_ENG17_ACK')
-    self._inv_sem = self.reg('regMMVM_INVALIDATE_ENG17_SEM')
-    self._inv_req = self.reg('regMMVM_INVALIDATE_ENG17_REQ')
-    self._fb_loc_top = self.reg('regMMMC_VM_FB_LOCATION_TOP')
-
-  def read(self, reg:int) -> int:
-    if reg == self._inv_ack or reg == self._inv_sem: return 0x1
-    if reg == self._fb_loc_top: return VRAM_SIZE >> 24
-    return super().read(reg)
-
-  def write(self, reg:int, val:int):
-    super().write(reg, val)
-    if reg == self._inv_req: self.gpu.mmu.invalidate(self._gfx.get_pt_base(), self._gfx.get_va_base())
-
-class MockNBIO(MockIPBlock):
-  def __init__(self, gpu, mmio):
-    regs = _build_ip_regs('nbif', am.NBIO_HWIP)
-    regs.update(_build_ip_regs('hdp', am.HDP_HWIP))
-    super().__init__(gpu, mmio, regs)
-    self._remap_hdp = self.reg('regBIF_BX0_REMAP_HDP_MEM_FLUSH_CNTL')
-    self._hdp_flush = self.reg('regHDP_MEM_FLUSH_CNTL')
-
-  def read(self, reg:int) -> int:
-    if reg == self._remap_hdp and self._hdp_flush is not None: return self._hdp_flush * 4
-    return super().read(reg)
-
-class MockMMIOInterface:
-  def __init__(self, gpu:MockAMGPU):
-    self.gpu = gpu
-    self.regs: dict[int, int] = {}
-    gfx = MockGFX(gpu, self)
-    self.gmc = MockGMC(gpu, self, gfx)
-    self.blocks = [MockPSP(gpu, self), MockSMU(gpu, self), MockSDMA(gpu, self), gfx, self.gmc, MockNBIO(gpu, self)]
-    self._addr_block: dict[int, MockIPBlock] = {}
-    for block in self.blocks:
-      for addr in block.addrs: self._addr_block.setdefault(addr, block)
-
-  def __getitem__(self, index:int|slice) -> int|list[int]:
-    if isinstance(index, slice): return [self[i] for i in range(index.start or 0, index.stop or 0, index.step or 1)]  # type: ignore[misc]
-    if index == 0xde3: return VRAM_SIZE >> 20
-    if block := self._addr_block.get(index): return block.read(index)
-    return self.regs.get(index, 0)
-
-  def __setitem__(self, index:int|slice, val:int|list[int]|tuple[int, ...]):
-    if isinstance(index, slice):
-      vals = val if isinstance(val, (list, tuple)) else [val] * ((index.stop - index.start) // (index.step or 1))  # type: ignore[operator]
-      for i, v in zip(range(index.start or 0, index.stop or 0, index.step or 1), vals): self[i] = v
-      return
-    assert isinstance(val, int)
-    self.regs[index] = val
-    if block := self._addr_block.get(index): block.write(index, val)
-
-  def __len__(self): return 0x10000000
-
-class MockAMGPU(AMDGPU):
-  def __init__(self, gpuid:int=0):
-    super().__init__(gpuid)
-    self.vram_fd = os.memfd_create("vram")
-    os.ftruncate(self.vram_fd, VRAM_SIZE)
-    self.vram_addr = libc.mmap(0, VRAM_SIZE, mmap.PROT_READ | mmap.PROT_WRITE, mmap.MAP_SHARED, self.vram_fd, 0)
-    self.vram = (ctypes.c_ubyte * VRAM_SIZE).from_address(self.vram_addr)
-    self.doorbell_fd = os.memfd_create("doorbell")
-    os.ftruncate(self.doorbell_fd, 0x2000)
-    self.arch = "rdna4"
-    self._sysmem_map:dict[int,int] = {}
-    self._next_sysmem_paddr = 0x100000000
-    self.mmu = MockMMU(self)
-    self.mmio = MockMMIOInterface(self)
-    self._preboot()
-
-  def translate_addr(self, addr:int) -> int: return self.mmu.addr_to_host(addr)
-
-  def map_vram_at(self, va:int, paddr:int, size:int):
-    libc.mmap(va, size, mmap.PROT_READ | mmap.PROT_WRITE, mmap.MAP_SHARED | 0x10, self.vram_fd, paddr)
-
-  def _preboot(self):
-    ip_data = bytearray()
-    for hwip, (major, minor, rev) in IP_VERSIONS.items():
-      ip = am.struct_ip_v4(hw_id=IP_HWIDS[hwip], num_base_address=len(IP_BASES[hwip]), major=major, minor=minor, revision=rev)
-      ip_data += bytes(ip) + b'\x00'
-      for b in IP_BASES[hwip]: ip_data += struct.pack('<I', b)
-
-    dhdr = am.struct_die_header(num_ips=len(IP_VERSIONS))
-    ihdr = am.struct_ip_discovery_header(signature=am.DISCOVERY_TABLE_SIGNATURE, version=4, num_dies=1)
-    ip_disc_off = ctypes.sizeof(am.struct_binary_header)
-    ihdr.die_info[0].die_offset = ip_disc_off + ctypes.sizeof(am.struct_ip_discovery_header)
-
-    gc = am.struct_gc_info_v2_1()
-    gc.header.table_id, gc.header.version_major, gc.header.version_minor = am.GC, 2, 1
-    gc.header.size = ctypes.sizeof(am.struct_gc_info_v2_1)
-    for field, val in GC_INFO.items(): setattr(gc, field, val)
-
-    gc_off = ip_disc_off + ctypes.sizeof(am.struct_ip_discovery_header) + ctypes.sizeof(am.struct_die_header) + len(ip_data)
-    bhdr = am.struct_binary_header(binary_signature=am.BINARY_SIGNATURE)
-    bhdr.table_list[am.IP_DISCOVERY].offset = ip_disc_off
-    bhdr.table_list[am.GC].offset = gc_off
-
-    tbl = bytes(bhdr) + bytes(ihdr) + bytes(dhdr) + ip_data + bytes(gc)
-    tbl_offset = VRAM_SIZE - (64 << 10)
-    self.vram[tbl_offset:tbl_offset + len(tbl)] = list(tbl)
-
-  @property
-  def mc_base(self) -> int:
-    fb_loc_base = self.mmio.gmc.reg('regMMMC_VM_FB_LOCATION_BASE') or 0
-    return (self.mmio.regs.get(fb_loc_base, 0) & 0xFFFFFF) << 24

test/mockgpu/amd/amdgpu.py

@@ -127,7 +127,7 @@ class PM4Executor(AMDQueue):
     val = val_lo + (val_hi << 32)
     _ = self._next_dword() # ev
 
-    ptr = to_mv(self.gpu.translate_addr(addr_lo + (addr_hi << 32)), 8)
+    ptr = to_mv(addr_lo + (addr_hi << 32), 8)
     if mem_data_sel == 1 or mem_data_sel == 2: ptr.cast('Q')[0] = val
     elif mem_data_sel == 3:
       if mem_event_type == CACHE_FLUSH_AND_INV_TS_EVENT: ptr.cast('Q')[0] = int(time.perf_counter() * 1e8)
@@ -143,7 +143,7 @@ class PM4Executor(AMDQueue):
     dst_addr_lo = self._next_dword()
     dst_addr_hi = self._next_dword()
     assert copy_data_flags in {0x100204, 0x000204}, hex(copy_data_flags) # better fail than silently do the wrong thing
-    to_mv(self.gpu.translate_addr(dst_addr_hi<<32|dst_addr_lo), 4).cast('I')[0] = self.gpu.regs[src_addr_lo]
+    to_mv(dst_addr_hi<<32|dst_addr_lo, 4).cast('I')[0] = self.gpu.regs[src_addr_lo]
 
   def _exec_wait_reg_mem(self, n):
     assert n == 5
@@ -161,7 +161,7 @@ class PM4Executor(AMDQueue):
 
     if mem_space == 0 and mem_op == 1: mval = val # hack for memory barrier, should properly handle (req_req, reg_done)
     elif mem_space == 0: mval = self.gpu.regs[addr_hi<<32|addr_lo]
-    elif mem_space == 1: mval = to_mv(self.gpu.translate_addr(addr_lo + (addr_hi << 32)), 4).cast('I')[0]
+    elif mem_space == 1: mval = to_mv(addr_lo + (addr_hi << 32), 4).cast('I')[0]
 
     mval &= mask
 
@@ -225,7 +225,7 @@ class PM4Executor(AMDQueue):
     wptr = memoryview(bytearray(8)).cast('Q')
     rptr[0] = 0
     wptr[0] = buf_sz
-    self.ib_executor = PM4Executor(self.gpu, self.gpu.translate_addr((addr_hi << 32) | addr_lo), buf_sz * 4, rptr, wptr)
+    self.ib_executor = PM4Executor(self.gpu, (addr_hi << 32) | addr_lo, buf_sz * 4, rptr, wptr)
 
   def _exec_event_write(self, n):
     assert n == 0
@@ -276,7 +276,7 @@ class SDMAExecutor(AMDQueue):
 
   def _execute_fence(self):
     struct = sdma_pkts.fence.from_address(self.base + self.rptr[0] % self.size)
-    to_mv(self.gpu.translate_addr(struct.addr), 8).cast('Q')[0] = struct.data
+    to_mv(struct.addr, 8).cast('Q')[0] = struct.data
     self.rptr[0] += ctypes.sizeof(struct)
 
   def _execute_trap(self):
@@ -287,7 +287,7 @@ class SDMAExecutor(AMDQueue):
     struct = sdma_pkts.poll_regmem.from_address(self.base + self.rptr[0] % self.size)
 
     if struct.mem_poll == 0: mval = struct.value & struct.mask
-    elif struct.mem_poll == 1: mval = to_mv(self.gpu.translate_addr(struct.addr), 4).cast('I')[0] & struct.mask
+    elif struct.mem_poll == 1: mval = to_mv(struct.addr, 4).cast('I')[0] & struct.mask
 
     if struct.func == WAIT_REG_MEM_FUNCTION_GEQ: can_cont = bool(mval >= struct.value)
     elif struct.func == WAIT_REG_MEM_FUNCTION_EQ: can_cont = bool(mval == struct.value)
@@ -302,7 +302,7 @@ class SDMAExecutor(AMDQueue):
   def _execute_timestamp(self):
     struct = sdma_pkts.timestamp.from_address(self.base + self.rptr[0] % self.size)
 
-    mem = to_mv(self.gpu.translate_addr(struct.addr), 8).cast('Q')
+    mem = to_mv(struct.addr, 8).cast('Q')
     mem[0] = int(time.perf_counter() * 1e8)
 
     self.rptr[0] += ctypes.sizeof(struct)
@@ -313,8 +313,8 @@ class SDMAExecutor(AMDQueue):
 
   def _execute_copy(self):
     struct = sdma_pkts.copy_linear.from_address(self.base + self.rptr[0] % self.size)
-    count_cnt = to_mv(self.base + self.rptr[0] % self.size + 4, 4).cast('I')[0] & 0x3FFFFFFF
-    ctypes.memmove(self.gpu.translate_addr(struct.dst_addr), self.gpu.translate_addr(struct.src_addr), count_cnt + 1)
+    count_cnt = to_mv(self.base + self.rptr[0] + 4, 4).cast('I')[0] & 0x3FFFFFFF
+    ctypes.memmove(struct.dst_addr, struct.src_addr, count_cnt + 1)
     self.rptr[0] += ctypes.sizeof(struct)
 
 class AMDGPURegisters:
@@ -343,7 +343,6 @@ class AMDGPU(VirtGPU):
     self.queues = []
     self.arch = "cdna" if MOCKGPU_ARCH == "cdna4" else MOCKGPU_ARCH
 
-  def translate_addr(self, addr:int) -> int: return addr
   def map_range(self, vaddr, size): self.mapped_ranges.add((vaddr, size))
   def unmap_range(self, vaddr, size): self.mapped_ranges.remove((vaddr, size))
   def add_pm4_queue(self, base, size, rptr, wptr):

test/mockgpu/mockgpu.py

@@ -1,9 +1,7 @@
 import ctypes, ctypes.util, time, os, builtins, fcntl
-from tinygrad.helpers import getenv
 from tinygrad.runtime.support.hcq import FileIOInterface
 from test.mockgpu.nv.nvdriver import NVDriver
 from test.mockgpu.amd.amddriver import AMDDriver
-from test.mockgpu.am.amdriver import AMDriver, AMUSBDriver
 start = time.perf_counter()
 
 # *** ioctl lib ***
@@ -11,8 +9,7 @@ libc = ctypes.CDLL(ctypes.util.find_library("c"))
 libc.mmap.argtypes = [ctypes.c_void_p, ctypes.c_size_t, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_long]
 libc.mmap.restype = ctypes.c_void_p
 
-_amd_iface = getenv("AMD_IFACE", "")
-drivers = [NVDriver(), AMDriver() if _amd_iface == "PCI" else (AMUSBDriver() if _amd_iface == "USB" else AMDDriver())]
+drivers = [AMDDriver(), NVDriver()]
 tracked_fds = {}
 
 original_memoryview = builtins.memoryview
@@ -80,10 +77,9 @@ class MockFileIOInterface(FileIOInterface):
     return libc.mmap(start, sz, prot, flags, self.fd, offset)
 
   def read(self, size=None, binary=False, offset=None):
-    if self.fd in tracked_fds:
-      if offset is not None: tracked_fds[self.fd].seek(offset)
-      return tracked_fds[self.fd].read_contents(size)
     if binary: raise NotImplementedError()
+    if self.fd in tracked_fds:
+      return tracked_fds[self.fd].read_contents(size)
     with open(self.fd, "rb" if binary else "r", closefd=False) as file:
       if file.tell() >= os.fstat(self.fd).st_size: file.seek(0)
       return file.read(size)
@@ -93,20 +89,13 @@ class MockFileIOInterface(FileIOInterface):
       return tracked_fds[self.fd].list_contents()
     return os.listdir(self.path)
 
-  def write(self, content, binary=False, offset=None):
-    if self.fd in tracked_fds:
-      if offset is not None: tracked_fds[self.fd].seek(offset)
-      return tracked_fds[self.fd].write_contents(content)
-    raise NotImplementedError()
+  def write(self, content, binary=False, offset=None): raise NotImplementedError()
   def seek(self, offset):
     if self.fd in tracked_fds:
       tracked_fds[self.fd].seek(offset)
     else:
       os.lseek(self.fd, offset, os.SEEK_CUR)
   @staticmethod
-  def anon_mmap(start, sz, prot, flags, offset):
-    return FileIOInterface._mmap(start, sz, prot, flags & ~0x4a000, -1, offset)  # strip MAP_LOCKED|MAP_POPULATE|MAP_HUGETLB
-  @staticmethod
   def exists(path): return _open(path, os.O_RDONLY) is not None
   @staticmethod
   def readlink(path): raise NotImplementedError()

test/mockgpu/usb.py

@@ -1,213 +1,16 @@
-from __future__ import annotations
-import ctypes, mmap, struct, sys
-if sys.platform != "win32": from tinygrad.runtime.autogen import libc
-
 class MockUSB:
   def __init__(self, mem):
     self.mem = mem
-  def read(self, address, size): return bytes(self.mem[address:address+size])
-  def write(self, address, data, ignore_cache=False): self.mem[address:address+len(data)] = data
+
+  def read(self, address, size):
+    return bytes(self.mem[address:address+size])
+
+  def write(self, address, data, ignore_cache=False):
+    self.mem[address:address+len(data)] = data
+
   def pcie_mem_req(self, address, value=None, size=1):
     if value is None: return int.from_bytes(self.mem[address:address+size], "little")
     else: self.mem[address:address+size] = value.to_bytes(size, "little")
+
   def pcie_mem_write(self, address, values, size):
     for i, value in enumerate(values): self.pcie_mem_req(address + i * size, value, size)
-
-# *** ASM24 Controller Mock ***
-
-_mock_usb_state: MockASM24State|None = None
-
-class MockASM24State:
-  """Mock ASM24 controller: XRAM memory map, DMA windows, TLP engine, PCI config space.
-
-  Memory map (64KB XRAM):
-    0xA000-0xAFFF: DMA window -> sys 0x820000
-    0xB000-0xB1FF: DMA window -> sys 0x800000
-    0xB200-0xB7FF: PCI MMIO (TLP engine)
-    0xF000-0xFFFF: DMA window -> sys 0x200000 (512KB)
-  """
-  XRAM_SIZE = 0x10000
-
-  TLP_FMT_TYPE = 0xB210
-  TLP_BYTE_EN = 0xB217
-  TLP_ADDR_LO = 0xB218
-  TLP_ADDR_HI = 0xB21C
-  TLP_DATA = 0xB220
-  TLP_COMPL = 0xB22A
-  TLP_TRIGGER = 0xB254
-  TLP_LINK_STATUS = 0xB284
-  TLP_STATUS = 0xB296
-
-  def __init__(self, gpu, driver, vram_size:int, doorbell_size:int, mmio_size:int):
-    self.gpu, self.driver = gpu, driver
-    self._xram = bytearray(self.XRAM_SIZE)
-
-    self._doorbell_addr = libc.mmap(0, doorbell_size, mmap.PROT_READ | mmap.PROT_WRITE, mmap.MAP_SHARED, gpu.doorbell_fd, 0)
-    self._doorbell = (ctypes.c_ubyte * doorbell_size).from_address(self._doorbell_addr)
-
-    # DMA windows: ctrl_addr -> (host_addr, size)
-    self._dma_regions: dict[int, tuple[int, int]] = {}
-    self._add_dma_window(0xF000, 0x200000, 0x80000)
-    self._add_dma_window(0xA000, 0x820000, 0x1000)
-    self._add_dma_window(0xB000, 0x800000, 0x200)
-
-    # PCI config space: (bus,dev,fn) -> bytearray(4096)
-    self._pci_cfg: dict[tuple[int,int,int], bytearray] = {}
-
-    # GPU BAR definitions: reg_offset -> (size, type_bits, is_64bit)
-    self._gpu_bars: dict[int, tuple[int, int, bool]] = {
-      0x10: (vram_size, 0x0C, True),       # BAR0: VRAM, 64-bit prefetchable
-      0x18: (doorbell_size, 0x00, False),   # BAR2: doorbell, 32-bit
-      0x1C: (0, 0x00, False),              # BAR3: unused
-      0x20: (0, 0x00, False),              # BAR4: unused
-      0x24: (mmio_size, 0x00, False),      # BAR5: MMIO, 32-bit
-    }
-    self._bar_addrs: dict[int, tuple[int, int]] = {}  # reg_offset -> (addr, size)
-
-    # Initialize GPU config space (bus=4, dev=0, fn=0) with BAR type bits and REBAR capability
-    gpu_cfg = self._get_cfg(4, 0, 0)
-    for reg_off, (sz, type_bits, _) in self._gpu_bars.items():
-      if sz > 0: struct.pack_into('<I', gpu_cfg, reg_off, type_bits)
-    struct.pack_into('<I', gpu_cfg, 0x100, 0x15 | (1 << 16))  # REBAR cap header: id=0x15, version=1, next=0
-    struct.pack_into('<I', gpu_cfg, 0x104, sum(1 << (i + 4) for i in range(10)))  # supported sizes up to 512MB
-
-  def _get_cfg(self, bus:int, dev:int, fn:int) -> bytearray:
-    if (key:=(bus, dev, fn)) not in self._pci_cfg: self._pci_cfg[key] = bytearray(4096)
-    return self._pci_cfg[key]
-
-  def _add_dma_window(self, ctrl_addr:int, sys_addr:int, size:int):
-    host_addr = libc.mmap(0, size, mmap.PROT_READ | mmap.PROT_WRITE, mmap.MAP_SHARED | mmap.MAP_ANONYMOUS, -1, 0)
-    self._dma_regions[ctrl_addr] = (host_addr, size)
-    for off in range(0, size, 0x1000): self.gpu._sysmem_map[sys_addr + off] = host_addr + off
-
-  # --- XRAM access ---
-
-  def _xram_read(self, addr:int, length:int) -> bytes:
-    for ctrl_addr, (host_addr, dma_size) in self._dma_regions.items():
-      if ctrl_addr <= addr < ctrl_addr + dma_size:
-        return bytes((ctypes.c_ubyte * length).from_address(host_addr + (addr - ctrl_addr)))
-    return bytes(self._xram[addr:addr+length])
-
-  def _xram_write_byte(self, addr:int, value:int):
-    for ctrl_addr, (host_addr, dma_size) in self._dma_regions.items():
-      if ctrl_addr <= addr < ctrl_addr + dma_size:
-        (ctypes.c_ubyte * 1).from_address(host_addr + (addr - ctrl_addr))[0] = value
-        return
-    if addr == self.TLP_STATUS:
-      self._xram[addr] &= ~value & 0xFF
-      return
-    self._xram[addr] = value
-    if addr == self.TLP_TRIGGER and value == 0x0F: self._process_tlp()
-
-  # --- TLP engine ---
-
-  def _process_tlp(self):
-    fmt_type, byte_en = self._xram[self.TLP_FMT_TYPE], self._xram[self.TLP_BYTE_EN]
-    addr_lo = int.from_bytes(self._xram[self.TLP_ADDR_LO:self.TLP_ADDR_LO+4], 'big')
-    addr_hi = int.from_bytes(self._xram[self.TLP_ADDR_HI:self.TLP_ADDR_HI+4], 'big')
-    address = addr_lo | (addr_hi << 32)
-
-    size, offset, tmp = 0, 0, byte_en
-    while tmp and not (tmp & 1):
-      offset += 1
-      tmp >>= 1
-    while tmp:
-      size += tmp & 1
-      tmp >>= 1
-
-    is_write, is_cfg = bool(fmt_type & 0x40), (fmt_type & 0xbe) == 0x04
-
-    if is_cfg:
-      bus, dev, fn, byte_addr = (address >> 24) & 0xFF, (address >> 19) & 0x1F, (address >> 16) & 0x7, address & 0xFFC
-      if is_write:
-        data = int.from_bytes(self._xram[self.TLP_DATA:self.TLP_DATA+4], 'big')
-        self._cfg_write(bus, dev, fn, byte_addr + offset, (data >> (8 * offset)) & ((1 << (8 * size)) - 1), size)
-      else:
-        self._xram[self.TLP_DATA:self.TLP_DATA+4] = int.from_bytes(self._get_cfg(bus, dev, fn)[byte_addr:byte_addr+4], 'little').to_bytes(4, 'big')
-      self._xram[self.TLP_COMPL:self.TLP_COMPL+2] = (4).to_bytes(2, 'big')
-      self._xram[self.TLP_LINK_STATUS] = 0x01 if not is_write else 0x00
-      self._xram[self.TLP_STATUS] = 0x02
-      return
-
-    if is_write:
-      data = int.from_bytes(self._xram[self.TLP_DATA:self.TLP_DATA+4], 'big')
-      self._pcie_dispatch(address + offset, (data >> (8 * offset)) & ((1 << (8 * size)) - 1), size)
-    else:
-      result = self._pcie_dispatch(address + offset, None, size)
-      if result is not None:
-        self._xram[self.TLP_DATA:self.TLP_DATA+4] = ((result << (8 * offset)) & 0xFFFFFFFF).to_bytes(4, 'big')
-
-    self._xram[self.TLP_COMPL:self.TLP_COMPL+2] = (size & 0xFFF).to_bytes(2, 'big')
-    self._xram[self.TLP_LINK_STATUS] = 0x01 if not is_write else 0x00
-    self._xram[self.TLP_STATUS] = 0x02
-
-  def _cfg_write(self, bus:int, dev:int, fn:int, byte_addr:int, val:int, size:int):
-    cfg = self._get_cfg(bus, dev, fn)
-
-    # Handle BAR register writes for GPU device (bus=4, dev=0, fn=0)
-    if (bus, dev, fn) == (4, 0, 0) and 0x10 <= byte_addr < 0x28 and size == 4:
-      reg_off = byte_addr & ~0x3
-      if (bar_def:=self._gpu_bars.get(reg_off)) is not None:
-        bar_size, type_bits, is_64 = bar_def
-        if bar_size == 0: return  # unused BAR
-        if val == 0xFFFFFFFF:  # size probe
-          struct.pack_into('<I', cfg, reg_off, (~(bar_size - 1)) & 0xFFFFFFF0 | type_bits)
-        else:
-          struct.pack_into('<I', cfg, reg_off, val)
-          hi = struct.unpack_from('<I', cfg, reg_off + 4)[0] if is_64 else 0
-          self._bar_addrs[reg_off] = ((hi << 32) | (val & ~0xF), bar_size)
-        return
-      # Check if upper 32 bits of a 64-bit BAR
-      for breg, (bsz, _, b64) in self._gpu_bars.items():
-        if b64 and reg_off == breg + 4:
-          struct.pack_into('<I', cfg, reg_off, 0xFFFFFFFF if val == 0xFFFFFFFF else val)
-          if val != 0xFFFFFFFF:
-            self._bar_addrs[breg] = ((val << 32) | (struct.unpack_from('<I', cfg, breg)[0] & ~0xF), bsz)
-          return
-
-    # Generic config write
-    for i in range(size): cfg[byte_addr + i] = (val >> (8 * i)) & 0xFF
-
-  def _pcie_dispatch(self, address:int, value:int|None, size:int) -> int|None:
-    for reg_off, (bar_addr, bar_size) in self._bar_addrs.items():
-      if bar_addr <= address < bar_addr + bar_size:
-        offset = address - bar_addr
-        if reg_off == 0x10:  # BAR0 - VRAM
-          if value is None: return int.from_bytes(bytes(self.gpu.vram[offset:offset+size]), "little")
-          self.gpu.vram[offset:offset+size] = list(value.to_bytes(size, "little"))
-          return None
-        if reg_off == 0x18:  # BAR2 - Doorbell
-          if value is None: return int.from_bytes(bytes(self._doorbell[offset:offset+size]), "little")
-          for i, b in enumerate(value.to_bytes(size, "little")): self._doorbell[offset + i] = b
-          self.driver._emulate_execute()
-          return None
-        if reg_off == 0x24:  # BAR5 - MMIO
-          if value is None: return self.gpu.mmio[offset // 4]
-          self.gpu.mmio[offset // 4] = value
-          return None
-    raise ValueError(f"PCIe address {address:#x} not mapped to any BAR")
-
-  # --- CDB processing (called by MockUSB3.send_batch) ---
-
-  def process_cdb(self, cdb:bytes, rlen:int, send_data:bytes|None) -> bytes|None:
-    op = cdb[0]
-    if op == 0xE5:  # write byte
-      self._xram_write_byte(((cdb[2] << 16) | (cdb[3] << 8) | cdb[4]) & 0xFFFF, cdb[1])
-      return None
-    if op == 0xE4:  # read
-      return self._xram_read(((cdb[2] << 16) | (cdb[3] << 8) | cdb[4]) & 0xFFFF, cdb[1])
-    if op == 0x8A and send_data is not None and 0xF000 in self._dma_regions:  # SCSI write
-      host_addr, dma_size = self._dma_regions[0xF000]
-      ctypes.memmove(host_addr, send_data, min(len(send_data), dma_size))
-    return None
-
-class MockUSB3:
-  def __init__(self, *args, **kwargs): pass
-  def send_batch(self, cdbs:list[bytes], idata:list[int]|None=None, odata:list[bytes|None]|None=None) -> list[bytes|None]:
-    assert _mock_usb_state is not None
-    idata, odata = idata or [0] * len(cdbs), odata or [None] * len(cdbs)
-    results: list[bytes|None] = []
-    for cdb, rlen, sdata in zip(cdbs, idata, odata):
-      result = _mock_usb_state.process_cdb(cdb, rlen, sdata)
-      results.append(result if rlen > 0 else None)
-    return results

test/null/test_const_folding.py

@@ -9,9 +9,7 @@ def _check_ast_count(desired_count:int, t:Tensor):
   # NOTE: this has side effect because everything can be scheduled only once
   schedule = t.schedule()
   asts = [s for s in schedule if s.ast.op is Ops.SINK]
-  len(asts)
-  # NOT SUPPORTED ANYMORE
-  #assert len(asts) == desired_count, f"{len(asts)} != {desired_count}"
+  assert len(asts) == desired_count, f"{len(asts)} != {desired_count}"
 
 class TestUnaryOpsConstFolding(unittest.TestCase):
   def test_all_consts_ops(self):

test/null/test_gpudims.py

@@ -1,101 +0,0 @@
-import unittest, math
-import z3
-from tinygrad.codegen.gpudims import get_grouped_dims
-from tinygrad.uop.ops import UOp, Ops
-from tinygrad.uop.validate import uops_to_z3
-from tinygrad.dtype import dtypes
-from tinygrad.helpers import flatten, dedup
-
-class TestGroupedDims(unittest.TestCase):
-  def _check_grouped_dims(self, prefix, dims, max_sizes, reverse, expected_sizes, assert_same_length=True):
-    idxs = get_grouped_dims(prefix, dims, max_sizes, reverse)
-    loop_idxs = dedup(flatten([[y for y in x.toposort() if y.op is Ops.SPECIAL] for x in idxs]))
-    loop_idxs = sorted(loop_idxs, key=lambda uop: uop.arg)
-    sizes = [x.src[0].arg for x in loop_idxs]
-    assert len(idxs) == len(dims), f"expected idxs to have same length as dims {len(dims)}, got {len(idxs)}"
-    if assert_same_length:
-      assert len(loop_idxs) == min(len(sizes), len(dims)), f"expected idxs to have length {min(len(sizes), len(dims))}, got {len(loop_idxs)}"
-    assert sizes == expected_sizes, f"expected sizes={expected_sizes}, got {sizes=}"
-    self._verify_indices_z3(idxs, dims)
-
-  def _verify_indices_z3(self, idxs, dims):
-    """Use z3 to prove bijectivity: bounds (0 <= flat < total) + injectivity (different inputs => different flat)."""
-    total = math.prod(dims)
-    specials = sorted(dedup(flatten([[y for y in x.toposort() if y.op is Ops.SPECIAL] for x in idxs])), key=lambda u: u.arg)
-    # build flat index and primed flat (same expression with renamed SPECIALs)
-    flat = UOp.const(dtypes.index, 0)
-    for i, idx in enumerate(idxs):
-      flat = flat + idx * int(math.prod(dims[i+1:]))
-    flat_p = flat.substitute({s: UOp(Ops.SPECIAL, s.dtype, s.src, s.arg+"_p") for s in specials})
-    solver = z3.Solver()
-    [z3_flat, z3_flat_p] = uops_to_z3(solver, flat, flat_p)
-    # bounds
-    self.assertEqual(solver.check(z3_flat < 0), z3.unsat, f"flat can be negative: {dims=}")
-    self.assertEqual(solver.check(z3_flat >= total), z3.unsat, f"flat can be >= {total}: {dims=}")
-    # injectivity: flat == flat' but inputs differ => unsat
-    inputs_differ = z3.Or(*[z3.Int(s.arg) != z3.Int(s.arg+"_p") for s in specials])
-    self.assertEqual(solver.check(z3.And(z3_flat == z3_flat_p, inputs_differ)), z3.unsat, f"not injective: {dims=}")
-
-  def test_grouped_dims(self):
-    # no-op
-    self._check_grouped_dims("gidx", (2,), (16,16,16), False, [2])
-    self._check_grouped_dims("gidx", (2,3), (16,16,16), False, [2,3])
-
-    # check reverse dims
-    self._check_grouped_dims("gidx", (2,3), (16,16,16), True, [3,2])
-    self._check_grouped_dims("gidx", (2,3,4), (16,16,16), False, [2,3,4])
-
-    # test splitting globals:    len(dims) == len(max)
-    self._check_grouped_dims("gidx", (64,3,4), (16,16,16), False, [16,12,4])
-    self._check_grouped_dims("gidx", (64,3,4), (16,4,16), False, [16,3,16])
-    self._check_grouped_dims("gidx", (64,3,4), (16,16,16), True, [16,3,16])
-    self._check_grouped_dims("gidx", (128,3,4), (16,4,256), False, [16,3,32])
-    self._check_grouped_dims("gidx", (4,4,512), (16,4,256), False, [8,4,256])
-    self._check_grouped_dims("gidx", (5,12,7), (8,4,16), False, [10,3,14])
-
-    # prefer group_dim strategy when possible
-    self._check_grouped_dims("gidx", (512,4,2), (8192,2,2), False, [2048,2])
-
-    # test splitting globals:    len(dims) < len(max)
-    #                            len(dim)        ->          len(limited)
-    #                              1             ->             2
-    self._check_grouped_dims("gidx", (128,), (16,16,256), False, [16,8], False)
-    #                              1             ->             3
-    self._check_grouped_dims("gidx", (65536,), (16,16,256), False, [16,16,256], False)
-    #                              2             ->             2
-    self._check_grouped_dims("gidx", (65536,2), (65535,65535,65535), False, [32768,4], False)
-    # test when the only divisor is the square root of dim
-    self._check_grouped_dims("gidx", (121,), (12,12,12), False, [11,11], False)
-    #                              2             ->             3
-    self._check_grouped_dims("gidx", (128,128), (16,16,256), False, [16,16,64], False)
-
-    # collapse on onto the left most axis
-    self._check_grouped_dims("gidx", (2,3,4,5), (16,16,16), False, [6,4,5])
-    self._check_grouped_dims("gidx", (2,3,4,5), (32,16,16), True, [20,3,2])
-
-    # collapse on left-most available axis (the left most is too small)
-    self._check_grouped_dims("gidx", (2,3,4,5), (4,16,16), False, [2,12,5])
-    self._check_grouped_dims("gidx", (2,3,4,5), (16,16,16), True, [5,12,2])
-
-    # dim too large and not factorable
-    with self.assertRaises(RuntimeError):
-      get_grouped_dims("gidx", (23,), (16,16,16), False,)
-    with self.assertRaises(RuntimeError):
-      get_grouped_dims("gidx", (128,3,4), (16,2,2), False,)
-
-    # too large for sizes
-    with self.assertRaises(RuntimeError):
-      get_grouped_dims("gidx", (2,3,4,5,6), (16,16,16))
-
-  def test_grouped_direct_dims_are_special(self):
-    # when (2,3) are merged into 6, the unmerged dims (4,5) should map directly to SPECIAL ops (no div/mod)
-    idxs = get_grouped_dims("gidx", (2,3,4,5), (16,16,16), False)
-    assert idxs[2].op is Ops.SPECIAL, f"expected SPECIAL for direct-mapped dim, got {idxs[2].op}"
-    assert idxs[3].op is Ops.SPECIAL, f"expected SPECIAL for direct-mapped dim, got {idxs[3].op}"
-
-  def test_max_sizes_none(self):
-    self._check_grouped_dims("gidx", (2,3,4), None, False, [2,3,4])
-    self._check_grouped_dims("gidx", (100,), None, False, [100])
-
-if __name__ == '__main__':
-  unittest.main()

test/null/test_multitensor.py

@@ -1,13 +1,11 @@
-import gc, unittest
+import unittest
 from tinygrad import Tensor, GlobalCounters, dtypes
 
 class TestMultiRamUsage(unittest.TestCase):
   def setUp(self):
-    gc.collect()
     self.baseline = GlobalCounters.mem_used
     self.N = 100
   def assertUsed(self, amt, strict=True):
-    gc.collect()
     used = GlobalCounters.mem_used - self.baseline
     print(f"used {used} bytes")
     if strict: self.assertEqual(used, amt)
@@ -22,43 +20,25 @@ class TestMultiRamUsage(unittest.TestCase):
     del _
     self.assertUsed(0)
 
+  @unittest.skip("flaky")
   def test_zeros_copy(self):
     devices_2 = ("NULL:1", "NULL:2")
     _ = Tensor.zeros(self.N, self.N).contiguous().to(devices_2).realize()
     # NOTE: the first one on the DEFAULT device should be freed
     self.assertUsed(self.N*self.N*4*2)
 
+  @unittest.skip("flaky")
   def test_zeros_shard(self, devices=("NULL:1", "NULL:2")):
     _ = Tensor.zeros(self.N, self.N).contiguous().shard(devices, axis=0).realize()
     self.assertUsed(self.N*self.N*4) # sharding should not increase total ram usage
   def test_zeros_shard_self(self): self.test_zeros_shard(("NULL:0", "NULL:1"))
 
+  @unittest.skip("flaky")
   def test_zeros_contiguous_shard(self):
     devices_2 = ("NULL:1", "NULL:2")
     _ = Tensor.zeros(self.N, self.N).contiguous().shard(devices_2, axis=0).contiguous().realize()
     self.assertUsed(self.N*self.N*4) # sharding should not increase total ram usage
 
-  def test_sharded_memory_replicated(self):
-    devices_4 = tuple(f"NULL:{i+1}" for i in range(4))
-    X = Tensor.ones(256).contiguous().realize()
-    self.assertUsed(256 * 4)
-    X.shard_(devices_4).realize()
-    self.assertUsed(256 * 4 * 4)
-
-  def test_sharded_memory_replicated_const(self):
-    devices_4 = tuple(f"NULL:{i+1}" for i in range(4))
-    X = Tensor.ones(256).realize()
-    self.assertUsed(0)
-    X.shard_(devices_4).realize()
-    self.assertUsed(256 * 4 * 4)  # TODO: can be zero
-
-  def test_sharded_memory_axis_const(self):
-    devices_4 = tuple(f"NULL:{i+1}" for i in range(4))
-    X = Tensor.ones(256).realize()
-    self.assertUsed(0)
-    X.shard_(devices_4, axis=0).realize()
-    self.assertUsed(256 * 4)  # TODO: can be zero
-
   def _test_matmul_half(self, dev_count:int):
     N = 32
     total_mem = {}
@@ -74,26 +54,5 @@ class TestMultiRamUsage(unittest.TestCase):
   def test_matmul_half(self): self._test_matmul_half(dev_count=2)
   def test_matmul_half_alt(self): self._test_matmul_half(dev_count=4)
 
-class TestMultiAxis(unittest.TestCase):
-  def test_reshape_shard_invalid(self):
-    devices = ("NULL:0", "NULL:1")
-    t = Tensor.ones(4, 3).shard(devices, axis=0)
-    with self.assertRaises(RuntimeError, msg="reshape cannot move items between shards"):
-      t.reshape(3, 4).uop.axis
-
-  def test_reshape_shard_valid(self):
-    devices = ("NULL:0", "NULL:1")
-    t = Tensor.ones(4, 8).shard(devices, axis=0)
-    self.assertEqual(t.reshape(2, 16).uop.axis, 0)
-    self.assertEqual(t.reshape(2, 2, 8).uop.axis, 0)
-
-  def test_empty_like_sharded(self):
-    t = Tensor.ones(4, 8).shard(("NULL:0", "NULL:1"), axis=0)
-    e = t.empty_like()
-    self.assertEqual(e.shape, t.shape)
-    self.assertEqual(e.device, t.device)
-    self.assertEqual(e.uop.axis, 0)
-    self.assertTrue(e.uop.has_buffer_identity())
-
 if __name__ == '__main__':
   unittest.main()

test/null/test_opts.py

@@ -0,0 +1,21 @@
+import unittest
+from tinygrad import Tensor, Device
+from tinygrad.helpers import CPU_LLVM, CPU_LVP
+from tinygrad.codegen.opt import Opt, OptOps
+from tinygrad.engine.realize import get_program
+
+class TestOpts(unittest.TestCase):
+  def test_opt_upcast(self):
+    opts = (Opt(OptOps.UPCAST, 0, 4),)
+    a = Tensor.empty(16)
+    b = Tensor.empty(16)
+    out = (a+b).contiguous(arg=opts)
+    s = out.schedule()
+    self.assertEqual(s[-1].ast.arg.opts_to_apply, opts)
+    if Device.DEFAULT in {"CPU", "CL", "METAL"} and not CPU_LLVM and not CPU_LVP:
+      prg = get_program(s[-1].ast, renderer=Device[Device.DEFAULT].renderer)
+      self.assertIn('float4', prg.src)
+
+if __name__ == '__main__':
+  unittest.main()
+

test/null/test_real_world.py

@@ -98,7 +98,7 @@ class TestRealWorld(unittest.TestCase):
     @TinyJit
     def test(t, v):
       with Context(JIT=0): return model(t, v).realize()
-    helper_test("test_gpt2", lambda: (Tensor([[1,]]),Variable("pos", 1, 100).bind(1)), test, 0.23, 168, all_jitted=True)
+    helper_test("test_gpt2", lambda: (Tensor([[1,]]),Variable("pos", 1, 100).bind(1)), test, 0.23, 160, all_jitted=True)
 
   @slow
   def test_train_mnist(self):

test/null/test_rewrite_map.py

@@ -0,0 +1,202 @@
+import unittest
+from tinygrad import dtypes
+from tinygrad.uop.ops import UOp, graph_rewrite_map, _substitute
+from tinygrad.uop.symbolic import symbolic
+
+class TestRewriteMap(unittest.TestCase):
+  def test_substitute(self):
+    a = UOp.variable('a', 0, 10)
+    b = UOp.variable('b', 0, 10)
+    c = UOp.variable('c', 0, 10)
+    e = UOp.variable('e', 0, 10)
+    ret = (a+b)*c
+    sub = {a+b: e}
+    sub_map = graph_rewrite_map(ret, _substitute, sub, bottom_up=True)
+    self.assertIs(sub_map[a+b], e)
+    self.assertIs(sub_map[(a+b)*c], e*c)
+
+  def test_substitute_depth_2(self):
+    a = UOp.variable('a', 0, 10)
+    b = UOp.variable('b', 0, 10)
+    c = UOp.variable('c', 0, 10)
+    d = UOp.variable('d', 0, 10)
+    e = UOp.variable('e', 0, 10)
+    f = UOp.variable('f', 0, 10)
+    ret = (a+b)*c+d
+    sub = {a+b: e, (a+b)*c: f}
+    sub_map = graph_rewrite_map(ret, _substitute, sub, bottom_up=True)
+    self.assertIs(sub_map[a+b], e)
+    self.assertIs(sub_map[(a+b)*c], f)
+
+  def test_multistage_substitute(self):
+    a = UOp.variable('a', 0, 10)
+    b = UOp.variable('b', 0, 10)
+    c = UOp.variable('c', 0, 10)
+    d = UOp.variable('d', 0, 10)
+    sub1 = {a+b:c}
+    start = (a+b)*c
+    # stage 1: (a+b)*c -> c*c
+    sub_map1 = graph_rewrite_map(start, _substitute, sub1, bottom_up=True)
+    self.assertIs(sub_map1[(a+b)*c], c*c)
+    # stage 2: c*c -> d
+    sub2 = {c*c:d}
+    sub_map2 = graph_rewrite_map(sub_map1[start], _substitute, sub2, input_map=sub_map1, bottom_up=True)
+    # (a+b)*c -> c*c -> d
+    self.assertIs(sub_map2[(a+b)*c], d)
+
+  def test_add_zero(self):
+    # Build a small graph: add(0, add(const=0, const=5))
+    zero_node = UOp.const(dtypes.index, 0)
+    five_node = UOp.const(dtypes.index, 5)
+    inner_add = zero_node + five_node
+    root_add = zero_node + inner_add
+
+    # Perform top-down rewrite
+    node_map = graph_rewrite_map(root_add, symbolic)
+
+    # We expect that add(0, add(0, 5)) -> add(0, 5) -> 5
+    # Check the mapping
+    assert node_map[root_add] == five_node
+    assert node_map[inner_add] == five_node
+    # zero_node and five_node map to themselves
+    assert node_map[zero_node] == zero_node
+    assert node_map[five_node] == five_node
+
+  def test_double_neg(self):
+    """
+    Test rewriting neg(neg(5)) => 5 using symbolic.
+    """
+    # In some versions of TinyGrad, you might do: (-(-five_node))
+    five_node = UOp.const(dtypes.index, 5)
+    # If your code allows UOp(...), do that; else you might do something like:
+    # double_neg_five = -(-five_node)
+    # But let's be explicit:
+    neg_five = -five_node
+    double_neg_five = -neg_five
+
+    node_map = graph_rewrite_map(double_neg_five, symbolic)
+
+    # node_map should map double_neg_five -> five_node
+    self.assertEqual(node_map[double_neg_five], five_node)
+    # five_node maps to itself
+    self.assertEqual(node_map[five_node], five_node)
+
+  def test_add_zero_and_double_neg(self):
+    """
+    Combine both rewrites: add(0, neg(neg(5))) => add(0, 5) => 5
+    """
+    zero_node = UOp.const(dtypes.index, 0)
+    five_node = UOp.const(dtypes.index, 5)
+    neg_five = -five_node
+    double_neg_five = -neg_five
+    root_add = zero_node + double_neg_five
+
+    node_map = graph_rewrite_map(root_add, symbolic)
+
+    # node_map: root_add -> five_node, double_neg_five -> five_node
+    self.assertEqual(node_map[root_add], five_node)
+    self.assertEqual(node_map[double_neg_five], five_node)
+    # zero_node, five_node map to themselves
+    self.assertEqual(node_map[zero_node], zero_node)
+    self.assertEqual(node_map[five_node], five_node)
+
+  def test_multi_var_rewrites(self):
+    x_var = UOp.variable('x', 0, 10)
+    y_var = UOp.variable('y', -5, 5)
+    zero_node = UOp.const(dtypes.index, 0)
+
+    sum_with_zero = y_var + zero_node    # (y + 0)
+    combined = x_var + sum_with_zero     # x + (y + 0)
+    double_neg = -(-combined)           # neg(neg(x + y))
+    final_expr = zero_node + double_neg  # 0 + (x + y)
+
+    node_map = graph_rewrite_map(final_expr, symbolic)
+
+    # The final root should be (x_var + y_var).
+    expected = x_var + y_var
+
+    # Each sub-expression has its own "final" result.
+    # (y + 0) -> y_var
+    self.assertEqual(node_map[sum_with_zero], y_var)
+    # (x + (y+0)) -> (x + y)
+    self.assertEqual(node_map[combined], expected)
+    # neg(neg(x+y)) -> (x + y)
+    self.assertEqual(node_map[double_neg], expected)
+    # 0 + (x+y) -> (x + y)
+    self.assertEqual(node_map[final_expr], expected)
+
+    # x_var, y_var, zero_node remain unchanged
+    self.assertEqual(node_map[x_var], x_var)
+    self.assertEqual(node_map[y_var], y_var)
+    self.assertEqual(node_map[zero_node], zero_node)
+
+  def test_complex_multi_var_edges(self):
+    """
+    Build a multi-variable expression with multiple intermediates:
+
+      x_var = UOp.variable('x', 1, 10)
+      y_var = UOp.variable('y', -5, 5)
+      z_var = UOp.variable('z', 0, 5)
+      zero_node = UOp.const(dtypes.int, 0)
+      one_node = UOp.const(dtypes.int, 1)
+
+      yz_sum       = y_var + z_var
+      yz_sum_zero  = yz_sum + zero_node   -> rewrites to yz_sum
+      yz_neg       = -yz_sum_zero        -> -(y+z)
+      yz_dneg      = -yz_neg             -> y+z    (double neg gone)
+      x_plus_yz    = x_var + yz_dneg     -> x + (y+z)
+      double_neg_x = -(-x_plus_yz)       -> x + (y+z)
+      final_expr   = double_neg_x * one_node -> x + (y+z)
+
+    We expect the final result to be (x + (y+z)).
+    Each original node should map to the final node that replaces it,
+    which might be structurally equivalent but not the same reference.
+    """
+    x_var = UOp.variable('x', 1, 10)
+    y_var = UOp.variable('y', -5, 5)
+    z_var = UOp.variable('z', 0, 5)
+    zero_node = UOp.const(dtypes.index, 0)
+    one_node = UOp.const(dtypes.index, 1)
+
+    # Build sub-expressions
+    yz_sum = y_var + z_var              # (y + z)
+    yz_sum_zero = yz_sum + zero_node    # (y + z) + 0
+    yz_neg = -yz_sum_zero               # -(y+z)
+    yz_dneg = -yz_neg                   # -(-(y+z)) -> (y+z)
+    x_plus_yz = x_var + yz_dneg         # x + (y+z)
+    double_neg_x = -(-x_plus_yz)        # neg(neg(x+(y+z))) -> x+(y+z)
+    final_expr = double_neg_x * one_node  # (x+(y+z)) * 1 -> x+(y+z)
+
+    node_map = graph_rewrite_map(final_expr, symbolic)
+
+    # (y + z) is unchanged
+    self.assertEqual(node_map[yz_sum], yz_sum)
+
+    # (y+z) + 0 => (y+z)
+    self.assertEqual(node_map[yz_sum_zero], yz_sum)
+
+    # -(y+z) remains -(y+z), but might be a new UOp with updated children
+    # Compare structurally to -(y_var + z_var).
+    self.assertEqual(node_map[yz_neg], -yz_sum)
+
+    # -(-(y+z)) => (y+z)
+    self.assertEqual(node_map[yz_dneg], yz_sum)
+
+    # x + (y+z) => might get recreated if yz_dneg was changed, so compare to x + yz_sum
+    self.assertEqual(node_map[x_plus_yz], x_var + yz_sum)
+
+    # -(-(x+(y+z))) => x + (y+z)
+    self.assertEqual(node_map[double_neg_x], x_var + yz_sum)
+
+    # (x+(y+z)) * 1 => x+(y+z)
+    self.assertEqual(node_map[final_expr], x_var + yz_sum)
+
+    # Unchanged atomic nodes map to themselves
+    self.assertEqual(node_map[x_var], x_var)
+    self.assertEqual(node_map[y_var], y_var)
+    self.assertEqual(node_map[z_var], z_var)
+    self.assertEqual(node_map[zero_node], zero_node)
+    self.assertEqual(node_map[one_node], one_node)
+
+if __name__ == "__main__":
+  unittest.main()

test/null/test_schedule.py

@@ -1,5 +1,5 @@
 # schedule tests that pass on NULL backend (no copyout needed)
-import gc, unittest, time
+import unittest, time
 from tinygrad import nn, dtypes, Device, Tensor
 from tinygrad.device import is_dtype_supported
 from tinygrad.uop.ops import UOp, Ops, GroupOp, UPat
@@ -59,7 +59,7 @@ class TestBufferUOp(unittest.TestCase):
 
   def test_buffer_view_not_allowed(self):
     permuted_view = Tensor.empty(1, 2, 3).permute(0, 2, 1)
-    with self.assertRaises(RuntimeError):
+    with self.assertRaisesRegex(AssertionError, "can only be RESHAPE"):
       permuted_view.uop.buffer # cannot access Buffer of a non contiguous VIEW
 
   def test_buffer_only_after_realize(self):
@@ -74,7 +74,7 @@ class TestBufferUOp(unittest.TestCase):
     self.assertIsNotNone(a.uop.buffer)
 
   def test_const_does_not_realize(self):
-    a = Tensor(1)
+    a = Tensor(1)+Tensor(2)
     run_schedule(check_schedule(a, 0))
     self.assertIsNone(a.uop.base.realized)
 
@@ -169,7 +169,7 @@ class TestSchedule(unittest.TestCase):
   def test_empty_is_not_realized(self):
     a = Tensor.empty(10)
     child = a+2
-    assert not a.uop.is_realized
+    assert a.uop.is_realized
     child.realize()
     assert a.uop.is_realized
 
@@ -185,19 +185,12 @@ class TestSchedule(unittest.TestCase):
   def test_childless_empty_never_allocates(self):
     a = Tensor.empty(10)
     a.realize()
-    assert not a.uop.is_realized
+    assert not a.uop.buffer.is_allocated()
 
   def test_simplify_padded_const(self):
     a, _ = Tensor.empty(1022).cummax(axis=0)
     check_schedule(a, 3)
 
-  @unittest.skip("should this pass?")
-  def test_contiguous_assign(self):
-    a = Tensor.ones(10) * 2
-    b = Tensor.empty(10)
-    c = b.assign(a.contiguous())
-    check_schedule(c, 1)
-
   def test_basic_binop_fusion(self):
     a = Tensor.empty(10)
     b = Tensor.empty(10)
@@ -412,20 +405,20 @@ class TestSchedule(unittest.TestCase):
       out = bn(c1(img)).relu()
       check_schedule(out, 4, [c1.weight, c1.bias])
 
-  def test_fold_conv_batchnorm_optim(self, adam=False):
-    # 2 is too low?
-    optim, cnt = (nn.optim.Adam, 16) if adam else (nn.optim.SGD, 2)
-    with Tensor.train():
-      img = Tensor.ones(1,3,4,4)
-      c1 = nn.Conv2d(3,32,3)
-      bn = nn.BatchNorm2d(32, track_running_stats=False)
-      _realize_weights([c1, bn])
-      opt = optim(nn.state.get_parameters([c1, bn]))
-      img_bn = bn(c1(img)).elu().sum()
-      opt.zero_grad()
-      img_bn.backward()
-      check_schedule(opt.schedule_step(), cnt)
-  def test_fold_conv_batchnorm_optim_adam(self): self.test_fold_conv_batchnorm_optim(True)
+  def test_fold_conv_batchnorm_optim(self):
+    # this is too high
+    for optim, cnt in [(nn.optim.Adam, 27), (nn.optim.SGD, 7)]:
+      with self.subTest(optim=optim.__name__):
+        with Tensor.train():
+          img = Tensor.ones(1,3,4,4)
+          c1 = nn.Conv2d(3,32,3)
+          bn = nn.BatchNorm2d(32, track_running_stats=False)
+          _realize_weights([c1, bn])
+          opt = optim(nn.state.get_parameters([c1, bn]))
+          img_bn = bn(c1(img)).elu().sum()
+          opt.zero_grad()
+          img_bn.backward()
+          check_schedule(opt.schedule_step(), cnt)
 
   def test_fold_batchnorm_backward(self):
     with Tensor.train():
@@ -649,7 +642,6 @@ class TestSchedule(unittest.TestCase):
     t = Tensor([1.0, 2.0, 3.0]) ** 8
     self.assertEqual(self._alu_from_tensor(t), [Ops.MUL, Ops.MUL, Ops.MUL])
 
-  @unittest.skip("const folding is removed")
   def test_pow_const_tensor_to_zero(self):
     x = Tensor([1,2,3,4])
     out = x ** Tensor(0.0)
@@ -774,7 +766,7 @@ class TestSchedule(unittest.TestCase):
       _realize_weights(layer)
       opt = nn.optim.Adam(nn.state.get_parameters(layer), lr=1e-4)
       layer(x).relu().sum().backward()
-      check_schedule(opt.schedule_step(), 13)
+      check_schedule(opt.schedule_step(), 19)
 
   def test_adam_conv_fuse(self):
     with Tensor.train():
@@ -784,7 +776,7 @@ class TestSchedule(unittest.TestCase):
       opt = nn.optim.Adam(nn.state.get_parameters(c1), lr=1e-4)
       opt.zero_grad()
       c1(img).relu().sum().backward()
-      check_schedule(opt.schedule_step(), 13)
+      check_schedule(opt.schedule_step(), 19)
 
   def test_adam_2convs_fuse(self):
     with Tensor.train():
@@ -795,7 +787,7 @@ class TestSchedule(unittest.TestCase):
       opt = nn.optim.Adam(nn.state.get_parameters([c1, c2]), lr=1e-4)
       opt.zero_grad()
       c2(c1(img).relu()).relu().sum().backward()
-      check_schedule(opt.schedule_step(), 15)
+      check_schedule(opt.schedule_step(), 21)
 
   def test_sgd_conv_fuse(self):
     with Tensor.train():
@@ -827,7 +819,7 @@ class TestSchedule(unittest.TestCase):
       opt = nn.optim.SGD(nn.state.get_parameters([c1, c2]), nesterov=True, momentum=0.9, weight_decay=0.1)
       opt.zero_grad()
       c2(c1(img).relu()).relu().sum().backward()
-      check_schedule(opt.schedule_step(), 11)
+      check_schedule(opt.schedule_step(), 13)
 
   def test_sgd_4convs_fuse(self):
     with Tensor.train():
@@ -903,11 +895,9 @@ class TestSchedule(unittest.TestCase):
     check_schedule(out, 2)
 
   def test_schedule_mem_used(self):
-    gc.collect()
     base = GlobalCounters.mem_used
     Tensor.ones(256).contiguous().realize()
     Tensor.ones(5, 5).contiguous().schedule()
-    gc.collect()
     self.assertEqual(GlobalCounters.mem_used-base, 0)
 
   def test_const_schedule(self):
@@ -1011,7 +1001,6 @@ class TestUOpBecome(unittest.TestCase):
 
   # sometimes we prefer to perform an op before movement ops, in this case we should stack the mops on top of the new buffer
 
-  @unittest.skip("no longer supported")
   def test_reorder_expand(self):
     a = Tensor.empty(4, 1)
     b = a.expand(4, 4).reciprocal()
@@ -1047,7 +1036,6 @@ class TestUOpBecome(unittest.TestCase):
     late_add = noop+2
     late_add.realize()
 
-  @unittest.skip("const folding is removed")
   def test_become_const_in_base(self):
     a = Tensor.empty(4)
     b = a*0
@@ -1055,7 +1043,6 @@ class TestUOpBecome(unittest.TestCase):
     check_schedule(b, 0)
     assert UPat(Ops.CONST, arg=0).match(b.uop.base, {}) # scheduling replaces the tensor uop with a VIEW(BUFFER)
 
-  @unittest.skip("const folding is removed")
   def test_become_const_from_const(self):
     const_add = Tensor(1)+Tensor(2)
     assert UPat(Ops.ADD).match(const_add.uop, {})
@@ -1144,7 +1131,7 @@ class TestFusionOp(unittest.TestCase):
     a = Tensor(val)
     for _ in range(24): a = Tensor.stack(a, a)[0]
     sched = a.schedule()
-    self.assertLessEqual(len(sched), 1)
+    self.assertEqual(len(sched), 0)
     self.assertLess(time.perf_counter()-st, 2.0)
 
   def test_recursive_reshape(self):

test/null/test_tensor_metadata.py

@@ -4,7 +4,6 @@ from tinygrad.tensor import _METADATA
 from tinygrad.engine.realize import capturing
 from tinygrad.helpers import Context
 
-@unittest.skip("tensor metadata is no longer supported")
 class TestTensorMetadata(unittest.TestCase):
   def setUp(self) -> None:
     _METADATA.set(None)

test/null/test_tensor_uop_representation.py

@@ -8,7 +8,6 @@ def is_pattern_uop(u:UOp, pat:UPat): assert pat.match(u, {}), f"{u}\nis not\n{pa
 def is_pattern(ten:Tensor, pat:UPat): is_pattern_uop(ten.uop, pat)
 
 class TestTensorMutates(unittest.TestCase):
-  @unittest.skip("this doesn't mutate anymore")
   def test_mutate_add(self):
     a = Tensor([1,2,3])
     b = Tensor([4,5,6])

test/null/test_uop_symbolic.py

@@ -390,9 +390,6 @@ class TestSymbolic(unittest.TestCase):
     self.helper_test_variable(Variable("a", 0, 6) < 3, 0, 1, "(a<3)")
     self.helper_test_variable(Variable("a", 0, 6) < 8, 1, 1, "True")
 
-  def test_cast_bool(self):
-    self.helper_test_variable(Variable("a", 0, 10).cast(dtypes.bool), 0, 1, "a!=0")
-
   def test_lt_sum_remove(self):
     self.helper_test_variable(Variable("a", 0, 6) + 2 < 3, 0, 1, "(a<1)")
 
@@ -658,24 +655,6 @@ class TestSymbolic(unittest.TestCase):
     with self.assertRaises(AssertionError):
       self.helper_test_variable((31 * b + 1) % 18 + ((31 * b + 1) // 18) * 18, 1, 3101, "((b*31)+1)")
 
-  def test_div_mod_recombine_3level(self):
-    gidx = Variable("gidx", 0, 150527)
-    self.helper_test_variable(gidx//3%224*3 + gidx%3 + gidx//672*672, 0, 150527, "gidx")
-    # different shapes
-    x = Variable("x", 0, 5*7*11-1)
-    self.helper_test_variable(x//11%7*11 + x%11 + x//77*77, 0, 5*7*11-1, "x")
-    # result is x//a*c2 not just x
-    x2 = Variable("x2", 0, 5*6*7-1)
-    self.helper_test_variable(x2//7%6*14 + x2//42*84, 0, (5*6*7-1)//7*14, "(x2//7*14)")
-    # negative variable range
-    xn = Variable("x", -1000, 1000)
-    self.helper_test_variable(xn//3%224*3 + xn%3 + xn//672*672, -1000, 1000, "x")
-    self.helper_test_variable(xn//3%7*3 + xn//21*21, -999, 999, "(x//3*3)")
-    # should NOT simplify: a*c1 != b (3*224 != 600)
-    self.helper_test_variable(gidx//3%224*3 + gidx//600*600, 0, 150669, "(gidx//600*600+gidx//3%224*3)")
-    # should NOT simplify: c1*c2 != c3 (224*3 != 700)
-    self.helper_test_variable(gidx//3%224*3 + gidx//672*700, 0, 156769, "(gidx//672*700+gidx//3%224*3)")
-
   def test_div_mod_recombine_with_gcd(self):
     b = Variable("b", 0, 100)
     exp = (16 * b + 2) % 18 + ((16 * b + 2) // 18) * 18
@@ -856,33 +835,34 @@ class TestSymbolicNumeric(unittest.TestCase):
   def test_times_2_plus_3_div_4(self): self.helper_test_numeric(lambda x: (x*2 + 3)//4)
   def test_times_2_plus_3_div_4_mod_4(self): self.helper_test_numeric(lambda x: ((x*2 + 3)//4)%4)
 
-class TestSymbolicVariables(unittest.TestCase):
+class TestSymbolicVars(unittest.TestCase):
   def test_simple(self):
     z = uconst(0)
     a = Variable("a", 0, 10)
     b = Variable("b", 0, 10)
     c = Variable("c", 0, 10)
-    assert z.variables() == []
-    assert a.variables() == [a]
+    assert z.vars() == z.vars() == set()
+    print(a.vars())
+    assert a.vars() == a.vars() == {a}
     m = a * 3
-    assert m.variables() == [a]
+    assert m.vars() == {a}
     s = usum([a, b, c])
-    assert s.variables() == [a, b, c]
+    assert s.vars() == {a, b, c}
 
   def test_compound(self):
     a = Variable("a", 0, 10)
     b = Variable("b", 0, 10)
     c = Variable("c", 0, 10)
-    assert (a + b * c).variables() == [a, b, c]
-    assert (a % 3 + b // 5).variables() == [a, b]
+    assert (a + b * c).vars() == {a, b, c}
+    assert (a % 3 + b // 5).vars() == {a, b}
     # TODO: fix me
     with self.assertRaises(AssertionError):
-      assert (a + b + c - a).variables() == [b, c]
+      assert (a + b + c - a).vars() == {b, c}
 
   def test_dedup(self):
     a = Variable("a", 0, 10)
-    assert (a * a).variables() == [a]
-    assert (a//4 + a//6).variables() == [a]
+    assert (a * a).vars() == {a}
+    assert (a//4 + a//6).vars() == {a}
 
 class TestSymInfer(unittest.TestCase):
   def test_sym_infer(self):

test/null/test_uops.py

@@ -94,6 +94,12 @@ class TestExecALU(unittest.TestCase):
     # test no truncate
     self.assertEqual(exec_alu(Ops.ADD, dtypes.uint8, (250, 250), truncate_output=False), 500)
 
+class TestConstantFolding(unittest.TestCase):
+  def test_cast_const(self):
+    t = Tensor(1, dtype=dtypes.float).cast(dtypes.int)
+    si = t.schedule()
+    assert len(si) == 0
+
 class TestGatedStoreRewrite(unittest.TestCase):
   def test_tiny_gate_store(self):
     gmem = UOp(Ops.PARAM, dtypes.float.ptr(), (), 0)

test/null/test_uops_stats.py

@@ -45,7 +45,6 @@ class TestMemoryCount(unittest.TestCase):
     _, mem = get_stats(a+b)
     self.assertEqual(mem, 1024*1024*2 + 1024)  # 1 full read + 1 lil read + 1 write
 
-  @unittest.skip("no longer supported")
   def test_both_expanded(self):
     # TODO: this probably should be a full write
     a = Tensor.empty(1024, 1, dtype=dtypes.uint8).expand(1024, 1024)

test/null/test_viz.py

@@ -286,20 +286,6 @@ class TestVizIntegration(BaseTestViz):
     self.assertEqual(lst[0]["name"], "Schedule 1 Kernel n1")
     self.assertEqual(lst[1]["name"], prg.name)
 
-  # schedule graph CALL nodes have a link to jump to codegen
-  def test_link_sched_codegen(self):
-    c1 = Tensor.empty(4).add(1)
-    c2 = Tensor.empty(8).add(1)
-    sched = Tensor.schedule(c1, c2)
-    prgs = [si.lower().prg.p.name for si in sched]
-    lst = get_viz_list()
-    viz_kernel = next(i for i,s in enumerate(lst[0]["steps"]) if s["name"] == "View Kernel Graph")
-    graph = next(get_viz_details(0, viz_kernel))["graph"]
-    call_nodes = [n for n in graph.values() if n["label"].startswith("CALL")]
-    for i,n in enumerate(call_nodes):
-      assert n["ref"] is not None
-      self.assertEqual(lst[n["ref"]]["name"], prgs[i])
-
   def test_metadata_tracing(self):
     with Context(TRACEMETA=2):
       a = Tensor.empty(1)

test/null/test_winograd.py

@@ -45,7 +45,7 @@ class TestWinograd(unittest.TestCase):
 
     # TODO: what's optimal on this?
     self.assertLess(ops_ratio, 4.3)
-    self.assertLess(mem_ratio, 4)
+    self.assertLess(mem_ratio, 3)
 
   def test_dtype(self):
     IC, OC, X, Y = 4,4,9,9

test/testextra/test_cfg_viz.py

@@ -30,7 +30,7 @@ class TestCfg(unittest.TestCase):
   def setUp(self):
     self.arch = Device["AMD"].arch
     if not any(self.arch.startswith(a) for a in {"gfx11", "gfx12"}):
-      self.skipTest(f"tests written for RDNA, got arch {self.arch}")
+      self.skipTest(f"tests written for RDNA, got arch {arch}")
 
   def test_simple(self):
     k = Kernel(arch=Device["AMD"].arch)
@@ -69,8 +69,6 @@ class TestCfg(unittest.TestCase):
     self.assertEqual(len(references["r0"]), 2)
     insts = [cfg["pc_tokens"][pc][0]["st"] for pc in references["r0"]]
     self.assertEqual(insts, ['s_mov_b32', 's_cmp_eq_u64'])
-    end_block_content = "\n".join(" ".join(t["st"] for t in cfg["pc_tokens"][pc]) for pc in list(cfg["blocks"].values())[-1])
-    self.assertEqual(end_block_content, "s_endpgm\ns_code_end (217x)")
 
   def test_loop(self):
     k = Kernel(arch=Device["AMD"].arch)

test/testextra/test_hk_fa.py

@@ -128,7 +128,7 @@ class TestFA(unittest.TestCase):
     assert_allclose(k.grad, k_ref.grad, atol=1e-5, rtol=1e-5)
     assert_allclose(v.grad, v_ref.grad, atol=1e-5, rtol=1e-5)
 
-  def test_fast_fa_bwd_dp(self):
+  def test_fast_fa_bwd_multidevice(self):
     Tensor.manual_seed(42)
 
     B, N, H, H_KV, D = 2, 1024, 32, 8, 128
@@ -175,52 +175,5 @@ class TestFA(unittest.TestCase):
     assert_allclose(v.grad, v_ref.grad, atol=1e-5, rtol=1e-5)
     assert_allclose(k.grad, k_ref.grad, atol=1e-5, rtol=1e-5)
 
-  def test_fast_fa_bwd_mp(self):
-    Tensor.manual_seed(42)
-
-    B, N, H, H_KV, D = 2, 1024, 32, 8, 128
-    GPUS = tuple(f"AMD:{i}" for i in range(B))
-
-    with Context(DEBUG=0):
-      base_q = Tensor.randn(B, N, H, D, dtype=dtypes.bfloat16, requires_grad=True).contiguous()
-      base_k = Tensor.randn(B, N, H_KV, D, dtype=dtypes.bfloat16, requires_grad=True).contiguous()
-      base_v = Tensor.randn(B, N, H_KV, D, dtype=dtypes.bfloat16, requires_grad=True).contiguous()
-
-      base_do = Tensor.ones(B, N, H, D, dtype=dtypes.float32).contiguous()
-
-    with Context(DEBUG=0):
-      q = base_q.clone().requires_grad_(True).shard(GPUS, axis=2)
-      k = base_k.clone().requires_grad_(True).shard(GPUS, axis=2)
-      v = base_v.clone().requires_grad_(True).shard(GPUS, axis=2)
-      Tensor.realize(q, k, v)
-
-      do = base_do.clone().shard(GPUS, axis=2)
-      Tensor.realize(do)
-
-    q_, k_, v_ = q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2)
-    out = flash_attention(q_, k_, v_, is_causal=True)
-    out = out.float().transpose(1, 2)
-    out.backward(do)
-    Tensor.realize(q.grad, k.grad, v.grad)
-
-    with Context(DEBUG=0):
-      q_ref = base_q.clone().requires_grad_(True)
-      k_ref = base_k.clone().requires_grad_(True)
-      v_ref = base_v.clone().requires_grad_(True)
-      Tensor.realize(q_ref, k_ref, v_ref)
-
-      do_ref = base_do.clone()
-      Tensor.realize(do_ref)
-
-    q_ref_, k_ref_, v_ref_ = q_ref.transpose(1, 2), k_ref.transpose(1, 2), v_ref.transpose(1, 2)
-    ref = flash_attention(q_ref_, k_ref_, v_ref_, is_causal=True)
-    ref = ref.float().transpose(1, 2)
-    ref.backward(do_ref)
-    Tensor.realize(q_ref.grad, k_ref.grad, v_ref.grad)
-
-    assert_allclose(q.grad, q_ref.grad, atol=1e-5, rtol=1e-5)
-    assert_allclose(v.grad, v_ref.grad, atol=1e-5, rtol=1e-5)
-    assert_allclose(k.grad, k_ref.grad, atol=1e-5, rtol=1e-5)
-
 if __name__ == "__main__":
   unittest.main()

test/unit/test_assign.py

@@ -2,7 +2,6 @@
 import unittest
 import numpy as np
 from tinygrad import dtypes, Tensor, TinyJit, GlobalCounters, Variable
-from tinygrad.uop.ops import Ops
 from tinygrad.device import is_dtype_supported
 from tinygrad.helpers import temp, CI, CPU_LVP, Context
 
@@ -129,7 +128,6 @@ class TestAssign(unittest.TestCase):
     new = a + old_a
     np.testing.assert_allclose(new.numpy(), 4)
 
-  @unittest.skip("TODO: this is broken")
   def test_assign_changes_alt(self, realize=False):
     a = Tensor(1).contiguous()
     if realize: a.realize()
@@ -233,6 +231,7 @@ class TestAssign(unittest.TestCase):
     np.testing.assert_equal(b0.numpy(), 128)
     np.testing.assert_equal(b1.numpy(), 608)
 
+  @unittest.skip("TODO: bring this assert back")
   def test_crossunder_assign(self):
     # NOTE: should *not* raise AssertionError from numpy
     with self.assertRaisesRegex(RuntimeError, "cycle"):
@@ -638,7 +637,6 @@ class TestAssignOrdering(unittest.TestCase):
     self.assertEqual(r1.item(), 4)
     self.assertEqual(r2.item(), 8)
 
-  @unittest.skip("TODO: this is broken")
   def test_write_read_write_chain(self):
     """Write, read, write chain - middle read must complete before second write."""
     buf = Tensor.zeros(4).contiguous().realize()
@@ -792,79 +790,5 @@ class TestAssignOrdering(unittest.TestCase):
     buf[2:3].assign(Tensor.full((1,), 3.0))
     self.assertEqual(buf.sum().realize().item(), 6.0)
 
-# TODO: assigns into views of unrealized non-BUFFER bases are silently dropped
-class TestAssignToUnrealizedView(unittest.TestCase):
-  def test_copy(self):
-    t = Tensor.zeros(2,2, dtype=dtypes.int).to("CPU:0").contiguous().realize()
-    c = t.to("CPU:1")  # unrealized COPY
-    self.assertIs(c.uop.base.op, Ops.COPY)
-    c[:, 1:2].assign(Tensor.ones(2,1, dtype=dtypes.int).to("CPU:1").contiguous().realize())
-    # TODO: should be [[0,1],[0,1]]
-    self.assertEqual(c.tolist(), [[0,0],[0,0]])
-
-  def test_contiguous(self):
-    t = Tensor([[1,2],[3,4]]).contiguous().realize()
-    c = t.permute(1,0).contiguous()  # unrealized CONTIGUOUS
-    self.assertIs(c.uop.base.op, Ops.CONTIGUOUS)
-    c[:, 1:2].assign(Tensor.ones(2,1, dtype=dtypes.int).contiguous().realize())
-    # TODO: should be [[1,1],[2,1]]
-    self.assertEqual(c.tolist(), [[1,3],[2,4]])
-
-  def test_contiguous_backward(self):
-    t = Tensor([[1,2],[3,4]]).contiguous().realize()
-    cb = t.contiguous_backward()  # unrealized CONTIGUOUS_BACKWARD
-    self.assertIs(cb.uop.base.op, Ops.CONTIGUOUS_BACKWARD)
-    cb[:, 1:2].assign(Tensor.ones(2,1, dtype=dtypes.int).contiguous().realize())
-    # TODO: should be [[1,1],[3,1]]
-    self.assertEqual(cb.tolist(), [[1,2],[3,4]])
-
-  def test_detach_copy(self):
-    t = Tensor.zeros(2,2, dtype=dtypes.int).to("CPU:0").contiguous().realize()
-    d = t.to("CPU:1").detach()  # DETACH(unrealized COPY)
-    self.assertIs(d.uop.base.op, Ops.COPY)
-    d[:, 1:2].assign(Tensor.ones(2,1, dtype=dtypes.int).to("CPU:1").contiguous().realize())
-    # TODO: should be [[0,1],[0,1]]
-    self.assertEqual(d.tolist(), [[0,0],[0,0]])
-
-  def test_detach_contiguous(self):
-    t = Tensor([[1,2],[3,4]]).contiguous().realize()
-    d = t.permute(1,0).contiguous().detach()  # DETACH(unrealized CONTIGUOUS)
-    self.assertIs(d.uop.base.op, Ops.CONTIGUOUS)
-    d[:, 1:2].assign(Tensor.ones(2,1, dtype=dtypes.int).contiguous().realize())
-    # TODO: should be [[1,1],[2,1]]
-    self.assertEqual(d.tolist(), [[1,3],[2,4]])
-
-  def test_alu(self):
-    a = Tensor([1,2,3,4]).contiguous().realize()
-    b = Tensor([5,6,7,8]).contiguous().realize()
-    c = a + b  # unrealized ADD
-    self.assertIs(c.uop.base.op, Ops.ADD)
-    c[:2].assign(Tensor([99, 99]).realize())
-    # TODO: silently dropped, should be [99,99,10,12] or raise an error
-    self.assertEqual(c.tolist(), [6,8,10,12])
-
-  def test_reduce(self):
-    a = Tensor([[1,2],[3,4]]).contiguous().realize()
-    r = a.sum(axis=0)  # unrealized REDUCE_AXIS
-    self.assertIs(r.uop.base.op, Ops.REDUCE_AXIS)
-    r[:1].assign(Tensor([99]).realize())
-    # TODO: silently dropped, should be [99,6] or raise an error
-    self.assertEqual(r.tolist(), [4,6])
-
-  def test_cast(self):
-    a = Tensor([1,2,3,4]).contiguous().realize()
-    c = a.float()  # unrealized CAST
-    self.assertIs(c.uop.base.op, Ops.CAST)
-    c[:2].assign(Tensor([99, 99], dtype=dtypes.float).realize())
-    # TODO: silently dropped, should be [99,99,3,4] or raise an error
-    self.assertEqual(c.tolist(), [1,2,3,4])
-
-  def test_const(self):
-    c = Tensor(5).reshape(1, 1).expand(2, 2)
-    self.assertIs(c.uop.base.op, Ops.CONST)
-    c[:, 1:2].assign(Tensor.ones(2,1, dtype=dtypes.int).contiguous().realize())
-    # TODO: silently dropped, should be [[5,1],[5,1]] or raise an error
-    self.assertEqual(c.tolist(), [[5,5],[5,5]])
-
 if __name__ == "__main__":
   unittest.main()

test/unit/test_call.py

@@ -92,13 +92,5 @@ class TestCall(unittest.TestCase):
     np.testing.assert_allclose(a.grad.numpy(), gt_a_grad, rtol=1e-5)
     np.testing.assert_allclose(b.grad.numpy(), gt_b_grad, rtol=1e-5)
 
-  def test_call_plus_sharded(self):
-    devs = ("CPU:0", "CPU:1")
-    a = Tensor.ones(10, 10).shard(devs, axis=0)
-    b = Tensor.ones(10, 10).shard(devs, axis=0)
-    Tensor.realize(a, b)
-    c = Tensor.call(a, b, fxn=a.as_param(0) + b.as_param(1))
-    np.testing.assert_equal(c.numpy(), 2 * np.ones((10, 10)))
-
 if __name__ == '__main__':
   unittest.main()

test/unit/test_callify.py

@@ -1,120 +0,0 @@
-import unittest
-from tinygrad import Tensor, dtypes
-
-class TestCallify(unittest.TestCase):
-  def test_basic(self):
-    a = Tensor([1.,2,3])
-    b = Tensor([4.,5,6])
-    out = a + b
-    out.callify()
-    self.assertListEqual(out.tolist(), [5.0, 7.0, 9.0])
-
-  def test_const(self):
-    out = Tensor(2.0) + Tensor(3.0)
-    out.callify()
-    self.assertEqual(out.item(), 5.0)
-
-  def test_sum(self):
-    out = Tensor.ones(16).contiguous().sum()
-    out.callify()
-    self.assertEqual(out.item(), 16.0)
-
-  def test_multi_output(self):
-    a = Tensor([1.,2,3])
-    b = Tensor([4.,5,6])
-    c = a + b
-    d = a * b
-    c.callify(d)
-    self.assertListEqual(c.tolist(), [5.0, 7.0, 9.0])
-    self.assertListEqual(d.tolist(), [4.0, 10.0, 18.0])
-
-  def test_two_callify_independent(self):
-    a = Tensor([1.,2,3])
-    b = Tensor([4.,5,6])
-    c = a + b
-    c.callify()
-
-    d = Tensor([10.,20,30])
-    e = Tensor([1.,1,1])
-    f = d - e
-    f.callify()
-
-    self.assertListEqual(c.tolist(), [5.0, 7.0, 9.0])
-    self.assertListEqual(f.tolist(), [9.0, 19.0, 29.0])
-
-  def test_two_callify_shared_input(self):
-    a = Tensor([1.,2,3]).contiguous().realize()
-    b = a + 1
-    b.callify()
-    c = a * 2
-    c.callify()
-    self.assertListEqual(b.tolist(), [2.0, 3.0, 4.0])
-    self.assertListEqual(c.tolist(), [2.0, 4.0, 6.0])
-
-  def test_chained_callify(self):
-    a = Tensor([1.,2,3])
-    b = a + 1
-    b.callify()
-    b.realize()
-    c = b + 1
-    c.callify()
-    self.assertListEqual(c.tolist(), [3.0, 4.0, 5.0])
-
-  def test_gemm(self):
-    a = Tensor.ones(8, 8).contiguous()
-    b = Tensor.eye(8).contiguous()
-    out = a @ b
-    out.callify()
-    lst = out.tolist()
-    for y in range(8):
-      for x in range(8):
-        self.assertEqual(lst[y][x], 1.0)
-
-  def test_int_dtype(self):
-    a = Tensor([1,2,3], dtype=dtypes.int)
-    b = Tensor([4,5,6], dtype=dtypes.int)
-    out = a + b
-    out.callify()
-    self.assertListEqual(out.tolist(), [5, 7, 9])
-
-  def test_callify_then_schedule(self):
-    a = Tensor([1.,2,3])
-    b = Tensor([4.,5,6])
-    out = a + b
-    out.callify()
-    schedule = out.schedule()
-    self.assertGreater(len(schedule), 0)
-    self.assertListEqual(out.tolist(), [5.0, 7.0, 9.0])
-
-  def test_reduce(self):
-    out = Tensor([1.,2,3,4]).sum()
-    out.callify()
-    self.assertEqual(out.item(), 10.0)
-
-  def test_multiple_ops(self):
-    a = Tensor([1.,2,3])
-    b = Tensor([4.,5,6])
-    out = (a + b) * (a - b)
-    out.callify()
-    self.assertListEqual(out.tolist(), [-15.0, -21.0, -27.0])
-
-  def test_double_callify(self):
-    a = Tensor([1.,2,3])
-    b = Tensor([4.,5,6])
-    out = a + b
-    out.callify()
-    out.callify()
-    self.assertListEqual(out.tolist(), [5.0, 7.0, 9.0])
-
-  def test_double_callify_multi_output(self):
-    a = Tensor([1.,2,3])
-    b = Tensor([4.,5,6])
-    c = a + b
-    d = a * b
-    c.callify(d)
-    c.callify(d)
-    self.assertListEqual(c.tolist(), [5.0, 7.0, 9.0])
-    self.assertListEqual(d.tolist(), [4.0, 10.0, 18.0])
-
-if __name__ == "__main__":
-  unittest.main()

test/unit/test_disk_tensor.py

@@ -85,7 +85,7 @@ class TestRawDiskBuffer(unittest.TestCase):
     _test_bitcasted(t, dtypes.uint32, 0x40490FDB)
     # doesn't suport normal cast
     with self.assertRaises(NotImplementedError):
-      Tensor.empty((4,), dtype=dtypes.int16, device=f"disk:{tmp}").cast(dtypes.float16).to(None).realize()
+      Tensor.empty((4,), dtype=dtypes.int16, device=f"disk:{tmp}").cast(dtypes.float16).realize()
 
     # Those two should be moved to test_dtype.py:test_shape_change_bitcast after bitcast works on non-disk
     with self.assertRaises(RuntimeError):
@@ -264,20 +264,18 @@ class TestDiskTensor(TempDirTestCase):
   def test_strided_read(self):
     # test non-contiguous (strided) read - should read elements at indices 0, 2, 4
     dt = Tensor([0, 1, 2, 3, 4, 5]).to(f"disk:{self.tmp('dt_strided_read')}")
-    with self.assertRaises(RuntimeError):
-      result = dt[::2].tolist()
-      # TODO: dt[::2] selects indices 0, 2, 4, so result should be [0, 2, 4]
-      # self.assertEqual(result, [0, 2, 4])
-      self.assertEqual(result, [0, 1, 2])  # wrong!
+    result = dt[::2].tolist()
+    # TODO: dt[::2] selects indices 0, 2, 4, so result should be [0, 2, 4]
+    # self.assertEqual(result, [0, 2, 4])
+    self.assertEqual(result, [0, 1, 2])  # wrong!
 
   def test_permuted_read(self):
     # test non-contiguous (permuted) read - should read transposed
     dt = Tensor([[0, 1, 2], [3, 4, 5]]).to(f"disk:{self.tmp('dt_permuted_read')}")
-    with self.assertRaises(RuntimeError):
-      result = dt.T.tolist()
-      # TODO: transpose should give [[0, 3], [1, 4], [2, 5]]
-      # self.assertEqual(result, [[0, 3], [1, 4], [2, 5]])
-      self.assertEqual(result, [[0, 1], [2, 3], [4, 5]])  # wrong!
+    result = dt.T.tolist()
+    # TODO: transpose should give [[0, 3], [1, 4], [2, 5]]
+    # self.assertEqual(result, [[0, 3], [1, 4], [2, 5]])
+    self.assertEqual(result, [[0, 1], [2, 3], [4, 5]])  # wrong!
 
   def test_write_ones(self):
     out = Tensor.ones(10, 10, device="CPU").contiguous()
@@ -305,11 +303,10 @@ class TestDiskTensor(TempDirTestCase):
   def test_strided_setitem(self):
     # test non-contiguous (strided) setitem - should set elements at indices 0, 2, 4
     dt = Tensor([1, 2, 3, 4, 5, 6]).to(f"disk:{self.tmp('dt_strided_setitem')}")
-    with self.assertRaises(RuntimeError):
-      dt[::2] = Tensor([10, 20, 30])
-      # TODO: dt[::2] selects indices 0, 2, 4, so result should be [10, 2, 20, 4, 30, 6]
-      # self.assertEqual(dt.tolist(), [10, 2, 20, 4, 30, 6])
-      self.assertEqual(dt.tolist(), [10, 20, 30, 4, 5, 6])  # wrong!
+    dt[::2] = Tensor([10, 20, 30])
+    # TODO: dt[::2] selects indices 0, 2, 4, so result should be [10, 2, 20, 4, 30, 6]
+    # self.assertEqual(dt.tolist(), [10, 2, 20, 4, 30, 6])
+    self.assertEqual(dt.tolist(), [10, 20, 30, 4, 5, 6])  # wrong!
 
   def test_advanced_setitem_not_supported(self):
     dt = Tensor.arange(12).reshape(3, 4).to(f"disk:{self.tmp('dt_advanced_setitem')}")

test/unit/test_gguf.py

@@ -1,38 +1,62 @@
-import os, unittest
+import os, unittest, ctypes
 from tinygrad import dtypes, Tensor, fetch, Device
 from tinygrad.nn.state import ggml_data_to_tensor, gguf_load
 from tinygrad.device import is_dtype_supported
 import numpy as np
-from gguf import GGUFReader, GGUFValueType, GGMLQuantizationType, GGML_QUANT_SIZES, dequantize, quantize
+import ggml
 
 ggml_test_block_count = 4
+ggml_type_to_np_dtype = {
+  ggml.GGML_TYPE_F16: np.float16, ggml.GGML_TYPE_F32:np.float32, ggml.GGML_TYPE_F64:np.float64,
+  ggml.GGML_TYPE_I8:np.int8, ggml.GGML_TYPE_I16: np.int16, ggml.GGML_TYPE_I32: np.int32, ggml.GGML_TYPE_I64: np.int64,
+}
+np_dtype_to_ctype = { np.float16: ctypes.c_uint16 }
+gguf_val_getters = [
+  ggml.gguf_get_val_u8, ggml.gguf_get_val_i8, ggml.gguf_get_val_u16, ggml.gguf_get_val_i16,
+  ggml.gguf_get_val_u32, ggml.gguf_get_val_i32, ggml.gguf_get_val_f32, ggml.gguf_get_val_bool,
+  lambda *args: ggml.gguf_get_val_str(*args).decode("utf-8"), None,
+  ggml.gguf_get_val_u64, ggml.gguf_get_val_i64, ggml.gguf_get_val_f64,
+]
+
+def ggml_tensor_to_numpy(tensor: ggml.ggml_tensor_p):
+  ctx: ggml.ggml_context_p | None = None
+  ggml_type, n_dims, n_els = tensor.contents.type, ggml.ggml_n_dims(tensor), ggml.ggml_nelements(tensor)
+  shape = tuple(reversed(tensor.contents.ne[:n_dims]))
+  if ggml_type not in ggml_type_to_np_dtype:
+    ctx = ggml.ggml_init(ggml.ggml_init_params(mem_size=n_els * 5 + 500, mem_buffer=None))
+    ntensor = ggml.ggml_new_tensor(ctx, ggml.GGML_TYPE_F32, n_dims, tensor.contents.ne)
+    type_traits = ggml.ggml_internal_get_type_traits(ggml_type)
+    type_traits.to_float(ggml.ggml_get_data(tensor), ggml.ggml_get_data_f32(ntensor), n_els)
+    tensor, ggml_type = ntensor, ggml.GGML_TYPE_F32
+
+  np_type = ggml_type_to_np_dtype[ggml_type]
+  ctypes_type = np_dtype_to_ctype.get(np_type, None) or np.ctypeslib.as_ctypes_type(np_type)
+  data = ggml.ggml_get_data(tensor)
+  if data is None: raise ValueError("tensor data is None")
+  arr = (ctypes_type * ggml.ggml_nelements(tensor)).from_address(data)
+  strides = tuple(reversed(tensor.contents.nb[:n_dims]))
+  output = np.ctypeslib.as_array(arr)
+  output.dtype = np_type
+  return np.lib.stride_tricks.as_strided(output, shape=shape, strides=strides), ctx
 
 @unittest.skipIf(any(not is_dtype_supported(t) for t in [ dtypes.uint8, dtypes.half ]), "Backend must support uint8 and half")
 class TestGGUF(unittest.TestCase):
+  def setUp(self) -> None:
+    params = ggml.ggml_init_params(mem_size=0, mem_buffer=None, no_alloc=False)
+    self.ctx = ctypes.cast(ggml.ggml_init(params), ctypes.POINTER(ctypes.c_void_p))
+  def tearDown(self) -> None: ggml.ggml_free(self.ctx)
+
   def test_load_tinyllama_q8_0(self): self._test_gguf_load("https://huggingface.co/ggml-org/models/resolve/main/tinyllamas/stories15M-q8_0.gguf?download=true")
   def test_load_tinyllama_q4_0(self): self._test_gguf_load("https://huggingface.co/ggml-org/models/resolve/main/tinyllamas/stories15M-q4_0.gguf?download=true")
   def test_load_gpt2_q4_1(self): self._test_gguf_load("https://huggingface.co/PrunaAI/gpt2-GGUF-smashed/resolve/main/gpt2.Q4_1.gguf?download=true")
   def test_load_sample_q6_k(self): self._test_gguf_load("https://huggingface.co/Isotr0py/test-gguf-sample/resolve/main/Quant_Q6_K_1024.gguf?download=true")
+  def test_load_sample_mxfp4(self): self._test_gguf_load("https://huggingface.co/ngxson/boring-testing-tiny/resolve/main/stories260K-mxfp4.gguf?download=true")
 
-  def test_dequantization_q8_0_hardcoded(self):
-    # Q8_0: 2 bytes float16 scale + 32 bytes int8 values, dequant = scale * values
-    block = np.frombuffer(np.float16(2.0).tobytes() + np.arange(1, 33, dtype=np.int8).tobytes(), dtype=np.uint8).copy()
-    expected = np.arange(1, 33, dtype=np.float32) * 2.0
-    np.testing.assert_equal(ggml_data_to_tensor(Tensor(block), 32, GGMLQuantizationType.Q8_0.value).numpy().flatten(), expected)
-
-  def test_dequantization_mxfp4_hardcoded(self):
-    # MXFP4: 1 byte shared exponent E + 16 packed bytes (32 x 4-bit values)
-    # nibble: bit3=sign, bit2:1=exp, bit0=mant; E=128 gives scale=1.0
-    # codes 0-7 = [0, 1, 2, 3, 4, 6, 8, 12], codes 8-15 are their negatives
-    block = np.array([0x80] + list(range(16)), dtype=np.uint8)  # E=128, nibbles 0-15 in low, zeros in high
-    expected = np.array([0., 1., 2., 3., 4., 6., 8., 12., -0., -1., -2., -3., -4., -6., -8., -12.] + [0.]*16, dtype=np.float32)
-    np.testing.assert_equal(ggml_data_to_tensor(Tensor(block), 32, 39).numpy().flatten(), expected)
-
-  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_q8_0(self): self._test_dequantization(GGMLQuantizationType.Q8_0)
-  def test_dequantization_q4_k(self): self._test_dequantization(GGMLQuantizationType.Q4_K)
-  def test_dequantization_q6_k(self): self._test_dequantization(GGMLQuantizationType.Q6_K)
+  def test_dequantization_q4_0(self): self._test_dequantization(ggml.GGML_TYPE_Q4_0)
+  def test_dequantization_q4_1(self): self._test_dequantization(ggml.GGML_TYPE_Q4_1)
+  def test_dequantization_q8_0(self): self._test_dequantization(ggml.GGML_TYPE_Q8_0)
+  def test_dequantization_q4_k(self): self._test_dequantization(ggml.GGML_TYPE_Q4_K)
+  def test_dequantization_q6_k(self): self._test_dequantization(ggml.GGML_TYPE_Q6_K)
   def test_dequantization_mxfp4(self):
     MXFP4 = 39
 
@@ -44,7 +68,7 @@ class TestGGUF(unittest.TestCase):
       sign = -1.0 if (code & 0b1000) else 1.0
       exp = (code >> 1) & 0b11
       mant = code & 0b1
-      val = 2 * ((1.0 + 0.5 * mant) * np.exp2(exp - 1) if exp else 0.5 * mant)
+      val = (1.0 + 0.5 * mant) * np.exp2(exp - 1) if exp else 0.5 * mant
       scale = np.exp2(E - 128) if E >= 2 else np.exp2(-127 if E == 1 else -128)
       return sign * val * scale
 
@@ -60,44 +84,24 @@ class TestGGUF(unittest.TestCase):
     # TODO: should this be exact equal? somehow failed on CI
     np.testing.assert_allclose(out.numpy(), expected, atol=0.0, rtol=1e-6)
 
-  def test_dequantization_mxfp4_block(self):
-    MXFP4 = 39
-    # https://gist.github.com/Ananta-Ranganathan/3317b6ed51a3b033e9c2564fafb4e043
-    # used the above script to download the first block of blk.0.attn_k_b.weight from
-    # https://huggingface.co/unsloth/GLM-4.7-Flash-GGUF/blob/main/GLM-4.7-Flash-MXFP4_MOE.gguf
-    # and compute the canonical expected dequantized output with the GGUF PY implementation
-    block = np.array([0x7a, 0x29, 0xab, 0x61, 0x10, 0x21, 0x02, 0x4a,
-                    0x15, 0xca, 0x05, 0x01, 0x9b, 0x39, 0x0b, 0x0b, 0x1c], dtype=np.uint8)
-    expected = np.array([-0.01562500, -0.04687500, 0.01562500, 0.00000000,
-                        0.01562500,  0.03125000, -0.03125000, 0.09375000,
-                        -0.03125000,  0.09375000, 0.01562500, -0.04687500,
-                        -0.01562500, -0.04687500, -0.04687500, -0.06250000,
-                        0.03125000, -0.03125000, 0.12500000,  0.01562500,
-                        0.03125000,  0.00000000, 0.06250000,  0.01562500,
-                        -0.06250000,  0.00000000, 0.00000000, -0.01562500,
-                        0.04687500,  0.00000000, 0.00000000,  0.01562500], dtype=np.float32)
-    out = ggml_data_to_tensor(Tensor(block), 32, MXFP4)
-    # TODO: similar to previous test fails on Mac CI with assert_equal for unclear reason
-    np.testing.assert_allclose(out.numpy(), expected, atol=0.0, rtol=1e-6)
-
   def test_expected_failure_unknown_type(self):
     with self.assertRaises(ValueError):
       ggml_data_to_tensor(Tensor.empty(512, dtype=dtypes.uint8), 256, 1337)
 
-  def _test_dequantization(self, qtype: GGMLQuantizationType):
-    block_size, type_size = GGML_QUANT_SIZES[qtype]
-    n_el, n_bytes = ggml_test_block_count * block_size, ggml_test_block_count * type_size
+  def _test_dequantization(self, ttype: int):
+    type_traits = ggml.ggml_internal_get_type_traits(ttype)
+    n_el, n_bytes = ggml_test_block_count * type_traits.blck_size, ggml_test_block_count * type_traits.type_size
 
-    try:
-      q_data = quantize((np.random.random((n_el,)).astype(np.float32) * 100 - 50), qtype)
-    except NotImplementedError:
-      q_data = np.random.default_rng(42).integers(0, 256, size=n_bytes, dtype=np.uint8)
-    ref = dequantize(q_data, qtype)
+    data_in = (np.random.random((n_el,)).astype(np.float32) * 100 - 50).ctypes.data_as(ctypes.POINTER(ctypes.c_float))
 
-    q_tensor = Tensor(q_data)
-    dq_tensor = ggml_data_to_tensor(q_tensor, n_el, qtype.value).reshape(n_el)
+    c_q_data, c_dq_data = (ctypes.c_char * n_bytes)(0), (ctypes.c_float * n_el)(0)
+    type_traits.from_float(data_in, c_q_data, n_el)
+    type_traits.to_float(c_q_data, c_dq_data, n_el)
 
-    np.testing.assert_equal(dq_tensor.numpy(), ref)
+    q_tensor = Tensor(np.frombuffer(c_q_data, dtype=np.uint8, count=n_bytes))
+    dq_tensor = ggml_data_to_tensor(q_tensor, n_el, ttype).reshape(n_el)
+
+    np.testing.assert_equal(dq_tensor.numpy(), np.frombuffer(c_dq_data, dtype=np.float32))
 
   def _test_gguf_load(self, url: str):
     fp = fetch(url)
@@ -105,20 +109,24 @@ class TestGGUF(unittest.TestCase):
     gguf_tensor = Tensor.empty(model_size, dtype=dtypes.uint8, device=f"disk:{fp}").to(Device.DEFAULT)
     kv_data, tensors = gguf_load(gguf_tensor)
 
-    reader = GGUFReader(fp)
+    gguf_params = ggml.gguf_init_params(ctx=self.ctx, no_alloc=False)
+    gguf_ctx = ggml.gguf_init_from_file(str(fp).encode("utf8"), gguf_params)
+    param_ctx = gguf_params.ctx.contents.value
 
-    for rt in reader.tensors:
-      ref = dequantize(rt.data, rt.tensor_type)
-      np.testing.assert_equal(tensors[rt.name].numpy(), ref.reshape(tensors[rt.name].shape))
+    for ggml_tensor_idx in range(ggml.gguf_get_n_tensors(gguf_ctx)):
+      tensor_name = ggml.gguf_get_tensor_name(gguf_ctx, ggml_tensor_idx)
+      ggml_tensor = ggml.ggml_get_tensor(param_ctx, tensor_name)
+      ggml_tensor_numpy, temp_ctx = ggml_tensor_to_numpy(ggml_tensor)
+      tensor = tensors.get(tensor_name.decode("utf-8"))
+      np.testing.assert_equal(tensor.numpy(), ggml_tensor_numpy)
+      if temp_ctx is not None: ggml.ggml_free(temp_ctx)
 
-    for k, f in reader.fields.items():
-      if k.startswith("GGUF."): continue  # skip file header keys (version, tensor_count, kv_count)
-      def read_val(i, parts=f.parts, is_str=(f.types[-1] == GGUFValueType.STRING)):
-        return bytes(parts[i]).decode("utf-8") if is_str else parts[i][0].item()
-      if f.types[0] == GGUFValueType.ARRAY:
-        self.assertEqual(kv_data[k], [read_val(i) for i in f.data])
-      else:
-        self.assertEqual(kv_data[k], read_val(-1))
+    for gguf_key_id in range(ggml.gguf_get_n_kv(gguf_ctx)):
+      v = kv_data[ggml.gguf_get_key(gguf_ctx, gguf_key_id).decode("utf-8")]
+      v_type = ggml.gguf_get_kv_type(gguf_ctx, gguf_key_id)
+      if (get_fn := gguf_val_getters[v_type]) is not None: self.assertEqual(get_fn(gguf_ctx, gguf_key_id), v)
+
+    ggml.gguf_free(gguf_ctx)
 
 if __name__ == '__main__':
   unittest.main()

test/unit/test_realize_is_realize.py

@@ -28,25 +28,7 @@ class TestRealizeIsRealized(unittest.TestCase):
     t = Tensor.ones(8).contiguous().shard((d, d), axis=0).realize()
     assert all(u.is_realized for u in t.uop.src)
 
-  def test_empty(self):
-    t = Tensor.empty(4, 4).realize()
-    assert not t.uop.is_realized
-
-  def test_disk(self):
-    with tempfile.NamedTemporaryFile() as f:
-      f.write(b'\x00' * 16)
-      f.flush()
-      t = Tensor.empty(4, dtype=dtypes.float32, device=f"disk:{f.name}").realize()
-      assert not t.uop.is_realized
-
-  def test_assign(self):
-    t = Tensor([1, 2, 3])
-    t += 1
-    t.realize()
-    assert t.uop.is_realized
-
-  # TODO: these are not realized after .realize()
-
+  # TODO: these are not realized after .realize() because they stay as consts / don't allocate buffers
   def test_const_not_realized(self):
     t = Tensor(3.14).realize()
     assert not t.uop.is_realized
@@ -55,6 +37,17 @@ class TestRealizeIsRealized(unittest.TestCase):
     t = Tensor.ones(4, 4).realize()
     assert not t.uop.is_realized
 
+  def test_empty_not_realized(self):
+    t = Tensor.empty(4, 4).realize()
+    assert t.uop.is_realized
+
+  def test_disk(self):
+    with tempfile.NamedTemporaryFile() as f:
+      f.write(b'\x00' * 16)
+      f.flush()
+      t = Tensor.empty(4, dtype=dtypes.float32, device=f"disk:{f.name}").realize()
+      assert t.uop.is_realized
+
   def test_none_not_realized(self):
     t = Tensor(None).realize()
     assert not t.uop.is_realized

test/unit/test_setitem_schedule.py

@@ -36,8 +36,7 @@ class TestSetitemInto(unittest.TestCase):
     self.assertEqual(GlobalCounters.kernel_count, 0)
     t.realize()
     self.assertEqual(GlobalCounters.kernel_count, 1)
-    # TODO: this can be just 4 if empty goes through is_realized setitem path
-    self.assertEqual(GlobalCounters.global_mem, 4*(3*2+1)) # 3 elements had +1, 1 is assigned directly
+    self.assertEqual(GlobalCounters.global_mem, 4)
     t[1].realize()
     t.realize()
     self.assertEqual(GlobalCounters.kernel_count, 1)

test/unit/test_system_pci_scan_bus.py

@@ -1,28 +0,0 @@
-import sys
-import pytest
-
-@pytest.mark.skipif(sys.platform != "linux", reason="uses linux sysfs layout")
-def test_pci_scan_bus_filters_vendor(monkeypatch):
-  import tinygrad.runtime.support.system as system
-
-  fake = {
-    "/sys/bus/pci/devices/0000:00:01.0/vendor": "0x1234",
-    "/sys/bus/pci/devices/0000:00:01.0/device": "0x1111",
-    "/sys/bus/pci/devices/0000:00:02.0/vendor": "0xabcd",
-    "/sys/bus/pci/devices/0000:00:02.0/device": "0x1111",
-  }
-
-  class FakeFileIOInterface:
-    def __init__(self, path, *args, **kwargs):
-      self.path = path
-
-    def listdir(self):
-      assert self.path == "/sys/bus/pci/devices"
-      return ["0000:00:01.0", "0000:00:02.0"]
-
-    def read(self, *args, **kwargs):
-      return fake[self.path]
-
-  monkeypatch.setattr(system, "FileIOInterface", FakeFileIOInterface)
-
-  assert system.System.pci_scan_bus(0x1234, devices=[(0xffff, [0x1111])]) == ["0000:00:01.0"]

test/unit/test_tinyfs.py

@@ -1,87 +0,0 @@
-import json, math, os, socketserver, threading, unittest
-import numpy as np
-from tinygrad import Tensor, dtypes
-from extra.tinyfs.fetch_file import hash_file, _python_hash_1mb
-
-_chunks: dict[bytes, bytes] = {}
-
-class _Handler(socketserver.StreamRequestHandler):
-  def handle(self):
-    while line := self.rfile.readline():
-      cmd = line.decode().strip()
-      if cmd == "INFO":
-        self.wfile.write(json.dumps({"node0": ["node0", f"127.0.0.1:{self.server.server_address[1]}"]}).encode() + b"\r\n")
-      elif cmd.startswith("STORE_IN"):
-        data = self.rfile.read(int(cmd.split()[1]))
-        hashes = bytearray()
-        for i in range(math.ceil(len(data) / Tensor.CHUNK_SIZE)):
-          chunk = data[i*Tensor.CHUNK_SIZE:(i+1)*Tensor.CHUNK_SIZE].ljust(Tensor.CHUNK_SIZE, b'\0')
-          h = _python_hash_1mb(chunk)
-          _chunks[h] = chunk
-          hashes.extend(h)
-        self.wfile.write(hashes)
-      elif cmd.startswith("LOAD_IN"):
-        hashes = self.rfile.read(int(cmd.split()[1]))
-        self.wfile.write(json.dumps(["node0"] * (len(hashes) // 16)).encode() + b"\r\n")
-      elif cmd.startswith("CHUNK_OUT"):
-        size = int(cmd.split()[1])
-        self.wfile.write(_chunks.get(self.rfile.read(16), bytes(size))[:size])
-      self.wfile.flush()
-
-# regressed in 55d3a5def "preallocate all realized buffers"
-class TestTinyFS(unittest.TestCase):
-  @classmethod
-  def setUpClass(cls):
-    _chunks.clear()
-    cls._server = socketserver.ThreadingTCPServer(('127.0.0.1', 0), _Handler)
-    cls._server.daemon_threads = True
-    threading.Thread(target=cls._server.serve_forever, daemon=True).start()
-    os.environ["TINYFS_ENDPOINT"] = f"127.0.0.1:{cls._server.server_address[1]}"
-
-  @classmethod
-  def tearDownClass(cls):
-    _chunks.clear()
-    os.environ.pop("TINYFS_ENDPOINT", None)
-    cls._server.shutdown()
-    cls._server.server_close()
-
-  @unittest.expectedFailure
-  def test_store(self):
-    h = Tensor([1.0, 2.0, 3.0, 4.0]).fs_store().realize()
-    self.assertEqual(h.shape, (16,))
-    self.assertEqual(h.dtype, dtypes.uint8)
-
-  @unittest.expectedFailure
-  def test_store_deterministic(self):
-    a = Tensor([1.0, 2.0, 3.0, 4.0]).fs_store().realize()
-    b = Tensor([1.0, 2.0, 3.0, 4.0]).fs_store().realize()
-    np.testing.assert_array_equal(a.numpy(), b.numpy())
-
-  @unittest.expectedFailure
-  def test_store_different_data(self):
-    a = Tensor([1.0, 2.0, 3.0, 4.0]).fs_store().realize()
-    b = Tensor([5.0, 6.0, 7.0, 8.0]).fs_store().realize()
-    self.assertNotEqual(a.tolist(), b.tolist())
-
-  @unittest.expectedFailure
-  def test_roundtrip_uint8(self):
-    arr = np.arange(256, dtype=np.uint8)
-    loaded = Tensor(arr).fs_store().realize().fs_load(len(arr))
-    np.testing.assert_array_equal(loaded.numpy(), arr)
-
-  @unittest.expectedFailure
-  def test_roundtrip_multichunk_uint8(self):
-    arr = np.random.default_rng(42).integers(0, 256, size=Tensor.CHUNK_SIZE + 1024, dtype=np.uint8)
-    loaded = Tensor(arr).fs_store().realize().fs_load(len(arr))
-    np.testing.assert_array_equal(loaded.numpy(), arr)
-
-  @unittest.expectedFailure
-  def test_hash_matches_python_impl(self):
-    arr = np.arange(256, dtype=np.uint8)
-    h = Tensor(arr).fs_store().realize()
-    # the hash from fs_store should match the pure-Python hash_file reference
-    padded = arr.tobytes().ljust(Tensor.CHUNK_SIZE, b'\0')
-    self.assertEqual(h.data().tobytes(), hash_file(padded))
-
-if __name__ == "__main__":
-  unittest.main()

tinygrad/apps/llm.py

@@ -340,10 +340,6 @@ if __name__ == "__main__":
   # do benchmark
   if args.benchmark:
     param_bytes = sum(x.nbytes() for x in nn.state.get_parameters(model))
-    for b in model.blk:
-      if hasattr(b, 'ffn_gate_exps'):
-        expert_bytes = b.ffn_gate_exps.weight.nbytes() + b.ffn_up_exps.weight.nbytes() + b.ffn_down_exps.weight.nbytes()
-        param_bytes -= int(expert_bytes * (1 - b.num_experts_per_tok / b.ffn_gate_exps.weight.shape[0]))
     gen = model.generate([0], 0)
     for _ in range(args.benchmark):
       GlobalCounters.reset()

tinygrad/codegen/gpudims.py

@@ -48,9 +48,10 @@ def get_grouped_dims(prefix, dims:tuple[sint, ...], max_sizes:tuple[int, ...]|No
   elif (a:=len(limited)) > (b:=len(dims)):
     if a == 2 and b == 1: return [raw_idxs[0] * limited[1] + raw_idxs[1]]
     if a == 3 and b == 1: return [(raw_idxs[0] * limited[1] + raw_idxs[1]) * limited[2] + raw_idxs[2]]
-  if limited != dims:
+    if a == 3 and b == 2: return [raw_idxs[0] * limited[1] + raw_idxs[1], raw_idxs[2]]
+  elif limited != dims:
     # Convert to 1D
-    flat = raw_idxs[0]*limited[1]+raw_idxs[1] if len(limited) == 2 else raw_idxs[0]*(limited[1]*limited[2])+raw_idxs[1]*limited[2]+raw_idxs[2]
+    flat = raw_idxs[0]*limited[1]+raw_idxs[1] if len(dims) == 2 else raw_idxs[0]*(limited[1]*limited[2])+raw_idxs[1]*limited[2]+raw_idxs[2]
     # Get back original indices from 1D
     return [flat//dims[1], flat%dims[1]] if len(dims) == 2 else [flat//(dims[2]*dims[1]), (flat//dims[2])%dims[1], flat%dims[2]]
   return raw_idxs

tinygrad/codegen/late/devectorizer.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass, field
 from tinygrad.dtype import dtypes, ImageDType, DType, AddrSpace, Invalid, PtrDType
 from tinygrad.uop.ops import UOp, Ops, UPat, PatternMatcher, GroupOp, identity_element
 from tinygrad.uop.symbolic import uop_given_valid, parse_valid, invalid_gate
-from tinygrad.helpers import getenv, flatten, AMX, prod, IMAGE
+from tinygrad.helpers import getenv, flatten, AMX, prod, ceildiv, IMAGE
 from tinygrad.renderer import Renderer
 
 # ***** image load valid simplification *****
@@ -187,9 +187,9 @@ def _do_image_fixup(dt:ImageDType, idx:UOp) -> tuple[UOp, UOp, int, int]:
   buf = idx.src[0]
   x, valid = idx.src[1].get_idx(), idx.src[1].get_valid()
   h, w = dt.shape[0], dt.shape[1]
-  if IMAGE == 1 and valid is not None:
-    h, w = max(ImageDType.valid_dims(dt), key=lambda hw:
-               (len(_drop_valid_stmts(valid, idx:=uop_given_valid(valid, UOp.vectorize((x//4)%hw[1], x//(4*hw[1]))), *hw)), -len(idx.backward_slice)))
+  if IMAGE == 1 and valid is not None and (tp:=dt.size // 4) // 64:
+    h, w = max(([(1, tp)] * (tp < 16384)) + [(tp//64//k, 64*k) for k in range(ceildiv(tp//64, 16384), min(tp//64, 256)+1) if (tp//64) % k == 0],
+               key=lambda hw: len(_drop_valid_stmts(valid, UOp.vectorize((x//4)%hw[1], x//(4*hw[1])), *hw)))
     buf = buf.replace(dtype=(dtypes.imageh if dt.itemsize == 2 else dtypes.imagef)((h, w, 4), w * 4 * dt.itemsize))
   oidx = UOp(Ops.VECTORIZE, dtypes.index.vec(2), ((x // 4) % w, (x // (4*w))))
   return x, idx.replace(src=(buf, oidx.valid(valid))), w, h

tinygrad/codegen/opt/postrange.py

@@ -7,7 +7,7 @@ from tinygrad.uop.ops import axis_letters, axis_colors, axis_to_pos
 from tinygrad.device import Buffer
 from tinygrad.dtype import dtypes, ImageDType
 from tinygrad.helpers import colored, BEAM, getenv, DEBUG, to_function_name, NOOPT, argsort, round_up, prod, merge_dicts, get_single_element, flatten
-from tinygrad.helpers import ALLOW_TF32, count, Context
+from tinygrad.helpers import ALLOW_TF32, count, Context, ceildiv
 from tinygrad.codegen.opt import Opt, OptOps, KernelOptError, check
 from tinygrad.codegen.simplify import pm_flatten_range
 from tinygrad.renderer import Renderer
@@ -353,17 +353,26 @@ def apply_opts(ast:UOp, ren:Renderer) -> UOp:
       k = hand_coded_optimizations(k)
   return k.get_optimized_ast(name_override=ast.arg.name if ast.arg is not None and ast.arg.name != "test" else None)
 
+# max image width (pixels): 16384. max image size: 4 * 16384 ** 2
+def _image_shape(dt):
+  if dt.base not in (dtypes.half, dtypes.float) or isinstance(dt, ImageDType) or dt.size > 4*16384*16384 or dt.nbytes()%64 != 0: return None
+  if dt.size <= 4 * 16384: return (1, dt.size // 4, 4)
+  if (pxls:=dt.size // 4) % 64: return None
+  # verify that a valid format exists
+  try: return next((pxls // 64 // k, 64 * k, 4) for k in range(ceildiv(pxls // 64, 16384), min(pxls // 64, 256)+1))
+  except StopIteration: return None
+
 def make_image(pa, off, idx):
-  if not isinstance(dt:=pa.dtype, ImageDType) and (idx.tag is None or idx.tag) and (shapes:=ImageDType.valid_dims(dt)):
-    new_pa = pa.replace(dtype=(dtypes.imageh if dt.base==dtypes.half else dtypes.imagef)(shapes[0] + (4,), shapes[0][1] * 4 * dt.itemsize))
-    new_idx = idx.replace(src=(new_pa, off), dtype=dtypes.float if dt.base == dtypes.half else idx.dtype)
+  if (idx.tag is None or idx.tag) and (shape:=_image_shape(dt:=pa.dtype)):
+    new_idx = idx.replace(src=(pa.replace(dtype=(dtypes.imageh if dt.base==dtypes.half else dtypes.imagef)(shape, shape[1] * 4 * dt.itemsize)), off),
+                          dtype=dtypes.float if dt.base == dtypes.half else idx.dtype)
     return new_idx if idx.tag or dt.base == dtypes.float else new_idx.cast(dtypes.half)
 
 pm_make_images = PatternMatcher([
   # ensure we dont create an unfoldable image store
   (UPat(Ops.STORE, src=(UPat.var("idx"),), allow_any_len=True, name="st"), lambda idx,st:
    st.replace(src=(idx.rtag(is_image:=any(c.op is Ops.RANGE and (c.vmax+1)%4 == 0 for c in idx.src[1].get_idx().split_uop(Ops.ADD))),
-                   st.src[1].cast(dtypes.float if is_image and ImageDType.valid_dims(idx.src[0].dtype) else idx.dtype.base)))),
+                   st.src[1].cast(dtypes.float if is_image and _image_shape(idx.src[0].dtype) else idx.dtype.base)))),
   (UPat(Ops.INDEX, src=(UPat(Ops.PARAM, name="pa"), UPat.var("off")), name="idx"), make_image),
   # remove double cast from image loads / stores
   (UPat(Ops.INDEX, src=(UPat(Ops.PARAM, name="pa"),), allow_any_len=True, name="idx").cast(dtypes.half).cast(dtypes.float), lambda idx,pa:

tinygrad/device.py

@@ -283,10 +283,10 @@ class CompilerSet: cset:list[tuple[type[Renderer]|functools.partial, ContextVar|
 class Compiled:
   profile_events:list[ProfileEvent] = [ProfileDeviceEvent("CPU")] # NOTE: CPU is the default device.
 
-  def __init__(self, device:str, allocator:Allocator, compilers:CompilerSet|None, runtime, graph=None):
+  def __init__(self, device:str, allocator:Allocator, compilers:CompilerSet|None, runtime, graph=None, group_id=None):
     from tinygrad.renderer import Renderer
 
-    self.device, self.allocator, self.runtime, self.graph = device, allocator, runtime, graph
+    self.device, self.allocator, self.runtime, self.graph, self.group_id = device, allocator, runtime, graph, group_id
 
     self.comps_ctrl_var = compilers.ctrl_var if compilers is not None else None
     self.comp_sets:dict[str, tuple[ContextVar|None, type[Renderer]|functools.partial]] = {}