tinygrad 0.10.0__py3-none-any.whl → 0.10.1__py3-none-any.whl

tinygrad/multi.py

@@ -1,177 +0,0 @@
-from __future__ import annotations
-from typing import Optional, Tuple, List, Dict
-import functools, itertools, operator
-from tinygrad.helpers import all_same, all_int, dedup, prod, DEBUG, RING, getenv
-from tinygrad.dtype import DType
-from tinygrad.ops import Ops, MathTrait
-from tinygrad.engine.lazy import LazyBuffer
-from tinygrad.shape.shapetracker import sint
-
-def all_reduce(bop: Ops, lbs: List[LazyBuffer]) -> List[LazyBuffer]:
-  assert all_int(lbs[0].shape), f"does not support symbolic shape {lbs[0].shape}"
-  assert all_same([lb.shape[0] for lb in lbs]), "allreduce with uneven shards is undefined"
-  n_lbs, shape, numel = len(lbs), lbs[0].shape, prod(lbs[0].shape)
-  # ring allreduce doesn't provide a benefit with only 2 nodes or where number of elements is less than 256k (empirically)
-  # fallback to naive allreduce to save on kernel dispatch, chunking and reassembling chunks.
-  use_ring = (RING >= 2 or (n_lbs > 2 and numel > getenv("RING_ALLREDUCE_THRESHOLD", 256_000) and RING >= 1))
-  if DEBUG >= 2: print(f"{'RING ALLREDUCE' if use_ring else 'NAIVE ALLREDUCE'} {n_lbs}x{numel} | {lbs[0].dtype}")
-  if not use_ring: return [functools.reduce(lambda x,y: x.alu(bop, y), [x.copy_to_device(lb.device) for x in lbs]) for lb in lbs]
-
-  factor = next(f for f in [32, 16, 8, 4, 2, 1] if numel % f == 0)
-  base, left = (numel // factor) // n_lbs, (numel // factor) % n_lbs
-  chunk_sizes = [(base + 1) * factor] * left + [base * factor] * (n_lbs - left)
-  acc = 0
-  chunks = [(acc, (acc := acc + i)) for i in chunk_sizes if i > 0]
-  chunked = [[lb.reshape((numel,)).shrink(((s,e),)) for s,e in chunks] for lb in lbs]
-
-  # scatter-reduce
-  for step in range(n_lbs-1):
-    for i in range(len(chunks)):
-      src, dest = (i+step)%n_lbs, (i+step+1)%n_lbs
-      chunked[dest][i] = chunked[dest][i].alu(bop, chunked[src][i].copy_to_device(chunked[dest][i].device, force=True))
-
-  # allgather
-  for step in range(n_lbs-1):
-    for i in range(len(chunks)):
-      src, dest = (i+step-1)%n_lbs, (i+step)%n_lbs
-      chunked[dest][i] = chunked[src][i].copy_to_device(chunked[dest][i].device, force=True)
-
-  # assemble chunks back
-  pads = [((s,numel-e),) for s,e in chunks]
-  return [functools.reduce(operator.add, [c.pad(pad) for pad,c in zip(pads,lb_c)]).reshape(shape) for lb_c in chunked]
-
-def to_sharded(lbs:List[LazyBuffer], axis:int, bounds: Tuple[Tuple[int, int], ...]) -> List[LazyBuffer]:
-  if DEBUG >= 3 and lbs[0].shape[axis] % len(lbs) != 0: print(f"multi axis uneven: {lbs[0].shape=} {axis=} {len(lbs)=}, bounds={bounds}")
-  return [lb.shrink(tuple((0,s) if a != axis else bound for a,s in enumerate(lb.shape))) for i, (bound, lb) in enumerate(zip(bounds, lbs))]
-
-class MultiLazyBuffer(MathTrait):
-  def __init__(self, lbs:List[LazyBuffer], axis:Optional[int], real:Optional[List[bool]]=None):
-    assert all(isinstance(x, LazyBuffer) for x in lbs) and len(lbs), "all lbs must be LazyBuffers, and we need at least one of them"
-    assert all_same([x.dtype for x in lbs]), f"all multilazybuffer needs same dtype, getting {[x.dtype for x in lbs]}"
-    self.lbs, self.axis, self.dtype, self.device, self.real = lbs, axis, lbs[0].dtype, tuple(x.device for x in lbs), real or [True]*len(lbs)
-    if axis is not None:
-      splits = list(itertools.accumulate([lb.shape[axis] for lb in lbs], initial=0))
-      self.bounds = tuple(zip(splits, splits[1:]))
-
-  @property
-  def shape(self): return tuple(sum(y.shape[a] for y in self.real_lbs) if a == self.axis else s for a,s in enumerate(self.real_lbs[0].shape))
-
-  @property
-  def size(self): return sum(x.size for x in self.real_lbs)
-
-  @property
-  def real_lbs(self): return [lb for lb,r in zip(self.lbs, self.real) if r]
-
-  def __repr__(self): return f"<MLB {self.axis=} {self.real=} {chr(10)}{chr(10).join([f'{x.device} {x.st}' for x in self.lbs])}>"
-
-  @staticmethod
-  def from_sharded(lb:LazyBuffer, devices:Tuple[str, ...], axis:Optional[int], bounds:Optional[Tuple[Tuple[int, int], ...]]):
-    assert (axis is None) == (bounds is None), "must specify bounds iff axis is specified"
-    lbs = [lb] * len(devices)
-    sharded_lbs = [lb.copy_to_device(d) for lb,d in zip(to_sharded(lbs, axis, bounds) if axis is not None and bounds is not None else lbs, devices)]
-    return MultiLazyBuffer([lb if lb.is_unrealized_unmasked_const() else lb.contiguous(allow_buffer_view=False) for lb in sharded_lbs], axis)
-
-  def copy_to_device(self, device:str) -> LazyBuffer:
-    if self.axis is None:
-      # if we already have a copy on the device, return that
-      return next((lb for lb in self.real_lbs if lb.device == device), self.real_lbs[0].copy_to_device(device))
-    # copy lbs to device, pad to final shape, and sum
-    llbs:List[LazyBuffer] = []
-    for lb,real,(start,end) in zip(self.lbs, self.real, self.bounds):
-      if not real: continue
-      pad_arg = tuple((0,0) if a != self.axis else (start, self.bounds[-1][1]-end) for a in range(len(lb.shape)))
-      llbs.append(lb.copy_to_device(device).pad(pad_arg))
-    return functools.reduce(operator.add, llbs)
-
-  # passthroughs
-  @property
-  def is_realized(self) -> bool: return all(lb.base.realized is not None for lb in self.real_lbs)
-  def cast(self, dtype:DType, bitcast:bool=False, allow_buffer_view=True):
-    return MultiLazyBuffer([x.cast(dtype, bitcast, allow_buffer_view) for x in self.lbs], self.axis, self.real)
-  def const_like(self, b) -> MultiLazyBuffer: return MultiLazyBuffer([x.const_like(b) for x in self.lbs], self.axis, self.real)
-  def assign(self, x:MultiLazyBuffer): return MultiLazyBuffer([s.assign(d) for s,d in zip(self.lbs, x.lbs)], self.axis, self.real)
-  def contiguous(self): return MultiLazyBuffer([x.contiguous() for x in self.lbs], self.axis, self.real)
-  def clone(self) -> MultiLazyBuffer: return MultiLazyBuffer([lb.clone() for lb in self.lbs], self.axis, self.real)
-
-  # elementwise is simple
-  def alu(self, op:Ops, *in_srcs:MultiLazyBuffer) -> MultiLazyBuffer:
-    msrcs = (self,)+in_srcs
-    assert all(isinstance(x, MultiLazyBuffer) for x in msrcs), f"all buffers must be MultiLazyBuffer {msrcs}"
-    assert all_same([x.device for x in msrcs]), f"all buffers must have the same device {[x.device for x in msrcs]}"
-
-    # NOTE: they all have to share an axis, we always choose [-1]
-    axis, bounds = axes[-1] if len(axes := dedup([(x.axis, x.bounds) for x in msrcs if x.axis is not None])) else (None, None)
-    srcs:List[List[LazyBuffer]] = []
-    not_all_real = not all(all(mlb.real) for mlb in msrcs)
-    new_real = [all(transposed) for transposed in zip(*[mlb.real for mlb in msrcs])] if not_all_real else self.real
-    assert any(new_real), "output contains no real lb"
-    for mlb in msrcs:
-      if (mlb.axis == axis and (mlb.axis is None or mlb.bounds == bounds)) or not_all_real: srcs.append(mlb.lbs)
-      elif mlb.axis is None and axis is not None: srcs.append(to_sharded(mlb.lbs, axis, bounds))
-      else: srcs.append(to_sharded([mlb.copy_to_device(lb.device) for lb in mlb.lbs], axis, bounds))
-    new_real_lbs:Dict[int,LazyBuffer] = {i:lsrcs[0].alu(op, *lsrcs[1:]) for i,(lsrcs,r) in enumerate(zip(zip(*srcs), new_real)) if r}
-    # NOTE: const dtype should match real
-    new_dtype = next(iter(new_real_lbs.values())).dtype
-    return MultiLazyBuffer([new_real_lbs.get(i, lsrcs[0].const_like(0).cast(new_dtype)) for i,lsrcs in enumerate(zip(*srcs))], axis, new_real)
-
-  def r(self, op:Ops, axis:Tuple[int, ...]) -> MultiLazyBuffer:
-    if self.axis is not None and self.axis in axis:
-      # all-reduce on sharded axes
-      reduced_parts = [(x if r else x.const_like(0)).r(op, axis) for x,r in zip(self.lbs, self.real)]
-      # if all partitions are real, do all_reduce
-      if all(self.real): return MultiLazyBuffer(all_reduce(op, reduced_parts), None)
-      # only one partition is real, keep it
-      return MultiLazyBuffer(reduced_parts, None, self.real)
-    # reduce on non sharded axes, piecewise is fine. if axis is None this is also correct
-    return MultiLazyBuffer([x.r(op, axis) for x in self.lbs], self.axis, self.real)
-
-  # *** movement ops ***
-
-  def _shape_to_single_shard(self, shape:Tuple[sint, ...], lb:LazyBuffer) -> Tuple[sint, ...]:
-    return tuple(lb.shape[self.axis] if a == self.axis else s for a,s in enumerate(shape))
-
-  def reshape(self, arg:Tuple[sint, ...]):
-    if self.axis is None: return MultiLazyBuffer([x.reshape(arg) for x in self.lbs], None, self.real)
-    assert prod(self.shape) == prod(arg), "reshape must maintain prod(shape)"
-    arg_acc:List[sint] = list(itertools.accumulate(arg, operator.mul, initial=1))
-    # new_axis is the last one that preserves prod(prior to new_axis) and must not move items between shards
-    # todo: what to do about shrinking to self.shape[self.axis]==1 len(self.real_lbs)==1?
-    new_axis = len(arg_acc) - arg_acc[::-1].index(prod(self.shape[:self.axis])) - 1
-    assert all(prod(lb.shape[self.axis:])%prod(arg[new_axis+1:])==0 for lb in self.lbs), f"reshape cannot move items between shards {self=} {arg=}"
-    lbs = [x.reshape(tuple(s if a!=new_axis else prod(x.shape[self.axis:])//prod(arg[new_axis+1:]) for a,s in enumerate(arg))) for x in self.lbs]
-    return MultiLazyBuffer(lbs, new_axis, self.real)
-
-  def pad(self, arg:Tuple[Tuple[sint, sint], ...]):
-    assert self.axis is None or arg[self.axis] == (0,0) or not all(self.real), f"padding not supported for {arg=}"
-    # pad on shard axis -> fill others with zeros and set real to all True
-    if self.axis is not None and arg[self.axis] != (0,0):
-      # pad back to whole axis, remove real mask
-      assert all(arg[i] == (0, 0) for i in range(len(self.shape)) if i != self.axis), "cannot pad sharded and non-sharded axis at the same time"
-      dim, bound = sum(lb.shape[self.axis] for lb in self.lbs), self.bounds[self.real.index(True)]
-      assert arg[self.axis] == (bound[0], dim-bound[1]), "can only pad to whole axis"
-      return MultiLazyBuffer([x if r else x.const_like(0) for x,r in zip(self.lbs, self.real)], self.axis)
-    return MultiLazyBuffer([x.pad(arg) for x in self.lbs], self.axis, self.real)
-
-  def expand(self, arg:Tuple[sint, ...]):
-    # NOTE: this assert isn't needed, sharded axis can have dim 1
-    assert self.axis is None or arg[self.axis] == self.shape[self.axis], f"expand not supported on sharded axis {arg=}"
-    return MultiLazyBuffer([x.expand(self._shape_to_single_shard(arg, x)) for x in self.lbs], self.axis, self.real)
-
-  def permute(self, arg:Tuple[int, ...]):
-    # all permutes supported!
-    return MultiLazyBuffer([x.permute(arg) for x in self.lbs], arg.index(self.axis) if self.axis is not None else None, self.real)
-
-  def shrink(self, arg:Tuple[Tuple[sint, sint], ...]):
-    assert self.axis is None or arg[self.axis] == (0, self.shape[self.axis]) or arg[self.axis] in self.bounds, f"shrinking not supported for {arg=}"
-    if self.axis is not None and arg[self.axis] in self.bounds and arg[self.axis] != (0, self.shape[self.axis]):
-      assert all(arg[i] == (0, s) or i == self.axis for i,s in enumerate(self.shape)), "cannot shrink sharded and non-sharded axis at the same time"
-      # NOTE: shrink on the shard axis is only allowed when result is a single partition, denoted by the new real
-      idx = self.bounds.index(arg[self.axis])
-      # zero out other lbs to not create lb reference
-      return MultiLazyBuffer([lb if i==idx else lb.const_like(0) for i,lb in enumerate(self.lbs)], self.axis, [i==idx for i in range(len(self.lbs))])
-    return MultiLazyBuffer([x.shrink(tuple((0, x.shape[self.axis]) if a == self.axis else s for a,s in enumerate(arg))) for x in self.lbs],
-                           self.axis, self.real)
-
-  def stride(self, arg:Tuple[int, ...]):
-    assert self.axis is None or arg[self.axis] == 1, "flipping not supported on sharded axis"
-    return MultiLazyBuffer([x.stride(arg) for x in self.lbs], self.axis, self.real)

tinygrad/runtime/graph/clang.py

@@ -1,39 +0,0 @@
-from typing import List, Dict, cast
-import ctypes
-from tinygrad.helpers import dedup, cpu_time_execution, DEBUG
-from tinygrad.engine.jit import GraphRunner, GraphException
-from tinygrad.device import Buffer, Device
-from tinygrad.engine.realize import ExecItem, CompiledRunner
-from tinygrad.ops import Variable
-from tinygrad.runtime.ops_clang import ClangProgram
-from tinygrad.renderer.cstyle import ClangRenderer
-render_dtype = ClangRenderer().render_dtype
-
-class ClangGraph(GraphRunner):
-  def __init__(self, jit_cache: List[ExecItem], input_rawbuffers: List[Buffer], var_vals: Dict[Variable, int]):
-    super().__init__(jit_cache, input_rawbuffers, var_vals)
-    if not all(isinstance(ji.prg, CompiledRunner) for ji in jit_cache): raise GraphException
-
-    prgs = '\n'.join(dedup([cast(CompiledRunner, ji.prg).p.src for ji in jit_cache]))
-    args = [f"{render_dtype(x.dtype)}* arg{i}" for i,x in enumerate(input_rawbuffers)]
-    args += sorted([f"int {v.expr}" for v in var_vals])
-    code = ["void batched("+','.join(args)+") {"]
-    for ji in jit_cache:
-      args = []
-      for buf in ji.bufs:
-        assert buf is not None
-        if buf in input_rawbuffers:
-          args.append(f"arg{input_rawbuffers.index(buf)}")
-        else:
-          args.append(f"({render_dtype(buf.dtype)}*)0x{ctypes.addressof(buf._buf):X}")
-      args += [x.expr for x in cast(CompiledRunner, ji.prg).p.vars]
-      code.append(f"  {cast(CompiledRunner, ji.prg).p.function_name}({','.join(args)});")
-    code.append("}")
-    if DEBUG >= 4: print("\n".join(code))
-    compiler = Device["CLANG"].compiler
-    assert compiler is not None
-    self.clprg = ClangProgram("batched", compiler.compile(prgs+"\n"+"\n".join(code))) # no point in caching the pointers
-
-  def __call__(self, rawbufs: List[Buffer], var_vals: Dict[Variable, int], wait=False):
-    return cpu_time_execution(
-    lambda: self.clprg(*[x._buf for x in rawbufs], *[x[1] for x in sorted(var_vals.items(), key=lambda x: x[0].expr)]), enable=wait)

tinygrad-0.10.0.dist-info/RECORD

@@ -1,77 +0,0 @@
-tinygrad/__init__.py,sha256=2Jhg7NSWlegCi4OAfGW0iHRVHeqMx09f7446rwAmc60,587
-tinygrad/device.py,sha256=8jr2SuxLHFk84e_9ky6pdh5v8MvPlT5rXsP0Ls04kNU,12513
-tinygrad/dtype.py,sha256=a9WaH5bISo1WNFvPpcC_EL_fHNP9faiBIOHFrKaYl9A,9874
-tinygrad/function.py,sha256=SAVRzPzh5kKyb01TSOCbFG8B02he7aer7S4uoY-XFoA,8464
-tinygrad/helpers.py,sha256=yJelGLmg8SH1R9gW77bv5bkuI4RCXuTcQVnZdPlk108,17969
-tinygrad/multi.py,sha256=cRy_bVA46GwB0aES_jcuLYLco6klQUuiosQcIiANBJ0,11809
-tinygrad/ops.py,sha256=sckffasep4LxfWFeEBS6BeMEYpjvqoBUL2k6mMh__ME,60926
-tinygrad/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tinygrad/tensor.py,sha256=NF2UNn_Mvv1uZT9H8PYVLawQ7dEpRwQU-1wiu-cREhM,170536
-tinygrad/codegen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tinygrad/codegen/kernel.py,sha256=WzcvbkOLBPhcC8tuPUEH1BLF_UqFzL7PZkanfefSHgQ,45406
-tinygrad/codegen/linearize.py,sha256=kQ1NQE_8OThIoWRrMVCvXKqd_8uXB_4uIrB_tw_hXGc,3926
-tinygrad/codegen/lowerer.py,sha256=GwFiie_j1-kLZrXELJv_HTEltSJ1DULWxsbiQDnnrT8,7725
-tinygrad/codegen/transcendental.py,sha256=lZX8y_eAPQGom8gNypNLg5PpxBchrrLKG6b24CZLLkc,13155
-tinygrad/codegen/uopgraph.py,sha256=bqGgqSbmE76pj77V96i5E3HucpRA67Q84MqHX0Fn3MY,28842
-tinygrad/engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tinygrad/engine/jit.py,sha256=wXlTUhXa4p11ZmShCPY5nH2PGxJpDXbfCRFk7rOMGiA,15838
-tinygrad/engine/lazy.py,sha256=g8i1W5Lrd5WA8rcKBBonVxLUIVVOjPO46ZIDteADIrk,13836
-tinygrad/engine/memory.py,sha256=30WHQahkQR0MooGgxA2DuyLnxpLtiRu-nuF11hhzZb4,3303
-tinygrad/engine/realize.py,sha256=cGVrGrryfaNgoNM9DNhvfngH7tkSm73nMLc35G_Ud6E,12922
-tinygrad/engine/schedule.py,sha256=jP4F0bgGWKVDxWjzK8ozHwcntn22Kkgixvj2UAAd1B4,23495
-tinygrad/engine/search.py,sha256=fJfiwttnpC0NpCfrRPwbk_9VPMLnBDXH0S1IkK3Ow6s,12473
-tinygrad/nn/__init__.py,sha256=Jl7ddXj8EOhximbQWUgVzkwn_ODupNJPda_v-HJp1As,15574
-tinygrad/nn/datasets.py,sha256=JyhoLwNB9Yek2IORMQ6cGRh5fnrYol5hkz1cAuTELPk,1067
-tinygrad/nn/optim.py,sha256=eznleXq_eudT--oEIUD79ZMRtAOczoCssTAPWQ_t30E,6808
-tinygrad/nn/state.py,sha256=XvgYNHEHksQyGvQnHmtRB4PLF1OUQi72FX7MKp_CTWI,14806
-tinygrad/renderer/__init__.py,sha256=Edhs-ldaHirH0F_JAN7HrVZ9AGCjLzQdb57l1es4muE,4529
-tinygrad/renderer/cstyle.py,sha256=oMIQk2TscKi1huNaUwSyJC0u-NZABvJ9xI3Ti1a7RII,31279
-tinygrad/renderer/llvmir.py,sha256=k_OPni2X7xVCUugiJ5ZczXf8wYrlkFllcZXhlMt1fNc,8137
-tinygrad/renderer/ptx.py,sha256=lIcMtqcvcrC9vW6SNqiSBDyobP-ytGwGahZZFQwSKTQ,16041
-tinygrad/runtime/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tinygrad/runtime/ops_amd.py,sha256=7ZKaqBLL6gqhYlwhB8m6n5wlN-hPs_t36MPaQR_ocBA,29860
-tinygrad/runtime/ops_clang.py,sha256=kEbyFQimfLwuhOeIIKvcXUpw7R8H1Mf5YzceYPTcs4E,1758
-tinygrad/runtime/ops_cloud.py,sha256=wO4CZxl2fdVwcZsk41Rr473git_IDexIMru_KZV_vno,10425
-tinygrad/runtime/ops_cuda.py,sha256=TDXjERPZ8l0btVa1WRqVLd-DOAECBfxvMvLitC9Rows,6994
-tinygrad/runtime/ops_disk.py,sha256=b3jwNJW_s3CtRmubUIWbHChERJFbUJrfCl_alFDtepg,6689
-tinygrad/runtime/ops_dsp.py,sha256=NgOjV-hrsmwfJEtkr63KW7esuzQH2rk4yjzxjLcpuOg,10292
-tinygrad/runtime/ops_gpu.py,sha256=0l2QF3EMtNjRFRE8q5rp7B6Ub88Mir_6rz0aDnLupZM,9006
-tinygrad/runtime/ops_hip.py,sha256=nbYQIGKbSgAJ2PILJH3J-i3QR5AmJG8KTVMGqsbPLtE,3845
-tinygrad/runtime/ops_llvm.py,sha256=mSrWSKTY1wAy1skFXTgMAJPYLgxFD_ycphEkzhfhIZo,2499
-tinygrad/runtime/ops_metal.py,sha256=C_1CqWxf-VME0XyJ7i29Bzx7VURTcDUh4lH_t3QrFcw,11144
-tinygrad/runtime/ops_npy.py,sha256=HSDb47vcbPvDiG3EmSGPC0W-EPO9O5R0TqlQKnYxANU,404
-tinygrad/runtime/ops_nv.py,sha256=tpkmlEYFZW18k0mzHFP53esFpWx1O1mG06uv-y4GIro,38280
-tinygrad/runtime/ops_python.py,sha256=R6ie1DrY8uuaffS3ZPOWg3x1FBATlBLDMkIoBVWmUZs,11156
-tinygrad/runtime/ops_qcom.py,sha256=I8mXBCJk9gsDcFVwDakktgwuMwxjauHp5vub9LoKKjM,24453
-tinygrad/runtime/autogen/adreno.py,sha256=u7VxIomPAlW3nFUs4gSTe-6ijam_ywkvDM9OuTLF-j8,897915
-tinygrad/runtime/autogen/amd_gpu.py,sha256=blqmF-0gDby005JKnr07bNxuRSQLo5i0hpepcjUgQ_Y,2342436
-tinygrad/runtime/autogen/comgr.py,sha256=mhQtuF_vGDrJZD3iyQ_38FrS_2jp3WtImNZPC4TBuAg,39793
-tinygrad/runtime/autogen/cuda.py,sha256=N0QyaMvQumr_HZh7fusCHM1d4o4mYti3Wq1MN7JSKr8,243920
-tinygrad/runtime/autogen/hip.py,sha256=1yUHDCwL3KkD15if2Q1Ud3GbJiR7DxsNorKZTCINw54,245532
-tinygrad/runtime/autogen/hsa.py,sha256=7Hsrn17HmChyeFOSX_3Fnzl9c0COtq2Z2ExqGu5FNiU,277716
-tinygrad/runtime/autogen/io_uring.py,sha256=ZIZ2YnQkLr8WIHMieBw9Dv-NZ1ar9TwdP4YBv3gJm28,59786
-tinygrad/runtime/autogen/kfd.py,sha256=LQjcTZK93o4q6Qp4YlOu3aOVGL_RDlq6qDg5j0nRzQE,30815
-tinygrad/runtime/autogen/kgsl.py,sha256=Dg1skDsVdwZTGb1Cg-UTts-z4rta7qm8XFmods-ZiSU,50663
-tinygrad/runtime/autogen/libc.py,sha256=xKJk2hCzVpauJSc8wCQis5x3SwcXnDli7_HyRUqEGRc,197318
-tinygrad/runtime/autogen/nv_gpu.py,sha256=9X2tPdv2E5JmXGZeT8i9jL19YJ4ETTsYwfU_Wn9mTwc,1679326
-tinygrad/runtime/autogen/nvrtc.py,sha256=19te2-TW5suFy85KnJox3CPOmeeml5YxqIDeL-Bx_m4,23132
-tinygrad/runtime/autogen/opencl.py,sha256=NL6fa8P3KC_McNZ8g2babdr3b8vrY-bFK0qzNAtL-rE,82656
-tinygrad/runtime/autogen/qcom_dsp.py,sha256=jx36-zC6reTuWgfbHCrKVjOZcF4Q9fBnq3CuTbxztQk,61848
-tinygrad/runtime/graph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tinygrad/runtime/graph/clang.py,sha256=DakBGMhEu-U5VT6xb18yL3HOuZh80BWzioZnXqTaWnE,1994
-tinygrad/runtime/graph/cuda.py,sha256=MLXZbATjpfriNBGmA9OYXV5sAfqn6Q4hZ8H0Etw9HTg,5005
-tinygrad/runtime/graph/hcq.py,sha256=Wqu4Ry5juXCj1HOV_BpECf6tDqCtl2_sAWp8vuBJyD8,12391
-tinygrad/runtime/graph/metal.py,sha256=5HRmOrsXI8Q4eieT52zEeeNEbmjUZ1agAggefXk959U,6093
-tinygrad/runtime/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tinygrad/runtime/support/compiler_cuda.py,sha256=rS0XCFTy0blcdRstKVGKKRfoEU975DKzjbZKqg_YawY,5441
-tinygrad/runtime/support/compiler_hip.py,sha256=fbRP82UdG4T-KCRYH_H2hEXlMFeHIJntSnY35ZWE5JY,4398
-tinygrad/runtime/support/elf.py,sha256=FVoZu5r83RPk8ArBVpmOcbPDbtSz6hiv_OTCrQ9REHA,2385
-tinygrad/runtime/support/hcq.py,sha256=T4pp7Co69pLHKRULnZd-jwri_uAQ2Rji_gKVxTm5oR4,26306
-tinygrad/shape/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tinygrad/shape/shapetracker.py,sha256=VFJZghI4c_bZl5ceZBxgf-ztHz0CPsXgov-XenXzWhM,5644
-tinygrad/shape/view.py,sha256=E6AXLEFPnCGP0H6rG9OCJa3Hy9F68Q_xj2bClnVi7qk,19992
-tinygrad-0.10.0.dist-info/LICENSE,sha256=ABRhUPEILzINYIukgazD-_rPipkUNUwslrb0RxnV6Xc,1058
-tinygrad-0.10.0.dist-info/METADATA,sha256=0ytEHMHtcc-w9bbrcRp-YRDR_xQOJadcnzMbJkkkRVs,10933
-tinygrad-0.10.0.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-tinygrad-0.10.0.dist-info/top_level.txt,sha256=vDABMCWBFQnx2kn9Azueu88FP-1klQdePoHikQhHymc,9
-tinygrad-0.10.0.dist-info/RECORD,,