forked from IQ.Lvbs/IQ.Pilot
IQ.Pilot Prebuilt Release @ ab07000
This commit is contained in:
IQ.Lvbs history cleanup
38
tinygrad_repo/extra/dsp/Dockerfile
Normal file
38
tinygrad_repo/extra/dsp/Dockerfile
Normal file
@@ -0,0 +1,38 @@
|
||||
# Use a recent Ubuntu base image.
|
||||
FROM ubuntu:22.04
|
||||
|
||||
# Install required packages.
|
||||
RUN apt-get update && apt-get install -y \
|
||||
git \
|
||||
build-essential \
|
||||
python3 \
|
||||
python3-pip \
|
||||
python3-tomli \
|
||||
pkg-config \
|
||||
libglib2.0-dev \
|
||||
libfdt-dev \
|
||||
libpixman-1-dev \
|
||||
zlib1g-dev \
|
||||
ninja-build \
|
||||
meson \
|
||||
wget
|
||||
|
||||
# Clone QEMU source (you can pin a specific version if desired)
|
||||
RUN wget https://download.qemu.org/qemu-9.2.0.tar.xz && tar xvJf qemu-9.2.0.tar.xz
|
||||
|
||||
WORKDIR /qemu-9.2.0
|
||||
|
||||
RUN apt-get install -y flex bison
|
||||
|
||||
# Configure QEMU to build the hexagon user-mode emulator.
|
||||
RUN ./configure --target-list=hexagon-linux-user && make -j$(nproc)
|
||||
|
||||
# Optionally, install QEMU into /usr/local (or leave it in place).
|
||||
RUN make install
|
||||
|
||||
# delete the source (for space)
|
||||
RUN cd .. && rm -rf /qemu-9.2.0
|
||||
|
||||
# The QEMU binaries will be in /usr/local/bin.
|
||||
# Set the entrypoint to bash so you can interact with the container.
|
||||
ENTRYPOINT ["/bin/bash"]
|
||||
125
tinygrad_repo/extra/dsp/compile.py
Executable file
125
tinygrad_repo/extra/dsp/compile.py
Executable file
@@ -0,0 +1,125 @@
|
||||
#!/usr/bin/env python3
|
||||
import os, ctypes, time, fcntl, mmap
|
||||
import llvmlite.binding as llvm
|
||||
from tinygrad.helpers import getenv, to_mv
|
||||
from tinygrad.runtime.support.elf import elf_loader
|
||||
from hexdump import hexdump
|
||||
from tinygrad.runtime.autogen import libc
|
||||
if getenv("IOCTL"): import run # noqa: F401 # pylint: disable=unused-import
|
||||
|
||||
adsp = ctypes.CDLL(ctypes.util.find_library("adsprpc"))
|
||||
import adsprpc
|
||||
import ion
|
||||
import msm_ion
|
||||
ION_IOC_ALLOC = 0
|
||||
ION_IOC_MAP = 2
|
||||
ION_IOC_SHARE = 4
|
||||
ION_IOC_CUSTOM = 6
|
||||
ION_ADSP_HEAP_ID = 22
|
||||
ION_IOMMU_HEAP_ID = 25
|
||||
|
||||
def ion_iowr(fd, nr, args):
|
||||
ret = fcntl.ioctl(fd, (3 << 30) | (ctypes.sizeof(args) & 0x1FFF) << 16 | (ord(ion.ION_IOC_MAGIC) & 0xFF) << 8 | (nr & 0xFF), args)
|
||||
if ret != 0: raise RuntimeError(f"ioctl returned {ret}")
|
||||
|
||||
if __name__ == "__main__":
|
||||
# TODO: mmap tensors to the DSP
|
||||
# call the target function with the mmaped tensors
|
||||
ion_fd = os.open("/dev/ion", os.O_RDWR | os.O_CLOEXEC)
|
||||
arg3 = ion.struct_ion_allocation_data(len=0x1000, align=0x1000, heap_id_mask=1<<msm_ion.ION_SYSTEM_HEAP_ID, flags=ion.ION_FLAG_CACHED)
|
||||
ion_iowr(ion_fd, ION_IOC_ALLOC, arg3)
|
||||
print(arg3.handle)
|
||||
arg2 = ion.struct_ion_fd_data(handle=arg3.handle)
|
||||
ion_iowr(ion_fd, ION_IOC_SHARE, arg2)
|
||||
print(arg2.fd)
|
||||
|
||||
res = libc.mmap(0, 0x1000, mmap.PROT_READ|mmap.PROT_WRITE, mmap.MAP_SHARED, arg2.fd, 0)
|
||||
print("mmapped", hex(res))
|
||||
to_mv(res, 0x10)[1] = 0xaa
|
||||
|
||||
from tinygrad.runtime.ops_dsp import ClangCompiler
|
||||
cc = ClangCompiler(args=["--target=hexagon", "-mcpu=hexagonv65", "-fuse-ld=lld", "-nostdlib"])
|
||||
|
||||
obj = cc.compile("""
|
||||
typedef unsigned long long remote_handle64;
|
||||
typedef struct { void *pv; unsigned int len; } remote_buf;
|
||||
typedef struct { int fd; unsigned int offset; } remote_dma_handle;
|
||||
typedef union { remote_buf buf; remote_handle64 h64; remote_dma_handle dma; } remote_arg;
|
||||
void* HAP_mmap(void *addr, int len, int prot, int flags, int fd, long offset);
|
||||
int HAP_munmap(void *addr, int len);
|
||||
#define HAP_MEM_CACHE_WRITETHROUGH 0x40
|
||||
|
||||
int entry(unsigned long long handle, unsigned int sc, remote_arg* pra) {
|
||||
if (sc>>24 == 1) {
|
||||
//void *mmaped = *((void**)pra[0].buf.pv);
|
||||
void *a = HAP_mmap(0, 0x1000, 3, 0, pra[1].dma.fd, 0);
|
||||
((char*)a)[0] = 0x55;
|
||||
((char*)a)[4] = 0x55;
|
||||
((char*)a)[8] = 0x99;
|
||||
//((char*)a)[1] = 0x9b;
|
||||
//char ret = ((char*)a)[1];
|
||||
HAP_munmap(a, 0x1000);
|
||||
return 0;
|
||||
|
||||
//return ((int)mmaped)&0xFFFF;
|
||||
//return ((char*)mmaped)[1];
|
||||
//return sizeof(void*);
|
||||
|
||||
//((char*)mmaped)[0] = 55;
|
||||
//return ((int)mmaped)&0xFFFF;
|
||||
|
||||
//void addr = *((void**)pra[1])
|
||||
//return sizeof(remote_buf);
|
||||
//((char*)pra[1].h64)[0] = 55;
|
||||
|
||||
//return ((char*)mmaped)[1];
|
||||
//((char*)mmaped)[0] = 55;
|
||||
// NOTE: you have to return 0 for outbufs to work
|
||||
//return ((int)pra[1].h64)&0xFFFF;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
""")
|
||||
with open("/tmp/swag.so", "wb") as f: f.write(obj)
|
||||
|
||||
handle = ctypes.c_int64(-1)
|
||||
adsp.remote_handle64_open(ctypes.create_string_buffer(b"file:////tmp/swag.so?entry&_modver=1.0&_dom=cdsp"), ctypes.byref(handle))
|
||||
print("HANDLE", handle.value)
|
||||
#print(adsp.remote_handle64_invoke(handle, 0, None))
|
||||
|
||||
#rem = adsp.remote_register_buf(res, 0x1000, arg2.fd, 4)
|
||||
#rem = adsp.remote_register_dma_handle(arg2.fd, 0x1000)
|
||||
#print("remote_register_buf_attr", rem)
|
||||
|
||||
#out = ctypes.c_uint64(0)
|
||||
#ret = adsp.remote_mmap(arg2.fd, 0, 0, 0x1000, ctypes.byref(out))
|
||||
#print(ret)
|
||||
#print("mapped at", hex(out.value))
|
||||
|
||||
#arg_2 = ctypes.c_int64(out.value)
|
||||
arg_2 = ctypes.c_int64(arg2.fd)
|
||||
pra = (adsprpc.union_remote_arg64 * 3)()
|
||||
pra[0].buf.pv = ctypes.addressof(arg_2)
|
||||
pra[0].buf.len = 8
|
||||
pra[1].dma.fd = arg2.fd
|
||||
pra[1].dma.len = 0x1000
|
||||
print("invoke")
|
||||
ret = adsp.remote_handle64_invoke(handle, (1<<24) | (1<<16) | (1 << 4), pra)
|
||||
print("return value", ret, hex(ret))
|
||||
#print(hex(arg_2.value), arg_2.value)
|
||||
#time.sleep(0.1)
|
||||
|
||||
# flush the cache
|
||||
"""
|
||||
flush_data = msm_ion.struct_ion_flush_data(handle=arg3.handle, vaddr=res, offset=0, length=0x1000)
|
||||
# ION_IOC_CLEAN_INV_CACHES
|
||||
cd = ion.struct_ion_custom_data(
|
||||
cmd=(3 << 30) | (ctypes.sizeof(flush_data) & 0x1FFF) << 16 | (ord(msm_ion.ION_IOC_MSM_MAGIC) & 0xFF) << 8 | (2 & 0xFF),
|
||||
arg=ctypes.addressof(flush_data))
|
||||
ret = ion_iowr(ion_fd, ION_IOC_CUSTOM, cd)
|
||||
|
||||
res2 = libc.mmap(0, 0x1000, mmap.PROT_READ|mmap.PROT_WRITE, mmap.MAP_SHARED, arg2.fd, 0)
|
||||
"""
|
||||
hexdump(to_mv(res, 0x10))
|
||||
os._exit(0)
|
||||
|
||||
3
tinygrad_repo/extra/dsp/gen.sh
Executable file
3
tinygrad_repo/extra/dsp/gen.sh
Executable file
@@ -0,0 +1,3 @@
|
||||
#!/bin/bash
|
||||
clang2py adsprpc_shared.h -k cdefstum -o adsprpc.py
|
||||
|
||||
101
tinygrad_repo/extra/dsp/hook.py
Normal file
101
tinygrad_repo/extra/dsp/hook.py
Normal file
@@ -0,0 +1,101 @@
|
||||
import os
|
||||
print("from import")
|
||||
del os.environ["LD_PRELOAD"]
|
||||
import ctypes, ctypes.util
|
||||
from extra.dsp.run import install_hook, ioctl, libc, get_struct, qcom_dsp, format_struct, to_mv, hexdump
|
||||
|
||||
@ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_long)
|
||||
def _mmap(addr, length, prot, flags, fd, offset):
|
||||
mmap_type = ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_long)
|
||||
orig_mmap = mmap_type(ctypes.addressof(orig_mmap_mv))
|
||||
ret = orig_mmap(addr, length, prot, flags, fd, offset)
|
||||
# ll = os.readlink(f"/proc/self/fd/{fd}") if fd >= 0 else ""
|
||||
print(f"mmap {addr=}, {length=}, {prot=}, {flags=}, {fd=}, {offset=} {ret=}")
|
||||
return ret
|
||||
|
||||
#install_hook(libc.ioctl, ioctl)
|
||||
#orig_mmap_mv = install_hook(libc.mmap, _mmap)
|
||||
print("import done")
|
||||
import mmap
|
||||
|
||||
alloc_sizes = {}
|
||||
mmaped = {}
|
||||
|
||||
def handle_ioctl(fd, request, argp, ret):
|
||||
fn = os.readlink(f"/proc/self/fd/{fd}")
|
||||
idir, size, itype, nr = (request>>30), (request>>16)&0x3FFF, (request>>8)&0xFF, request&0xFF
|
||||
|
||||
if fn == "/dev/ion":
|
||||
if nr == 0:
|
||||
st = get_struct(argp, qcom_dsp.struct_ion_allocation_data)
|
||||
print(ret, "ION_IOC_ALLOC", format_struct(st))
|
||||
alloc_sizes[st.handle] = st.len
|
||||
elif nr == 1:
|
||||
st = get_struct(argp, qcom_dsp.struct_ion_handle_data)
|
||||
print(ret, "ION_IOC_FREE", format_struct(st))
|
||||
if st.handle in alloc_sizes: del alloc_sizes[st.handle]
|
||||
if st.handle in mmaped: del mmaped[st.handle]
|
||||
elif nr == 2:
|
||||
st = get_struct(argp, qcom_dsp.struct_ion_fd_data)
|
||||
print(ret, "ION_IOC_MAP", format_struct(st))
|
||||
mmaped[st.handle] = mmap.mmap(st.fd, alloc_sizes[st.handle])
|
||||
elif fn == "/dev/adsprpc-smd":
|
||||
assert chr(itype) == 'R'
|
||||
if nr == 8:
|
||||
st = ctypes.c_uint32.from_address(argp)
|
||||
print(ret, "FASTRPC_IOCTL_GETINFO", st.value)
|
||||
elif nr == 2:
|
||||
st = get_struct(argp, qcom_dsp.struct_fastrpc_ioctl_mmap)
|
||||
print(ret, "FASTRPC_IOCTL_MMAP", format_struct(st))
|
||||
elif nr == 1:
|
||||
# https://research.checkpoint.com/2021/pwn2own-qualcomm-dsp/
|
||||
st = get_struct(argp, qcom_dsp.struct_fastrpc_ioctl_invoke)
|
||||
print(ret, "FASTRPC_IOCTL_INVOKE", format_struct(st))
|
||||
# 0xFF000000 = Method index and attribute (the highest byte)
|
||||
# 0x00FF0000 = Number of input arguments
|
||||
# 0x0000FF00 = Number of output arguments
|
||||
# 0x000000F0 = Number of input handles
|
||||
# 0x0000000F = Number of output handles
|
||||
|
||||
method = (st.sc>>24) & 0xFF
|
||||
in_args = (st.sc>>16) & 0xFF
|
||||
out_args = (st.sc>>8) & 0xFF
|
||||
in_h = (st.sc>>4) & 0xF
|
||||
out_h = (st.sc>>0) & 0xF
|
||||
print(f"\tm:{method} ia:{in_args} oa:{out_args} ih:{in_h} oh:{out_h}")
|
||||
"""
|
||||
if in_args or out_args:
|
||||
for arg in range(in_args+out_args):
|
||||
print(arg, format_struct(st.pra[arg]))
|
||||
if st.pra[arg].buf.pv is not None:
|
||||
ww = to_mv(st.pra[arg].buf.pv, st.pra[arg].buf.len)
|
||||
hexdump(to_mv(st.pra[arg].buf.pv, st.pra[arg].buf.len)[:0x40])
|
||||
"""
|
||||
elif nr == 6:
|
||||
print(ret, "FASTRPC_IOCTL_INIT", format_struct(ini:=get_struct(argp, qcom_dsp.struct_fastrpc_ioctl_init)))
|
||||
print(os.readlink(f"/proc/self/fd/{ini.filefd}"))
|
||||
# print(bytearray(to_mv(ini.file, ini.filelen)))
|
||||
elif nr == 7:
|
||||
print(ret, "FASTRPC_IOCTL_INVOKE_ATTRS", format_struct(ini:=get_struct(argp, qcom_dsp.struct_fastrpc_ioctl_invoke_attrs)))
|
||||
elif nr == 12: print(ret, "FASTRPC_IOCTL_CONTROL", format_struct(get_struct(argp, qcom_dsp.struct_fastrpc_ioctl_control)))
|
||||
elif nr == 4:
|
||||
st_fd = get_struct(argp, qcom_dsp.struct_fastrpc_ioctl_invoke_fd)
|
||||
st = st_fd.inv
|
||||
print(ret, "FASTRPC_IOCTL_INVOKE_FD", format_struct(st))
|
||||
|
||||
method = (st.sc>>24) & 0xFF
|
||||
in_args = (st.sc>>16) & 0xFF
|
||||
out_args = (st.sc>>8) & 0xFF
|
||||
in_h = (st.sc>>4) & 0xF
|
||||
out_h = (st.sc>>0) & 0xF
|
||||
print(f"\tm:{method} ia:{in_args} oa:{out_args} ih:{in_h} oh:{out_h}")
|
||||
|
||||
if st.sc in [0x2030200, 0x3040300]:
|
||||
for handle, mapped in mmaped.items():
|
||||
print(f" buffer {handle} {alloc_sizes[handle]:X}")
|
||||
with open(f"/tmp/buf_{st.sc:X}_{handle}_{alloc_sizes[handle]:X}", "wb") as f: f.write(mapped)
|
||||
else:
|
||||
print(f"{ret} UNPARSED {nr}")
|
||||
else:
|
||||
print("ioctl", f"{idir=} {size=} {itype=} {nr=} {fd=} {ret=}", fn)
|
||||
|
||||
326
tinygrad_repo/extra/dsp/invoke_bug.py
Normal file
326
tinygrad_repo/extra/dsp/invoke_bug.py
Normal file
@@ -0,0 +1,326 @@
|
||||
from tinygrad.runtime.ops_dsp import DSPDevice
|
||||
|
||||
kernel = """__attribute__((noinline)) void r_6_10_13_4_4_29(float* restrict __attribute__((align_value(128))) data0, const float* restrict __attribute__((align_value(128))) data1, const float* restrict __attribute__((align_value(128))) data2, const float* restrict __attribute__((align_value(128))) data3) {
|
||||
float val0 = data1[0];
|
||||
float val1 = data1[1];
|
||||
float val2 = data1[2];
|
||||
float val3 = data1[3];
|
||||
float val4 = data1[4];
|
||||
float val5 = data1[5];
|
||||
float val6 = data1[6];
|
||||
float val7 = data1[7];
|
||||
float val8 = data1[8];
|
||||
float val9 = data1[9];
|
||||
float val10 = data1[10];
|
||||
float val11 = data1[11];
|
||||
float val12 = data1[12];
|
||||
float val13 = data1[13];
|
||||
float val14 = data1[14];
|
||||
float val15 = data1[15];
|
||||
float val16 = data1[16];
|
||||
float val17 = data1[17];
|
||||
float val18 = data1[18];
|
||||
float val19 = data1[19];
|
||||
float val20 = data1[20];
|
||||
float val21 = data1[21];
|
||||
float val22 = data1[22];
|
||||
float val23 = data1[23];
|
||||
float val24 = data1[24];
|
||||
float val25 = data1[25];
|
||||
float val26 = data1[26];
|
||||
float val27 = data1[27];
|
||||
float val28 = data1[28];
|
||||
for (int ridx0 = 0; ridx0 < 6; ridx0++) {
|
||||
for (int ridx1 = 0; ridx1 < 10; ridx1++) {
|
||||
int alu0 = ((ridx0*1160)+(ridx1*4));
|
||||
float val29 = data3[alu0+1];
|
||||
float val30 = data3[alu0+2];
|
||||
float val31 = data3[alu0+3];
|
||||
float val32 = data3[alu0+40];
|
||||
float val33 = data3[alu0+41];
|
||||
float val34 = data3[alu0+42];
|
||||
float val35 = data3[alu0+43];
|
||||
float val36 = data3[alu0+80];
|
||||
float val37 = data3[alu0+81];
|
||||
float val38 = data3[alu0+82];
|
||||
float val39 = data3[alu0+83];
|
||||
float val40 = data3[alu0+120];
|
||||
float val41 = data3[alu0+121];
|
||||
float val42 = data3[alu0+122];
|
||||
float val43 = data3[alu0+123];
|
||||
float val44 = data3[alu0+160];
|
||||
float val45 = data3[alu0+161];
|
||||
float val46 = data3[alu0+162];
|
||||
float val47 = data3[alu0+163];
|
||||
float val48 = data3[alu0+200];
|
||||
float val49 = data3[alu0+201];
|
||||
float val50 = data3[alu0+202];
|
||||
float val51 = data3[alu0+203];
|
||||
float val52 = data3[alu0+240];
|
||||
float val53 = data3[alu0+241];
|
||||
float val54 = data3[alu0+242];
|
||||
float val55 = data3[alu0+243];
|
||||
float val56 = data3[alu0+280];
|
||||
float val57 = data3[alu0+281];
|
||||
float val58 = data3[alu0+282];
|
||||
float val59 = data3[alu0+283];
|
||||
float val60 = data3[alu0+320];
|
||||
float val61 = data3[alu0+321];
|
||||
float val62 = data3[alu0+322];
|
||||
float val63 = data3[alu0+323];
|
||||
float val64 = data3[alu0+360];
|
||||
float val65 = data3[alu0+361];
|
||||
float val66 = data3[alu0+362];
|
||||
float val67 = data3[alu0+363];
|
||||
float val68 = data3[alu0+400];
|
||||
float val69 = data3[alu0+401];
|
||||
float val70 = data3[alu0+402];
|
||||
float val71 = data3[alu0+403];
|
||||
float val72 = data3[alu0+440];
|
||||
float val73 = data3[alu0+441];
|
||||
float val74 = data3[alu0+442];
|
||||
float val75 = data3[alu0+443];
|
||||
float val76 = data3[alu0+480];
|
||||
float val77 = data3[alu0+481];
|
||||
float val78 = data3[alu0+482];
|
||||
float val79 = data3[alu0+483];
|
||||
float val80 = data3[alu0+520];
|
||||
float val81 = data3[alu0+521];
|
||||
float val82 = data3[alu0+522];
|
||||
float val83 = data3[alu0+523];
|
||||
float val84 = data3[alu0+560];
|
||||
float val85 = data3[alu0+561];
|
||||
float val86 = data3[alu0+562];
|
||||
float val87 = data3[alu0+563];
|
||||
float val88 = data3[alu0+600];
|
||||
float val89 = data3[alu0+601];
|
||||
float val90 = data3[alu0+602];
|
||||
float val91 = data3[alu0+603];
|
||||
float val92 = data3[alu0+640];
|
||||
float val93 = data3[alu0+641];
|
||||
float val94 = data3[alu0+642];
|
||||
float val95 = data3[alu0+643];
|
||||
float val96 = data3[alu0+680];
|
||||
float val97 = data3[alu0+681];
|
||||
float val98 = data3[alu0+682];
|
||||
float val99 = data3[alu0+683];
|
||||
float val100 = data3[alu0+720];
|
||||
float val101 = data3[alu0+721];
|
||||
float val102 = data3[alu0+722];
|
||||
float val103 = data3[alu0+723];
|
||||
float val104 = data3[alu0+760];
|
||||
float val105 = data3[alu0+761];
|
||||
float val106 = data3[alu0+762];
|
||||
float val107 = data3[alu0+763];
|
||||
float val108 = data3[alu0+800];
|
||||
float val109 = data3[alu0+801];
|
||||
float val110 = data3[alu0+802];
|
||||
float val111 = data3[alu0+803];
|
||||
float val112 = data3[alu0+840];
|
||||
float val113 = data3[alu0+841];
|
||||
float val114 = data3[alu0+842];
|
||||
float val115 = data3[alu0+843];
|
||||
float val116 = data3[alu0+880];
|
||||
float val117 = data3[alu0+881];
|
||||
float val118 = data3[alu0+882];
|
||||
float val119 = data3[alu0+883];
|
||||
float val120 = data3[alu0+920];
|
||||
float val121 = data3[alu0+921];
|
||||
float val122 = data3[alu0+922];
|
||||
float val123 = data3[alu0+923];
|
||||
float val124 = data3[alu0+960];
|
||||
float val125 = data3[alu0+961];
|
||||
float val126 = data3[alu0+962];
|
||||
float val127 = data3[alu0+963];
|
||||
float val128 = data3[alu0+1000];
|
||||
float val129 = data3[alu0+1001];
|
||||
float val130 = data3[alu0+1002];
|
||||
float val131 = data3[alu0+1003];
|
||||
float val132 = data3[alu0+1040];
|
||||
float val133 = data3[alu0+1041];
|
||||
float val134 = data3[alu0+1042];
|
||||
float val135 = data3[alu0+1043];
|
||||
float val136 = data3[alu0+1080];
|
||||
float val137 = data3[alu0+1081];
|
||||
float val138 = data3[alu0+1082];
|
||||
float val139 = data3[alu0+1083];
|
||||
float val140 = data3[alu0+1120];
|
||||
float val141 = data3[alu0+1121];
|
||||
float val142 = data3[alu0+1122];
|
||||
float val143 = data3[alu0+1123];
|
||||
float val144 = data3[alu0];
|
||||
for (int ridx2 = 0; ridx2 < 13; ridx2++) {
|
||||
int alu1 = (ridx2*4);
|
||||
int alu2 = ((ridx0*2080)+(ridx1*208)+alu1);
|
||||
float val145 = data2[alu1+1];
|
||||
float cast0 = (float)(((val0!=val145)!=1));
|
||||
float cast1 = (float)(((val1!=val145)!=1));
|
||||
float cast2 = (float)(((val2!=val145)!=1));
|
||||
float cast3 = (float)(((val3!=val145)!=1));
|
||||
float cast4 = (float)(((val4!=val145)!=1));
|
||||
float cast5 = (float)(((val5!=val145)!=1));
|
||||
float cast6 = (float)(((val6!=val145)!=1));
|
||||
float cast7 = (float)(((val7!=val145)!=1));
|
||||
float cast8 = (float)(((val8!=val145)!=1));
|
||||
float cast9 = (float)(((val9!=val145)!=1));
|
||||
float cast10 = (float)(((val10!=val145)!=1));
|
||||
float cast11 = (float)(((val11!=val145)!=1));
|
||||
float cast12 = (float)(((val12!=val145)!=1));
|
||||
float cast13 = (float)(((val13!=val145)!=1));
|
||||
float cast14 = (float)(((val14!=val145)!=1));
|
||||
float cast15 = (float)(((val15!=val145)!=1));
|
||||
float cast16 = (float)(((val16!=val145)!=1));
|
||||
float cast17 = (float)(((val17!=val145)!=1));
|
||||
float cast18 = (float)(((val18!=val145)!=1));
|
||||
float cast19 = (float)(((val19!=val145)!=1));
|
||||
float cast20 = (float)(((val20!=val145)!=1));
|
||||
float cast21 = (float)(((val21!=val145)!=1));
|
||||
float cast22 = (float)(((val22!=val145)!=1));
|
||||
float cast23 = (float)(((val23!=val145)!=1));
|
||||
float cast24 = (float)(((val24!=val145)!=1));
|
||||
float cast25 = (float)(((val25!=val145)!=1));
|
||||
float cast26 = (float)(((val26!=val145)!=1));
|
||||
float cast27 = (float)(((val27!=val145)!=1));
|
||||
float cast28 = (float)(((val28!=val145)!=1));
|
||||
data0[alu2+1] = ((cast0*val144)+(cast1*val32)+(cast2*val36)+(cast3*val40)+(cast4*val44)+(cast5*val48)+(cast6*val52)+(cast7*val56)+(cast8*val60)+(cast9*val64)+(cast10*val68)+(cast11*val72)+(cast12*val76)+(cast13*val80)+(cast14*val84)+(cast15*val88)+(cast16*val92)+(cast17*val96)+(cast18*val100)+(cast19*val104)+(cast20*val108)+(cast21*val112)+(cast22*val116)+(cast23*val120)+(cast24*val124)+(cast25*val128)+(cast26*val132)+(cast27*val136)+(cast28*val140));
|
||||
data0[alu2+53] = ((cast0*val29)+(cast1*val33)+(cast2*val37)+(cast3*val41)+(cast4*val45)+(cast5*val49)+(cast6*val53)+(cast7*val57)+(cast8*val61)+(cast9*val65)+(cast10*val69)+(cast11*val73)+(cast12*val77)+(cast13*val81)+(cast14*val85)+(cast15*val89)+(cast16*val93)+(cast17*val97)+(cast18*val101)+(cast19*val105)+(cast20*val109)+(cast21*val113)+(cast22*val117)+(cast23*val121)+(cast24*val125)+(cast25*val129)+(cast26*val133)+(cast27*val137)+(cast28*val141));
|
||||
data0[alu2+105] = ((cast0*val30)+(cast1*val34)+(cast2*val38)+(cast3*val42)+(cast4*val46)+(cast5*val50)+(cast6*val54)+(cast7*val58)+(cast8*val62)+(cast9*val66)+(cast10*val70)+(cast11*val74)+(cast12*val78)+(cast13*val82)+(cast14*val86)+(cast15*val90)+(cast16*val94)+(cast17*val98)+(cast18*val102)+(cast19*val106)+(cast20*val110)+(cast21*val114)+(cast22*val118)+(cast23*val122)+(cast24*val126)+(cast25*val130)+(cast26*val134)+(cast27*val138)+(cast28*val142));
|
||||
data0[alu2+157] = ((cast0*val31)+(cast1*val35)+(cast2*val39)+(cast3*val43)+(cast4*val47)+(cast5*val51)+(cast6*val55)+(cast7*val59)+(cast8*val63)+(cast9*val67)+(cast10*val71)+(cast11*val75)+(cast12*val79)+(cast13*val83)+(cast14*val87)+(cast15*val91)+(cast16*val95)+(cast17*val99)+(cast18*val103)+(cast19*val107)+(cast20*val111)+(cast21*val115)+(cast22*val119)+(cast23*val123)+(cast24*val127)+(cast25*val131)+(cast26*val135)+(cast27*val139)+(cast28*val143));
|
||||
float val146 = data2[alu1+2];
|
||||
float cast29 = (float)(((val0!=val146)!=1));
|
||||
float cast30 = (float)(((val1!=val146)!=1));
|
||||
float cast31 = (float)(((val2!=val146)!=1));
|
||||
float cast32 = (float)(((val3!=val146)!=1));
|
||||
float cast33 = (float)(((val4!=val146)!=1));
|
||||
float cast34 = (float)(((val5!=val146)!=1));
|
||||
float cast35 = (float)(((val6!=val146)!=1));
|
||||
float cast36 = (float)(((val7!=val146)!=1));
|
||||
float cast37 = (float)(((val8!=val146)!=1));
|
||||
float cast38 = (float)(((val9!=val146)!=1));
|
||||
float cast39 = (float)(((val10!=val146)!=1));
|
||||
float cast40 = (float)(((val11!=val146)!=1));
|
||||
float cast41 = (float)(((val12!=val146)!=1));
|
||||
float cast42 = (float)(((val13!=val146)!=1));
|
||||
float cast43 = (float)(((val14!=val146)!=1));
|
||||
float cast44 = (float)(((val15!=val146)!=1));
|
||||
float cast45 = (float)(((val16!=val146)!=1));
|
||||
float cast46 = (float)(((val17!=val146)!=1));
|
||||
float cast47 = (float)(((val18!=val146)!=1));
|
||||
float cast48 = (float)(((val19!=val146)!=1));
|
||||
float cast49 = (float)(((val20!=val146)!=1));
|
||||
float cast50 = (float)(((val21!=val146)!=1));
|
||||
float cast51 = (float)(((val22!=val146)!=1));
|
||||
float cast52 = (float)(((val23!=val146)!=1));
|
||||
float cast53 = (float)(((val24!=val146)!=1));
|
||||
float cast54 = (float)(((val25!=val146)!=1));
|
||||
float cast55 = (float)(((val26!=val146)!=1));
|
||||
float cast56 = (float)(((val27!=val146)!=1));
|
||||
float cast57 = (float)(((val28!=val146)!=1));
|
||||
data0[alu2+2] = ((cast29*val144)+(cast30*val32)+(cast31*val36)+(cast32*val40)+(cast33*val44)+(cast34*val48)+(cast35*val52)+(cast36*val56)+(cast37*val60)+(cast38*val64)+(cast39*val68)+(cast40*val72)+(cast41*val76)+(cast42*val80)+(cast43*val84)+(cast44*val88)+(cast45*val92)+(cast46*val96)+(cast47*val100)+(cast48*val104)+(cast49*val108)+(cast50*val112)+(cast51*val116)+(cast52*val120)+(cast53*val124)+(cast54*val128)+(cast55*val132)+(cast56*val136)+(cast57*val140));
|
||||
data0[alu2+54] = ((cast29*val29)+(cast30*val33)+(cast31*val37)+(cast32*val41)+(cast33*val45)+(cast34*val49)+(cast35*val53)+(cast36*val57)+(cast37*val61)+(cast38*val65)+(cast39*val69)+(cast40*val73)+(cast41*val77)+(cast42*val81)+(cast43*val85)+(cast44*val89)+(cast45*val93)+(cast46*val97)+(cast47*val101)+(cast48*val105)+(cast49*val109)+(cast50*val113)+(cast51*val117)+(cast52*val121)+(cast53*val125)+(cast54*val129)+(cast55*val133)+(cast56*val137)+(cast57*val141));
|
||||
data0[alu2+106] = ((cast29*val30)+(cast30*val34)+(cast31*val38)+(cast32*val42)+(cast33*val46)+(cast34*val50)+(cast35*val54)+(cast36*val58)+(cast37*val62)+(cast38*val66)+(cast39*val70)+(cast40*val74)+(cast41*val78)+(cast42*val82)+(cast43*val86)+(cast44*val90)+(cast45*val94)+(cast46*val98)+(cast47*val102)+(cast48*val106)+(cast49*val110)+(cast50*val114)+(cast51*val118)+(cast52*val122)+(cast53*val126)+(cast54*val130)+(cast55*val134)+(cast56*val138)+(cast57*val142));
|
||||
data0[alu2+158] = ((cast29*val31)+(cast30*val35)+(cast31*val39)+(cast32*val43)+(cast33*val47)+(cast34*val51)+(cast35*val55)+(cast36*val59)+(cast37*val63)+(cast38*val67)+(cast39*val71)+(cast40*val75)+(cast41*val79)+(cast42*val83)+(cast43*val87)+(cast44*val91)+(cast45*val95)+(cast46*val99)+(cast47*val103)+(cast48*val107)+(cast49*val111)+(cast50*val115)+(cast51*val119)+(cast52*val123)+(cast53*val127)+(cast54*val131)+(cast55*val135)+(cast56*val139)+(cast57*val143));
|
||||
float val147 = data2[alu1+3];
|
||||
float cast58 = (float)(((val0!=val147)!=1));
|
||||
float cast59 = (float)(((val1!=val147)!=1));
|
||||
float cast60 = (float)(((val2!=val147)!=1));
|
||||
float cast61 = (float)(((val3!=val147)!=1));
|
||||
float cast62 = (float)(((val4!=val147)!=1));
|
||||
float cast63 = (float)(((val5!=val147)!=1));
|
||||
float cast64 = (float)(((val6!=val147)!=1));
|
||||
float cast65 = (float)(((val7!=val147)!=1));
|
||||
float cast66 = (float)(((val8!=val147)!=1));
|
||||
float cast67 = (float)(((val9!=val147)!=1));
|
||||
float cast68 = (float)(((val10!=val147)!=1));
|
||||
float cast69 = (float)(((val11!=val147)!=1));
|
||||
float cast70 = (float)(((val12!=val147)!=1));
|
||||
float cast71 = (float)(((val13!=val147)!=1));
|
||||
float cast72 = (float)(((val14!=val147)!=1));
|
||||
float cast73 = (float)(((val15!=val147)!=1));
|
||||
float cast74 = (float)(((val16!=val147)!=1));
|
||||
float cast75 = (float)(((val17!=val147)!=1));
|
||||
float cast76 = (float)(((val18!=val147)!=1));
|
||||
float cast77 = (float)(((val19!=val147)!=1));
|
||||
float cast78 = (float)(((val20!=val147)!=1));
|
||||
float cast79 = (float)(((val21!=val147)!=1));
|
||||
float cast80 = (float)(((val22!=val147)!=1));
|
||||
float cast81 = (float)(((val23!=val147)!=1));
|
||||
float cast82 = (float)(((val24!=val147)!=1));
|
||||
float cast83 = (float)(((val25!=val147)!=1));
|
||||
float cast84 = (float)(((val26!=val147)!=1));
|
||||
float cast85 = (float)(((val27!=val147)!=1));
|
||||
float cast86 = (float)(((val28!=val147)!=1));
|
||||
data0[alu2+3] = ((cast58*val144)+(cast59*val32)+(cast60*val36)+(cast61*val40)+(cast62*val44)+(cast63*val48)+(cast64*val52)+(cast65*val56)+(cast66*val60)+(cast67*val64)+(cast68*val68)+(cast69*val72)+(cast70*val76)+(cast71*val80)+(cast72*val84)+(cast73*val88)+(cast74*val92)+(cast75*val96)+(cast76*val100)+(cast77*val104)+(cast78*val108)+(cast79*val112)+(cast80*val116)+(cast81*val120)+(cast82*val124)+(cast83*val128)+(cast84*val132)+(cast85*val136)+(cast86*val140));
|
||||
data0[alu2+55] = ((cast58*val29)+(cast59*val33)+(cast60*val37)+(cast61*val41)+(cast62*val45)+(cast63*val49)+(cast64*val53)+(cast65*val57)+(cast66*val61)+(cast67*val65)+(cast68*val69)+(cast69*val73)+(cast70*val77)+(cast71*val81)+(cast72*val85)+(cast73*val89)+(cast74*val93)+(cast75*val97)+(cast76*val101)+(cast77*val105)+(cast78*val109)+(cast79*val113)+(cast80*val117)+(cast81*val121)+(cast82*val125)+(cast83*val129)+(cast84*val133)+(cast85*val137)+(cast86*val141));
|
||||
data0[alu2+107] = ((cast58*val30)+(cast59*val34)+(cast60*val38)+(cast61*val42)+(cast62*val46)+(cast63*val50)+(cast64*val54)+(cast65*val58)+(cast66*val62)+(cast67*val66)+(cast68*val70)+(cast69*val74)+(cast70*val78)+(cast71*val82)+(cast72*val86)+(cast73*val90)+(cast74*val94)+(cast75*val98)+(cast76*val102)+(cast77*val106)+(cast78*val110)+(cast79*val114)+(cast80*val118)+(cast81*val122)+(cast82*val126)+(cast83*val130)+(cast84*val134)+(cast85*val138)+(cast86*val142));
|
||||
data0[alu2+159] = ((cast58*val31)+(cast59*val35)+(cast60*val39)+(cast61*val43)+(cast62*val47)+(cast63*val51)+(cast64*val55)+(cast65*val59)+(cast66*val63)+(cast67*val67)+(cast68*val71)+(cast69*val75)+(cast70*val79)+(cast71*val83)+(cast72*val87)+(cast73*val91)+(cast74*val95)+(cast75*val99)+(cast76*val103)+(cast77*val107)+(cast78*val111)+(cast79*val115)+(cast80*val119)+(cast81*val123)+(cast82*val127)+(cast83*val131)+(cast84*val135)+(cast85*val139)+(cast86*val143));
|
||||
float val148 = data2[alu1];
|
||||
float cast87 = (float)(((val0!=val148)!=1));
|
||||
float cast88 = (float)(((val1!=val148)!=1));
|
||||
float cast89 = (float)(((val2!=val148)!=1));
|
||||
float cast90 = (float)(((val3!=val148)!=1));
|
||||
float cast91 = (float)(((val4!=val148)!=1));
|
||||
float cast92 = (float)(((val5!=val148)!=1));
|
||||
float cast93 = (float)(((val6!=val148)!=1));
|
||||
float cast94 = (float)(((val7!=val148)!=1));
|
||||
float cast95 = (float)(((val8!=val148)!=1));
|
||||
float cast96 = (float)(((val9!=val148)!=1));
|
||||
float cast97 = (float)(((val10!=val148)!=1));
|
||||
float cast98 = (float)(((val11!=val148)!=1));
|
||||
float cast99 = (float)(((val12!=val148)!=1));
|
||||
float cast100 = (float)(((val13!=val148)!=1));
|
||||
float cast101 = (float)(((val14!=val148)!=1));
|
||||
float cast102 = (float)(((val15!=val148)!=1));
|
||||
float cast103 = (float)(((val16!=val148)!=1));
|
||||
float cast104 = (float)(((val17!=val148)!=1));
|
||||
float cast105 = (float)(((val18!=val148)!=1));
|
||||
float cast106 = (float)(((val19!=val148)!=1));
|
||||
float cast107 = (float)(((val20!=val148)!=1));
|
||||
float cast108 = (float)(((val21!=val148)!=1));
|
||||
float cast109 = (float)(((val22!=val148)!=1));
|
||||
float cast110 = (float)(((val23!=val148)!=1));
|
||||
float cast111 = (float)(((val24!=val148)!=1));
|
||||
float cast112 = (float)(((val25!=val148)!=1));
|
||||
float cast113 = (float)(((val26!=val148)!=1));
|
||||
float cast114 = (float)(((val27!=val148)!=1));
|
||||
float cast115 = (float)(((val28!=val148)!=1));
|
||||
data0[alu2+52] = ((cast87*val29)+(cast88*val33)+(cast89*val37)+(cast90*val41)+(cast91*val45)+(cast92*val49)+(cast93*val53)+(cast94*val57)+(cast95*val61)+(cast96*val65)+(cast97*val69)+(cast98*val73)+(cast99*val77)+(cast100*val81)+(cast101*val85)+(cast102*val89)+(cast103*val93)+(cast104*val97)+(cast105*val101)+(cast106*val105)+(cast107*val109)+(cast108*val113)+(cast109*val117)+(cast110*val121)+(cast111*val125)+(cast112*val129)+(cast113*val133)+(cast114*val137)+(cast115*val141));
|
||||
data0[alu2+104] = ((cast87*val30)+(cast88*val34)+(cast89*val38)+(cast90*val42)+(cast91*val46)+(cast92*val50)+(cast93*val54)+(cast94*val58)+(cast95*val62)+(cast96*val66)+(cast97*val70)+(cast98*val74)+(cast99*val78)+(cast100*val82)+(cast101*val86)+(cast102*val90)+(cast103*val94)+(cast104*val98)+(cast105*val102)+(cast106*val106)+(cast107*val110)+(cast108*val114)+(cast109*val118)+(cast110*val122)+(cast111*val126)+(cast112*val130)+(cast113*val134)+(cast114*val138)+(cast115*val142));
|
||||
data0[alu2+156] = ((cast87*val31)+(cast88*val35)+(cast89*val39)+(cast90*val43)+(cast91*val47)+(cast92*val51)+(cast93*val55)+(cast94*val59)+(cast95*val63)+(cast96*val67)+(cast97*val71)+(cast98*val75)+(cast99*val79)+(cast100*val83)+(cast101*val87)+(cast102*val91)+(cast103*val95)+(cast104*val99)+(cast105*val103)+(cast106*val107)+(cast107*val111)+(cast108*val115)+(cast109*val119)+(cast110*val123)+(cast111*val127)+(cast112*val131)+(cast113*val135)+(cast114*val139)+(cast115*val143));
|
||||
data0[alu2] = ((cast87*val144)+(cast88*val32)+(cast89*val36)+(cast90*val40)+(cast91*val44)+(cast92*val48)+(cast93*val52)+(cast94*val56)+(cast95*val60)+(cast96*val64)+(cast97*val68)+(cast98*val72)+(cast99*val76)+(cast100*val80)+(cast101*val84)+(cast102*val88)+(cast103*val92)+(cast104*val96)+(cast105*val100)+(cast106*val104)+(cast107*val108)+(cast108*val112)+(cast109*val116)+(cast110*val120)+(cast111*val124)+(cast112*val128)+(cast113*val132)+(cast114*val136)+(cast115*val140));
|
||||
}
|
||||
}
|
||||
}
|
||||
}"""
|
||||
|
||||
entry = """typedef union { struct { void *pv; unsigned int len; } buf; struct { int fd; unsigned int offset; } dma; } remote_arg;
|
||||
void* HAP_mmap(void *addr, int len, int prot, int flags, int fd, long offset);
|
||||
int HAP_munmap(void *addr, int len);
|
||||
int HAP_mmap_get(int fd, void **vaddr, void **paddr);
|
||||
int HAP_mmap_put(int fd);
|
||||
unsigned long long HAP_perf_get_time_us(void);
|
||||
int entry(unsigned long long handle, unsigned int sc, remote_arg* pra) {
|
||||
if ((sc>>24) != 2) return 0;
|
||||
|
||||
unsigned long long start = HAP_perf_get_time_us();
|
||||
for (int i = 0; i < 50; i++) {
|
||||
void* buf = HAP_mmap(0, 1, 3, 0, pra[2].dma.fd, 0);
|
||||
HAP_munmap(buf, 1);
|
||||
}
|
||||
*(unsigned long long *)(pra[1].buf.pv) = HAP_perf_get_time_us() - start;
|
||||
|
||||
return 0; }
|
||||
"""
|
||||
|
||||
if __name__ == "__main__":
|
||||
dev = DSPDevice()
|
||||
|
||||
bufs = [dev.allocator.alloc(0x60000) for _ in range(4)]
|
||||
|
||||
only_entry = dev.compiler.compile(entry)
|
||||
app1 = dev.runtime("test", only_entry)
|
||||
x = app1(*bufs)
|
||||
|
||||
entry_n_unsued_code = dev.compiler.compile(kernel + "\n" + entry)
|
||||
app2 = dev.runtime("test", entry_n_unsued_code)
|
||||
x = app2(*bufs)
|
||||
279
tinygrad_repo/extra/dsp/invoke_bug_2.py
Normal file
279
tinygrad_repo/extra/dsp/invoke_bug_2.py
Normal file
@@ -0,0 +1,279 @@
|
||||
from tinygrad.runtime.ops_dsp import DSPDevice
|
||||
|
||||
kernel = """__attribute__((noinline)) void r_64_4_4_64_4_4_4(float* restrict __attribute__((align_value(128))) data0, const float* restrict __attribute__((align_value(128))) data1, const float* restrict __attribute__((align_value(128))) data2, const float* restrict __attribute__((align_value(128))) data3) {
|
||||
for (int ridx0 = 0; ridx0 < 64; ridx0++) {
|
||||
int alu0 = (ridx0*4096);
|
||||
for (int ridx1 = 0; ridx1 < 4; ridx1++) {
|
||||
int alu1 = (ridx1*64);
|
||||
for (int ridx2 = 0; ridx2 < 4; ridx2++) {
|
||||
int alu2 = (ridx2*4);
|
||||
int alu3 = ((ridx0*1024)+alu1+alu2);
|
||||
int alu4 = (alu1+alu2);
|
||||
float val0 = data3[alu4+1];
|
||||
float val1 = data3[alu4+2];
|
||||
float val2 = data3[alu4+3];
|
||||
float val3 = data3[alu4+16];
|
||||
float val4 = data3[alu4+17];
|
||||
float val5 = data3[alu4+18];
|
||||
float val6 = data3[alu4+19];
|
||||
float val7 = data3[alu4+32];
|
||||
float val8 = data3[alu4+33];
|
||||
float val9 = data3[alu4+34];
|
||||
float val10 = data3[alu4+35];
|
||||
float val11 = data3[alu4+48];
|
||||
float val12 = data3[alu4+49];
|
||||
float val13 = data3[alu4+50];
|
||||
float val14 = data3[alu4+51];
|
||||
float val15 = data3[alu4];
|
||||
float acc0 = 0.0f;
|
||||
float acc1 = 0.0f;
|
||||
float acc2 = 0.0f;
|
||||
float acc3 = 0.0f;
|
||||
float acc4 = 0.0f;
|
||||
float acc5 = 0.0f;
|
||||
float acc6 = 0.0f;
|
||||
float acc7 = 0.0f;
|
||||
float acc8 = 0.0f;
|
||||
float acc9 = 0.0f;
|
||||
float acc10 = 0.0f;
|
||||
float acc11 = 0.0f;
|
||||
float acc12 = 0.0f;
|
||||
float acc13 = 0.0f;
|
||||
float acc14 = 0.0f;
|
||||
float acc15 = 0.0f;
|
||||
float acc16 = 0.0f;
|
||||
float acc17 = 0.0f;
|
||||
float acc18 = 0.0f;
|
||||
float acc19 = 0.0f;
|
||||
float acc20 = 0.0f;
|
||||
float acc21 = 0.0f;
|
||||
float acc22 = 0.0f;
|
||||
float acc23 = 0.0f;
|
||||
float acc24 = 0.0f;
|
||||
float acc25 = 0.0f;
|
||||
float acc26 = 0.0f;
|
||||
float acc27 = 0.0f;
|
||||
float acc28 = 0.0f;
|
||||
float acc29 = 0.0f;
|
||||
float acc30 = 0.0f;
|
||||
float acc31 = 0.0f;
|
||||
float acc32 = 0.0f;
|
||||
float acc33 = 0.0f;
|
||||
float acc34 = 0.0f;
|
||||
float acc35 = 0.0f;
|
||||
float acc36 = 0.0f;
|
||||
float acc37 = 0.0f;
|
||||
float acc38 = 0.0f;
|
||||
float acc39 = 0.0f;
|
||||
float acc40 = 0.0f;
|
||||
float acc41 = 0.0f;
|
||||
float acc42 = 0.0f;
|
||||
float acc43 = 0.0f;
|
||||
float acc44 = 0.0f;
|
||||
float acc45 = 0.0f;
|
||||
float acc46 = 0.0f;
|
||||
float acc47 = 0.0f;
|
||||
float acc48 = 0.0f;
|
||||
float acc49 = 0.0f;
|
||||
float acc50 = 0.0f;
|
||||
float acc51 = 0.0f;
|
||||
float acc52 = 0.0f;
|
||||
float acc53 = 0.0f;
|
||||
float acc54 = 0.0f;
|
||||
float acc55 = 0.0f;
|
||||
float acc56 = 0.0f;
|
||||
float acc57 = 0.0f;
|
||||
float acc58 = 0.0f;
|
||||
float acc59 = 0.0f;
|
||||
float acc60 = 0.0f;
|
||||
float acc61 = 0.0f;
|
||||
float acc62 = 0.0f;
|
||||
float acc63 = 0.0f;
|
||||
for (int ridx3 = 0; ridx3 < 64; ridx3++) {
|
||||
int alu5 = (alu0+(ridx2*256)+ridx3);
|
||||
float val16 = data2[alu5+64];
|
||||
float val17 = data2[alu5+128];
|
||||
float val18 = data2[alu5+192];
|
||||
float val19 = data2[alu5+1024];
|
||||
float val20 = data2[alu5+1088];
|
||||
float val21 = data2[alu5+1152];
|
||||
float val22 = data2[alu5+1216];
|
||||
float val23 = data2[alu5+2048];
|
||||
float val24 = data2[alu5+2112];
|
||||
float val25 = data2[alu5+2176];
|
||||
float val26 = data2[alu5+2240];
|
||||
float val27 = data2[alu5+3072];
|
||||
float val28 = data2[alu5+3136];
|
||||
float val29 = data2[alu5+3200];
|
||||
float val30 = data2[alu5+3264];
|
||||
float val31 = data2[alu5];
|
||||
int alu6 = (alu0+(ridx1*256)+ridx3);
|
||||
float val32 = data1[alu6+64];
|
||||
float val33 = data1[alu6+128];
|
||||
float val34 = data1[alu6+192];
|
||||
float val35 = data1[alu6+1024];
|
||||
float val36 = data1[alu6+1088];
|
||||
float val37 = data1[alu6+1152];
|
||||
float val38 = data1[alu6+1216];
|
||||
float val39 = data1[alu6+2048];
|
||||
float val40 = data1[alu6+2112];
|
||||
float val41 = data1[alu6+2176];
|
||||
float val42 = data1[alu6+2240];
|
||||
float val43 = data1[alu6+3072];
|
||||
float val44 = data1[alu6+3136];
|
||||
float val45 = data1[alu6+3200];
|
||||
float val46 = data1[alu6+3264];
|
||||
float val47 = data1[alu6];
|
||||
acc0 = (acc0+(val47*val31));
|
||||
acc1 = (acc1+(val35*val19));
|
||||
acc2 = (acc2+(val39*val23));
|
||||
acc3 = (acc3+(val43*val27));
|
||||
acc4 = (acc4+(val32*val31));
|
||||
acc5 = (acc5+(val36*val19));
|
||||
acc6 = (acc6+(val40*val23));
|
||||
acc7 = (acc7+(val44*val27));
|
||||
acc8 = (acc8+(val33*val31));
|
||||
acc9 = (acc9+(val37*val19));
|
||||
acc10 = (acc10+(val41*val23));
|
||||
acc11 = (acc11+(val45*val27));
|
||||
acc12 = (acc12+(val34*val31));
|
||||
acc13 = (acc13+(val38*val19));
|
||||
acc14 = (acc14+(val42*val23));
|
||||
acc15 = (acc15+(val46*val27));
|
||||
acc16 = (acc16+(val47*val16));
|
||||
acc17 = (acc17+(val35*val20));
|
||||
acc18 = (acc18+(val39*val24));
|
||||
acc19 = (acc19+(val43*val28));
|
||||
acc20 = (acc20+(val32*val16));
|
||||
acc21 = (acc21+(val36*val20));
|
||||
acc22 = (acc22+(val40*val24));
|
||||
acc23 = (acc23+(val44*val28));
|
||||
acc24 = (acc24+(val33*val16));
|
||||
acc25 = (acc25+(val37*val20));
|
||||
acc26 = (acc26+(val41*val24));
|
||||
acc27 = (acc27+(val45*val28));
|
||||
acc28 = (acc28+(val34*val16));
|
||||
acc29 = (acc29+(val38*val20));
|
||||
acc30 = (acc30+(val42*val24));
|
||||
acc31 = (acc31+(val46*val28));
|
||||
acc32 = (acc32+(val47*val17));
|
||||
acc33 = (acc33+(val35*val21));
|
||||
acc34 = (acc34+(val39*val25));
|
||||
acc35 = (acc35+(val43*val29));
|
||||
acc36 = (acc36+(val32*val17));
|
||||
acc37 = (acc37+(val36*val21));
|
||||
acc38 = (acc38+(val40*val25));
|
||||
acc39 = (acc39+(val44*val29));
|
||||
acc40 = (acc40+(val33*val17));
|
||||
acc41 = (acc41+(val37*val21));
|
||||
acc42 = (acc42+(val41*val25));
|
||||
acc43 = (acc43+(val45*val29));
|
||||
acc44 = (acc44+(val34*val17));
|
||||
acc45 = (acc45+(val38*val21));
|
||||
acc46 = (acc46+(val42*val25));
|
||||
acc47 = (acc47+(val46*val29));
|
||||
acc48 = (acc48+(val47*val18));
|
||||
acc49 = (acc49+(val35*val22));
|
||||
acc50 = (acc50+(val39*val26));
|
||||
acc51 = (acc51+(val43*val30));
|
||||
acc52 = (acc52+(val32*val18));
|
||||
acc53 = (acc53+(val36*val22));
|
||||
acc54 = (acc54+(val40*val26));
|
||||
acc55 = (acc55+(val44*val30));
|
||||
acc56 = (acc56+(val33*val18));
|
||||
acc57 = (acc57+(val37*val22));
|
||||
acc58 = (acc58+(val41*val26));
|
||||
acc59 = (acc59+(val45*val30));
|
||||
acc60 = (acc60+(val34*val18));
|
||||
acc61 = (acc61+(val38*val22));
|
||||
acc62 = (acc62+(val42*val26));
|
||||
acc63 = (acc63+(val46*val30));
|
||||
}
|
||||
data0[alu3] = ((acc0*0.125f)+val15);
|
||||
data0[alu3+256] = ((acc1*0.125f)+val15);
|
||||
data0[alu3+512] = ((acc2*0.125f)+val15);
|
||||
data0[alu3+768] = ((acc3*0.125f)+val15);
|
||||
data0[alu3+16] = ((acc4*0.125f)+val3);
|
||||
data0[alu3+272] = ((acc5*0.125f)+val3);
|
||||
data0[alu3+528] = ((acc6*0.125f)+val3);
|
||||
data0[alu3+784] = ((acc7*0.125f)+val3);
|
||||
data0[alu3+32] = ((acc8*0.125f)+val7);
|
||||
data0[alu3+288] = ((acc9*0.125f)+val7);
|
||||
data0[alu3+544] = ((acc10*0.125f)+val7);
|
||||
data0[alu3+800] = ((acc11*0.125f)+val7);
|
||||
data0[alu3+48] = ((acc12*0.125f)+val11);
|
||||
data0[alu3+304] = ((acc13*0.125f)+val11);
|
||||
data0[alu3+560] = ((acc14*0.125f)+val11);
|
||||
data0[alu3+816] = ((acc15*0.125f)+val11);
|
||||
data0[alu3+1] = ((acc16*0.125f)+val0);
|
||||
data0[alu3+257] = ((acc17*0.125f)+val0);
|
||||
data0[alu3+513] = ((acc18*0.125f)+val0);
|
||||
data0[alu3+769] = ((acc19*0.125f)+val0);
|
||||
data0[alu3+17] = ((acc20*0.125f)+val4);
|
||||
data0[alu3+273] = ((acc21*0.125f)+val4);
|
||||
data0[alu3+529] = ((acc22*0.125f)+val4);
|
||||
data0[alu3+785] = ((acc23*0.125f)+val4);
|
||||
data0[alu3+33] = ((acc24*0.125f)+val8);
|
||||
data0[alu3+289] = ((acc25*0.125f)+val8);
|
||||
data0[alu3+545] = ((acc26*0.125f)+val8);
|
||||
data0[alu3+801] = ((acc27*0.125f)+val8);
|
||||
data0[alu3+49] = ((acc28*0.125f)+val12);
|
||||
data0[alu3+305] = ((acc29*0.125f)+val12);
|
||||
data0[alu3+561] = ((acc30*0.125f)+val12);
|
||||
data0[alu3+817] = ((acc31*0.125f)+val12);
|
||||
data0[alu3+2] = ((acc32*0.125f)+val1);
|
||||
data0[alu3+258] = ((acc33*0.125f)+val1);
|
||||
data0[alu3+514] = ((acc34*0.125f)+val1);
|
||||
data0[alu3+770] = ((acc35*0.125f)+val1);
|
||||
data0[alu3+18] = ((acc36*0.125f)+val5);
|
||||
data0[alu3+274] = ((acc37*0.125f)+val5);
|
||||
data0[alu3+530] = ((acc38*0.125f)+val5);
|
||||
data0[alu3+786] = ((acc39*0.125f)+val5);
|
||||
data0[alu3+34] = ((acc40*0.125f)+val9);
|
||||
data0[alu3+290] = ((acc41*0.125f)+val9);
|
||||
data0[alu3+546] = ((acc42*0.125f)+val9);
|
||||
data0[alu3+802] = ((acc43*0.125f)+val9);
|
||||
data0[alu3+50] = ((acc44*0.125f)+val13);
|
||||
data0[alu3+306] = ((acc45*0.125f)+val13);
|
||||
data0[alu3+562] = ((acc46*0.125f)+val13);
|
||||
data0[alu3+818] = ((acc47*0.125f)+val13);
|
||||
data0[alu3+3] = ((acc48*0.125f)+val2);
|
||||
data0[alu3+259] = ((acc49*0.125f)+val2);
|
||||
data0[alu3+515] = ((acc50*0.125f)+val2);
|
||||
data0[alu3+771] = ((acc51*0.125f)+val2);
|
||||
data0[alu3+19] = ((acc52*0.125f)+val6);
|
||||
data0[alu3+275] = ((acc53*0.125f)+val6);
|
||||
data0[alu3+531] = ((acc54*0.125f)+val6);
|
||||
data0[alu3+787] = ((acc55*0.125f)+val6);
|
||||
data0[alu3+35] = ((acc56*0.125f)+val10);
|
||||
data0[alu3+291] = ((acc57*0.125f)+val10);
|
||||
data0[alu3+547] = ((acc58*0.125f)+val10);
|
||||
data0[alu3+803] = ((acc59*0.125f)+val10);
|
||||
data0[alu3+51] = ((acc60*0.125f)+val14);
|
||||
data0[alu3+307] = ((acc61*0.125f)+val14);
|
||||
data0[alu3+563] = ((acc62*0.125f)+val14);
|
||||
data0[alu3+819] = ((acc63*0.125f)+val14);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
"""
|
||||
|
||||
entry = """unsigned long long HAP_perf_get_time_us(void);
|
||||
int entry(unsigned long long handle, unsigned int sc, void* pra) {
|
||||
return HAP_perf_get_time_us() == 1 ? 4 : 0;
|
||||
}
|
||||
"""
|
||||
|
||||
if __name__ == "__main__":
|
||||
dev = DSPDevice()
|
||||
|
||||
bufs = [dev.allocator.alloc(0x60000) for _ in range(4)]
|
||||
|
||||
only_entry = dev.compiler.compile(entry)
|
||||
app1 = dev.runtime("test", only_entry)
|
||||
x = app1(*bufs)
|
||||
|
||||
entry_n_unsued_code = dev.compiler.compile(kernel + "\n" + entry)
|
||||
app2 = dev.runtime("test", entry_n_unsued_code)
|
||||
x = app2(*bufs)
|
||||
27
tinygrad_repo/extra/dsp/opt.py
Normal file
27
tinygrad_repo/extra/dsp/opt.py
Normal file
@@ -0,0 +1,27 @@
|
||||
from tinygrad import Device
|
||||
|
||||
# PATH=/opt/homebrew/opt/llvm/bin:$PATH python3 extra/dsp/opt.py
|
||||
|
||||
if __name__ == "__main__":
|
||||
compiler = Device["DSP"].compiler
|
||||
|
||||
lib = compiler.compile("""
|
||||
typedef long HVX_Vector __attribute__((__vector_size__(128))) __attribute__ ((aligned(128)));
|
||||
typedef long HVX_VectorPair __attribute__((__vector_size__(256))) __attribute__ ((aligned(256)));
|
||||
|
||||
void test(unsigned char *c, unsigned char *a, unsigned char *b) {
|
||||
HVX_Vector t0 = *(HVX_Vector*)a;
|
||||
//HVX_VectorPair t1 = *((HVX_VectorPair*)b);
|
||||
HVX_Vector acc = __builtin_HEXAGON_V6_vd0_128B();
|
||||
for (int i = 0; i < 128; i++) {
|
||||
//__builtin_HEXAGON_V6_lvsplatb_128B(t0[i])
|
||||
//acc += __builtin_HEXAGON_V6_lvsplatb_128B(t0[i]) * t1;
|
||||
//acc += t0[i] * t1;
|
||||
unsigned int t1 = ((unsigned int *)b)[i];
|
||||
//acc = __builtin_HEXAGON_V6_vrmpyub_acc_128B(acc, t0, t1);
|
||||
acc = __builtin_HEXAGON_V6_vrmpybus_acc_128B(acc, t0, t1);
|
||||
}
|
||||
*((HVX_Vector*)c) = acc;
|
||||
}""")
|
||||
|
||||
compiler.disassemble(lib)
|
||||
152
tinygrad_repo/extra/dsp/run.py
Executable file
152
tinygrad_repo/extra/dsp/run.py
Executable file
@@ -0,0 +1,152 @@
|
||||
# mypy: ignore-errors
|
||||
#!/usr/bin/env python3
|
||||
import os, ctypes, ctypes.util, struct, platform, time
|
||||
from tinygrad.runtime.autogen import libc, qcom_dsp
|
||||
def to_mv(ptr, sz) -> memoryview: return memoryview(ctypes.cast(ptr, ctypes.POINTER(ctypes.c_uint8 * sz)).contents).cast("B")
|
||||
from hexdump import hexdump
|
||||
|
||||
def get_struct(argp, stype):
|
||||
return ctypes.cast(ctypes.c_void_p(argp), ctypes.POINTER(stype)).contents
|
||||
|
||||
def format_struct(s):
|
||||
sdats = []
|
||||
for field in s._fields_:
|
||||
dat = getattr(s, field[0])
|
||||
if isinstance(dat, int): sdats.append(f"{field[0]}:0x{dat:X}")
|
||||
elif hasattr(dat, "_fields_"): sdats.append((field[0], format_struct(dat)))
|
||||
elif field[0] == "PADDING_0": pass
|
||||
else: sdats.append(f"{field[0]}:{dat}")
|
||||
return sdats
|
||||
|
||||
@ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_ulong, ctypes.c_void_p)
|
||||
def ioctl(fd, request, argp):
|
||||
fn = os.readlink(f"/proc/self/fd/{fd}")
|
||||
idir, size, itype, nr = (request>>30), (request>>16)&0x3FFF, (request>>8)&0xFF, request&0xFF
|
||||
|
||||
if fn == "/dev/adsprpc-smd":
|
||||
if nr == 1:
|
||||
st = get_struct(argp, qcom_dsp.struct_fastrpc_ioctl_invoke)
|
||||
method = (st.sc>>24) & 0xFF
|
||||
in_args = (st.sc>>16) & 0xFF
|
||||
out_args = (st.sc>>8) & 0xFF
|
||||
if out_args:
|
||||
for arg in range(in_args, in_args+out_args):
|
||||
ctypes.memset(st.pra[arg].buf.pv, 0, st.pra[arg].buf.len)
|
||||
|
||||
# print("enter", libc.gettid())
|
||||
ret = libc.syscall(0x1d, ctypes.c_int(fd), ctypes.c_ulong(request), ctypes.c_void_p(argp))
|
||||
# print("done", libc.gettid())
|
||||
if fn == "/dev/ion":
|
||||
if nr == 0:
|
||||
st = get_struct(argp, qcom_dsp.struct_ion_allocation_data)
|
||||
print(ret, "ION_IOC_ALLOC", format_struct(st))
|
||||
elif nr == 1:
|
||||
st = get_struct(argp, qcom_dsp.struct_ion_handle_data)
|
||||
print(ret, "ION_IOC_FREE", format_struct(st))
|
||||
elif nr == 2:
|
||||
st = get_struct(argp, qcom_dsp.struct_ion_fd_data)
|
||||
print(ret, "ION_IOC_MAP", format_struct(st))
|
||||
elif fn == "/dev/adsprpc-smd":
|
||||
assert chr(itype) == 'R'
|
||||
if nr == 8:
|
||||
st = ctypes.c_uint32.from_address(argp)
|
||||
print(ret, "FASTRPC_IOCTL_GETINFO", st.value)
|
||||
elif nr == 2:
|
||||
st = get_struct(argp, qcom_dsp.struct_fastrpc_ioctl_mmap)
|
||||
print(ret, "FASTRPC_IOCTL_MMAP", format_struct(st))
|
||||
elif nr == 1:
|
||||
# https://research.checkpoint.com/2021/pwn2own-qualcomm-dsp/
|
||||
st = get_struct(argp, qcom_dsp.struct_fastrpc_ioctl_invoke)
|
||||
print(ret, "FASTRPC_IOCTL_INVOKE", format_struct(st))
|
||||
# 0xFF000000 = Method index and attribute (the highest byte)
|
||||
# 0x00FF0000 = Number of input arguments
|
||||
# 0x0000FF00 = Number of output arguments
|
||||
# 0x000000F0 = Number of input handles
|
||||
# 0x0000000F = Number of output handles
|
||||
|
||||
method = (st.sc>>24) & 0xFF
|
||||
in_args = (st.sc>>16) & 0xFF
|
||||
out_args = (st.sc>>8) & 0xFF
|
||||
in_h = (st.sc>>4) & 0xF
|
||||
out_h = (st.sc>>0) & 0xF
|
||||
print(f"\tm:{method} ia:{in_args} oa:{out_args} ih:{in_h} oh:{out_h}")
|
||||
if in_args or out_args:
|
||||
for arg in range(in_args+out_args):
|
||||
print(arg, format_struct(st.pra[arg]))
|
||||
if st.pra[arg].buf.pv is not None:
|
||||
ww = to_mv(st.pra[arg].buf.pv, st.pra[arg].buf.len)
|
||||
hexdump(to_mv(st.pra[arg].buf.pv, st.pra[arg].buf.len)[:0x40])
|
||||
elif nr == 6:
|
||||
print(ret, "FASTRPC_IOCTL_INIT", format_struct(ini:=get_struct(argp, qcom_dsp.struct_fastrpc_ioctl_init)))
|
||||
print(os.readlink(f"/proc/self/fd/{ini.filefd}"))
|
||||
# print(bytearray(to_mv(ini.file, ini.filelen)))
|
||||
elif nr == 7:
|
||||
print(ret, "FASTRPC_IOCTL_INVOKE_ATTRS", format_struct(ini:=get_struct(argp, qcom_dsp.struct_fastrpc_ioctl_invoke_attrs)))
|
||||
elif nr == 12: print(ret, "FASTRPC_IOCTL_CONTROL", format_struct(get_struct(argp, qcom_dsp.struct_fastrpc_ioctl_control)))
|
||||
else:
|
||||
print(f"{ret} UNPARSED {nr}")
|
||||
else:
|
||||
print("ioctl", f"{idir=} {size=} {itype=} {nr=} {fd=} {ret=}", fn)
|
||||
return ret
|
||||
|
||||
def install_hook(c_function, python_function):
|
||||
orig_func = (ctypes.c_char*4096)()
|
||||
python_function_addr = ctypes.cast(ctypes.byref(python_function), ctypes.POINTER(ctypes.c_ulong)).contents.value
|
||||
# AARCH64 trampoline to ioctl
|
||||
# 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)
|
||||
|
||||
# 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
|
||||
ret = libc.mprotect(ctypes.c_ulong((ctypes.addressof(orig_func)//0x1000)*0x1000), 0x3000, 7)
|
||||
assert ret == 0
|
||||
libc.memcpy(orig_func, ioctl_address.contents, 0x1000)
|
||||
libc.memcpy(ioctl_address.contents, ctypes.create_string_buffer(tramp), len(tramp))
|
||||
return orig_func
|
||||
|
||||
libc = ctypes.CDLL(ctypes.util.find_library("libc"))
|
||||
#install_hook(libc.ioctl, ioctl)
|
||||
adsp = ctypes.CDLL(ctypes.util.find_library("adsprpc"))
|
||||
|
||||
def send_rpc_invoke(filename):
|
||||
pass
|
||||
|
||||
if __name__ == "__main__":
|
||||
print("calculator_open")
|
||||
# /dsp/cdsp/fastrpc_shell_3
|
||||
|
||||
handle = ctypes.c_int64(-1)
|
||||
z = adsp.remote_handle64_open(ctypes.create_string_buffer(b"file:///libcalculator_skel.so?calculator_skel_handle_invoke&_modver=1.0&_dom=cdsp"),
|
||||
ctypes.byref(handle))
|
||||
|
||||
print("handle", z, hex(handle.value))
|
||||
assert handle.value != -1
|
||||
test = (ctypes.c_int32 * 100)()
|
||||
for i in range(100): test[i] = i
|
||||
print("calculator_sum")
|
||||
pra = (qcom_dsp.union_remote_arg64 * 3)()
|
||||
#arg_0 = ctypes.c_int32(100)
|
||||
arg_0 = ctypes.c_int32(100)
|
||||
arg_2 = ctypes.c_int64(-1)
|
||||
pra[0].buf.pv = ctypes.addressof(arg_0)
|
||||
pra[0].buf.len = 4
|
||||
pra[1].buf.pv = ctypes.addressof(test)
|
||||
pra[1].buf.len = 0x190
|
||||
pra[2].buf.pv = ctypes.addressof(arg_2)
|
||||
pra[2].buf.len = 8
|
||||
adsp.remote_handle64_invoke(handle, (2<<24) | (2<<16) | (1<<8), pra)
|
||||
print(arg_2.value)
|
||||
print("done")
|
||||
|
||||
print("closing")
|
||||
x = adsp.remote_handle64_close(handle)
|
||||
print(x)
|
||||
print("dun")
|
||||
os._exit(0)
|
||||
312
tinygrad_repo/extra/dsp/run_3.py
Executable file
312
tinygrad_repo/extra/dsp/run_3.py
Executable file
@@ -0,0 +1,312 @@
|
||||
#!/usr/bin/env python3
|
||||
import os, ctypes, ctypes.util, struct, platform, pathlib, contextlib, mmap, array
|
||||
from threading import Thread
|
||||
from tinygrad.runtime.autogen import qcom_dsp
|
||||
from tinygrad.helpers import round_up, mv_address, to_mv
|
||||
from hexdump import hexdump
|
||||
|
||||
def get_struct(argp, stype):
|
||||
return ctypes.cast(ctypes.c_void_p(argp), ctypes.POINTER(stype)).contents
|
||||
|
||||
def format_struct(s):
|
||||
sdats = []
|
||||
for field in s._fields_:
|
||||
dat = getattr(s, field[0])
|
||||
if isinstance(dat, int): sdats.append(f"{field[0]}:0x{dat:X}")
|
||||
elif hasattr(dat, "_fields_"): sdats.append((field[0], format_struct(dat)))
|
||||
elif field[0] == "PADDING_0": pass
|
||||
else: sdats.append(f"{field[0]}:{dat}")
|
||||
return sdats
|
||||
|
||||
@ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_ulong, ctypes.c_void_p)
|
||||
def ioctl(fd, request, argp):
|
||||
fn = os.readlink(f"/proc/self/fd/{fd}")
|
||||
idir, size, itype, nr = (request>>30), (request>>16)&0x3FFF, (request>>8)&0xFF, request&0xFF
|
||||
|
||||
# print("enter", libc.gettid())
|
||||
ret = libc.syscall(0x1d, ctypes.c_int(fd), ctypes.c_ulong(request), ctypes.c_void_p(argp))
|
||||
# print("done", libc.gettid())
|
||||
if fn == "/dev/ion":
|
||||
if nr == 0:
|
||||
st = get_struct(argp, qcom_dsp.struct_ion_allocation_data)
|
||||
print(ret, "ION_IOC_ALLOC", format_struct(st))
|
||||
elif nr == 1:
|
||||
st = get_struct(argp, qcom_dsp.struct_ion_handle_data)
|
||||
print(ret, "ION_IOC_FREE", format_struct(st))
|
||||
elif nr == 2:
|
||||
st = get_struct(argp, qcom_dsp.struct_ion_fd_data)
|
||||
print(ret, "ION_IOC_MAP", format_struct(st))
|
||||
elif fn == "/dev/adsprpc-smd":
|
||||
assert chr(itype) == 'R'
|
||||
if nr == 8:
|
||||
st = ctypes.c_uint32.from_address(argp)
|
||||
print(ret, "FASTRPC_IOCTL_GETINFO", st.value)
|
||||
elif nr == 2:
|
||||
st = get_struct(argp, qcom_dsp.struct_fastrpc_ioctl_mmap)
|
||||
print(ret, "FASTRPC_IOCTL_MMAP", format_struct(st))
|
||||
elif nr == 1:
|
||||
# https://research.checkpoint.com/2021/pwn2own-qualcomm-dsp/
|
||||
st = get_struct(argp, qcom_dsp.struct_fastrpc_ioctl_invoke)
|
||||
print(ret, "FASTRPC_IOCTL_INVOKE", format_struct(st))
|
||||
# 0xFF000000 = Method index and attribute (the highest byte)
|
||||
# 0x00FF0000 = Number of input arguments
|
||||
# 0x0000FF00 = Number of output arguments
|
||||
# 0x000000F0 = Number of input handles
|
||||
# 0x0000000F = Number of output handles
|
||||
|
||||
method = (st.sc>>24) & 0xFF
|
||||
in_args = (st.sc>>16) & 0xFF
|
||||
out_args = (st.sc>>8) & 0xFF
|
||||
in_h = (st.sc>>4) & 0xF
|
||||
out_h = (st.sc>>0) & 0xF
|
||||
print(f"\tm:{method} ia:{in_args} oa:{out_args} ih:{in_h} oh:{out_h}")
|
||||
if in_args or out_args:
|
||||
for arg in range(in_args+out_args):
|
||||
print(arg, format_struct(st.pra[arg]))
|
||||
# print(arg, f"arg (0x{st.pra[arg].buf.pv:X} len=0x{st.pra[arg].buf.len:X})")
|
||||
# print("input" if arg < in_args else "output", f"arg (0x{st.pra[arg].buf.pv:X} len=0x{st.pra[arg].buf.len:X})")
|
||||
if st.pra[arg].buf.pv is not None:
|
||||
# if st.pra[arg].buf.len == 0x258:
|
||||
# print(bytearray(to_mv(st.pra[arg].buf.pv, st.pra[arg].buf.len)))
|
||||
if st.pra[arg].buf.len == 0x68:
|
||||
print(bytearray(to_mv(st.pra[arg].buf.pv, st.pra[arg].buf.len)))
|
||||
|
||||
cut = 0x2000 if st.pra[arg].buf.len == 0x2000 or st.pra[arg].buf.len == 0x258 else 0x100
|
||||
ww = to_mv(st.pra[arg].buf.pv, st.pra[arg].buf.len)
|
||||
hexdump(to_mv(st.pra[arg].buf.pv, st.pra[arg].buf.len)[:cut])
|
||||
|
||||
# if st.pra[arg].buf.len == 0x1000 and ww[0x30] == 0x6e:
|
||||
# z = ww.cast('Q')[1] + 0x7F00000000
|
||||
# print("DOO")
|
||||
# hexdump(to_mv(z, 0x200))
|
||||
#print(format_struct(st.pra)))
|
||||
elif nr == 6:
|
||||
print(ret, "FASTRPC_IOCTL_INIT", format_struct(ini:=get_struct(argp, qcom_dsp.struct_fastrpc_ioctl_init)))
|
||||
print(os.readlink(f"/proc/self/fd/{ini.filefd}"))
|
||||
# print(bytearray(to_mv(ini.file, ini.filelen)))
|
||||
elif nr == 7:
|
||||
print(ret, "FASTRPC_IOCTL_INVOKE_ATTRS", format_struct(ini:=get_struct(argp, qcom_dsp.struct_fastrpc_ioctl_invoke_attrs)))
|
||||
elif nr == 12: print(ret, "FASTRPC_IOCTL_CONTROL", format_struct(get_struct(argp, qcom_dsp.struct_fastrpc_ioctl_control)))
|
||||
else:
|
||||
print(f"{ret} UNPARSED {nr}")
|
||||
else:
|
||||
print("ioctl", f"{idir=} {size=} {itype=} {nr=} {fd=} {ret=}", fn)
|
||||
return ret
|
||||
|
||||
def install_hook(c_function, python_function):
|
||||
orig_func = (ctypes.c_char*4096)()
|
||||
python_function_addr = ctypes.cast(ctypes.byref(python_function), ctypes.POINTER(ctypes.c_ulong)).contents.value
|
||||
# AARCH64 trampoline to ioctl
|
||||
# 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)
|
||||
|
||||
# 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
|
||||
ret = libc.mprotect(ctypes.c_ulong((ctypes.addressof(orig_func)//0x1000)*0x1000), 0x3000, 7)
|
||||
assert ret == 0
|
||||
libc.memcpy(orig_func, ioctl_address.contents, 0x1000)
|
||||
libc.memcpy(ioctl_address.contents, ctypes.create_string_buffer(tramp), len(tramp))
|
||||
return orig_func
|
||||
|
||||
libc = ctypes.CDLL(ctypes.util.find_library("libc"))
|
||||
install_hook(libc.ioctl, ioctl)
|
||||
from tinygrad.runtime.autogen import libc
|
||||
|
||||
# adsp = ctypes.CDLL(ctypes.util.find_library("adsprpc"))
|
||||
# print(adsp)
|
||||
|
||||
def rpc_invoke(rpcfd, handle, method, ins=None, outs=None):
|
||||
if ins or outs:
|
||||
ins = ins or list()
|
||||
outs = outs or list()
|
||||
pra = (qcom_dsp.union_remote_arg * (len(ins) + len(outs)))()
|
||||
for i,mv in enumerate(ins + outs):
|
||||
if isinstance(mv, memoryview):
|
||||
pra[i].buf.pv = mv_address(mv) if mv.nbytes > 0 else 0
|
||||
pra[i].buf.len = mv.nbytes
|
||||
else: assert False, "not supported"
|
||||
# pra = (qcom_dsp.union_remote_arg * (len(ins) + len(outs))).from_address(ctypes.addressof(pra))
|
||||
else:
|
||||
pra = None
|
||||
ins = ins or list()
|
||||
outs = outs or list()
|
||||
|
||||
sc = (method << 24) | (len(ins) << 16) | (len(outs) << 8)
|
||||
return qcom_dsp.FASTRPC_IOCTL_INVOKE(rpcfd, handle=handle, sc=sc, pra=pra)
|
||||
|
||||
def listner_worker():
|
||||
context = 0
|
||||
handle = 0xffffffff
|
||||
msg_send = memoryview(bytearray(0x10)).cast('I')
|
||||
msg_recv = memoryview(bytearray(0x10)).cast('I')
|
||||
out_buf = memoryview(bytearray(0x1000)).cast('I')
|
||||
in_buf = memoryview(bytearray(0x1000)).cast('I')
|
||||
|
||||
prev_res = 0xffffffff
|
||||
out_buf_size = 0
|
||||
|
||||
req_args = (qcom_dsp.union_remote_arg * 4)()
|
||||
req_args[0].buf = qcom_dsp.struct_remote_buf(pv=mv_address(msg_send), len=0x10)
|
||||
req_args[1].buf = qcom_dsp.struct_remote_buf(pv=mv_address(out_buf), len=0x1000)
|
||||
req_args[2].buf = qcom_dsp.struct_remote_buf(pv=mv_address(msg_recv), len=0x10)
|
||||
req_args[3].buf = qcom_dsp.struct_remote_buf(pv=mv_address(in_buf), len=0x1000)
|
||||
|
||||
while True:
|
||||
msg_send[0] = context
|
||||
msg_send[1] = prev_res
|
||||
msg_send[2] = out_buf_size
|
||||
msg_send[3] = 0x1000
|
||||
|
||||
req_args[1].buf.len = out_buf_size
|
||||
qcom_dsp.FASTRPC_IOCTL_INVOKE(rpcfd, handle=0x3, sc=0x04020200, pra=req_args) # listener
|
||||
|
||||
context = msg_recv[0]
|
||||
handle = msg_recv[1]
|
||||
sc = msg_recv[2]
|
||||
inbufs = (sc >> 16) & 0xff
|
||||
outbufs = (sc >> 8) & 0xff
|
||||
|
||||
in_args, out_args = [], []
|
||||
ptr = mv_address(in_buf)
|
||||
for i in range(inbufs):
|
||||
sz = to_mv(ptr, 4).cast('I')[0]
|
||||
obj_ptr = round_up(ptr + 4, 8)
|
||||
in_args.append(to_mv(obj_ptr, sz))
|
||||
ptr = obj_ptr + sz
|
||||
|
||||
ctypes.memset(mv_address(out_buf), 0, 0x1000)
|
||||
ptr_out = mv_address(out_buf)
|
||||
for i in range(outbufs):
|
||||
sz = to_mv(ptr, 4).cast('I')[0]
|
||||
ptr += 4
|
||||
|
||||
to_mv(ptr_out, 4).cast('I')[0] = sz
|
||||
obj_ptr = round_up(ptr_out + 4, 8)
|
||||
|
||||
out_args.append(to_mv(obj_ptr, sz))
|
||||
ptr_out = obj_ptr + sz
|
||||
|
||||
out_buf_size = ptr_out - mv_address(out_buf)
|
||||
|
||||
if sc == 0x20200: # greating?
|
||||
prev_res = 0
|
||||
elif sc == 0x13050100: # open
|
||||
# for a in in_args: hexdump(a)
|
||||
try:
|
||||
fd = os.open(in_args[3].tobytes()[:-1].decode(), os.O_RDONLY)
|
||||
out_args[0].cast('I')[0] = fd
|
||||
prev_res = 0
|
||||
except: prev_res = 2
|
||||
elif sc == 0x9010000: # seek
|
||||
res = os.lseek(in_args[0].cast('I')[0], in_args[0].cast('I')[1], in_args[0].cast('I')[2])
|
||||
prev_res = 0 if res >= 0 else res
|
||||
elif sc == 0x4010200: # read
|
||||
buf = os.read(in_args[0].cast('I')[0], in_args[0].cast('I')[1])
|
||||
out_args[1][:len(buf)] = buf
|
||||
out_args[0].cast('I')[0] = len(buf)
|
||||
out_args[0].cast('I')[1] = int(len(buf) == 0)
|
||||
prev_res = 0
|
||||
elif sc == 0x3010000: # close
|
||||
os.close(in_args[0].cast('I')[0])
|
||||
prev_res = 0
|
||||
elif sc == 0x1f020100: # stat
|
||||
# try:
|
||||
stat = os.stat(in_args[1].tobytes()[:-1].decode())
|
||||
out_stat = out_args[0].cast('Q')
|
||||
out_stat[1] = stat.st_dev
|
||||
out_stat[2] = stat.st_ino
|
||||
out_stat[3] = stat.st_mode | (stat.st_nlink << 32)
|
||||
out_stat[4] = stat.st_rdev
|
||||
out_stat[5] = stat.st_size
|
||||
# print(stat, stat.st_rdev)
|
||||
# assert False
|
||||
prev_res = 0
|
||||
# except: prev_res = 2
|
||||
elif sc == 0x2010100:
|
||||
heapid = in_args[0].cast('I')[0]
|
||||
lflags = in_args[0].cast('I')[1]
|
||||
rflags = in_args[0].cast('I')[2]
|
||||
assert rflags == 0x1000
|
||||
|
||||
# print(in_args[0])
|
||||
|
||||
# print("WOOW", in_args[0].cast('Q')[2])
|
||||
# print("WOOW2", in_args[0].cast('Q')[2])
|
||||
# print("WOOW3", in_args[0].cast('Q')[3])
|
||||
# print("WOOW3", in_args[0].cast('Q')[3])
|
||||
|
||||
vin = in_args[0].cast('Q')[2]
|
||||
sz = in_args[0].cast('Q')[3]
|
||||
# vin = to_mv(in_args[0].cast('Q')[2], 8).cast('Q')[0]
|
||||
# sz = to_mv(in_args[0].cast('Q')[3], 8).cast('Q')[0]
|
||||
|
||||
st = qcom_dsp.FASTRPC_IOCTL_MMAP(rpcfd, fd=-1, flags=rflags, vaddrin=0, size=sz)
|
||||
out_args[0].cast('Q')[0] = 0
|
||||
out_args[0].cast('Q')[1] = st.vaddrout
|
||||
prev_res = 0
|
||||
else: raise RuntimeError(f"Unknown {sc=:X}")
|
||||
|
||||
if __name__ == "__main__":
|
||||
ionfd = os.open('/dev/ion', os.O_RDONLY)
|
||||
rpcfd = os.open('/dev/adsprpc-smd', os.O_RDONLY | os.O_NONBLOCK)
|
||||
|
||||
with contextlib.suppress(RuntimeError, OSError): qcom_dsp.ION_IOC_FREE(ionfd, handle=0)
|
||||
info = qcom_dsp.FASTRPC_IOCTL_GETINFO(rpcfd, 3)
|
||||
# x = qcom_dsp.FASTRPC_IOCTL_SETMODE(rpcfd, 0, __force_as_val=True)
|
||||
|
||||
# init shell?
|
||||
fastrpc_shell = memoryview(bytearray(pathlib.Path('/vendor/dsp/cdsp/fastrpc_shell_3').read_bytes()))
|
||||
shell_mem = qcom_dsp.ION_IOC_ALLOC(ionfd, len=round_up(fastrpc_shell.nbytes, 0x1000), align=0x1000, heap_id_mask=0x2000000, flags=0x1)
|
||||
shell_mapped = qcom_dsp.ION_IOC_MAP(ionfd, handle=shell_mem.handle)
|
||||
fastrpc_shell_addr = libc.mmap(0, shell_mem.len, mmap.PROT_READ|mmap.PROT_WRITE, mmap.MAP_SHARED, shell_mapped.fd, 0)
|
||||
|
||||
ctypes.memmove(fastrpc_shell_addr, mv_address(fastrpc_shell), fastrpc_shell.nbytes)
|
||||
# ctypes.memset(fastrpc_shell_addr, 0x0, 0xd6000)
|
||||
# print(hex(fastrpc_shell_addr))
|
||||
|
||||
ctrls = qcom_dsp.FASTRPC_IOCTL_CONTROL(rpcfd, req=0x3)
|
||||
|
||||
init = qcom_dsp.FASTRPC_IOCTL_INIT(rpcfd, flags=0x1, file=fastrpc_shell_addr, filelen=fastrpc_shell.nbytes, filefd=shell_mapped.fd)
|
||||
print("init shell done", shell_mapped.fd)
|
||||
|
||||
# TODO: unmap here
|
||||
# qcom_dsp.ION_IOC_FREE(ionfd, handle=shell_mem.handle)
|
||||
|
||||
rpc_invoke(rpcfd, handle=3, method=3)
|
||||
|
||||
thread = Thread(target=listner_worker)
|
||||
thread.start()
|
||||
|
||||
a1 = memoryview(bytearray(b'\x52\x00\x00\x00\xFF\x00\x00\x00'))
|
||||
a2 = memoryview(bytearray(b"file:///libcalculator_skel.so?calculator_skel_handle_invoke&_modver=1.0&_dom=cdsp\0"))
|
||||
o1 = memoryview(bytearray(0x8))
|
||||
o2 = memoryview(bytearray(0xff))
|
||||
z = rpc_invoke(rpcfd, handle=0, method=0, ins=[a1, a2], outs=[o1, o2])
|
||||
prg_handle = o1.cast('I')[0]
|
||||
|
||||
# test
|
||||
test = (ctypes.c_int32 * 100)()
|
||||
for i in range(100): test[i] = i
|
||||
print("calculator_sum")
|
||||
pra = (qcom_dsp.union_remote_arg * 3)()
|
||||
#arg_0 = ctypes.c_int32(100)
|
||||
arg_0 = ctypes.c_int32(100)
|
||||
arg_2 = ctypes.c_int64(-1)
|
||||
pra[0].buf.pv = ctypes.addressof(arg_0)
|
||||
pra[0].buf.len = 4
|
||||
pra[1].buf.pv = ctypes.addressof(test)
|
||||
pra[1].buf.len = 0x190
|
||||
pra[2].buf.pv = ctypes.addressof(arg_2)
|
||||
pra[2].buf.len = 8
|
||||
qcom_dsp.FASTRPC_IOCTL_INVOKE(rpcfd, handle=prg_handle, sc=(2<<24) | (2<<16) | (1<<8), pra=pra)
|
||||
|
||||
print(arg_2.value)
|
||||
print("done")
|
||||
os._exit(0)
|
||||
11
tinygrad_repo/extra/dsp/snpe.sh
Executable file
11
tinygrad_repo/extra/dsp/snpe.sh
Executable file
@@ -0,0 +1,11 @@
|
||||
#!/bin/bash -e
|
||||
echo "building"
|
||||
gcc -shared -fPIC -o preload_python.so preload.c -L/usr/local/pyenv/versions/3.11.4/lib -lpython3.11 -I/usr/local/pyenv/versions/3.11.4/include/python3.11
|
||||
echo "compiled"
|
||||
export LD_LIBRARY_PATH="/usr/local/pyenv/versions/3.11.4/lib;/data/snpe"
|
||||
export LD_PRELOAD="$PWD/preload_python.so"
|
||||
export PYTHONPATH="/data/tinygrad"
|
||||
cd /data/snpe
|
||||
#ADSP_LIBRARY_PATH="." strace -f -e ioctl ./snpe-net-run --container MobileNetV2.dlc --input_list hello --use_dsp
|
||||
ADSP_LIBRARY_PATH="." ./snpe-net-run --container MobileNetV2.dlc --input_list hello --use_dsp
|
||||
|
||||
715
tinygrad_repo/extra/dsp/snpe_logs/dlc_info_2
Normal file
715
tinygrad_repo/extra/dsp/snpe_logs/dlc_info_2
Normal file
@@ -0,0 +1,715 @@
|
||||
DLC info for: /home/batman/xx/ml_tools/snpe/snpe-1.61.0.3358/mobilenetv2-7.dlc
|
||||
Model Version: N/A
|
||||
Model Copyright:N/A
|
||||
-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
| Id | Name | Type | Inputs | Outputs | Out Dims | Runtimes | Parameters |
|
||||
-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
| 0 | input | data | input | input | 1x224x224x3 | A D G C | input_preprocessing: passthrough |
|
||||
| | | | | | | | input_type: image |
|
||||
| 1 | Conv_0 | convolutional | input | 474 | 1x112x112x32 | A D G C | padding x: 1 |
|
||||
| | | | | | | | padding y: 1 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 2 |
|
||||
| | | | | | | | stride y: 2 |
|
||||
| | | | | | | | num filters: 32 |
|
||||
| | | | | | | | kernel: 3x3 |
|
||||
| | | | | | | | param count: 896 (0.0257%) |
|
||||
| | | | | | | | MACs per inference: 10M (3.6%) |
|
||||
| 2 | Clip_1 | neuron | 474 | 317 | 1x112x112x32 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 3 | Conv_2 | convolutional | 317 | 477 | 1x112x112x32 | A D G C | padding x: 1 |
|
||||
| | | | | | | | padding y: 1 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 32 |
|
||||
| | | | | | | | kernel: 3x3 |
|
||||
| | | | | | | | groups: 32 |
|
||||
| | | | | | | | param count: 320 (0.00917%) |
|
||||
| | | | | | | | MACs per inference: 3M (1.2%) |
|
||||
| 4 | Clip_3 | neuron | 477 | 320 | 1x112x112x32 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 5 | Conv_4 | convolutional | 320 | 480 | 1x112x112x16 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 16 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 528 (0.0151%) |
|
||||
| | | | | | | | MACs per inference: 6M (2.13%) |
|
||||
| 6 | Conv_5 | convolutional | 480 | 483 | 1x112x112x96 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 96 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 1k (0.0468%) |
|
||||
| | | | | | | | MACs per inference: 19M (6.4%) |
|
||||
| 7 | Clip_6 | neuron | 483 | 325 | 1x112x112x96 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 8 | Conv_7 | convolutional | 325 | 486 | 1x56x56x96 | A D G C | padding x: 1 |
|
||||
| | | | | | | | padding y: 1 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 2 |
|
||||
| | | | | | | | stride y: 2 |
|
||||
| | | | | | | | num filters: 96 |
|
||||
| | | | | | | | kernel: 3x3 |
|
||||
| | | | | | | | groups: 96 |
|
||||
| | | | | | | | param count: 960 (0.0275%) |
|
||||
| | | | | | | | MACs per inference: 2M (0.9%) |
|
||||
| 9 | Clip_8 | neuron | 486 | 328 | 1x56x56x96 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 10 | Conv_9 | convolutional | 328 | 489 | 1x56x56x24 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 24 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 2k (0.0667%) |
|
||||
| | | | | | | | MACs per inference: 7M (2.4%) |
|
||||
| 11 | Conv_10 | convolutional | 489 | 492 | 1x56x56x144 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 144 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 3k (0.103%) |
|
||||
| | | | | | | | MACs per inference: 10M (3.6%) |
|
||||
| 12 | Clip_11 | neuron | 492 | 333 | 1x56x56x144 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 13 | Conv_12 | convolutional | 333 | 495 | 1x56x56x144 | A D G C | padding x: 1 |
|
||||
| | | | | | | | padding y: 1 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 144 |
|
||||
| | | | | | | | kernel: 3x3 |
|
||||
| | | | | | | | groups: 144 |
|
||||
| | | | | | | | param count: 1k (0.0413%) |
|
||||
| | | | | | | | MACs per inference: 4M (1.35%) |
|
||||
| 14 | Clip_13 | neuron | 495 | 336 | 1x56x56x144 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 15 | Conv_14 | convolutional | 336 | 498 | 1x56x56x24 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 24 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 3k (0.0998%) |
|
||||
| | | | | | | | MACs per inference: 10M (3.6%) |
|
||||
| 16 | Add_15 | elementwise_binary_op | 489 | 339 | 1x56x56x24 | A D G C | operation: sum |
|
||||
| | | | 498 | | | | MACs per inference: 75k (0.025%) |
|
||||
| 17 | Conv_16 | convolutional | 339 | 501 | 1x56x56x144 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 144 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 3k (0.103%) |
|
||||
| | | | | | | | MACs per inference: 10M (3.6%) |
|
||||
| 18 | Clip_17 | neuron | 501 | 342 | 1x56x56x144 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 19 | Conv_18 | convolutional | 342 | 504 | 1x28x28x144 | A D G C | padding x: 1 |
|
||||
| | | | | | | | padding y: 1 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 2 |
|
||||
| | | | | | | | stride y: 2 |
|
||||
| | | | | | | | num filters: 144 |
|
||||
| | | | | | | | kernel: 3x3 |
|
||||
| | | | | | | | groups: 144 |
|
||||
| | | | | | | | param count: 1k (0.0413%) |
|
||||
| | | | | | | | MACs per inference: 1M (0.338%) |
|
||||
| 20 | Clip_19 | neuron | 504 | 345 | 1x28x28x144 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 21 | Conv_20 | convolutional | 345 | 507 | 1x28x28x32 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 32 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 4k (0.133%) |
|
||||
| | | | | | | | MACs per inference: 3M (1.2%) |
|
||||
| 22 | Conv_21 | convolutional | 507 | 510 | 1x28x28x192 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 192 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 6k (0.182%) |
|
||||
| | | | | | | | MACs per inference: 4M (1.6%) |
|
||||
| 23 | Clip_22 | neuron | 510 | 350 | 1x28x28x192 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 24 | Conv_23 | convolutional | 350 | 513 | 1x28x28x192 | A D G C | padding x: 1 |
|
||||
| | | | | | | | padding y: 1 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 192 |
|
||||
| | | | | | | | kernel: 3x3 |
|
||||
| | | | | | | | groups: 192 |
|
||||
| | | | | | | | param count: 1k (0.055%) |
|
||||
| | | | | | | | MACs per inference: 1M (0.45%) |
|
||||
| 25 | Clip_24 | neuron | 513 | 353 | 1x28x28x192 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 26 | Conv_25 | convolutional | 353 | 516 | 1x28x28x32 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 32 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 6k (0.177%) |
|
||||
| | | | | | | | MACs per inference: 4M (1.6%) |
|
||||
| 27 | Add_26 | elementwise_binary_op | 507 | 356 | 1x28x28x32 | A D G C | operation: sum |
|
||||
| | | | 516 | | | | MACs per inference: 25k (0.00833%) |
|
||||
| 28 | Conv_27 | convolutional | 356 | 519 | 1x28x28x192 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 192 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 6k (0.182%) |
|
||||
| | | | | | | | MACs per inference: 4M (1.6%) |
|
||||
| 29 | Clip_28 | neuron | 519 | 359 | 1x28x28x192 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 30 | Conv_29 | convolutional | 359 | 522 | 1x28x28x192 | A D G C | padding x: 1 |
|
||||
| | | | | | | | padding y: 1 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 192 |
|
||||
| | | | | | | | kernel: 3x3 |
|
||||
| | | | | | | | groups: 192 |
|
||||
| | | | | | | | param count: 1k (0.055%) |
|
||||
| | | | | | | | MACs per inference: 1M (0.45%) |
|
||||
| 31 | Clip_30 | neuron | 522 | 362 | 1x28x28x192 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 32 | Conv_31 | convolutional | 362 | 525 | 1x28x28x32 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 32 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 6k (0.177%) |
|
||||
| | | | | | | | MACs per inference: 4M (1.6%) |
|
||||
| 33 | Add_32 | elementwise_binary_op | 356 | 365 | 1x28x28x32 | A D G C | operation: sum |
|
||||
| | | | 525 | | | | MACs per inference: 25k (0.00833%) |
|
||||
| 34 | Conv_33 | convolutional | 365 | 528 | 1x28x28x192 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 192 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 6k (0.182%) |
|
||||
| | | | | | | | MACs per inference: 4M (1.6%) |
|
||||
| 35 | Clip_34 | neuron | 528 | 368 | 1x28x28x192 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 36 | Conv_35 | convolutional | 368 | 531 | 1x14x14x192 | A D G C | padding x: 1 |
|
||||
| | | | | | | | padding y: 1 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 2 |
|
||||
| | | | | | | | stride y: 2 |
|
||||
| | | | | | | | num filters: 192 |
|
||||
| | | | | | | | kernel: 3x3 |
|
||||
| | | | | | | | groups: 192 |
|
||||
| | | | | | | | param count: 1k (0.055%) |
|
||||
| | | | | | | | MACs per inference: 338k (0.113%) |
|
||||
| 37 | Clip_36 | neuron | 531 | 371 | 1x14x14x192 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 38 | Conv_37 | convolutional | 371 | 534 | 1x14x14x64 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 64 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 12k (0.354%) |
|
||||
| | | | | | | | MACs per inference: 2M (0.8%) |
|
||||
| 39 | Conv_38 | convolutional | 534 | 537 | 1x14x14x384 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 384 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 24k (0.716%) |
|
||||
| | | | | | | | MACs per inference: 4M (1.6%) |
|
||||
| 40 | Clip_39 | neuron | 537 | 376 | 1x14x14x384 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 41 | Conv_40 | convolutional | 376 | 540 | 1x14x14x384 | A D G C | padding x: 1 |
|
||||
| | | | | | | | padding y: 1 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 384 |
|
||||
| | | | | | | | kernel: 3x3 |
|
||||
| | | | | | | | groups: 384 |
|
||||
| | | | | | | | param count: 3k (0.11%) |
|
||||
| | | | | | | | MACs per inference: 677k (0.225%) |
|
||||
| 42 | Clip_41 | neuron | 540 | 379 | 1x14x14x384 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 43 | Conv_42 | convolutional | 379 | 543 | 1x14x14x64 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 64 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 24k (0.706%) |
|
||||
| | | | | | | | MACs per inference: 4M (1.6%) |
|
||||
| 44 | Add_43 | elementwise_binary_op | 534 | 382 | 1x14x14x64 | A D G C | operation: sum |
|
||||
| | | | 543 | | | | MACs per inference: 12k (0.00417%) |
|
||||
| 45 | Conv_44 | convolutional | 382 | 546 | 1x14x14x384 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 384 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 24k (0.716%) |
|
||||
| | | | | | | | MACs per inference: 4M (1.6%) |
|
||||
| 46 | Clip_45 | neuron | 546 | 385 | 1x14x14x384 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 47 | Conv_46 | convolutional | 385 | 549 | 1x14x14x384 | A D G C | padding x: 1 |
|
||||
| | | | | | | | padding y: 1 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 384 |
|
||||
| | | | | | | | kernel: 3x3 |
|
||||
| | | | | | | | groups: 384 |
|
||||
| | | | | | | | param count: 3k (0.11%) |
|
||||
| | | | | | | | MACs per inference: 677k (0.225%) |
|
||||
| 48 | Clip_47 | neuron | 549 | 388 | 1x14x14x384 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 49 | Conv_48 | convolutional | 388 | 552 | 1x14x14x64 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 64 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 24k (0.706%) |
|
||||
| | | | | | | | MACs per inference: 4M (1.6%) |
|
||||
| 50 | Add_49 | elementwise_binary_op | 382 | 391 | 1x14x14x64 | A D G C | operation: sum |
|
||||
| | | | 552 | | | | MACs per inference: 12k (0.00417%) |
|
||||
| 51 | Conv_50 | convolutional | 391 | 555 | 1x14x14x384 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 384 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 24k (0.716%) |
|
||||
| | | | | | | | MACs per inference: 4M (1.6%) |
|
||||
| 52 | Clip_51 | neuron | 555 | 394 | 1x14x14x384 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 53 | Conv_52 | convolutional | 394 | 558 | 1x14x14x384 | A D G C | padding x: 1 |
|
||||
| | | | | | | | padding y: 1 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 384 |
|
||||
| | | | | | | | kernel: 3x3 |
|
||||
| | | | | | | | groups: 384 |
|
||||
| | | | | | | | param count: 3k (0.11%) |
|
||||
| | | | | | | | MACs per inference: 677k (0.225%) |
|
||||
| 54 | Clip_53 | neuron | 558 | 397 | 1x14x14x384 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 55 | Conv_54 | convolutional | 397 | 561 | 1x14x14x64 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 64 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 24k (0.706%) |
|
||||
| | | | | | | | MACs per inference: 4M (1.6%) |
|
||||
| 56 | Add_55 | elementwise_binary_op | 391 | 400 | 1x14x14x64 | A D G C | operation: sum |
|
||||
| | | | 561 | | | | MACs per inference: 12k (0.00417%) |
|
||||
| 57 | Conv_56 | convolutional | 400 | 564 | 1x14x14x384 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 384 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 24k (0.716%) |
|
||||
| | | | | | | | MACs per inference: 4M (1.6%) |
|
||||
| 58 | Clip_57 | neuron | 564 | 403 | 1x14x14x384 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 59 | Conv_58 | convolutional | 403 | 567 | 1x14x14x384 | A D G C | padding x: 1 |
|
||||
| | | | | | | | padding y: 1 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 384 |
|
||||
| | | | | | | | kernel: 3x3 |
|
||||
| | | | | | | | groups: 384 |
|
||||
| | | | | | | | param count: 3k (0.11%) |
|
||||
| | | | | | | | MACs per inference: 677k (0.225%) |
|
||||
| 60 | Clip_59 | neuron | 567 | 406 | 1x14x14x384 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 61 | Conv_60 | convolutional | 406 | 570 | 1x14x14x96 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 96 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 36k (1.06%) |
|
||||
| | | | | | | | MACs per inference: 7M (2.4%) |
|
||||
| 62 | Conv_61 | convolutional | 570 | 573 | 1x14x14x576 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 576 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 55k (1.6%) |
|
||||
| | | | | | | | MACs per inference: 10M (3.6%) |
|
||||
| 63 | Clip_62 | neuron | 573 | 411 | 1x14x14x576 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 64 | Conv_63 | convolutional | 411 | 576 | 1x14x14x576 | A D G C | padding x: 1 |
|
||||
| | | | | | | | padding y: 1 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 576 |
|
||||
| | | | | | | | kernel: 3x3 |
|
||||
| | | | | | | | groups: 576 |
|
||||
| | | | | | | | param count: 5k (0.165%) |
|
||||
| | | | | | | | MACs per inference: 1M (0.338%) |
|
||||
| 65 | Clip_64 | neuron | 576 | 414 | 1x14x14x576 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 66 | Conv_65 | convolutional | 414 | 579 | 1x14x14x96 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 96 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 55k (1.59%) |
|
||||
| | | | | | | | MACs per inference: 10M (3.6%) |
|
||||
| 67 | Add_66 | elementwise_binary_op | 570 | 417 | 1x14x14x96 | A D G C | operation: sum |
|
||||
| | | | 579 | | | | MACs per inference: 18k (0.00625%) |
|
||||
| 68 | Conv_67 | convolutional | 417 | 582 | 1x14x14x576 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 576 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 55k (1.6%) |
|
||||
| | | | | | | | MACs per inference: 10M (3.6%) |
|
||||
| 69 | Clip_68 | neuron | 582 | 420 | 1x14x14x576 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 70 | Conv_69 | convolutional | 420 | 585 | 1x14x14x576 | A D G C | padding x: 1 |
|
||||
| | | | | | | | padding y: 1 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 576 |
|
||||
| | | | | | | | kernel: 3x3 |
|
||||
| | | | | | | | groups: 576 |
|
||||
| | | | | | | | param count: 5k (0.165%) |
|
||||
| | | | | | | | MACs per inference: 1M (0.338%) |
|
||||
| 71 | Clip_70 | neuron | 585 | 423 | 1x14x14x576 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 72 | Conv_71 | convolutional | 423 | 588 | 1x14x14x96 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 96 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 55k (1.59%) |
|
||||
| | | | | | | | MACs per inference: 10M (3.6%) |
|
||||
| 73 | Add_72 | elementwise_binary_op | 417 | 426 | 1x14x14x96 | A D G C | operation: sum |
|
||||
| | | | 588 | | | | MACs per inference: 18k (0.00625%) |
|
||||
| 74 | Conv_73 | convolutional | 426 | 591 | 1x14x14x576 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 576 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 55k (1.6%) |
|
||||
| | | | | | | | MACs per inference: 10M (3.6%) |
|
||||
| 75 | Clip_74 | neuron | 591 | 429 | 1x14x14x576 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 76 | Conv_75 | convolutional | 429 | 594 | 1x7x7x576 | A D G C | padding x: 1 |
|
||||
| | | | | | | | padding y: 1 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 2 |
|
||||
| | | | | | | | stride y: 2 |
|
||||
| | | | | | | | num filters: 576 |
|
||||
| | | | | | | | kernel: 3x3 |
|
||||
| | | | | | | | groups: 576 |
|
||||
| | | | | | | | param count: 5k (0.165%) |
|
||||
| | | | | | | | MACs per inference: 254k (0.0844%) |
|
||||
| 77 | Clip_76 | neuron | 594 | 432 | 1x7x7x576 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 78 | Conv_77 | convolutional | 432 | 597 | 1x7x7x160 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 160 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 92k (2.65%) |
|
||||
| | | | | | | | MACs per inference: 4M (1.5%) |
|
||||
| 79 | Conv_78 | convolutional | 597 | 600 | 1x7x7x960 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 960 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 154k (4.43%) |
|
||||
| | | | | | | | MACs per inference: 7M (2.5%) |
|
||||
| 80 | Clip_79 | neuron | 600 | 437 | 1x7x7x960 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 81 | Conv_80 | convolutional | 437 | 603 | 1x7x7x960 | A D G C | padding x: 1 |
|
||||
| | | | | | | | padding y: 1 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 960 |
|
||||
| | | | | | | | kernel: 3x3 |
|
||||
| | | | | | | | groups: 960 |
|
||||
| | | | | | | | param count: 9k (0.275%) |
|
||||
| | | | | | | | MACs per inference: 423k (0.141%) |
|
||||
| 82 | Clip_81 | neuron | 603 | 440 | 1x7x7x960 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 83 | Conv_82 | convolutional | 440 | 606 | 1x7x7x160 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 160 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 153k (4.41%) |
|
||||
| | | | | | | | MACs per inference: 7M (2.5%) |
|
||||
| 84 | Add_83 | elementwise_binary_op | 597 | 443 | 1x7x7x160 | A D G C | operation: sum |
|
||||
| | | | 606 | | | | MACs per inference: 7k (0.0026%) |
|
||||
| 85 | Conv_84 | convolutional | 443 | 609 | 1x7x7x960 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 960 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 154k (4.43%) |
|
||||
| | | | | | | | MACs per inference: 7M (2.5%) |
|
||||
| 86 | Clip_85 | neuron | 609 | 446 | 1x7x7x960 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 87 | Conv_86 | convolutional | 446 | 612 | 1x7x7x960 | A D G C | padding x: 1 |
|
||||
| | | | | | | | padding y: 1 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 960 |
|
||||
| | | | | | | | kernel: 3x3 |
|
||||
| | | | | | | | groups: 960 |
|
||||
| | | | | | | | param count: 9k (0.275%) |
|
||||
| | | | | | | | MACs per inference: 423k (0.141%) |
|
||||
| 88 | Clip_87 | neuron | 612 | 449 | 1x7x7x960 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 89 | Conv_88 | convolutional | 449 | 615 | 1x7x7x160 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 160 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 153k (4.41%) |
|
||||
| | | | | | | | MACs per inference: 7M (2.5%) |
|
||||
| 90 | Add_89 | elementwise_binary_op | 443 | 452 | 1x7x7x160 | A D G C | operation: sum |
|
||||
| | | | 615 | | | | MACs per inference: 7k (0.0026%) |
|
||||
| 91 | Conv_90 | convolutional | 452 | 618 | 1x7x7x960 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 960 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 154k (4.43%) |
|
||||
| | | | | | | | MACs per inference: 7M (2.5%) |
|
||||
| 92 | Clip_91 | neuron | 618 | 455 | 1x7x7x960 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 93 | Conv_92 | convolutional | 455 | 621 | 1x7x7x960 | A D G C | padding x: 1 |
|
||||
| | | | | | | | padding y: 1 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 960 |
|
||||
| | | | | | | | kernel: 3x3 |
|
||||
| | | | | | | | groups: 960 |
|
||||
| | | | | | | | param count: 9k (0.275%) |
|
||||
| | | | | | | | MACs per inference: 423k (0.141%) |
|
||||
| 94 | Clip_93 | neuron | 621 | 458 | 1x7x7x960 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 95 | Conv_94 | convolutional | 458 | 624 | 1x7x7x320 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 320 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 307k (8.82%) |
|
||||
| | | | | | | | MACs per inference: 15M (5%) |
|
||||
| 96 | Conv_95 | convolutional | 624 | 627 | 1x7x7x1280 | A D G C | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | padding mode: zero |
|
||||
| | | | | | | | stride x: 1 |
|
||||
| | | | | | | | stride y: 1 |
|
||||
| | | | | | | | num filters: 1280 |
|
||||
| | | | | | | | kernel: 1x1 |
|
||||
| | | | | | | | param count: 410k (11.8%) |
|
||||
| | | | | | | | MACs per inference: 20M (6.67%) |
|
||||
| 97 | Clip_96 | neuron | 627 | 463 | 1x7x7x1280 | A D G C | a: 0 |
|
||||
| | | | | | | | b: 0 |
|
||||
| | | | | | | | min_clamp: 0 |
|
||||
| | | | | | | | max_clamp: 6 |
|
||||
| | | | | | | | func: relu_min_max |
|
||||
| 98 | GlobalAveragePool_97 | pooling | 463 | 464 | 1x1x1x1280 | A D G C | pool size x: 7 |
|
||||
| | | | | | | | pool size y: 7 |
|
||||
| | | | | | | | stride x: 7 |
|
||||
| | | | | | | | stride y: 7 |
|
||||
| | | | | | | | padding x: 0 |
|
||||
| | | | | | | | padding y: 0 |
|
||||
| | | | | | | | pool_type: POOL_AVG |
|
||||
| | | | | | | | MACs per inference: 62k (0.0208%) |
|
||||
| 99 | 464.ncs | permute | 464 | 464.ncs | 1x1280x1x1 | A D G C | permute_order: [0, 3, 1, 2] |
|
||||
| 100 | Gemm_104 | fully_connected | 464.ncs | output | 1x1000 | A D G C | param count: 1M (36.7%) |
|
||||
| | | | | | | | MACs per inference: 1M (0.425%) |
|
||||
-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
Note: The supported runtimes column assumes a processor target of Snapdragon 835 (8998)
|
||||
Key : A:AIP
|
||||
D:DSP
|
||||
G:GPU
|
||||
C:CPU
|
||||
|
||||
Total parameters: 3487816 (13 MB assuming single precision float)
|
||||
Total MACs per inference: 301M (100%)
|
||||
Converter command: snpe-onnx-to-dlc adjust_nms_features_dims=False align_matmul_ranks=True copyright_file=None custom_op_config_paths=None debug=-1 disable_batchnorm_folding=False disable_chaining_eltwise_ops=False dry_run=None dumpIR=False dump_inferred_model=False dump_value_info=False enable_strict_validation=False extract_color_transform=False force_prune_cast_ops=True handle_gather_negative_indices=False inject_cast_for_gather=False input_dim=[['input', '1,3,224,224']] input_dtype=[] input_encoding=[] input_layout=[] input_type=[['input', 'image']] keep_disconnected_nodes=False keep_quant_nodes=False match_caffe_ssd_to_tf=False model_version=None no_simplification=False out_names=['output'] perform_axes_to_spatial_first_order=True prepare_inputs_as_params=True preprocess_lstm_ops=False preprocess_roi_pool_inputs=False quantization_overrides= squash_box_decoder=False unroll_lstm_time_steps=False use_convert_quantization_nodes=True validation_target=[]
|
||||
Quantizer command: N/A
|
||||
DLC created with converter version: 1.61.0.3358
|
||||
Layers used by DLC: CONVOLUTIONAL, DATA, ELEMENTWISE_BINARY_OP_SUM, FULLY_CONNECTED, NEURON_RELU_MIN_MAX, PERMUTE, POOLING
|
||||
Est. Steady-State Memory Needed to Run: 164.3 MiB
|
||||
-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
131
tinygrad_repo/extra/dsp/snpe_logs/high_perf_2
Normal file
131
tinygrad_repo/extra/dsp/snpe_logs/high_perf_2
Normal file
@@ -0,0 +1,131 @@
|
||||
Log File Created: Tue Mar 18 01:33:12 2025
|
||||
Time Scale: 1e-06
|
||||
Epoch Timestamp: 1742286792883569 Steady Clock Timestamp: 75586845756
|
||||
Software library version: 1.61.0.3358
|
||||
|
||||
Dnn Runtime Load/Deserialize/Create/De-Init Statistics:
|
||||
--------------------------------------------------
|
||||
Load: 333 us
|
||||
Deserialize: 32452 us
|
||||
Create: 143084 us
|
||||
|
||||
Init: 178071 us
|
||||
De-Init: 16710 us
|
||||
|
||||
Create Network(s): 86850 us
|
||||
RPC Init Time: 43213 us
|
||||
Snpe Accelerator Init Time: 42154 us
|
||||
Accelerator Init Time: 39189 us
|
||||
|
||||
Average SNPE Statistics:
|
||||
------------------------------
|
||||
Total Inference Time: 11868 us
|
||||
Forward Propagate Time: 11816 us
|
||||
RPC Execute Time: 9810 us
|
||||
Snpe Accelerator Time: 9129 us
|
||||
Accelerator Time: 8701 us
|
||||
Misc Accelerator Time: 10 us
|
||||
|
||||
Layer Times:
|
||||
---------------
|
||||
0: 42 us : DSP
|
||||
1: 0 us : DSP
|
||||
2: 254 us : DSP
|
||||
3: 0 us : DSP
|
||||
4: 153 us : DSP
|
||||
5: 295 us : DSP
|
||||
6: 0 us : DSP
|
||||
7: 287 us : DSP
|
||||
8: 0 us : DSP
|
||||
9: 162 us : DSP
|
||||
10: 210 us : DSP
|
||||
11: 0 us : DSP
|
||||
12: 138 us : DSP
|
||||
13: 0 us : DSP
|
||||
14: 176 us : DSP
|
||||
15: 293 us : DSP
|
||||
16: 60 us : DSP
|
||||
17: 0 us : DSP
|
||||
18: 157 us : DSP
|
||||
19: 0 us : DSP
|
||||
20: 112 us : DSP
|
||||
21: 134 us : DSP
|
||||
22: 0 us : DSP
|
||||
23: 81 us : DSP
|
||||
24: 0 us : DSP
|
||||
25: 104 us : DSP
|
||||
26: 130 us : DSP
|
||||
27: 37 us : DSP
|
||||
28: 0 us : DSP
|
||||
29: 81 us : DSP
|
||||
30: 0 us : DSP
|
||||
31: 87 us : DSP
|
||||
32: 124 us : DSP
|
||||
33: 30 us : DSP
|
||||
34: 0 us : DSP
|
||||
35: 87 us : DSP
|
||||
36: 0 us : DSP
|
||||
37: 63 us : DSP
|
||||
38: 74 us : DSP
|
||||
39: 0 us : DSP
|
||||
40: 102 us : DSP
|
||||
41: 0 us : DSP
|
||||
42: 82 us : DSP
|
||||
43: 95 us : DSP
|
||||
44: 29 us : DSP
|
||||
45: 0 us : DSP
|
||||
46: 112 us : DSP
|
||||
47: 0 us : DSP
|
||||
48: 88 us : DSP
|
||||
49: 96 us : DSP
|
||||
50: 25 us : DSP
|
||||
51: 0 us : DSP
|
||||
52: 103 us : DSP
|
||||
53: 0 us : DSP
|
||||
54: 80 us : DSP
|
||||
55: 100 us : DSP
|
||||
56: 26 us : DSP
|
||||
57: 0 us : DSP
|
||||
58: 102 us : DSP
|
||||
59: 0 us : DSP
|
||||
60: 85 us : DSP
|
||||
61: 129 us : DSP
|
||||
62: 0 us : DSP
|
||||
63: 155 us : DSP
|
||||
64: 0 us : DSP
|
||||
65: 113 us : DSP
|
||||
66: 194 us : DSP
|
||||
67: 34 us : DSP
|
||||
68: 0 us : DSP
|
||||
69: 157 us : DSP
|
||||
70: 0 us : DSP
|
||||
71: 120 us : DSP
|
||||
72: 198 us : DSP
|
||||
73: 34 us : DSP
|
||||
74: 0 us : DSP
|
||||
75: 155 us : DSP
|
||||
76: 0 us : DSP
|
||||
77: 101 us : DSP
|
||||
78: 121 us : DSP
|
||||
79: 0 us : DSP
|
||||
80: 256 us : DSP
|
||||
81: 0 us : DSP
|
||||
82: 134 us : DSP
|
||||
83: 159 us : DSP
|
||||
84: 31 us : DSP
|
||||
85: 0 us : DSP
|
||||
86: 199 us : DSP
|
||||
87: 0 us : DSP
|
||||
88: 142 us : DSP
|
||||
89: 152 us : DSP
|
||||
90: 26 us : DSP
|
||||
91: 0 us : DSP
|
||||
92: 202 us : DSP
|
||||
93: 0 us : DSP
|
||||
94: 143 us : DSP
|
||||
95: 278 us : DSP
|
||||
96: 0 us : DSP
|
||||
97: 316 us : DSP
|
||||
98: 40 us : DSP
|
||||
99: 12 us : DSP
|
||||
100: 199 us : DSP
|
||||
21
tinygrad_repo/extra/dsp/snpe_logs/parse.py
Normal file
21
tinygrad_repo/extra/dsp/snpe_logs/parse.py
Normal file
@@ -0,0 +1,21 @@
|
||||
di = open("dlc_info_2").read().split("\n")
|
||||
layers = {}
|
||||
for l in di:
|
||||
if not l.startswith("| "): continue
|
||||
if l.startswith("| |"): continue
|
||||
ll = [x.strip() for x in l.split("|")]
|
||||
if ll[1] == "Id": continue
|
||||
layers[int(ll[1])] = (ll[2], ll[6])
|
||||
hp = open("high_perf_2").read().split("Layer Times:")[1].strip().split("\n")[2:]
|
||||
sl = 1
|
||||
tms = 0
|
||||
for l in hp:
|
||||
kk, tm, _ = l.split(" ", 2)
|
||||
tm = int(tm)
|
||||
lnum = int(kk.strip(":"))
|
||||
if int(tm) != 0:
|
||||
print(f"{sl:2d} {tm:4d} us {layers[lnum]}")
|
||||
tms += tm
|
||||
sl += 1
|
||||
print(f"total time, {tms/1000:.2f} ms")
|
||||
|
||||
Reference in New Issue
Block a user