autogen cleanup (#6064)

* start autogen cleanup

* nvgpu

* better?

* better

* amd part

* gpu regen

* fix mockgpu amd

* nv

* amd fix linter

* remove import

* ugh

* nv on master

* amd on master

autogen_stubs.sh

@@ -7,7 +7,7 @@ if [[ ! $(clang2py -V) ]]; then
   sudo apt-get install -y --no-install-recommends clang
   pip install --upgrade pip setuptools
   pip install clang==14.0.6
-  git clone https://github.com/geohot/ctypeslib.git
+  git clone https://github.com/nimlgen/ctypeslib.git
   cd ctypeslib
   pip install --user .
   clang2py -V
@@ -39,56 +39,6 @@ def _try_dlopen_$name():
 EOF
 }
 
-process_cdefines() {
-  local input_file="$1"
-  local output_file="$2"
-
-  sed -E '
-    # Remove single-line comments
-    s/[[:space:]]*\/\*.*\*\///g
-
-    # Remove multi-line comments
-    /\/\*/,/\*\//d
-
-    /.*DT_MIPS_NUM.*/d
-
-    # Remove lines ending with backslash (multi-line macros)
-    /\\$/d
-
-    # Convert C integer literals (remove U suffix)
-    s/\b([0-9]+)U\b/\1/g
-
-    # Convert C types to Python ctypes
-    s/\bunsigned char\b/ctypes.c_ubyte/g
-    s/\bsigned char\b/ctypes.c_byte/g
-    s/\bunsigned short\b/ctypes.c_ushort/g
-    s/\bshort\b/ctypes.c_short/g
-    s/\bunsigned int\b/ctypes.c_uint/g
-    s/\bint\b/ctypes.c_int/g
-    s/\bunsigned long\b/ctypes.c_ulong/g
-    s/\blong\b/ctypes.c_long/g
-    s/\bfloat\b/ctypes.c_float/g
-    s/\bdouble\b/ctypes.c_double/g
-
-    # Function-like macros with parameters
-    /^#define[[:space:]]+([[:alnum:]_]+)[[:space:]]*\(([^)]*)\)[[:space:]]+(.+)/ {
-      s//def \1(\2): return \3/
-      p
-      d
-    }
-
-    # Simple #define statements (including those with parentheses)
-    /^#define[[:space:]]+([[:alnum:]_]+)[[:space:]]+(.+)/ {
-      s//\1 = \2/
-      p
-      d
-    }
-
-    # Drop all other lines
-    d
-  ' "$input_file" >> "$output_file"
-}
-
 generate_opencl() {
   clang2py /usr/include/CL/cl.h -o $BASE/opencl.py -l /usr/lib/x86_64-linux-gnu/libOpenCL.so.1 -k cdefstum
   fixup $BASE/opencl.py
@@ -126,11 +76,7 @@ generate_comgr() {
 
 generate_kfd() {
   clang2py /usr/include/linux/kfd_ioctl.h -o $BASE/kfd.py -k cdefstum
-  awk '/^#define AMDKFD_IOC_/ { if ($0 ~ /\\$/) { getline nextline; $0 = $0 nextline }
-    if (match($0, /AMDKFD_IOC_([A-Z_]+).*AMDKFD_(IOW?R?)\(0x([0-9A-F]+),.*struct ([a-z_]+)/, arr)) {
-      print "AMDKFD_IOC_" arr[1] " = (\"" arr[2] "\", 0x" arr[3] ", struct_" arr[4] ")"
-    }
-  }' /usr/include/linux/kfd_ioctl.h >> $BASE/kfd.py
+
   fixup $BASE/kfd.py
   sed -i "s\import ctypes\import ctypes, os\g" $BASE/kfd.py
   python3 -c "import tinygrad.runtime.autogen.kfd"
@@ -164,7 +110,7 @@ generate_nv() {
     popd
   fi
 
-  clang2py \
+  clang2py -k cdefstum \
     extra/nv_gpu_driver/clc6c0qmd.h \
     $NVKERN_SRC/src/common/sdk/nvidia/inc/class/cl0080.h \
     $NVKERN_SRC/src/common/sdk/nvidia/inc/class/cl2080_notification.h \
@@ -191,7 +137,7 @@ generate_nv() {
     $NVKERN_SRC/src/common/sdk/nvidia/inc/ctrl/ctrlcb33.h \
     $NVKERN_SRC/src/common/sdk/nvidia/inc/ctrl/ctrla06c.h \
     --clang-args="-include $NVKERN_SRC/src/common/sdk/nvidia/inc/nvtypes.h -I$NVKERN_SRC/src/common/inc -I$NVKERN_SRC/kernel-open/nvidia-uvm -I$NVKERN_SRC/kernel-open/common/inc -I$NVKERN_SRC/src/common/sdk/nvidia/inc -I$NVKERN_SRC/src/nvidia/arch/nvalloc/unix/include -I$NVKERN_SRC/src/common/sdk/nvidia/inc/ctrl" \
-    -o $BASE/nv_gpu.py -k cdefstum
+    -o $BASE/nv_gpu.py
   fixup $BASE/nv_gpu.py
   sed -i "s\(0000000001)\1\g" $BASE/nv_gpu.py
   sed -i "s\import ctypes\import ctypes, os\g" $BASE/nv_gpu.py
@@ -211,23 +157,15 @@ nv_status_codes = {}
 
 generate_amd() {
   # clang2py broken when pass -x c++ to prev headers
-  clang2py extra/hip_gpu_driver/sdma_registers.h \
+  clang2py -k cdefstum \
+    extra/hip_gpu_driver/sdma_registers.h \
+    extra/hip_gpu_driver/nvd.h \
+    extra/hip_gpu_driver/sdma_v6_0_0_pkt_open.h \
+    extra/hip_gpu_driver/gc_11_0_0_offset.h \
+    extra/hip_gpu_driver/gc_10_3_0_offset.h \
     --clang-args="-I/opt/rocm/include -x c++" \
     -o $BASE/amd_gpu.py
 
-  sed 's/^\(.*\)\(\s*\/\*\)\(.*\)$/\1 #\2\3/; s/^\(\s*\*\)\(.*\)$/#\1\2/' extra/hip_gpu_driver/nvd.h >> $BASE/amd_gpu.py # comments
-  sed 's/^\(.*\)\(\s*\/\*\)\(.*\)$/\1 #\2\3/; s/^\(\s*\*\)\(.*\)$/#\1\2/' extra/hip_gpu_driver/sdma_v6_0_0_pkt_open.h >> $BASE/amd_gpu.py # comments
-  sed 's/^\(.*\)\(\s*\/\*\)\(.*\)$/\1 #\2\3/; s/^\(\s*\*\)\(.*\)$/#\1\2/' extra/hip_gpu_driver/gc_11_0_0_offset.h >> $BASE/amd_gpu.py # comments
-  sed 's/^\(.*\)\(\s*\/\*\)\(.*\)$/\1 #\2\3/; s/^\(\s*\*\)\(.*\)$/#\1\2/' extra/hip_gpu_driver/gc_10_3_0_offset.h >> $BASE/amd_gpu.py # comments
-  sed -i 's/^\/\//#/' $BASE/amd_gpu.py # // -> #
-  sed -i 's/#\s*define\s*\([^ \t]*\)(\([^)]*\))\s*\(.*\)/def \1(\2): return \3/' $BASE/amd_gpu.py # #define name(x) (smth) -> def name(x): return (smth)
-  sed -i '/#\s*define\s\+\([^ \t]\+\)\s\+\([^ ]\+\)/s//\1 = \2/' $BASE/amd_gpu.py # #define name val -> name = val
-
-  # sed -e '/^reg/s/^\(reg[^ ]*\) [^ ]* \([^ ]*\) .*/\1 = \2/' \
-  #   -e '/^ix/s/^\(ix[^ ]*\) [^ ]* \([^ ]*\) .*/\1 = \2/' \
-  #   -e '/^[ \t]/d' \
-  #   extra/hip_gpu_driver/gc_11_0_0.reg >> $BASE/amd_gpu.py
-
   fixup $BASE/amd_gpu.py
   sed -i "s\import ctypes\import ctypes, os\g" $BASE/amd_gpu.py
   python3 -c "import tinygrad.runtime.autogen.amd_gpu"
@@ -252,28 +190,23 @@ generate_hsa() {
 }
 
 generate_io_uring() {
-  clang2py \
+  clang2py -k cdefstum \
     /usr/include/liburing.h \
     /usr/include/linux/io_uring.h \
     -o $BASE/io_uring.py
 
-  # clang2py can't parse defines
   sed -r '/^#define __NR_io_uring/ s/^#define __(NR_io_uring[^ ]+) (.*)$/\1 = \2/; t; d' /usr/include/asm-generic/unistd.h >> $BASE/io_uring.py # io_uring syscalls numbers
-  sed -r '/^#define\s+([^ \t]+)\s+([^ \t]+)/ s/^#define\s+([^ \t]+)\s*([^/]*).*$/\1 = \2/; s/1U/1/g; s/0ULL/0/g; t; d' /usr/include/linux/io_uring.h >> $BASE/io_uring.py # #define name (val) -> name = val
-
   fixup $BASE/io_uring.py
 }
 
 generate_libc() {
-  clang2py \
+  clang2py -k cdefstum \
     $(dpkg -L libc6-dev | grep sys/mman.h) \
     $(dpkg -L libc6-dev | grep sys/syscall.h) \
     /usr/include/elf.h \
     /usr/include/unistd.h \
     -o $BASE/libc.py
 
-  process_cdefines "/usr/include/elf.h" "$BASE/libc.py"
-
   sed -i "s\import ctypes\import ctypes, ctypes.util, os\g" $BASE/libc.py
   sed -i "s\FIXME_STUB\libc\g" $BASE/libc.py
   sed -i "s\FunctionFactoryStub()\ctypes.CDLL(ctypes.util.find_library('c'))\g" $BASE/libc.py

extra/mockgpu/amd/amddriver.py

@@ -10,9 +10,12 @@ libc.mmap.argtypes = [ctypes.c_void_p, ctypes.c_size_t, ctypes.c_int, ctypes.c_i
 libc.mmap.restype = ctypes.c_void_p
 
 def ioctls_from_header():
-  hdrpy = (pathlib.Path(__file__).parent.parent.parent.parent / "tinygrad" / "runtime" / "autogen" / "kfd.py").read_text()
-  pattern = r'# (AMDKFD_IOC_[A-Z0-9_]+)\s=\s_(IOW?R?).*\(( 0x[0-9a-fA-F]+) ,\s+struct\s([A-Za-z0-9_]+)\s+\)'
-  matches = re.findall(pattern, hdrpy, re.MULTILINE)
+  # hdrpy = (pathlib.Path(__file__).parent.parent.parent.parent / "tinygrad" / "runtime" / "autogen" / "kfd.py").read_text()
+  # pattern = r'# (AMDKFD_IOC_[A-Z0-9_]+)\s=\s_(IOW?R?).*\(( 0x[0-9a-fA-F]+) ,\s+struct\s([A-Za-z0-9_]+)\s+\)'
+  # matches = re.findall(pattern, hdrpy, re.MULTILINE)
+  hdr = (pathlib.Path(__file__).parent.parent.parent / "hip_gpu_driver" / "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 type("KFD_IOCTLS", (object, ), {name: int(nr, 0x10) for name, _, nr, _ in matches}), \
          {int(nr, 0x10): getattr(kfd, "struct_"+sname) for name, idir, nr, sname in matches}
 kfd_ioctls, kfd_headers = ioctls_from_header()

tinygrad/runtime/autogen/io_uring.py

@@ -157,6 +157,14 @@ def char_pointer_cast(string, encoding='utf-8'):
 
 
 
+LIB_URING_H = True # macro
+_XOPEN_SOURCE = 500 # macro
+# def uring_unlikely(cond):  # macro
+#    return __builtin_expect(!!(cond),0)
+# def uring_likely(cond):  # macro
+#    return __builtin_expect(!!(cond),1)
+# def io_uring_for_each_cqe(ring, head, cqe):  # macro
+#    return (head=*(ring)->cq.khead;(cqe=(head!=io_uring_smp_load_acquire((ring)->cq.ktail)?&(ring)->cq.cqes[head&(*(ring)->cq.kring_mask)]:NULL));head++)
 class struct_io_uring_sq(Structure):
     pass
 
@@ -685,6 +693,7 @@ try:
 except AttributeError:
     pass
 __u64 = ctypes.c_uint64
+# LIBURING_UDATA_TIMEOUT = ((__u64)-1) # macro
 try:
     io_uring_prep_rw = _libraries['FIXME_STUB'].io_uring_prep_rw
     io_uring_prep_rw.restype = None
@@ -1085,6 +1094,51 @@ try:
     io_uring_mlock_size_params.argtypes = [ctypes.c_uint32, ctypes.POINTER(struct_io_uring_params)]
 except AttributeError:
     pass
+LINUX_IO_URING_H = True # macro
+IORING_SETUP_IOPOLL = (1<<0) # macro
+IORING_SETUP_SQPOLL = (1<<1) # macro
+IORING_SETUP_SQ_AFF = (1<<2) # macro
+IORING_SETUP_CQSIZE = (1<<3) # macro
+IORING_SETUP_CLAMP = (1<<4) # macro
+IORING_SETUP_ATTACH_WQ = (1<<5) # macro
+IORING_SETUP_R_DISABLED = (1<<6) # macro
+IORING_FSYNC_DATASYNC = (1<<0) # macro
+IORING_TIMEOUT_ABS = (1<<0) # macro
+IORING_TIMEOUT_UPDATE = (1<<1) # macro
+IORING_TIMEOUT_BOOTTIME = (1<<2) # macro
+IORING_TIMEOUT_REALTIME = (1<<3) # macro
+IORING_LINK_TIMEOUT_UPDATE = (1<<4) # macro
+IORING_TIMEOUT_CLOCK_MASK = ((1<<2)|(1<<3)) # macro
+IORING_TIMEOUT_UPDATE_MASK = ((1<<1)|(1<<4)) # macro
+SPLICE_F_FD_IN_FIXED = (1<<31) # macro
+IORING_POLL_ADD_MULTI = (1<<0) # macro
+IORING_POLL_UPDATE_EVENTS = (1<<1) # macro
+IORING_POLL_UPDATE_USER_DATA = (1<<2) # macro
+IORING_CQE_F_BUFFER = (1<<0) # macro
+IORING_CQE_F_MORE = (1<<1) # macro
+IORING_OFF_SQ_RING = 0 # macro
+IORING_OFF_CQ_RING = 0x8000000 # macro
+IORING_OFF_SQES = 0x10000000 # macro
+IORING_SQ_NEED_WAKEUP = (1<<0) # macro
+IORING_SQ_CQ_OVERFLOW = (1<<1) # macro
+IORING_CQ_EVENTFD_DISABLED = (1<<0) # macro
+IORING_ENTER_GETEVENTS = (1<<0) # macro
+IORING_ENTER_SQ_WAKEUP = (1<<1) # macro
+IORING_ENTER_SQ_WAIT = (1<<2) # macro
+IORING_ENTER_EXT_ARG = (1<<3) # macro
+IORING_FEAT_SINGLE_MMAP = (1<<0) # macro
+IORING_FEAT_NODROP = (1<<1) # macro
+IORING_FEAT_SUBMIT_STABLE = (1<<2) # macro
+IORING_FEAT_RW_CUR_POS = (1<<3) # macro
+IORING_FEAT_CUR_PERSONALITY = (1<<4) # macro
+IORING_FEAT_FAST_POLL = (1<<5) # macro
+IORING_FEAT_POLL_32BITS = (1<<6) # macro
+IORING_FEAT_SQPOLL_NONFIXED = (1<<7) # macro
+IORING_FEAT_EXT_ARG = (1<<8) # macro
+IORING_FEAT_NATIVE_WORKERS = (1<<9) # macro
+IORING_FEAT_RSRC_TAGS = (1<<10) # macro
+IORING_REGISTER_FILES_SKIP = (-2) # macro
+IO_URING_OP_SUPPORTED = (1<<0) # macro
 
 # values for enumeration 'c__Ea_IOSQE_FIXED_FILE_BIT'
 c__Ea_IOSQE_FIXED_FILE_BIT__enumvalues = {
@@ -1102,6 +1156,12 @@ IOSQE_IO_HARDLINK_BIT = 3
 IOSQE_ASYNC_BIT = 4
 IOSQE_BUFFER_SELECT_BIT = 5
 c__Ea_IOSQE_FIXED_FILE_BIT = ctypes.c_uint32 # enum
+IOSQE_FIXED_FILE = (1<<IOSQE_FIXED_FILE_BIT) # macro
+IOSQE_IO_DRAIN = (1<<IOSQE_IO_DRAIN_BIT) # macro
+IOSQE_IO_LINK = (1<<IOSQE_IO_LINK_BIT) # macro
+IOSQE_IO_HARDLINK = (1<<IOSQE_IO_HARDLINK_BIT) # macro
+IOSQE_ASYNC = (1<<IOSQE_ASYNC_BIT) # macro
+IOSQE_BUFFER_SELECT = (1<<IOSQE_BUFFER_SELECT_BIT) # macro
 
 # values for enumeration 'c__Ea_IORING_OP_NOP'
 c__Ea_IORING_OP_NOP__enumvalues = {
@@ -1324,7 +1384,18 @@ struct_io_uring_getevents_arg._fields_ = [
 ]
 
 __all__ = \
-    ['IORING_CQE_BUFFER_SHIFT', 'IORING_OP_ACCEPT',
+    ['IORING_CQE_BUFFER_SHIFT', 'IORING_CQE_F_BUFFER',
+    'IORING_CQE_F_MORE', 'IORING_CQ_EVENTFD_DISABLED',
+    'IORING_ENTER_EXT_ARG', 'IORING_ENTER_GETEVENTS',
+    'IORING_ENTER_SQ_WAIT', 'IORING_ENTER_SQ_WAKEUP',
+    'IORING_FEAT_CUR_PERSONALITY', 'IORING_FEAT_EXT_ARG',
+    'IORING_FEAT_FAST_POLL', 'IORING_FEAT_NATIVE_WORKERS',
+    'IORING_FEAT_NODROP', 'IORING_FEAT_POLL_32BITS',
+    'IORING_FEAT_RSRC_TAGS', 'IORING_FEAT_RW_CUR_POS',
+    'IORING_FEAT_SINGLE_MMAP', 'IORING_FEAT_SQPOLL_NONFIXED',
+    'IORING_FEAT_SUBMIT_STABLE', 'IORING_FSYNC_DATASYNC',
+    'IORING_LINK_TIMEOUT_UPDATE', 'IORING_OFF_CQ_RING',
+    'IORING_OFF_SQES', 'IORING_OFF_SQ_RING', 'IORING_OP_ACCEPT',
     'IORING_OP_ASYNC_CANCEL', 'IORING_OP_CLOSE', 'IORING_OP_CONNECT',
     'IORING_OP_EPOLL_CTL', 'IORING_OP_FADVISE', 'IORING_OP_FALLOCATE',
     'IORING_OP_FILES_UPDATE', 'IORING_OP_FSYNC', 'IORING_OP_LAST',
@@ -1339,11 +1410,13 @@ __all__ = \
     'IORING_OP_SYMLINKAT', 'IORING_OP_SYNC_FILE_RANGE',
     'IORING_OP_TEE', 'IORING_OP_TIMEOUT', 'IORING_OP_TIMEOUT_REMOVE',
     'IORING_OP_UNLINKAT', 'IORING_OP_WRITE', 'IORING_OP_WRITEV',
-    'IORING_OP_WRITE_FIXED', 'IORING_REGISTER_BUFFERS',
-    'IORING_REGISTER_BUFFERS2', 'IORING_REGISTER_BUFFERS_UPDATE',
-    'IORING_REGISTER_ENABLE_RINGS', 'IORING_REGISTER_EVENTFD',
-    'IORING_REGISTER_EVENTFD_ASYNC', 'IORING_REGISTER_FILES',
-    'IORING_REGISTER_FILES2', 'IORING_REGISTER_FILES_UPDATE',
+    'IORING_OP_WRITE_FIXED', 'IORING_POLL_ADD_MULTI',
+    'IORING_POLL_UPDATE_EVENTS', 'IORING_POLL_UPDATE_USER_DATA',
+    'IORING_REGISTER_BUFFERS', 'IORING_REGISTER_BUFFERS2',
+    'IORING_REGISTER_BUFFERS_UPDATE', 'IORING_REGISTER_ENABLE_RINGS',
+    'IORING_REGISTER_EVENTFD', 'IORING_REGISTER_EVENTFD_ASYNC',
+    'IORING_REGISTER_FILES', 'IORING_REGISTER_FILES2',
+    'IORING_REGISTER_FILES_SKIP', 'IORING_REGISTER_FILES_UPDATE',
     'IORING_REGISTER_FILES_UPDATE2', 'IORING_REGISTER_IOWQ_AFF',
     'IORING_REGISTER_IOWQ_MAX_WORKERS', 'IORING_REGISTER_LAST',
     'IORING_REGISTER_PERSONALITY', 'IORING_REGISTER_PROBE',
@@ -1351,13 +1424,24 @@ __all__ = \
     'IORING_RESTRICTION_REGISTER_OP',
     'IORING_RESTRICTION_SQE_FLAGS_ALLOWED',
     'IORING_RESTRICTION_SQE_FLAGS_REQUIRED',
-    'IORING_RESTRICTION_SQE_OP', 'IORING_UNREGISTER_BUFFERS',
-    'IORING_UNREGISTER_EVENTFD', 'IORING_UNREGISTER_FILES',
-    'IORING_UNREGISTER_IOWQ_AFF', 'IORING_UNREGISTER_PERSONALITY',
-    'IOSQE_ASYNC_BIT', 'IOSQE_BUFFER_SELECT_BIT',
-    'IOSQE_FIXED_FILE_BIT', 'IOSQE_IO_DRAIN_BIT',
-    'IOSQE_IO_HARDLINK_BIT', 'IOSQE_IO_LINK_BIT', 'IO_WQ_BOUND',
-    'IO_WQ_UNBOUND', '__io_uring_get_cqe',
+    'IORING_RESTRICTION_SQE_OP', 'IORING_SETUP_ATTACH_WQ',
+    'IORING_SETUP_CLAMP', 'IORING_SETUP_CQSIZE',
+    'IORING_SETUP_IOPOLL', 'IORING_SETUP_R_DISABLED',
+    'IORING_SETUP_SQPOLL', 'IORING_SETUP_SQ_AFF',
+    'IORING_SQ_CQ_OVERFLOW', 'IORING_SQ_NEED_WAKEUP',
+    'IORING_TIMEOUT_ABS', 'IORING_TIMEOUT_BOOTTIME',
+    'IORING_TIMEOUT_CLOCK_MASK', 'IORING_TIMEOUT_REALTIME',
+    'IORING_TIMEOUT_UPDATE', 'IORING_TIMEOUT_UPDATE_MASK',
+    'IORING_UNREGISTER_BUFFERS', 'IORING_UNREGISTER_EVENTFD',
+    'IORING_UNREGISTER_FILES', 'IORING_UNREGISTER_IOWQ_AFF',
+    'IORING_UNREGISTER_PERSONALITY', 'IOSQE_ASYNC', 'IOSQE_ASYNC_BIT',
+    'IOSQE_BUFFER_SELECT', 'IOSQE_BUFFER_SELECT_BIT',
+    'IOSQE_FIXED_FILE', 'IOSQE_FIXED_FILE_BIT', 'IOSQE_IO_DRAIN',
+    'IOSQE_IO_DRAIN_BIT', 'IOSQE_IO_HARDLINK',
+    'IOSQE_IO_HARDLINK_BIT', 'IOSQE_IO_LINK', 'IOSQE_IO_LINK_BIT',
+    'IO_URING_OP_SUPPORTED', 'IO_WQ_BOUND', 'IO_WQ_UNBOUND',
+    'LIB_URING_H', 'LINUX_IO_URING_H', 'SPLICE_F_FD_IN_FIXED',
+    '_XOPEN_SOURCE', '__io_uring_get_cqe',
     '__io_uring_prep_poll_mask', '__io_uring_set_target_fixed_file',
     '__io_uring_sqring_wait', '__u64',
     'c__Ea_IORING_CQE_BUFFER_SHIFT', 'c__Ea_IORING_OP_NOP',
@@ -1434,53 +1518,3 @@ __all__ = \
 NR_io_uring_setup = 425
 NR_io_uring_enter = 426
 NR_io_uring_register = 427
-IOSQE_FIXED_FILE = (1 << IOSQE_FIXED_FILE_BIT)
-IOSQE_IO_DRAIN = (1 << IOSQE_IO_DRAIN_BIT)
-IOSQE_IO_LINK = (1 << IOSQE_IO_LINK_BIT)
-IOSQE_IO_HARDLINK = (1 << IOSQE_IO_HARDLINK_BIT)
-IOSQE_ASYNC = (1 << IOSQE_ASYNC_BIT)
-IOSQE_BUFFER_SELECT = (1 << IOSQE_BUFFER_SELECT_BIT)
-IORING_SETUP_IOPOLL = (1 << 0)	
-IORING_SETUP_SQPOLL = (1 << 1)	
-IORING_SETUP_SQ_AFF = (1 << 2)	
-IORING_SETUP_CQSIZE = (1 << 3)	
-IORING_SETUP_CLAMP = (1 << 4)	
-IORING_SETUP_ATTACH_WQ = (1 << 5)	
-IORING_SETUP_R_DISABLED = (1 << 6)	
-IORING_FSYNC_DATASYNC = (1 << 0)
-IORING_TIMEOUT_ABS = (1 << 0)
-IORING_TIMEOUT_UPDATE = (1 << 1)
-IORING_TIMEOUT_BOOTTIME = (1 << 2)
-IORING_TIMEOUT_REALTIME = (1 << 3)
-IORING_LINK_TIMEOUT_UPDATE = (1 << 4)
-IORING_TIMEOUT_CLOCK_MASK = (IORING_TIMEOUT_BOOTTIME | IORING_TIMEOUT_REALTIME)
-IORING_TIMEOUT_UPDATE_MASK = (IORING_TIMEOUT_UPDATE | IORING_LINK_TIMEOUT_UPDATE)
-SPLICE_F_FD_IN_FIXED = (1 << 31)
-IORING_POLL_ADD_MULTI = (1 << 0)
-IORING_POLL_UPDATE_EVENTS = (1 << 1)
-IORING_POLL_UPDATE_USER_DATA = (1 << 2)
-IORING_CQE_F_BUFFER = (1 << 0)
-IORING_CQE_F_MORE = (1 << 1)
-IORING_OFF_SQ_RING = 0
-IORING_OFF_CQ_RING = 0x8000000
-IORING_OFF_SQES = 0x10000000
-IORING_SQ_NEED_WAKEUP = (1 << 0)
-IORING_SQ_CQ_OVERFLOW = (1 << 1)
-IORING_CQ_EVENTFD_DISABLED = (1 << 0)
-IORING_ENTER_GETEVENTS = (1 << 0)
-IORING_ENTER_SQ_WAKEUP = (1 << 1)
-IORING_ENTER_SQ_WAIT = (1 << 2)
-IORING_ENTER_EXT_ARG = (1 << 3)
-IORING_FEAT_SINGLE_MMAP = (1 << 0)
-IORING_FEAT_NODROP = (1 << 1)
-IORING_FEAT_SUBMIT_STABLE = (1 << 2)
-IORING_FEAT_RW_CUR_POS = (1 << 3)
-IORING_FEAT_CUR_PERSONALITY = (1 << 4)
-IORING_FEAT_FAST_POLL = (1 << 5)
-IORING_FEAT_POLL_32BITS = (1 << 6)
-IORING_FEAT_SQPOLL_NONFIXED = (1 << 7)
-IORING_FEAT_EXT_ARG = (1 << 8)
-IORING_FEAT_NATIVE_WORKERS = (1 << 9)
-IORING_FEAT_RSRC_TAGS = (1 << 10)
-IORING_REGISTER_FILES_SKIP = (-2)
-IO_URING_OP_SUPPORTED = (1 << 0)

tinygrad/runtime/autogen/kfd.py

@@ -9,6 +9,19 @@
 import ctypes, os
 
 
+
+import fcntl, functools
+
+def _do_ioctl(__idir, __base, __nr, __user_struct, __fd, **kwargs):
+  ret = fcntl.ioctl(__fd, (__idir<<30) | (ctypes.sizeof(made := __user_struct(**kwargs))<<16) | (__base<<8) | __nr, made)
+  if ret != 0: raise RuntimeError(f"ioctl returned {ret}")
+  return made
+
+def _IO(base, nr): return functools.partial(_do_ioctl, 0, ord(base) if isinstance(base, str) else base, nr, None)
+def _IOW(base, nr, type): return functools.partial(_do_ioctl, 1, ord(base) if isinstance(base, str) else base, nr, type)
+def _IOR(base, nr, type): return functools.partial(_do_ioctl, 2, ord(base) if isinstance(base, str) else base, nr, type)
+def _IOWR(base, nr, type): return functools.partial(_do_ioctl, 3, ord(base) if isinstance(base, str) else base, nr, type)
+
 class AsDictMixin:
     @classmethod
     def as_dict(cls, self):
@@ -167,8 +180,8 @@ KFD_IOC_ALLOC_MEM_FLAGS_NO_SUBSTITUTE = (1<<28) # macro
 KFD_IOC_ALLOC_MEM_FLAGS_AQL_QUEUE_MEM = (1<<27) # macro
 KFD_IOC_ALLOC_MEM_FLAGS_COHERENT = (1<<26) # macro
 KFD_IOC_ALLOC_MEM_FLAGS_UNCACHED = (1<<25) # macro
-# def KFD_SMI_EVENT_MASK_FROM_INDEX(i):  # macro
-#    return (1<<((i)-1))
+def KFD_SMI_EVENT_MASK_FROM_INDEX(i):  # macro
+   return (1<<((i)-1))
 KFD_IOCTL_SVM_FLAG_HOST_ACCESS = 0x00000001 # macro
 KFD_IOCTL_SVM_FLAG_COHERENT = 0x00000002 # macro
 KFD_IOCTL_SVM_FLAG_HIVE_LOCAL = 0x00000004 # macro
@@ -176,47 +189,14 @@ KFD_IOCTL_SVM_FLAG_GPU_RO = 0x00000008 # macro
 KFD_IOCTL_SVM_FLAG_GPU_EXEC = 0x00000010 # macro
 KFD_IOCTL_SVM_FLAG_GPU_READ_MOSTLY = 0x00000020 # macro
 AMDKFD_IOCTL_BASE = 'K' # macro
-# def AMDKFD_IO(nr):  # macro
-#    return _IO('K',nr)
-# def AMDKFD_IOR(nr, type):  # macro
-#    return _IOR('K',nr,type)
-# def AMDKFD_IOW(nr, type):  # macro
-#    return _IOW('K',nr,type)
-# def AMDKFD_IOWR(nr, type):  # macro
-#    return _IOWR('K',nr,type)
-# AMDKFD_IOC_GET_VERSION = _IOR('K',nr,type) ( 0x01 , struct kfd_ioctl_get_version_args ) # macro
-# AMDKFD_IOC_CREATE_QUEUE = _IOWR('K',nr,type) ( 0x02 , struct kfd_ioctl_create_queue_args ) # macro
-# AMDKFD_IOC_DESTROY_QUEUE = _IOWR('K',nr,type) ( 0x03 , struct kfd_ioctl_destroy_queue_args ) # macro
-# AMDKFD_IOC_SET_MEMORY_POLICY = _IOW('K',nr,type) ( 0x04 , struct kfd_ioctl_set_memory_policy_args ) # macro
-# AMDKFD_IOC_GET_CLOCK_COUNTERS = _IOWR('K',nr,type) ( 0x05 , struct kfd_ioctl_get_clock_counters_args ) # macro
-# AMDKFD_IOC_GET_PROCESS_APERTURES = _IOR('K',nr,type) ( 0x06 , struct kfd_ioctl_get_process_apertures_args ) # macro
-# AMDKFD_IOC_UPDATE_QUEUE = _IOW('K',nr,type) ( 0x07 , struct kfd_ioctl_update_queue_args ) # macro
-# AMDKFD_IOC_CREATE_EVENT = _IOWR('K',nr,type) ( 0x08 , struct kfd_ioctl_create_event_args ) # macro
-# AMDKFD_IOC_DESTROY_EVENT = _IOW('K',nr,type) ( 0x09 , struct kfd_ioctl_destroy_event_args ) # macro
-# AMDKFD_IOC_SET_EVENT = _IOW('K',nr,type) ( 0x0A , struct kfd_ioctl_set_event_args ) # macro
-# AMDKFD_IOC_RESET_EVENT = _IOW('K',nr,type) ( 0x0B , struct kfd_ioctl_reset_event_args ) # macro
-# AMDKFD_IOC_WAIT_EVENTS = _IOWR('K',nr,type) ( 0x0C , struct kfd_ioctl_wait_events_args ) # macro
-# AMDKFD_IOC_DBG_REGISTER = _IOW('K',nr,type) ( 0x0D , struct kfd_ioctl_dbg_register_args ) # macro
-# AMDKFD_IOC_DBG_UNREGISTER = _IOW('K',nr,type) ( 0x0E , struct kfd_ioctl_dbg_unregister_args ) # macro
-# AMDKFD_IOC_DBG_ADDRESS_WATCH = _IOW('K',nr,type) ( 0x0F , struct kfd_ioctl_dbg_address_watch_args ) # macro
-# AMDKFD_IOC_DBG_WAVE_CONTROL = _IOW('K',nr,type) ( 0x10 , struct kfd_ioctl_dbg_wave_control_args ) # macro
-# AMDKFD_IOC_SET_SCRATCH_BACKING_VA = _IOWR('K',nr,type) ( 0x11 , struct kfd_ioctl_set_scratch_backing_va_args ) # macro
-# AMDKFD_IOC_GET_TILE_CONFIG = _IOWR('K',nr,type) ( 0x12 , struct kfd_ioctl_get_tile_config_args ) # macro
-# AMDKFD_IOC_SET_TRAP_HANDLER = _IOW('K',nr,type) ( 0x13 , struct kfd_ioctl_set_trap_handler_args ) # macro
-# AMDKFD_IOC_GET_PROCESS_APERTURES_NEW = _IOWR('K',nr,type) ( 0x14 , struct kfd_ioctl_get_process_apertures_new_args ) # macro
-# AMDKFD_IOC_ACQUIRE_VM = _IOW('K',nr,type) ( 0x15 , struct kfd_ioctl_acquire_vm_args ) # macro
-# AMDKFD_IOC_ALLOC_MEMORY_OF_GPU = _IOWR('K',nr,type) ( 0x16 , struct kfd_ioctl_alloc_memory_of_gpu_args ) # macro
-# AMDKFD_IOC_FREE_MEMORY_OF_GPU = _IOW('K',nr,type) ( 0x17 , struct kfd_ioctl_free_memory_of_gpu_args ) # macro
-# AMDKFD_IOC_MAP_MEMORY_TO_GPU = _IOWR('K',nr,type) ( 0x18 , struct kfd_ioctl_map_memory_to_gpu_args ) # macro
-# AMDKFD_IOC_UNMAP_MEMORY_FROM_GPU = _IOWR('K',nr,type) ( 0x19 , struct kfd_ioctl_unmap_memory_from_gpu_args ) # macro
-# AMDKFD_IOC_SET_CU_MASK = _IOW('K',nr,type) ( 0x1A , struct kfd_ioctl_set_cu_mask_args ) # macro
-# AMDKFD_IOC_GET_QUEUE_WAVE_STATE = _IOWR('K',nr,type) ( 0x1B , struct kfd_ioctl_get_queue_wave_state_args ) # macro
-# AMDKFD_IOC_GET_DMABUF_INFO = _IOWR('K',nr,type) ( 0x1C , struct kfd_ioctl_get_dmabuf_info_args ) # macro
-# AMDKFD_IOC_IMPORT_DMABUF = _IOWR('K',nr,type) ( 0x1D , struct kfd_ioctl_import_dmabuf_args ) # macro
-# AMDKFD_IOC_ALLOC_QUEUE_GWS = _IOWR('K',nr,type) ( 0x1E , struct kfd_ioctl_alloc_queue_gws_args ) # macro
-# AMDKFD_IOC_SMI_EVENTS = _IOWR('K',nr,type) ( 0x1F , struct kfd_ioctl_smi_events_args ) # macro
-# AMDKFD_IOC_SVM = _IOWR('K',nr,type) ( 0x20 , struct kfd_ioctl_svm_args ) # macro
-# AMDKFD_IOC_SET_XNACK_MODE = _IOWR('K',nr,type) ( 0x21 , struct kfd_ioctl_set_xnack_mode_args ) # macro
+def AMDKFD_IO(nr):  # macro
+   return _IO('K',nr)
+def AMDKFD_IOR(nr, type):  # macro
+   return _IOR('K',nr,type)
+def AMDKFD_IOW(nr, type):  # macro
+   return _IOW('K',nr,type)
+def AMDKFD_IOWR(nr, type):  # macro
+   return _IOWR('K',nr,type)
 AMDKFD_COMMAND_START = 0x01 # macro
 AMDKFD_COMMAND_END = 0x22 # macro
 class struct_kfd_ioctl_get_version_args(Structure):
@@ -228,6 +208,7 @@ struct_kfd_ioctl_get_version_args._fields_ = [
     ('minor_version', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_GET_VERSION = AMDKFD_IOR ( 0x01 , struct_kfd_ioctl_get_version_args ) # macro (from list)
 class struct_kfd_ioctl_create_queue_args(Structure):
     pass
 
@@ -250,6 +231,7 @@ struct_kfd_ioctl_create_queue_args._fields_ = [
     ('ctl_stack_size', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_CREATE_QUEUE = AMDKFD_IOWR ( 0x02 , struct_kfd_ioctl_create_queue_args ) # macro (from list)
 class struct_kfd_ioctl_destroy_queue_args(Structure):
     pass
 
@@ -259,6 +241,7 @@ struct_kfd_ioctl_destroy_queue_args._fields_ = [
     ('pad', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_DESTROY_QUEUE = AMDKFD_IOWR ( 0x03 , struct_kfd_ioctl_destroy_queue_args ) # macro (from list)
 class struct_kfd_ioctl_update_queue_args(Structure):
     pass
 
@@ -271,6 +254,7 @@ struct_kfd_ioctl_update_queue_args._fields_ = [
     ('queue_priority', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_UPDATE_QUEUE = AMDKFD_IOW ( 0x07 , struct_kfd_ioctl_update_queue_args ) # macro (from list)
 class struct_kfd_ioctl_set_cu_mask_args(Structure):
     pass
 
@@ -281,6 +265,7 @@ struct_kfd_ioctl_set_cu_mask_args._fields_ = [
     ('cu_mask_ptr', ctypes.c_uint64),
 ]
 
+AMDKFD_IOC_SET_CU_MASK = AMDKFD_IOW ( 0x1A , struct_kfd_ioctl_set_cu_mask_args ) # macro (from list)
 class struct_kfd_ioctl_get_queue_wave_state_args(Structure):
     pass
 
@@ -293,6 +278,7 @@ struct_kfd_ioctl_get_queue_wave_state_args._fields_ = [
     ('pad', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_GET_QUEUE_WAVE_STATE = AMDKFD_IOWR ( 0x1B , struct_kfd_ioctl_get_queue_wave_state_args ) # macro (from list)
 class struct_kfd_ioctl_set_memory_policy_args(Structure):
     pass
 
@@ -306,6 +292,7 @@ struct_kfd_ioctl_set_memory_policy_args._fields_ = [
     ('pad', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_SET_MEMORY_POLICY = AMDKFD_IOW ( 0x04 , struct_kfd_ioctl_set_memory_policy_args ) # macro (from list)
 class struct_kfd_ioctl_get_clock_counters_args(Structure):
     pass
 
@@ -319,6 +306,7 @@ struct_kfd_ioctl_get_clock_counters_args._fields_ = [
     ('pad', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_GET_CLOCK_COUNTERS = AMDKFD_IOWR ( 0x05 , struct_kfd_ioctl_get_clock_counters_args ) # macro (from list)
 class struct_kfd_process_device_apertures(Structure):
     pass
 
@@ -344,6 +332,7 @@ struct_kfd_ioctl_get_process_apertures_args._fields_ = [
     ('pad', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_GET_PROCESS_APERTURES = AMDKFD_IOR ( 0x06 , struct_kfd_ioctl_get_process_apertures_args ) # macro (from list)
 class struct_kfd_ioctl_get_process_apertures_new_args(Structure):
     pass
 
@@ -354,6 +343,7 @@ struct_kfd_ioctl_get_process_apertures_new_args._fields_ = [
     ('pad', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_GET_PROCESS_APERTURES_NEW = AMDKFD_IOWR ( 0x14 , struct_kfd_ioctl_get_process_apertures_new_args ) # macro (from list)
 class struct_kfd_ioctl_dbg_register_args(Structure):
     pass
 
@@ -363,6 +353,7 @@ struct_kfd_ioctl_dbg_register_args._fields_ = [
     ('pad', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_DBG_REGISTER = AMDKFD_IOW ( 0x0D , struct_kfd_ioctl_dbg_register_args ) # macro (from list)
 class struct_kfd_ioctl_dbg_unregister_args(Structure):
     pass
 
@@ -372,6 +363,7 @@ struct_kfd_ioctl_dbg_unregister_args._fields_ = [
     ('pad', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_DBG_UNREGISTER = AMDKFD_IOW ( 0x0E , struct_kfd_ioctl_dbg_unregister_args ) # macro (from list)
 class struct_kfd_ioctl_dbg_address_watch_args(Structure):
     pass
 
@@ -382,6 +374,7 @@ struct_kfd_ioctl_dbg_address_watch_args._fields_ = [
     ('buf_size_in_bytes', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_DBG_ADDRESS_WATCH = AMDKFD_IOW ( 0x0F , struct_kfd_ioctl_dbg_address_watch_args ) # macro (from list)
 class struct_kfd_ioctl_dbg_wave_control_args(Structure):
     pass
 
@@ -392,6 +385,7 @@ struct_kfd_ioctl_dbg_wave_control_args._fields_ = [
     ('buf_size_in_bytes', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_DBG_WAVE_CONTROL = AMDKFD_IOW ( 0x10 , struct_kfd_ioctl_dbg_wave_control_args ) # macro (from list)
 class struct_kfd_ioctl_create_event_args(Structure):
     pass
 
@@ -406,6 +400,7 @@ struct_kfd_ioctl_create_event_args._fields_ = [
     ('event_slot_index', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_CREATE_EVENT = AMDKFD_IOWR ( 0x08 , struct_kfd_ioctl_create_event_args ) # macro (from list)
 class struct_kfd_ioctl_destroy_event_args(Structure):
     pass
 
@@ -415,6 +410,7 @@ struct_kfd_ioctl_destroy_event_args._fields_ = [
     ('pad', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_DESTROY_EVENT = AMDKFD_IOW ( 0x09 , struct_kfd_ioctl_destroy_event_args ) # macro (from list)
 class struct_kfd_ioctl_set_event_args(Structure):
     pass
 
@@ -424,6 +420,7 @@ struct_kfd_ioctl_set_event_args._fields_ = [
     ('pad', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_SET_EVENT = AMDKFD_IOW ( 0x0A , struct_kfd_ioctl_set_event_args ) # macro (from list)
 class struct_kfd_ioctl_reset_event_args(Structure):
     pass
 
@@ -433,6 +430,7 @@ struct_kfd_ioctl_reset_event_args._fields_ = [
     ('pad', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_RESET_EVENT = AMDKFD_IOW ( 0x0B , struct_kfd_ioctl_reset_event_args ) # macro (from list)
 class struct_kfd_memory_exception_failure(Structure):
     pass
 
@@ -500,6 +498,7 @@ struct_kfd_ioctl_wait_events_args._fields_ = [
     ('wait_result', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_WAIT_EVENTS = AMDKFD_IOWR ( 0x0C , struct_kfd_ioctl_wait_events_args ) # macro (from list)
 class struct_kfd_ioctl_set_scratch_backing_va_args(Structure):
     pass
 
@@ -510,6 +509,7 @@ struct_kfd_ioctl_set_scratch_backing_va_args._fields_ = [
     ('pad', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_SET_SCRATCH_BACKING_VA = AMDKFD_IOWR ( 0x11 , struct_kfd_ioctl_set_scratch_backing_va_args ) # macro (from list)
 class struct_kfd_ioctl_get_tile_config_args(Structure):
     pass
 
@@ -525,6 +525,7 @@ struct_kfd_ioctl_get_tile_config_args._fields_ = [
     ('num_ranks', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_GET_TILE_CONFIG = AMDKFD_IOWR ( 0x12 , struct_kfd_ioctl_get_tile_config_args ) # macro (from list)
 class struct_kfd_ioctl_set_trap_handler_args(Structure):
     pass
 
@@ -536,6 +537,7 @@ struct_kfd_ioctl_set_trap_handler_args._fields_ = [
     ('pad', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_SET_TRAP_HANDLER = AMDKFD_IOW ( 0x13 , struct_kfd_ioctl_set_trap_handler_args ) # macro (from list)
 class struct_kfd_ioctl_acquire_vm_args(Structure):
     pass
 
@@ -545,6 +547,7 @@ struct_kfd_ioctl_acquire_vm_args._fields_ = [
     ('gpu_id', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_ACQUIRE_VM = AMDKFD_IOW ( 0x15 , struct_kfd_ioctl_acquire_vm_args ) # macro (from list)
 class struct_kfd_ioctl_alloc_memory_of_gpu_args(Structure):
     pass
 
@@ -558,6 +561,7 @@ struct_kfd_ioctl_alloc_memory_of_gpu_args._fields_ = [
     ('flags', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_ALLOC_MEMORY_OF_GPU = AMDKFD_IOWR ( 0x16 , struct_kfd_ioctl_alloc_memory_of_gpu_args ) # macro (from list)
 class struct_kfd_ioctl_free_memory_of_gpu_args(Structure):
     pass
 
@@ -566,6 +570,7 @@ struct_kfd_ioctl_free_memory_of_gpu_args._fields_ = [
     ('handle', ctypes.c_uint64),
 ]
 
+AMDKFD_IOC_FREE_MEMORY_OF_GPU = AMDKFD_IOW ( 0x17 , struct_kfd_ioctl_free_memory_of_gpu_args ) # macro (from list)
 class struct_kfd_ioctl_map_memory_to_gpu_args(Structure):
     pass
 
@@ -577,6 +582,7 @@ struct_kfd_ioctl_map_memory_to_gpu_args._fields_ = [
     ('n_success', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_MAP_MEMORY_TO_GPU = AMDKFD_IOWR ( 0x18 , struct_kfd_ioctl_map_memory_to_gpu_args ) # macro (from list)
 class struct_kfd_ioctl_unmap_memory_from_gpu_args(Structure):
     pass
 
@@ -588,6 +594,7 @@ struct_kfd_ioctl_unmap_memory_from_gpu_args._fields_ = [
     ('n_success', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_UNMAP_MEMORY_FROM_GPU = AMDKFD_IOWR ( 0x19 , struct_kfd_ioctl_unmap_memory_from_gpu_args ) # macro (from list)
 class struct_kfd_ioctl_alloc_queue_gws_args(Structure):
     pass
 
@@ -599,6 +606,7 @@ struct_kfd_ioctl_alloc_queue_gws_args._fields_ = [
     ('pad', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_ALLOC_QUEUE_GWS = AMDKFD_IOWR ( 0x1E , struct_kfd_ioctl_alloc_queue_gws_args ) # macro (from list)
 class struct_kfd_ioctl_get_dmabuf_info_args(Structure):
     pass
 
@@ -612,6 +620,7 @@ struct_kfd_ioctl_get_dmabuf_info_args._fields_ = [
     ('dmabuf_fd', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_GET_DMABUF_INFO = AMDKFD_IOWR ( 0x1C , struct_kfd_ioctl_get_dmabuf_info_args ) # macro (from list)
 class struct_kfd_ioctl_import_dmabuf_args(Structure):
     pass
 
@@ -623,6 +632,7 @@ struct_kfd_ioctl_import_dmabuf_args._fields_ = [
     ('dmabuf_fd', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_IMPORT_DMABUF = AMDKFD_IOWR ( 0x1D , struct_kfd_ioctl_import_dmabuf_args ) # macro (from list)
 
 # values for enumeration 'kfd_smi_event'
 kfd_smi_event__enumvalues = {
@@ -647,6 +657,7 @@ struct_kfd_ioctl_smi_events_args._fields_ = [
     ('anon_fd', ctypes.c_uint32),
 ]
 
+AMDKFD_IOC_SMI_EVENTS = AMDKFD_IOWR ( 0x1F , struct_kfd_ioctl_smi_events_args ) # macro (from list)
 
 # values for enumeration 'kfd_mmio_remap'
 kfd_mmio_remap__enumvalues = {
@@ -716,6 +727,7 @@ struct_kfd_ioctl_svm_args._fields_ = [
     ('attrs', struct_kfd_ioctl_svm_attribute * 0),
 ]
 
+AMDKFD_IOC_SVM = AMDKFD_IOWR ( 0x20 , struct_kfd_ioctl_svm_args ) # macro (from list)
 class struct_kfd_ioctl_set_xnack_mode_args(Structure):
     pass
 
@@ -724,6 +736,7 @@ struct_kfd_ioctl_set_xnack_mode_args._fields_ = [
     ('xnack_enabled', ctypes.c_int32),
 ]
 
+AMDKFD_IOC_SET_XNACK_MODE = AMDKFD_IOWR ( 0x21 , struct_kfd_ioctl_set_xnack_mode_args ) # macro (from list)
 __all__ = \
     ['AMDKFD_COMMAND_END', 'AMDKFD_COMMAND_START',
     'AMDKFD_IOCTL_BASE', 'KFD_HW_EXCEPTION_ECC',
@@ -770,10 +783,10 @@ __all__ = \
     'KFD_SMI_EVENT_NONE', 'KFD_SMI_EVENT_THERMAL_THROTTLE',
     'KFD_SMI_EVENT_VMFAULT', 'MAX_ALLOWED_AW_BUFF_SIZE',
     'MAX_ALLOWED_NUM_POINTS', 'MAX_ALLOWED_WAC_BUFF_SIZE',
-    'NUM_OF_SUPPORTED_GPUS', 'kfd_ioctl_svm_attr_type',
-    'kfd_ioctl_svm_location', 'kfd_ioctl_svm_op', 'kfd_mmio_remap',
-    'kfd_smi_event', 'struct_kfd_event_data',
-    'struct_kfd_hsa_hw_exception_data',
+    'NUM_OF_SUPPORTED_GPUS', '_IO', '_IOR', '_IOW', '_IOWR',
+    'kfd_ioctl_svm_attr_type', 'kfd_ioctl_svm_location',
+    'kfd_ioctl_svm_op', 'kfd_mmio_remap', 'kfd_smi_event',
+    'struct_kfd_event_data', 'struct_kfd_hsa_hw_exception_data',
     'struct_kfd_hsa_memory_exception_data',
     'struct_kfd_ioctl_acquire_vm_args',
     'struct_kfd_ioctl_alloc_memory_of_gpu_args',
@@ -810,35 +823,3 @@ __all__ = \
     'struct_kfd_ioctl_wait_events_args',
     'struct_kfd_memory_exception_failure',
     'struct_kfd_process_device_apertures', 'union_kfd_event_data_0']
-AMDKFD_IOC_GET_VERSION = ("IOR", 0x01, struct_kfd_ioctl_get_version_args)
-AMDKFD_IOC_CREATE_QUEUE = ("IOWR", 0x02, struct_kfd_ioctl_create_queue_args)
-AMDKFD_IOC_DESTROY_QUEUE = ("IOWR", 0x03, struct_kfd_ioctl_destroy_queue_args)
-AMDKFD_IOC_SET_MEMORY_POLICY = ("IOW", 0x04, struct_kfd_ioctl_set_memory_policy_args)
-AMDKFD_IOC_GET_CLOCK_COUNTERS = ("IOWR", 0x05, struct_kfd_ioctl_get_clock_counters_args)
-AMDKFD_IOC_GET_PROCESS_APERTURES = ("IOR", 0x06, struct_kfd_ioctl_get_process_apertures_args)
-AMDKFD_IOC_UPDATE_QUEUE = ("IOW", 0x07, struct_kfd_ioctl_update_queue_args)
-AMDKFD_IOC_CREATE_EVENT = ("IOWR", 0x08, struct_kfd_ioctl_create_event_args)
-AMDKFD_IOC_DESTROY_EVENT = ("IOW", 0x09, struct_kfd_ioctl_destroy_event_args)
-AMDKFD_IOC_SET_EVENT = ("IOW", 0x0A, struct_kfd_ioctl_set_event_args)
-AMDKFD_IOC_RESET_EVENT = ("IOW", 0x0B, struct_kfd_ioctl_reset_event_args)
-AMDKFD_IOC_WAIT_EVENTS = ("IOWR", 0x0C, struct_kfd_ioctl_wait_events_args)
-AMDKFD_IOC_DBG_REGISTER = ("IOW", 0x0D, struct_kfd_ioctl_dbg_register_args)
-AMDKFD_IOC_DBG_UNREGISTER = ("IOW", 0x0E, struct_kfd_ioctl_dbg_unregister_args)
-AMDKFD_IOC_DBG_ADDRESS_WATCH = ("IOW", 0x0F, struct_kfd_ioctl_dbg_address_watch_args)
-AMDKFD_IOC_DBG_WAVE_CONTROL = ("IOW", 0x10, struct_kfd_ioctl_dbg_wave_control_args)
-AMDKFD_IOC_SET_SCRATCH_BACKING_VA = ("IOWR", 0x11, struct_kfd_ioctl_set_scratch_backing_va_args)
-AMDKFD_IOC_GET_TILE_CONFIG = ("IOWR", 0x12, struct_kfd_ioctl_get_tile_config_args)
-AMDKFD_IOC_SET_TRAP_HANDLER = ("IOW", 0x13, struct_kfd_ioctl_set_trap_handler_args)
-AMDKFD_IOC_ACQUIRE_VM = ("IOW", 0x15, struct_kfd_ioctl_acquire_vm_args)
-AMDKFD_IOC_ALLOC_MEMORY_OF_GPU = ("IOWR", 0x16, struct_kfd_ioctl_alloc_memory_of_gpu_args)
-AMDKFD_IOC_FREE_MEMORY_OF_GPU = ("IOW", 0x17, struct_kfd_ioctl_free_memory_of_gpu_args)
-AMDKFD_IOC_MAP_MEMORY_TO_GPU = ("IOWR", 0x18, struct_kfd_ioctl_map_memory_to_gpu_args)
-AMDKFD_IOC_UNMAP_MEMORY_FROM_GPU = ("IOWR", 0x19, struct_kfd_ioctl_unmap_memory_from_gpu_args)
-AMDKFD_IOC_SET_CU_MASK = ("IOW", 0x1A, struct_kfd_ioctl_set_cu_mask_args)
-AMDKFD_IOC_GET_QUEUE_WAVE_STATE = ("IOWR", 0x1B, struct_kfd_ioctl_get_queue_wave_state_args)
-AMDKFD_IOC_GET_DMABUF_INFO = ("IOWR", 0x1C, struct_kfd_ioctl_get_dmabuf_info_args)
-AMDKFD_IOC_IMPORT_DMABUF = ("IOWR", 0x1D, struct_kfd_ioctl_import_dmabuf_args)
-AMDKFD_IOC_ALLOC_QUEUE_GWS = ("IOWR", 0x1E, struct_kfd_ioctl_alloc_queue_gws_args)
-AMDKFD_IOC_SMI_EVENTS = ("IOWR", 0x1F, struct_kfd_ioctl_smi_events_args)
-AMDKFD_IOC_SVM = ("IOWR", 0x20, struct_kfd_ioctl_svm_args)
-AMDKFD_IOC_SET_XNACK_MODE = ("IOWR", 0x21, struct_kfd_ioctl_set_xnack_mode_args)

tinygrad/runtime/autogen/opencl.py

@@ -610,17 +610,17 @@ CL_KHRONOS_VENDOR_ID_CODEPLAY = 0x10004 # macro
 CL_VERSION_MAJOR_BITS = (10) # macro
 CL_VERSION_MINOR_BITS = (10) # macro
 CL_VERSION_PATCH_BITS = (12) # macro
-# CL_VERSION_MAJOR_MASK = ((1<<(10)) # macro
-# CL_VERSION_MINOR_MASK = ((1<<(10)) # macro
-# CL_VERSION_PATCH_MASK = ((1<<(12)) # macro
-# def CL_VERSION_MAJOR(version):  # macro
-#    return ((version)>>((10)+(12)))
-# def CL_VERSION_MINOR(version):  # macro
-#    return (((version)>>(12))&((1<<(10)))
-# def CL_VERSION_PATCH(version):  # macro
-#    return ((version)&((1<<(12)))
-# def CL_MAKE_VERSION(major, minor, patch):  # macro
-#    return ((((major)&((1<<(10)))<<((10)+(12)))|(((minor)&((1<<(10)))<<(12))|((patch)&((1<<(12))))
+CL_VERSION_MAJOR_MASK = ((1<<(10))-1) # macro
+CL_VERSION_MINOR_MASK = ((1<<(10))-1) # macro
+CL_VERSION_PATCH_MASK = ((1<<(12))-1) # macro
+def CL_VERSION_MAJOR(version):  # macro
+   return ((version)>>((10)+(12)))
+def CL_VERSION_MINOR(version):  # macro
+   return (((version)>>(12))&((1<<(10))-1))
+def CL_VERSION_PATCH(version):  # macro
+   return ((version)&((1<<(12))-1))
+def CL_MAKE_VERSION(major, minor, patch):  # macro
+   return ((((major)&((1<<(10))-1))<<((10)+(12)))|(((minor)&((1<<(10))-1))<<(12))|((patch)&((1<<(12))-1)))
 class struct__cl_platform_id(Structure):
     pass
 

tinygrad/runtime/ops_amd.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 from typing import Tuple, List, Any, cast
-import os, fcntl, ctypes, ctypes.util, functools, pathlib, mmap, errno, time, array, contextlib, decimal
+import os, ctypes, ctypes.util, functools, pathlib, mmap, errno, time, array, contextlib, decimal
 from dataclasses import dataclass
 from tinygrad.device import HCQCompiled, HCQAllocator, HCQBuffer, HWComputeQueue, HWCopyQueue, HCQArgsState, \
                             HCQSignal, HCQProgram, BufferOptions
@@ -16,14 +16,6 @@ def is_usable_gpu(gpu_id):
   with contextlib.suppress(OSError): return int(pathlib.Path(gpu_id).read_text()) != 0
   return False
 
-def kfd_ioctl(idir, nr, user_struct, fd, **kwargs):
-  ret = fcntl.ioctl(fd, (idir<<30) | (ctypes.sizeof(made := user_struct(**kwargs))<<16) | (ord('K')<<8) | nr, made)
-  if ret != 0: raise RuntimeError(f"ioctl returned {ret}")
-  return made
-
-kio:Any = type("KIO", (object,), {name[11:].lower(): functools.partial(kfd_ioctl, {"IOW": 1, "IOR": 2, "IOWR": 3}[p[0]], p[1], p[2])
-                              for name,p in kfd.__dict__.items() if name.startswith("AMDKFD_IOC_")})
-
 regBIF_BX_PF1_GPU_HDP_FLUSH_REQ, regBIF_BX_PF1_GPU_HDP_FLUSH_DONE = 0x0106, 0x0107
 
 # VGT_EVENT_TYPE in navi10_enum.h
@@ -42,7 +34,7 @@ class AMDSignal(HCQSignal):
     self._signal = AMDDevice.signals_pool.pop()
     self._value_addr, self._timestamp_addr = mv_address(self._signal), mv_address(self._signal) + 8
     if alloc_event:
-      sync_event = kio.create_event(AMDDevice.kfd, auto_reset=1)
+      sync_event = kfd.AMDKFD_IOC_CREATE_EVENT(AMDDevice.kfd, auto_reset=1)
       self._event_mailbox_ptr = AMDDevice.event_page.va_addr + sync_event.event_slot_index*8
       self._event_id = sync_event.event_id
       self._evt_array = (kfd.struct_kfd_event_data)(event_id=self._event_id)
@@ -59,7 +51,7 @@ class AMDSignal(HCQSignal):
 
       # Wait active for 5s, then going to sleep.
       if time_spent > 5000 and self._event_id != 0:
-        kio.wait_events(AMDDevice.kfd, events_ptr=ctypes.addressof(self._evt_array), num_events=1, wait_for_all=1, timeout=1000)
+        kfd.AMDKFD_IOC_WAIT_EVENTS(AMDDevice.kfd, events_ptr=ctypes.addressof(self._evt_array), num_events=1, wait_for_all=1, timeout=1000)
     raise RuntimeError(f"wait_signal: not set to {value}, but {self._signal[0]}, {timeout} ms TIMEOUT!")
 
 class AMDComputeQueue(HWComputeQueue):
@@ -338,7 +330,8 @@ class AMDDevice(HCQCompiled):
     if self.gpu_id in getattr(mem, "mapped_gpu_ids", []): return
     mem.__setattr__("mapped_gpu_ids", getattr(mem, "mapped_gpu_ids", []) + [self.gpu_id])
     c_gpus = (ctypes.c_int32 * len(mem.mapped_gpu_ids))(*mem.mapped_gpu_ids)
-    stm = kio.map_memory_to_gpu(self.kfd, handle=mem.handle, device_ids_array_ptr=ctypes.addressof(c_gpus), n_devices=len(mem.mapped_gpu_ids))
+    stm = kfd.AMDKFD_IOC_MAP_MEMORY_TO_GPU(self.kfd, handle=mem.handle, device_ids_array_ptr=ctypes.addressof(c_gpus),
+                                           n_devices=len(mem.mapped_gpu_ids))
     assert stm.n_success == len(mem.mapped_gpu_ids)
 
   def _gpu_alloc(self, size:int, flags:int, uncached=False, public=False, map_to_gpu=True):
@@ -351,7 +344,8 @@ class AMDDevice(HCQCompiled):
       buf, addr = 0, libc.mmap(0, size, 0, mmap.MAP_PRIVATE|mmap.MAP_ANONYMOUS|MAP_NORESERVE, -1, 0)
     assert addr != 0xffffffffffffffff
 
-    try: mem = kio.alloc_memory_of_gpu(self.kfd, va_addr=addr, size=size, base=addr, length=size, gpu_id=self.gpu_id, flags=flags, mmap_offset=buf)
+    try: mem = kfd.AMDKFD_IOC_ALLOC_MEMORY_OF_GPU(self.kfd, va_addr=addr, size=size, base=addr, length=size, gpu_id=self.gpu_id,
+                                                  flags=flags, mmap_offset=buf)
     except OSError as e:
       if e.errno == errno.EINVAL and (flags & kfd.KFD_IOC_ALLOC_MEM_FLAGS_VRAM) and public:
         raise MemoryError("Cannot allocate host-visible VRAM. Ensure the resizable BAR option is enabled on your system.") from e
@@ -367,10 +361,10 @@ class AMDDevice(HCQCompiled):
   def _gpu_free(self, mem):
     if len(gpus:=getattr(mem, "mapped_gpu_ids", [])):
       c_gpus = (ctypes.c_int32 * len(gpus))(*gpus)
-      stm = kio.unmap_memory_from_gpu(self.kfd, handle=mem.handle, device_ids_array_ptr=ctypes.addressof(c_gpus), n_devices=len(gpus))
+      stm = kfd.AMDKFD_IOC_UNMAP_MEMORY_FROM_GPU(self.kfd, handle=mem.handle, device_ids_array_ptr=ctypes.addressof(c_gpus), n_devices=len(gpus))
       assert stm.n_success == len(gpus)
     libc.munmap(mem.va_addr, mem.size)
-    kio.free_memory_of_gpu(self.kfd, handle=mem.handle)
+    kfd.AMDKFD_IOC_FREE_MEMORY_OF_GPU(self.kfd, handle=mem.handle)
 
   def __init__(self, device:str=""):
     if AMDDevice.kfd == -1:
@@ -390,13 +384,13 @@ class AMDDevice(HCQCompiled):
     self.arch = "gfx%d%x%x" % (target // 10000, (target // 100) % 100, target % 100)
     if target < 110000 or target >= 120000: raise RuntimeError(f"Unsupported arch: {self.arch}")
 
-    kio.acquire_vm(AMDDevice.kfd, drm_fd=self.drm_fd, gpu_id=self.gpu_id)
+    kfd.AMDKFD_IOC_ACQUIRE_VM(AMDDevice.kfd, drm_fd=self.drm_fd, gpu_id=self.gpu_id)
 
     if AMDDevice.event_page is None:
       AMDDevice.signals_page = self._gpu_alloc(16 * 65536, kfd.KFD_IOC_ALLOC_MEM_FLAGS_GTT, uncached=True)
       AMDDevice.event_page = self._gpu_alloc(0x8000, kfd.KFD_IOC_ALLOC_MEM_FLAGS_GTT, uncached=True)
       AMDDevice.signals_pool = [to_mv(self.signals_page.va_addr + off, 16).cast("Q") for off in range(0, AMDDevice.signals_page.size, 16)]
-      kio.create_event(AMDDevice.kfd, event_page_offset=AMDDevice.event_page.handle)
+      kfd.AMDKFD_IOC_CREATE_EVENT(AMDDevice.kfd, event_page_offset=AMDDevice.event_page.handle)
     else:
       self._gpu_map(AMDDevice.signals_page)
       self._gpu_map(AMDDevice.event_page)
@@ -422,7 +416,7 @@ class AMDDevice(HCQCompiled):
     ring = self._gpu_alloc(ring_size, kfd.KFD_IOC_ALLOC_MEM_FLAGS_GTT, uncached=True)
     cwsr_ctx = self._gpu_alloc(ctx_save_restore_size, kfd.KFD_IOC_ALLOC_MEM_FLAGS_VRAM) if ctx_save_restore_size else None
     eop_buffer = self._gpu_alloc(eop_buffer_size, kfd.KFD_IOC_ALLOC_MEM_FLAGS_VRAM) if eop_buffer_size else None
-    queue = kio.create_queue(AMDDevice.kfd, ring_base_address=ring.va_addr, ring_size=ring.size, gpu_id=self.gpu_id,
+    queue = kfd.AMDKFD_IOC_CREATE_QUEUE(AMDDevice.kfd, ring_base_address=ring.va_addr, ring_size=ring.size, gpu_id=self.gpu_id,
       queue_type=queue_type, queue_percentage=kfd.KFD_MAX_QUEUE_PERCENTAGE, queue_priority=kfd.KFD_MAX_QUEUE_PRIORITY,
       eop_buffer_address=eop_buffer.va_addr if eop_buffer else 0, eop_buffer_size=eop_buffer.size if eop_buffer else 0,
       ctx_save_restore_address=cwsr_ctx.va_addr if cwsr_ctx else 0, ctx_save_restore_size=cwsr_ctx.size if cwsr_ctx else 0,

tinygrad/runtime/ops_gpu.py

@@ -9,7 +9,7 @@ from tinygrad.device import BufferOptions, LRUAllocator, Compiled, Compiler, Com
 # see test/external/external_osx_profiling.py to determine this ratio. it's in like GPU clocks or something
 OSX_TIMING_RATIO = (125/3) if OSX else 1.0
 
-cl_errors = {attr: k for k in dir(cl) if k.startswith("CL_") and (attr:=getattr(cl, k)) <= 0}
+cl_errors = {attr: k for k in dir(cl) if k.startswith("CL_") and isinstance(attr:=getattr(cl, k), int) and attr <= 0}
 def check(status):
   if status != 0: raise RuntimeError(f"OpenCL Error {status}: {cl_errors.get(status, 'Unknown error')}")
 def checked(ret, status): return (check(status.value), ret)[1]