IQ.Pilot Prebuilt Release @ ab07000

2026-08-22 23:42:42 -05:00
commit 9f9c9a70cc
3729 changed files with 778697 additions and 0 deletions
--- a/tinygrad_repo/extra/hip_gpu_driver/hip_ioctl.py
+++ b/tinygrad_repo/extra/hip_gpu_driver/hip_ioctl.py
@@ -0,0 +1,117 @@
+# type: ignore
+import ctypes, ctypes.util, struct, platform, pathlib, re, time, os
+start = time.perf_counter()
+
+# *** ioctl lib ***
+libc = ctypes.CDLL(ctypes.util.find_library("c"))
+# platform.processor calls `uname -p` which can return `unknown` on some systems
+processor = os.getenv("IOCTL_PROCESSOR") or platform.processor() or platform.machine()
+IOCTL_SYSCALL = {"aarch64": 0x1d, "x86_64":16}[processor]
+
+def get_struct(argp, stype):
+  return ctypes.cast(ctypes.c_void_p(argp), ctypes.POINTER(stype)).contents
+
+def format_struct(s):
+  sdats = []
+  for field_name, *_ in s._real_fields_:
+    dat = getattr(s, field_name)
+    if isinstance(dat, int): sdats.append(f"{field_name}:0x{dat:X}")
+    else: sdats.append(f"{field_name}:{dat}")
+  return sdats
+
+def install_hook(c_function, python_function):
+  python_function_addr = ctypes.cast(ctypes.byref(python_function), ctypes.POINTER(ctypes.c_ulong)).contents.value
+  # AARCH64 trampoline to ioctl
+  if processor == "aarch64":
+    # 0x0000000000000000:  70 00 00 10    adr x16, #0xc
+    # 0x0000000000000004:  10 02 40 F9    ldr x16, [x16]
+    # 0x0000000000000008:  00 02 1F D6    br  x16
+    tramp = b"\x70\x00\x00\x10\x10\x02\x40\xf9\x00\x02\x1f\xd6"
+    tramp += struct.pack("Q", python_function_addr)
+  elif processor == "x86_64":
+    # 0x0000000000000000:  49 B8 aa aa aa aa aa aa aa aa    movabs r8, <address>
+    # 0x000000000000000a:  41 FF E0                         jmp    r8
+    tramp = b"\x49\xB8" + struct.pack("Q", python_function_addr) + b"\x41\xFF\xE0"
+  else:
+    raise Exception(f"processor {processor} not supported")
+
+  # get real ioctl address
+  ioctl_address = ctypes.cast(ctypes.byref(c_function), ctypes.POINTER(ctypes.c_ulong))
+
+  # hook ioctl
+  ret = libc.mprotect(ctypes.c_ulong((ioctl_address.contents.value//0x1000)*0x1000), 0x2000, 7)
+  assert ret == 0
+  libc.memcpy(ioctl_address.contents, ctypes.create_string_buffer(tramp), len(tramp))
+
+# *** ioctl lib end ***
+
+import tinygrad.runtime.autogen.kfd as kfd_ioctl
+import tinygrad.runtime.autogen.hsa as hsa
+
+def print_aql_queue(read_pointer_address):
+  rptr_offset = getattr(hsa.amd_queue_v2_t, 'read_dispatch_id').offset
+  queue_base = read_pointer_address - rptr_offset
+  queue = hsa.amd_queue_v2_t.from_address(queue_base)
+  print(f"  AQL Queue @ 0x{queue_base:X}:")
+  for field_name, *_ in hsa.amd_queue_v2_t._real_fields_:
+    val = getattr(queue, field_name)
+    if isinstance(val, int): print(f"    {field_name}: 0x{val:X}")
+    elif hasattr(val, '_length_'):
+      arr_vals = [f"{format_struct(v)}" if hasattr(v, '_real_fields_') else f"{v:#X}" for v in val]
+      print(f"    {field_name}: [{', '.join(arr_vals)}]")
+    elif hasattr(val, '_real_fields_'): print(f"    {field_name}: {format_struct(val)}")
+    else: print(f"    {field_name}: {val}")
+
+def ioctls_from_header():
+  hdr = (pathlib.Path(__file__).parent / "kfd_ioctl.h").read_text().replace("\\\n", "")
+  pattern = r'#define\s+(AMDKFD_IOC_[A-Z0-9_]+)\s+AMDKFD_IOW?R?\((0x[0-9a-fA-F]+),\s+struct\s([A-Za-z0-9_]+)\)'
+  matches = re.findall(pattern, hdr, re.MULTILINE)
+  return {int(nr, 0x10):(name, getattr(kfd_ioctl, "struct_"+sname, None)) for name, nr, sname in matches}
+nrs = ioctls_from_header()
+
+@ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_ulong, ctypes.c_void_p)
+def ioctl(fd, request, argp):
+  st = time.perf_counter()
+  ret = libc.syscall(IOCTL_SYSCALL, ctypes.c_int(fd), ctypes.c_ulong(request), ctypes.c_void_p(argp))
+  et = time.perf_counter()-st
+  idir, size, itype, nr = (request>>30), (request>>16)&0x3FFF, (request>>8)&0xFF, request&0xFF
+  if nr in nrs and itype == 75:
+    # /dev/kfd
+    name, stype = nrs[nr]
+    s = get_struct(argp, stype)
+    print(f"{(st-start)*1000:7.2f} ms +{et*1000.:7.2f} ms : {ret:2d} = {name:40s}", ' '.join(format_struct(s)))
+    if name == "AMDKFD_IOC_SVM":
+      out = ctypes.cast(s.attrs, ctypes.POINTER(kfd_ioctl.struct_kfd_ioctl_svm_attribute))
+      for i in range(s.nattr): print(f"{i}: {kfd_ioctl.enum_kfd_ioctl_svm_attr_type.get(out[i].type):40s}: {out[i].value:#x}")
+    if name == "AMDKFD_IOC_CREATE_QUEUE" and s.queue_type == kfd_ioctl.KFD_IOC_QUEUE_TYPE_COMPUTE_AQL: print_aql_queue(s.read_pointer_address)
+  else:
+    print(f"{(st-start)*1000:7.2f} ms +{et*1000.:7.2f} ms : ioctl",
+          f"{idir=} {size=} {itype=} {nr=} {fd=} {ret=}", os.readlink(f"/proc/self/fd/{fd}") if fd >= 0 else "")
+  return ret
+
+install_hook(libc.ioctl, ioctl)
+
+# AMD_LOG_LEVEL=4 HSAKMT_DEBUG_LEVEL=7
+if __name__ == "__main__":
+  print("***** import tinygrad")
+  from tinygrad import Tensor, Device, TinyJit
+  print("***** access HIP")
+  dev = Device["HIP"]
+  print("***** create tensor a")
+  a = Tensor([1.,2.]*1024*1024, device="HIP").realize()
+  print("***** create tensor b")
+  b = Tensor([3.,4.]*1024*1024, device="HIP").realize()
+  @TinyJit
+  def add(a, b): return (a+b).realize()
+  for i in range(4):
+    print(f"***** add tensors {i}")
+    c = add(a, b)
+    #dev.synchronize()
+    c = add(b, a)
+    dev.synchronize()
+  print(f"***** copyout")
+  nc = c.numpy()
+  print(f"***** delete")
+  del add, a, b, c, dev
+  print(f"***** done")
+  os._exit(0)
--- a/tinygrad_repo/extra/hip_gpu_driver/test_kfd_2.py
+++ b/tinygrad_repo/extra/hip_gpu_driver/test_kfd_2.py
@@ -0,0 +1,207 @@
+import os, ctypes, pathlib, re, fcntl, functools, mmap, time
+import tinygrad.runtime.autogen.kfd as kfd
+from tinygrad.helpers import to_mv, getenv
+from extra.hip_gpu_driver import hip_ioctl
+import tinygrad.runtime.autogen.hsa as hsa
+from hexdump import hexdump
+
+libc = ctypes.CDLL("libc.so.6")
+libc.memset.argtypes = [ctypes.c_void_p, ctypes.c_char, ctypes.c_int]
+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
+MAP_NORESERVE = 0x4000
+MAP_FIXED = 0x10
+
+def kfd_ioctl(idir, nr, user_struct, fd, **kwargs):
+  made = user_struct(**kwargs)
+  ret = fcntl.ioctl(fd, (idir<<30) | (ctypes.sizeof(user_struct)<<16) | (ord('K')<<8) | nr, made)
+  if ret != 0: raise RuntimeError(f"ioctl returned {ret}")
+  return made
+
+def format_struct(s):
+  sdats = []
+  for field_name, field_type in s._fields_:
+    dat = getattr(s, field_name)
+    if isinstance(dat, int): sdats.append(f"{field_name}:0x{dat:X}")
+    else: sdats.append(f"{field_name}:{dat}")
+  return sdats
+
+idirs = {"IOW": 1, "IOR": 2, "IOWR": 3}
+def ioctls_from_header():
+  hdr = pathlib.Path("/usr/include/linux/kfd_ioctl.h").read_text().replace("\\\n", "")
+  pattern = r'#define\s+(AMDKFD_IOC_[A-Z0-9_]+)\s+AMDKFD_(IOW?R?)\((0x[0-9a-fA-F]+),\s+struct\s([A-Za-z0-9_]+)\)'
+  matches = re.findall(pattern, hdr, re.MULTILINE)
+
+  fxns = {}
+  for name, idir, nr, sname in matches:
+    fxns[name.replace("AMDKFD_IOC_", "").lower()] = functools.partial(kfd_ioctl, idirs[idir], int(nr, 0x10), getattr(kfd, "struct_"+sname))
+  return type("KIO", (object, ), fxns)
+kio = ioctls_from_header()
+
+# sudo su -c "echo 'file drivers/gpu/drm/amd/* +p' > /sys/kernel/debug/dynamic_debug/control"
+
+def gpu_alloc_userptr(fd, size, flags):
+  addr = libc.mmap(0, size, mmap.PROT_READ|mmap.PROT_WRITE, mmap.MAP_SHARED|mmap.MAP_ANONYMOUS, -1, 0)
+  assert addr != 0xffffffffffffffff
+  mem = kio.alloc_memory_of_gpu(fd, va_addr=addr, size=size, gpu_id=GPU_ID, flags=flags, mmap_offset=addr)
+  return mem
+
+def gpu_alloc(fd, size, flags):
+  addr = libc.mmap(0, size, 0, mmap.MAP_PRIVATE|mmap.MAP_ANONYMOUS|MAP_NORESERVE, -1, 0)
+  assert addr != 0xffffffffffffffff
+  mem = kio.alloc_memory_of_gpu(fd, va_addr=addr, size=size, gpu_id=GPU_ID, flags=flags)
+  buf = libc.mmap(mem.va_addr, mem.size, mmap.PROT_READ|mmap.PROT_WRITE, mmap.MAP_SHARED|MAP_FIXED, drm_fd, mem.mmap_offset)
+  assert buf != 0xffffffffffffffff
+  assert addr == buf == mem.va_addr
+  return mem
+
+if __name__ == "__main__":
+  fd = os.open("/dev/kfd", os.O_RDWR)
+  gpu_num = getenv("GPU", 0)
+  drm_fd = os.open(f"/dev/dri/renderD{128+gpu_num}", os.O_RDWR)
+  with open(f"/sys/devices/virtual/kfd/kfd/topology/nodes/{1+gpu_num}/gpu_id", "r") as f: GPU_ID = int(f.read())
+
+  #ver = kio.get_version(fd)
+  st = kio.acquire_vm(fd, drm_fd=drm_fd, gpu_id=GPU_ID)
+  #exit(0)
+
+  # 0xF0000001 = KFD_IOC_ALLOC_MEM_FLAGS_VRAM | KFD_IOC_ALLOC_MEM_FLAGS_WRITABLE | KFD_IOC_ALLOC_MEM_FLAGS_EXECUTABLE | KFD_IOC_ALLOC_MEM_FLAGS_PUBLIC | KFD_IOC_ALLOC_MEM_FLAGS_NO_SUBSTITUTE
+  # 0xD6000002 = KFD_IOC_ALLOC_MEM_FLAGS_GTT | KFD_IOC_ALLOC_MEM_FLAGS_WRITABLE | KFD_IOC_ALLOC_MEM_FLAGS_EXECUTABLE | KFD_IOC_ALLOC_MEM_FLAGS_NO_SUBSTITUTE
+  # 0xD6000004 = KFD_IOC_ALLOC_MEM_FLAGS_USERPTR | KFD_IOC_ALLOC_MEM_FLAGS_WRITABLE | KFD_IOC_ALLOC_MEM_FLAGS_EXECUTABLE | KFD_IOC_ALLOC_MEM_FLAGS_NO_SUBSTITUTE
+  # 0x94000010 = KFD_IOC_ALLOC_MEM_FLAGS_MMIO_REMAP | KFD_IOC_ALLOC_MEM_FLAGS_WRITABLE | KFD_IOC_ALLOC_MEM_FLAGS_NO_SUBSTITUTE
+  #addr = libc.mmap(0, 0x1000, mmap.PROT_READ|mmap.PROT_WRITE, mmap.MAP_PRIVATE|mmap.MAP_ANONYMOUS, -1, 0)
+  #addr = libc.mmap(0, 0x1000, mmap.PROT_READ|mmap.PROT_WRITE, mmap.MAP_SHARED|mmap.MAP_ANONYMOUS, -1, 0)
+  #mem = kio.AMDKFD_IOC_ALLOC_MEMORY_OF_GPU(fd, va_addr=addr, size=0x1000, gpu_id=GPU_ID, flags=0xD6000004)
+
+  #mem = gpu_alloc(fd, 0x1000, kfd.KFD_IOC_ALLOC_MEM_FLAGS_VRAM |
+  #                            kfd.KFD_IOC_ALLOC_MEM_FLAGS_WRITABLE | kfd.KFD_IOC_ALLOC_MEM_FLAGS_EXECUTABLE |
+  #                            kfd.KFD_IOC_ALLOC_MEM_FLAGS_PUBLIC | kfd.KFD_IOC_ALLOC_MEM_FLAGS_NO_SUBSTITUTE)
+  #arr = (ctypes.c_int32 * 1)(GPU_ID)
+  #stm = kio.map_memory_to_gpu(fd, handle=mem.handle, device_ids_array_ptr=ctypes.addressof(arr), n_devices=1)
+
+  arr = (ctypes.c_int32 * 1)(GPU_ID)
+  rw_ptr = gpu_alloc(fd, 0x1000, kfd.KFD_IOC_ALLOC_MEM_FLAGS_GTT | kfd.KFD_IOC_ALLOC_MEM_FLAGS_WRITABLE |
+                                 kfd.KFD_IOC_ALLOC_MEM_FLAGS_COHERENT | kfd.KFD_IOC_ALLOC_MEM_FLAGS_UNCACHED |
+                                 kfd.KFD_IOC_ALLOC_MEM_FLAGS_EXECUTABLE | kfd.KFD_IOC_ALLOC_MEM_FLAGS_NO_SUBSTITUTE)
+  stm = kio.map_memory_to_gpu(fd, handle=rw_ptr.handle, device_ids_array_ptr=ctypes.addressof(arr), n_devices=1)
+  assert stm.n_success == 1
+  event_page = gpu_alloc(fd, 0x8000, kfd.KFD_IOC_ALLOC_MEM_FLAGS_GTT | kfd.KFD_IOC_ALLOC_MEM_FLAGS_WRITABLE |
+                                 kfd.KFD_IOC_ALLOC_MEM_FLAGS_COHERENT | kfd.KFD_IOC_ALLOC_MEM_FLAGS_UNCACHED |
+                                 kfd.KFD_IOC_ALLOC_MEM_FLAGS_EXECUTABLE | kfd.KFD_IOC_ALLOC_MEM_FLAGS_NO_SUBSTITUTE)
+  stm = kio.map_memory_to_gpu(fd, handle=event_page.handle, device_ids_array_ptr=ctypes.addressof(arr), n_devices=1)
+  assert stm.n_success == 1
+  ring_base = gpu_alloc_userptr(fd, 0x1000, kfd.KFD_IOC_ALLOC_MEM_FLAGS_USERPTR | kfd.KFD_IOC_ALLOC_MEM_FLAGS_WRITABLE |
+                                    kfd.KFD_IOC_ALLOC_MEM_FLAGS_COHERENT | kfd.KFD_IOC_ALLOC_MEM_FLAGS_UNCACHED |
+                                    kfd.KFD_IOC_ALLOC_MEM_FLAGS_EXECUTABLE | kfd.KFD_IOC_ALLOC_MEM_FLAGS_NO_SUBSTITUTE)
+  stm = kio.map_memory_to_gpu(fd, handle=ring_base.handle, device_ids_array_ptr=ctypes.addressof(arr), n_devices=1)
+  assert stm.n_success == 1
+  signals = gpu_alloc_userptr(fd, 0x1000, kfd.KFD_IOC_ALLOC_MEM_FLAGS_USERPTR | kfd.KFD_IOC_ALLOC_MEM_FLAGS_WRITABLE |
+                                    kfd.KFD_IOC_ALLOC_MEM_FLAGS_COHERENT | kfd.KFD_IOC_ALLOC_MEM_FLAGS_UNCACHED |
+                                    kfd.KFD_IOC_ALLOC_MEM_FLAGS_EXECUTABLE | kfd.KFD_IOC_ALLOC_MEM_FLAGS_NO_SUBSTITUTE)
+  stm = kio.map_memory_to_gpu(fd, handle=signals.handle, device_ids_array_ptr=ctypes.addressof(arr), n_devices=1)
+  assert stm.n_success == 1
+  eop_buffer = gpu_alloc(fd, 0x1000, kfd.KFD_IOC_ALLOC_MEM_FLAGS_VRAM |
+                                     kfd.KFD_IOC_ALLOC_MEM_FLAGS_WRITABLE | kfd.KFD_IOC_ALLOC_MEM_FLAGS_EXECUTABLE |
+                                     kfd.KFD_IOC_ALLOC_MEM_FLAGS_NO_SUBSTITUTE)
+  stm = kio.map_memory_to_gpu(fd, handle=eop_buffer.handle, device_ids_array_ptr=ctypes.addressof(arr), n_devices=1)
+  assert stm.n_success == 1
+  ctx_save_restore_address = gpu_alloc(fd, 0x2C02000, kfd.KFD_IOC_ALLOC_MEM_FLAGS_VRAM |
+                                     kfd.KFD_IOC_ALLOC_MEM_FLAGS_WRITABLE | kfd.KFD_IOC_ALLOC_MEM_FLAGS_EXECUTABLE |
+                                     kfd.KFD_IOC_ALLOC_MEM_FLAGS_NO_SUBSTITUTE)
+  stm = kio.map_memory_to_gpu(fd, handle=ctx_save_restore_address.handle, device_ids_array_ptr=ctypes.addressof(arr), n_devices=1)
+  assert stm.n_success == 1
+
+  #113.00 ms +   0.00 ms :  0 = AMDKFD_IOC_CREATE_QUEUE                  ring_base_address:0x797465200000 write_pointer_address:0x79751C068038 read_pointer_address:0x79751C068080 doorbell_offset:0x0 ring_size:0x800000 gpu_id:0x433D queue_type:0x2 queue_per
+  #centage:0x64 queue_priority:0x7 queue_id:0x0 eop_buffer_address:0x79751C064000 eop_buffer_size:0x1000 ctx_save_restore_address:0x796E52400000 ctx_save_restore_size:0x2BEA000 ctl_stack_size:0xA000
+
+  #113.84 ms +   0.59 ms :  0 = AMDKFD_IOC_CREATE_QUEUE                  ring_base_address:0x71AC3F600000 write_pointer_address:0x71B302AB0038 read_pointer_address:0x71B302AB0080 doorbell_offset:0xD0CF400000000008 ring_size:0x800000 gpu_id:0x433D queue_typ
+  #e:0x2 queue_percentage:0x64 queue_priority:0x7 queue_id:0x1 eop_buffer_address:0x71B302AAC000 eop_buffer_size:0x1000 ctx_save_restore_address:0x71AC3C800000 ctx_save_restore_size:0x2BEA000 ctl_stack_size:0xA000
+
+  #define KFD_MMAP_TYPE_SHIFT	62
+  #define KFD_MMAP_TYPE_DOORBELL	(0x3ULL << KFD_MMAP_TYPE_SHIFT)
+  evt = kio.create_event(fd, event_page_offset=event_page.handle, auto_reset=1)
+
+  nq = kio.create_queue(fd, ring_base_address=ring_base.va_addr, ring_size=0x1000, gpu_id=GPU_ID,
+                        queue_type=kfd.KFD_IOC_QUEUE_TYPE_COMPUTE_AQL, queue_percentage=kfd.KFD_MAX_QUEUE_PERCENTAGE,
+                        queue_priority=kfd.KFD_MAX_QUEUE_PRIORITY,
+                        eop_buffer_address=eop_buffer.va_addr, eop_buffer_size=0x1000,
+                        ctx_save_restore_address=ctx_save_restore_address.va_addr, ctx_save_restore_size=0x2C02000,
+                        ctl_stack_size = 0xa000,
+                        # write_pointer_address and read_pointer_address are on GART
+                        #write_pointer_address=0xaaaabbbb, read_pointer_address=0xaaaacccc)
+                        write_pointer_address=rw_ptr.va_addr+0, read_pointer_address=rw_ptr.va_addr+0x8)
+  doorbell = libc.mmap(0, 8192, mmap.PROT_READ|mmap.PROT_WRITE, mmap.MAP_SHARED, fd, nq.doorbell_offset)
+  print("doorbell", hex(doorbell))
+
+  to_mv(signals.va_addr, 0x40)
+
+  """
+  hexdump(to_mv(event_page.va_addr, 0x40))
+  kio.set_event(fd, event_id=evt.event_id)
+  hexdump(to_mv(event_page.va_addr, 0x40))
+  kio.reset_event(fd, event_id=evt.event_id)
+  hexdump(to_mv(event_page.va_addr, 0x40))
+  """
+
+  # KFD_EVENT_TYPE_SIGNAL
+
+  BARRIER_HEADER  = 1 << hsa.HSA_PACKET_HEADER_BARRIER
+  BARRIER_HEADER |= hsa.HSA_FENCE_SCOPE_SYSTEM << hsa.HSA_PACKET_HEADER_SCACQUIRE_FENCE_SCOPE
+  BARRIER_HEADER |= hsa.HSA_FENCE_SCOPE_SYSTEM << hsa.HSA_PACKET_HEADER_SCRELEASE_FENCE_SCOPE
+  BARRIER_HEADER |= hsa.HSA_PACKET_TYPE_BARRIER_AND << hsa.HSA_PACKET_HEADER_TYPE
+
+  AQL_PACKET_SIZE = ctypes.sizeof(hsa.hsa_kernel_dispatch_packet_t)
+  EMPTY_SIGNAL = hsa.hsa_signal_t()
+
+  ds = to_mv(rw_ptr.va_addr, 0x100).cast("Q")
+  ds[0] = 1 #ring_base.va_addr + AQL_PACKET_SIZE
+  ds[1] = 0 #ring_base.va_addr
+  #libc.memset(rw_ptr.va_addr, 0xaa, 0x100)
+  #hexdump(to_mv(rw_ptr.va_addr, 0x100))
+
+  #packet = hsa.hsa_barrier_and_packet_t.from_address(rw_ptr.va_addr+0x38)
+  packet = hsa.hsa_barrier_and_packet_t.from_address(ring_base.va_addr)
+  packet.reserved0 = 0
+  packet.reserved1 = 0
+  for i in range(5): packet.dep_signal[i] = EMPTY_SIGNAL
+  #packet.dep_signal[0] = hsa.hsa_signal_t(evt.event_id)
+  packet.reserved2 = 0
+  #packet.completion_signal = EMPTY_SIGNAL
+  packet.completion_signal = hsa.hsa_signal_t(signals.va_addr)
+  packet.header = BARRIER_HEADER
+  hexdump(to_mv(ring_base.va_addr, AQL_PACKET_SIZE))
+
+  # _HsaEventData
+  to_mv(signals.va_addr, 0x40).cast("Q")[0] = 1
+  to_mv(signals.va_addr, 0x40).cast("Q")[1] = 1
+  #to_mv(signals.va_addr, 0x40).cast("Q")[2] = event_page
+  to_mv(signals.va_addr, 0x40).cast("Q")[2] = event_page.va_addr + evt.event_slot_index*8  # HWData2=HWAddress
+  to_mv(signals.va_addr, 0x40).cast("Q")[3] = evt.event_trigger_data # HWData3=HWData
+  print(hex(ds[0]), hex(ds[1]), hex(ds[2]))
+  hexdump(to_mv(signals.va_addr, 0x40))
+
+  # 10 08 49 3E 46 77 00 00
+
+
+  # ring doorbell
+  print(hex(to_mv(doorbell, 0x10).cast("I")[0]))
+  #to_mv(doorbell, 0x10).cast("I")[0] = 0xffffffff
+  to_mv(doorbell, 0x10).cast("I")[0] = 0
+
+  evt_arr = (kfd.struct_kfd_event_data * 1)()
+  evt_arr[0].event_id = evt.event_id
+  kio.wait_events(fd, events_ptr=ctypes.addressof(evt_arr), num_events=1, wait_for_all=0, timeout=1000)
+
+  print(hex(ds[0]), hex(ds[1]), hex(ds[2]))
+  hexdump(to_mv(signals.va_addr, 0x40))
+
+  #nq = kio.create_queue(fd, ring_base_address=buf, ring_size=0x1000, gpu_id=GPU_ID,
+  #                      queue_type=kfd.KFD_IOC_QUEUE_TYPE_COMPUTE_AQL, queue_percentage=kfd.KFD_MAX_QUEUE_PERCENTAGE,
+  #                      queue_priority=kfd.KFD_MAX_QUEUE_PRIORITY, write_pointer_address=buf+8, read_pointer_address=buf+0x10)
+  #print(nq)
+
+  #mv = to_mv(buf, 0x1000)
+  #addr = libc.mmap(0, 0x1000, mmap.PROT_READ|mmap.PROT_WRITE, mmap.MAP_PRIVATE|mmap.MAP_ANONYMOUS, -1, 0)
+
+  #print('\n'.join(format_struct(ver)))
+  #print('\n'.join(format_struct(st)))
--- a/tinygrad_repo/extra/hip_gpu_driver/test_pm4.py
+++ b/tinygrad_repo/extra/hip_gpu_driver/test_pm4.py
@@ -0,0 +1,156 @@
+import time
+from hexdump import hexdump
+from tinygrad import Tensor, Device
+import tinygrad.runtime.autogen.amd_gpu as amd_gpu
+import tinygrad.runtime.autogen.kfd as kfd
+import tinygrad.runtime.autogen.hsa as hsa
+from tinygrad.runtime.ops_amd import kio, AMDProgram
+from tinygrad.helpers import to_mv
+
+DISPATCH_INIT_VALUE = 0x21 | 0x8000
+
+#mmCOMPUTE_START_X = 0x2e04
+#mmCOMPUTE_PGM_LO = 0x2e0c
+
+BASE_ADDR = 0x00001260
+PACKET3_SET_SH_REG_START = 0x2c00
+SUB = PACKET3_SET_SH_REG_START - BASE_ADDR
+
+regCOMPUTE_PGM_LO = 0x1bac - SUB
+regCOMPUTE_START_X = 0x1ba4 - SUB
+regCOMPUTE_NUM_THREAD_X = 0x1ba7 - SUB
+regCOMPUTE_USER_DATA_0 = 0x1be0 - SUB
+regCOMPUTE_USER_DATA_8 = 0x1be8 - SUB
+
+regCOMPUTE_PGM_RSRC1 = 0x1bb2 - SUB
+regCOMPUTE_PGM_RSRC2 = 0x1bb3 - SUB
+
+# DEBUG=6 python3 extra/hip_gpu_driver/test_pm4.py
+# sudo umr -i 1 -s amd744c.gfx1100 --sbank 1 1 2 | grep regCOMPUTE
+
+# 0x00009025
+
+COMPUTE_SHADER_EN = 1
+USE_THREAD_DIMENSIONS = 1 << 5
+CS_W32_EN = 1 << 15
+
+def format_struct(s):
+  sdats = []
+  for field_name, field_type in s._fields_:
+    dat = getattr(s, field_name)
+    if isinstance(dat, int): sdats.append(f"{field_name}:0x{dat:X}")
+    else: sdats.append(f"{field_name}:{dat}")
+  return sdats
+
+if __name__ == "__main__":
+  dev = Device["KFD"]
+
+  a = Tensor([0.,1.,2.], device="KFD").realize()
+  b = a + 7
+  b.uop.buffer.allocate()
+  si = b.schedule()[-1]
+  runner = dev.get_runner(*si.ast)
+  prg: AMDProgram = runner.clprg
+  print("device initted")
+
+  # Compute Queue
+
+  gart_compute = dev._gpu_alloc(0x1000, kfd.KFD_IOC_ALLOC_MEM_FLAGS_GTT, uncached=True)
+  eop_buffer = dev._gpu_alloc(0x1000, kfd.KFD_IOC_ALLOC_MEM_FLAGS_VRAM)
+  compute_ring = dev._gpu_alloc(0x800000, kfd.KFD_IOC_ALLOC_MEM_FLAGS_GTT, uncached=True)
+  ctx_save_restore_address = dev._gpu_alloc(0x2C02000, kfd.KFD_IOC_ALLOC_MEM_FLAGS_VRAM)
+  compute_queue = kio.create_queue(dev.kfd, ring_base_address=compute_ring.va_addr, ring_size=compute_ring.size, gpu_id=dev.gpu_id,
+    queue_type=kfd.KFD_IOC_QUEUE_TYPE_COMPUTE, queue_percentage=kfd.KFD_MAX_QUEUE_PERCENTAGE, queue_priority=kfd.KFD_MAX_QUEUE_PRIORITY,
+    #eop_buffer_address=eop_buffer.va_addr, eop_buffer_size=eop_buffer.size,
+    #ctx_save_restore_address=ctx_save_restore_address.va_addr, ctx_save_restore_size=ctx_save_restore_address.size,
+    #ctl_stack_size = 0xa000,
+    write_pointer_address=gart_compute.va_addr, read_pointer_address=gart_compute.va_addr+8)
+  compute_doorbell = to_mv(dev.doorbells + compute_queue.doorbell_offset - dev.doorbells_base, 4).cast("I")
+
+  #scratch = dev._gpu_alloc(0x10000, kfd.KFD_IOC_ALLOC_MEM_FLAGS_VRAM)
+  ka = to_mv(dev.kernargs_ptr, 0x10).cast("Q")
+  ka[0] = b.uop.buffer._buf.va_addr
+  ka[1] = a.uop.buffer._buf.va_addr
+
+  compute_read_pointer = to_mv(compute_queue.read_pointer_address, 8).cast("Q")
+  compute_write_pointer = to_mv(compute_queue.write_pointer_address, 8).cast("Q")
+
+  hexdump(to_mv(prg.handle, 0x40))
+  code = hsa.amd_kernel_code_t.from_address(prg.handle)
+
+  #print(format_struct(code))
+  #print("code")
+  #hexdump(to_mv(code_ptr, 0x100))
+  #runner.local_size = [2,1,1]
+
+  print(runner.local_size, runner.global_size)
+
+  #pm4_cmd += [amd_gpu.PACKET3(amd_gpu.PACKET3_SET_SH_REG, 6), mmCOMPUTE_PGM_LO,
+  #  prg.handle&0xFFFFFFFF, prg.handle>>32, 0, 0, (scratch.va_addr>>8)&0xFFFFFFFF, scratch.va_addr>>40]
+  code_ptr = (prg.handle + code.kernel_code_entry_byte_offset) >> 8
+  pm4_cmd  = [amd_gpu.PACKET3(amd_gpu.PACKET3_SET_SH_REG, 6), regCOMPUTE_PGM_LO, code_ptr&0xFFFFFFFF, code_ptr>>32, 0, 0, 0, 0]
+  pm4_cmd += [amd_gpu.PACKET3(amd_gpu.PACKET3_SET_SH_REG, 2), regCOMPUTE_PGM_RSRC1, code.compute_pgm_rsrc1, code.compute_pgm_rsrc2]
+  pm4_cmd += [amd_gpu.PACKET3(amd_gpu.PACKET3_SET_SH_REG, 2), regCOMPUTE_USER_DATA_0, dev.kernargs_ptr&0xFFFFFFFF, dev.kernargs_ptr>>32]
+  #pm4_cmd += [amd_gpu.PACKET3(amd_gpu.PACKET3_SET_SH_REG, 2), regCOMPUTE_USER_DATA_0, 0, 0]
+  pm4_cmd += [amd_gpu.PACKET3(amd_gpu.PACKET3_SET_SH_REG, 8), regCOMPUTE_START_X, 0,0,0,
+              runner.local_size[0],runner.local_size[1],runner.local_size[2],0,0]
+  # disabled USE_THREAD_DIMENSIONS
+  pm4_cmd += [amd_gpu.PACKET3(amd_gpu.PACKET3_DISPATCH_DIRECT, 3),
+              runner.global_size[0],runner.global_size[1],runner.global_size[2], CS_W32_EN | COMPUTE_SHADER_EN]
+
+  #pm4_cmd = [amd_gpu.PACKET3(amd_gpu.PACKET3_NOP, 0x3fff)]*0x200
+
+  """
+  addr=0x0
+  sz=(1 << 64)-1
+  gli=0
+  glv=0
+  glk=0
+  gl1=0
+  gl2=0
+  pm4_cmd = [amd_gpu.PACKET3(amd_gpu.PACKET3_ACQUIRE_MEM, 6), 0,
+              sz & 0xffffffff, (sz >> 32) & 0xff, addr & 0xffffffff, (addr >> 32) & 0xffffff, 0,
+              amd_gpu.PACKET3_ACQUIRE_MEM_GCR_CNTL_GLI_INV(gli) | amd_gpu.PACKET3_ACQUIRE_MEM_GCR_CNTL_GLK_INV(glk) | \
+              amd_gpu.PACKET3_ACQUIRE_MEM_GCR_CNTL_GLV_INV(glv) | amd_gpu.PACKET3_ACQUIRE_MEM_GCR_CNTL_GL1_INV(gl1) | \
+              amd_gpu.PACKET3_ACQUIRE_MEM_GCR_CNTL_GL2_INV(gl2)]
+  print(pm4_cmd)
+  """
+
+  wptr = 0
+  pm4_buffer_view = to_mv(compute_ring.va_addr, compute_ring.size).cast("I")
+
+  for j in range(0x80000):
+    for i, value in enumerate(pm4_cmd): pm4_buffer_view[wptr+i] = value
+    wptr += len(pm4_cmd)
+
+    compute_write_pointer[0] = wptr
+    compute_doorbell[0] = wptr
+    for k in range(10):
+      done = compute_read_pointer[0] == compute_write_pointer[0]
+      print(compute_read_pointer[0], compute_write_pointer[0], done)
+      if done: break
+      time.sleep(0.01)
+    break
+    #break
+
+    #print(compute_read_pointer[0])
+    #time.sleep(0.05)
+    #print(compute_read_pointer[0])
+
+  #time.sleep(100)
+
+  print(a.numpy())
+  print(b.numpy())
+  exit(0)
+
+  #pm4_cmd = [amd_gpu.PACKET3(amd_gpu.PACKET3_SET_SH_REG, 8), mmCOMPUTE_PGM_LO, 0,0,0,1,1,1,0,0]
+
+
+  #pm4_cmd += [amd_gpu.PACKET3(amd_gpu.PACKET3_DISPATCH_DIRECT, )]
+
+
+  #pm4_cmd = [amd_gpu.PACKET3(amd_gpu.PACKET3_ACQUIRE_MEM, 6), 0,
+  #          sz & 0xffffffff, (sz >> 32) & 0xff, addr & 0xffffffff, (addr >> 32) & 0xffffff, 0,
+  #          amd_gpu.PACKET3_ACQUIRE_MEM_GCR_CNTL_GLI_INV(gli) | amd_gpu.PACKET3_ACQUIRE_MEM_GCR_CNTL_GLK_INV(glk) | \
+  #          amd_gpu.PACKET3_ACQUIRE_MEM_GCR_CNTL_GLV_INV(glv) | amd_gpu.PACKET3_ACQUIRE_MEM_GCR_CNTL_GL1_INV(gl1) | \
+  #          amd_gpu.PACKET3_ACQUIRE_MEM_GCR_CNTL_GL2_INV(gl2)]
--- a/tinygrad_repo/extra/hip_gpu_driver/test_sdma_fun.py
+++ b/tinygrad_repo/extra/hip_gpu_driver/test_sdma_fun.py
@@ -0,0 +1,43 @@
+import ctypes, mmap, time
+from tinygrad.runtime.ops_amd import AMDDevice, kio, sdma_pkts, libc
+import tinygrad.runtime.autogen.amd_sdma as amd_sdma
+import tinygrad.runtime.autogen.kfd as kfd
+from tinygrad.helpers import to_mv
+
+if __name__ == "__main__":
+  dev = AMDDevice()
+
+  sdma_ring = dev._gpu_alloc(1 << 22, kfd.KFD_IOC_ALLOC_MEM_FLAGS_USERPTR, uncached=True)
+  gart = dev._gpu_alloc(0x1000, kfd.KFD_IOC_ALLOC_MEM_FLAGS_GTT, uncached=True)
+  sdma_queue = kio.create_queue(AMDDevice.kfd,
+    ring_base_address=sdma_ring.va_addr, ring_size=sdma_ring.size, gpu_id=dev.gpu_id,
+    queue_type=kfd.KFD_IOC_QUEUE_TYPE_SDMA, queue_percentage=kfd.KFD_MAX_QUEUE_PERCENTAGE, queue_priority=kfd.KFD_MAX_QUEUE_PRIORITY,
+    write_pointer_address=gart.va_addr + 0x100, read_pointer_address=gart.va_addr + 0x108)
+
+  doorbells_base = sdma_queue.doorbell_offset & (~0xfff)
+  doorbells = libc.mmap(0, 8192, mmap.PROT_READ|mmap.PROT_WRITE, mmap.MAP_SHARED, AMDDevice.kfd, doorbells_base)
+
+  sdma_read_pointer = to_mv(sdma_queue.read_pointer_address, 8).cast("Q")
+  sdma_write_pointer = to_mv(sdma_queue.write_pointer_address, 8).cast("Q")
+  sdma_doorbell = to_mv(doorbells + sdma_queue.doorbell_offset - doorbells_base, 4).cast("I")
+
+  test_write_page = dev._gpu_alloc(0x1000, kfd.KFD_IOC_ALLOC_MEM_FLAGS_USERPTR, uncached=True)
+  cmd = sdma_pkts.timestamp(op=amd_sdma.SDMA_OP_TIMESTAMP, sub_op=amd_sdma.SDMA_SUBOP_TIMESTAMP_GET_GLOBAL, addr=test_write_page.va_addr)
+
+  sdma_doorbell_value = 0
+  def blit_sdma_command(cmd):
+    ctypes.memmove(sdma_ring.va_addr + (sdma_doorbell_value % sdma_ring.size), ctypes.addressof(cmd), sz:=ctypes.sizeof(cmd))
+    return sz
+
+  while True:
+    sdma_doorbell_value += blit_sdma_command(cmd)
+    sdma_write_pointer[0] = sdma_doorbell_value
+    sdma_doorbell[0] = sdma_doorbell_value
+    while sdma_read_pointer[0] != sdma_write_pointer[0]: continue
+    tm = to_mv(test_write_page.va_addr, 0x1000).cast("Q")[0]/1e8
+    print(f"{tm:.3f} s @ 0x{sdma_ring.va_addr + (sdma_doorbell_value % sdma_ring.size):X} R:0x{sdma_queue.read_pointer_address:X} W:0x{sdma_queue.write_pointer_address:X}")
+    time.sleep(0.01)
+
+
+
+