From 9980c95a3fd8be8d5e48adf43d34b353026f96eb Mon Sep 17 00:00:00 2001 From: "-T.K.-" Date: Sat, 13 Jul 2024 22:31:59 -0700 Subject: [PATCH] ADD: update --- CMakeLists.txt | 4 +- nn/impl/rvv/abs.c | 22 +++--- nn/impl/rvv/add.c | 24 ++---- nn/impl/rvv/maximum1.c | 21 ++---- nn/impl/rvv/minimum1.c | 21 ++---- tests/CMakeLists.txt | 11 ++- tests/src/generate_test.py | 6 +- tests/src/generated.c | 146 ++++++++++++++++++++++++++++--------- tests/src/unittest.h | 2 +- 9 files changed, 155 insertions(+), 102 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 9775019..94dccda 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -47,7 +47,7 @@ set(WRAP_SPECS_FILE "htif_wrap.specs") set(SPECS_FILE "htif_nano.specs") set(LIBGLOSS_DIR "$ENV{RISCV}/riscv64-unknown-elf/lib/") -set(MARCH "rv64gcv_zfh_zvfh") +set(MARCH "rv64gcv_zfh_zvfh_zvfhmin") set(MABI "lp64d") set(MCMODEL "medany") @@ -60,6 +60,8 @@ target_compile_options(target-riscv INTERFACE -march=${MARCH} -mabi=${MABI} -mcm target_compile_options(target-riscv INTERFACE -Wl,-Map=output.map -specs=${SPECS_FILE} -specs=${WRAP_SPECS_FILE}) target_compile_options(target-riscv INTERFACE -T ${LINKER_SCRIPT}) +target_compile_definitions(target-riscv INTERFACE FLT16_MAX=65504.0f) + target_link_options(target-riscv INTERFACE -static) target_link_options(target-riscv INTERFACE -march=${MARCH} -mabi=${MABI} -mcmodel=${MCMODEL}) target_link_options(target-riscv INTERFACE -Wl,-Map=output.map -specs=${SPECS_FILE} -specs=${WRAP_SPECS_FILE}) diff --git a/nn/impl/rvv/abs.c b/nn/impl/rvv/abs.c index 5a64229..6e745f2 100644 --- a/nn/impl/rvv/abs.c +++ b/nn/impl/rvv/abs.c @@ -45,17 +45,17 @@ void NN__abs_i32(size_t n, int32_t *y, size_t incy, int32_t *x, size_t incx) { } } -// void NN__abs_f16(size_t n, float16_t *y, size_t incy, float16_t *x, size_t incx) { -// while (n > 0) { -// size_t vl = __riscv_vsetvl_e16m1(n); -// vfloat16m1_t vec_x = __riscv_vlse16_v_f16m1(x, sizeof(float16_t) * incx, vl); -// vfloat16m1_t vec_y = __riscv_vfabs_v_f16m1(vec_x, vl); -// __riscv_vse16_v_f16m1(y, sizeof(float16_t) * incy, vec_y, vl); -// x += vl; -// y += vl; -// n -= vl; -// } -// } +void NN__abs_f16(size_t n, float16_t *y, size_t incy, float16_t *x, size_t incx) { + while (n > 0) { + size_t vl = __riscv_vsetvl_e16m1(n); + vfloat16m1_t vec_x = __riscv_vlse16_v_f16m1(x, sizeof(float16_t) * incx, vl); + vfloat16m1_t vec_y = __riscv_vfabs_v_f16m1(vec_x, vl); + __riscv_vsse16_v_f16m1(y, sizeof(float16_t) * incy, vec_y, vl); + x += vl; + y += vl; + n -= vl; + } +} void NN__abs_f32(size_t n, float *y, size_t incy, float *x, size_t incx) { while (n > 0) { diff --git a/nn/impl/rvv/add.c b/nn/impl/rvv/add.c index c39aa16..cd0269a 100644 --- a/nn/impl/rvv/add.c +++ b/nn/impl/rvv/add.c @@ -20,25 +20,11 @@ void NN__add_i8(size_t n, int8_t *z, size_t incz, int8_t *x, size_t incx, int8_t void NN__add_f16(size_t n, float16_t *z, size_t incz, float16_t *x, size_t incx, float16_t *y, size_t incy) { while (n > 0) { - size_t vl; - - printf("hi\n"); - - // size_t vl = __riscv_vsetvl_e16m1(n); - asm volatile("vsetvli %0, %1, e16, m1, ta, ma" : "=r"(vl) : "r"(n)); - - // vfloat16m1_t vec_x = __riscv_vlse16_v_f16m1(x, sizeof(float16_t) * incx, vl); - asm volatile("vlse16.v v24, (%0), %1" : : "r"(x), "r"(sizeof(float16_t) * incx)); - - // vfloat16m1_t vec_y = __riscv_vlse16_v_f16m1(y, sizeof(float16_t) * incy, vl); - asm volatile("vlse16.v v25, (%0), %1" : : "r"(y), "r"(sizeof(float16_t) * incy)); - - // // vfloat16m1_t vec_z = __riscv_vfadd_vv_f16m1(vec_x, vec_y, vl); - asm volatile("vfadd.vv v24, v24, v25"); - - // __riscv_vsse16_v_f16m1(z, sizeof(float16_t) * incz, vec_z, vl); - asm volatile("vsse16.v v24, (%0), %1" : : "r"(z), "r"(sizeof(float16_t) * incz)); - + size_t vl = __riscv_vsetvl_e16m1(n); + vfloat16m1_t vec_x = __riscv_vlse16_v_f16m1(x, sizeof(float16_t) * incx, vl); + vfloat16m1_t vec_y = __riscv_vlse16_v_f16m1(y, sizeof(float16_t) * incy, vl); + vfloat16m1_t vec_z = __riscv_vfadd_vv_f16m1(vec_x, vec_y, vl); + __riscv_vsse16_v_f16m1(z, sizeof(float16_t) * incz, vec_z, vl); x += vl; y += vl; z += vl; diff --git a/nn/impl/rvv/maximum1.c b/nn/impl/rvv/maximum1.c index ab908b7..cb4b06f 100644 --- a/nn/impl/rvv/maximum1.c +++ b/nn/impl/rvv/maximum1.c @@ -6,22 +6,11 @@ void NN__maximum1_f16(size_t n, float16_t *y, size_t incy, float16_t *x, size_t incx, float16_t scalar) { while (n > 0) { - size_t vl; - // size_t vl = __riscv_vsetvl_e16m1(n); - asm volatile("vsetvli %0, %1, e16, m1, ta, ma" : "=r"(vl) : "r"(n)); - - // vfloat16m1_t vec_x = __riscv_vlse16_v_f16m1(x, sizeof(float16_t) * incx, vl); - asm volatile("vlse16.v v26, (%0), %1" : : "r"(x), "r"(sizeof(float16_t) * incx)); - - // vfloat16m1_t vec_s = __riscv_vfmv_v_f_f16m1(scalar, vl); - asm volatile("vmv.v.x v25, %0" : : "r"(scalar)); - - // vfloat16m1_t vec_y = __riscv_vfmax_vv_f16m1(vec_x, vec_s, vl); - asm volatile("vfmax.vv v25, v26, v25"); - - // __riscv_vsse16_v_f16m1(y, sizeof(float16_t) * incy, vec_y, vl); - asm volatile("vsse16.v v25, (%0), %1" : : "r"(y), "r"(sizeof(float16_t) * incy)); - + size_t vl = __riscv_vsetvl_e16m1(n); + vfloat16m1_t vec_x = __riscv_vlse16_v_f16m1(x, sizeof(float16_t) * incx, vl); + vfloat16m1_t vec_s = __riscv_vfmv_v_f_f16m1(scalar, vl); + vfloat16m1_t vec_y = __riscv_vfmax_vv_f16m1(vec_x, vec_s, vl); + __riscv_vsse16_v_f16m1(y, sizeof(float16_t) * incy, vec_y, vl); x += vl; y += vl; n -= vl; diff --git a/nn/impl/rvv/minimum1.c b/nn/impl/rvv/minimum1.c index 040cbda..135bfe4 100644 --- a/nn/impl/rvv/minimum1.c +++ b/nn/impl/rvv/minimum1.c @@ -6,22 +6,11 @@ void NN__minimum1_f16(size_t n, float16_t *y, size_t incy, float16_t *x, size_t incx, float16_t scalar) { while (n > 0) { - size_t vl; - // size_t vl = __riscv_vsetvl_e16m1(n); - asm volatile("vsetvli %0, %1, e16, m1, ta, ma" : "=r"(vl) : "r"(n)); - - // vfloat16m1_t vec_x = __riscv_vlse16_v_f16m1(x, sizeof(float16_t) * incx, vl); - asm volatile("vlse16.v v26, (%0), %1" : : "r"(x), "r"(sizeof(float16_t) * incx)); - - // vfloat16m1_t vec_s = __riscv_vfmv_v_f_f16m1(scalar, vl); - asm volatile("vmv.v.x v25, %0" : : "r"(scalar)); - - // vfloat16m1_t vec_y = __riscv_vfmin_vv_f16m1(vec_x, vec_s, vl); - asm volatile("vfmin.vv v25, v26, v25"); - - // __riscv_vsse16_v_f16m1(y, sizeof(float16_t) * incy, vec_y, vl); - asm volatile("vsse16.v v25, (%0), %1" : : "r"(y), "r"(sizeof(float16_t) * incy)); - + size_t vl = __riscv_vsetvl_e16m1(n); + vfloat16m1_t vec_x = __riscv_vlse16_v_f16m1(x, sizeof(float16_t) * incx, vl); + vfloat16m1_t vec_s = __riscv_vfmv_v_f_f16m1(scalar, vl); + vfloat16m1_t vec_y = __riscv_vfmin_vv_f16m1(vec_x, vec_s, vl); + __riscv_vsse16_v_f16m1(y, sizeof(float16_t) * incy, vec_y, vl); x += vl; y += vl; n -= vl; diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index ae32572..e2b9ffc 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -12,6 +12,15 @@ elseif (RISCV) endif() -target_link_libraries(tests PUBLIC nn) +# include_directories( +# ../nn +# ../nn/functional +# ../nn/impl) + +find_library(LIB_TO_INCLUDE nn ./) + +target_link_libraries(tests PUBLIC ${LIB_TO_INCLUDE}) + +# target_link_libraries(tests PUBLIC nn) target_link_libraries(tests PUBLIC m) diff --git a/tests/src/generate_test.py b/tests/src/generate_test.py index bd37d49..ca795a6 100644 --- a/tests/src/generate_test.py +++ b/tests/src/generate_test.py @@ -41,9 +41,9 @@ def functional_rms_norm(x, w, eps): test_pattern = [ - # ("abs", lambda a: torch.abs(a), [("a", rand((7, 7))), ]), - # ("add", lambda a, b: a + b, [("a", rand((6, 7))), ("b", rand((6, 7))) ]), - # ("add", lambda a, b: a + b, [("a", rand((6, 7))), ("b", rand((1, 7))) ]), + ("abs", lambda a: torch.abs(a), [("a", rand((7, 7))), ]), + ("add", lambda a, b: a + b, [("a", rand((6, 7))), ("b", rand((6, 7))) ]), + ("add", lambda a, b: a + b, [("a", rand((6, 7))), ("b", rand((1, 7))) ]), # ("add", lambda a, b: a + b, [("a", rand((6, 7))), ("b", rand((6, 1))) ]), # ("add", lambda a, b: a + b, [("a", rand((6, 7))), ("b", rand((7, ))) ]), # ("add_inplace", lambda a, b: a + b, [("actual", torch.zeros((7, 7))), ("b", rand((7, 7))) ]), diff --git a/tests/src/generated.c b/tests/src/generated.c index 4433723..5dd4b06 100644 --- a/tests/src/generated.c +++ b/tests/src/generated.c @@ -16,12 +16,87 @@ int main() { { printf("abs: "); - // [[-0.332 -0.454 0.6143 0.1875 -0.1846 -0.255 0.6904]] - Tensor *a = NN_tensor(2, (size_t[]){ 1, 7 }, DTYPE_F16, (uint8_t[]){ 0x50,0xb5,0x44,0xb7,0xea,0x38,0x0,0x32,0xe8,0xb1,0x14,0xb4,0x86,0x39 }); + // [[-0.0374341 2.682218 -4.115226 -3.6796951 -1.9257718 1.3407868 -0.09 + Tensor *a = NN_tensor(2, (size_t[]){ 7, 7 }, DTYPE_F32, (uint8_t[]){ 0x80,0x54,0x19,0xbd,0x76,0xa9,0x2b,0x40,0xee,0xaf,0x83,0xc0,0x20,0x80,0x6b,0xc0,0xb1,0x7f,0xf6,0xbf,0xe7,0x9e,0xab,0x3f,0x10,0xe3,0xca,0xbd,0x82,0xb9,0x7d,0x40,0x4c,0x2f,0xe3,0xbe,0x1f,0x5a,0xa9,0x3f,0x97,0x6a,0xc1,0xbf,0x8c,0x9a,0x7b,0xbf,0x13,0xdb,0x98,0xc0,0x26,0xee,0x53,0xc0,0x51,0xe9,0x3,0xc0,0xc0,0xa9,0x3d,0x3e,0xb8,0x3,0xfd,0x3f,0xde,0x1,0x40,0x40,0xef,0xf0,0x58,0xc0,0x1e,0x59,0xb,0xc0,0x7e,0x75,0xe8,0x3f,0xb1,0xdc,0x84,0x40,0x4d,0xb6,0x83,0xbf,0xb3,0x75,0x6f,0x40,0x90,0x50,0x4e,0xbf,0x2a,0x71,0x7,0x3f,0x4e,0xe0,0x90,0x40,0x61,0x6d,0x94,0xc0,0xc0,0x73,0x49,0xc0,0x98,0x6,0xa2,0xbf,0xd3,0x78,0xf9,0xbf,0x79,0x3d,0x8a,0x40,0xe0,0x6a,0x4f,0xc0,0x78,0x4e,0x13,0xc0,0xa0,0x90,0x5f,0xc0,0x8a,0xd9,0x95,0xc0,0x5,0xcc,0x3a,0xc0,0x23,0x89,0x89,0x40,0x36,0xca,0xe,0x40,0x60,0x18,0x1b,0x40,0x68,0xa2,0x86,0x3e,0x8,0xf,0x24,0xc0,0x70,0x8e,0x58,0x3f,0x23,0x64,0x95,0xc0,0xa0,0x38,0x67,0xc0,0x38,0xf8,0x24,0xc0,0x70,0xe6,0x49,0x40,0x70,0x9f,0x3b,0x40,0x1d,0xeb,0xd,0xc0 }); - // [[0.332 0.454 0.6143 0.1875 0.1846 0.255 0.6904]] - Tensor *golden = NN_tensor(2, (size_t[]){ 1, 7 }, DTYPE_F16, (uint8_t[]){ 0x50,0x35,0x44,0x37,0xea,0x38,0x0,0x32,0xe8,0x31,0x14,0x34,0x86,0x39 }); + // [[0.0374341 2.682218 4.115226 3.6796951 1.9257718 1.3407868 0.0990659 ] + Tensor *golden = NN_tensor(2, (size_t[]){ 7, 7 }, DTYPE_F32, (uint8_t[]){ 0x80,0x54,0x19,0x3d,0x76,0xa9,0x2b,0x40,0xee,0xaf,0x83,0x40,0x20,0x80,0x6b,0x40,0xb1,0x7f,0xf6,0x3f,0xe7,0x9e,0xab,0x3f,0x10,0xe3,0xca,0x3d,0x82,0xb9,0x7d,0x40,0x4c,0x2f,0xe3,0x3e,0x1f,0x5a,0xa9,0x3f,0x97,0x6a,0xc1,0x3f,0x8c,0x9a,0x7b,0x3f,0x13,0xdb,0x98,0x40,0x26,0xee,0x53,0x40,0x51,0xe9,0x3,0x40,0xc0,0xa9,0x3d,0x3e,0xb8,0x3,0xfd,0x3f,0xde,0x1,0x40,0x40,0xef,0xf0,0x58,0x40,0x1e,0x59,0xb,0x40,0x7e,0x75,0xe8,0x3f,0xb1,0xdc,0x84,0x40,0x4d,0xb6,0x83,0x3f,0xb3,0x75,0x6f,0x40,0x90,0x50,0x4e,0x3f,0x2a,0x71,0x7,0x3f,0x4e,0xe0,0x90,0x40,0x61,0x6d,0x94,0x40,0xc0,0x73,0x49,0x40,0x98,0x6,0xa2,0x3f,0xd3,0x78,0xf9,0x3f,0x79,0x3d,0x8a,0x40,0xe0,0x6a,0x4f,0x40,0x78,0x4e,0x13,0x40,0xa0,0x90,0x5f,0x40,0x8a,0xd9,0x95,0x40,0x5,0xcc,0x3a,0x40,0x23,0x89,0x89,0x40,0x36,0xca,0xe,0x40,0x60,0x18,0x1b,0x40,0x68,0xa2,0x86,0x3e,0x8,0xf,0x24,0x40,0x70,0x8e,0x58,0x3f,0x23,0x64,0x95,0x40,0xa0,0x38,0x67,0x40,0x38,0xf8,0x24,0x40,0x70,0xe6,0x49,0x40,0x70,0x9f,0x3b,0x40,0x1d,0xeb,0xd,0x40 }); + Tensor *actual = NN_zeros(2, (size_t[]){ 7, 7 }, DTYPE_F32); + + cycles = read_cycles(); + NN_abs(actual, a); + cycles = read_cycles() - cycles; + printf("%s (%lu cycles)\n", compare_tensor(golden, actual, 1e-4) ? "PASS" : "FAIL", cycles); + + NN_delete_tensor(a); + + NN_delete_tensor(golden); + NN_free_tensor_data(actual); + NN_delete_tensor(actual); + } + + { + printf("add: "); + + // [[-0.18041193 3.1978035 4.9706655 1.9844109 0.6754643 3.3524318 -2.94 + Tensor *a = NN_tensor(2, (size_t[]){ 6, 7 }, DTYPE_F32, (uint8_t[]){ 0xe8,0xbd,0x38,0xbe,0xd0,0xa8,0x4c,0x40,0xb1,0xf,0x9f,0x40,0x2d,0x1,0xfe,0x3f,0x3a,0xeb,0x2c,0x3f,0x3e,0x8e,0x56,0x40,0xb0,0x6a,0x3c,0xc0,0x36,0x85,0x6e,0x3f,0x7,0x19,0x78,0xc0,0x9e,0xc9,0x5d,0xc0,0x86,0x4e,0x25,0xc0,0x98,0xca,0x10,0x40,0xfb,0xb0,0x0,0x40,0x84,0x8d,0x3d,0xc0,0x3a,0x59,0xc1,0x3f,0xca,0xab,0x2f,0x40,0xe8,0x8e,0x21,0xbf,0x50,0x7d,0x43,0x3e,0x80,0x4a,0x94,0x3f,0x40,0x85,0x46,0x40,0x8d,0xa1,0x99,0x40,0x7c,0x99,0x76,0xc0,0x67,0x8a,0xea,0xbf,0xbe,0x86,0xfb,0x3f,0x62,0x91,0x84,0x40,0xb1,0x3b,0x8b,0x40,0x55,0x2d,0x8d,0x40,0x16,0xbd,0x7e,0x3f,0x1b,0x22,0x8b,0xc0,0x34,0x80,0xeb,0x3e,0x97,0x31,0x48,0xc0,0xd8,0x1c,0x95,0xc0,0xa7,0x28,0x8e,0x40,0xac,0x50,0x73,0x40,0xbf,0x9a,0x9f,0xc0,0x8a,0x94,0x6f,0x3f,0xfa,0xa0,0x57,0xbf,0x66,0xa3,0x52,0xbf,0x72,0x7b,0x12,0xc0,0xaf,0x1d,0xf6,0x3f,0x81,0x89,0x3d,0xc0,0x53,0x9e,0xea,0x3f }); + // [[ 2.5285406 3.5793579 1.8695557 -4.948676 -3.2434845 2.496575 1.046 + Tensor *b = NN_tensor(2, (size_t[]){ 6, 7 }, DTYPE_F32, (uint8_t[]){ 0x9c,0xd3,0x21,0x40,0x33,0x14,0x65,0x40,0x9a,0x4d,0xef,0x3f,0x8e,0x5b,0x9e,0xc0,0x40,0x95,0x4f,0xc0,0xe3,0xc7,0x1f,0x40,0xef,0xf3,0x85,0x3f,0x7c,0xa0,0x79,0xc0,0x22,0x43,0x38,0xc0,0x17,0x85,0x96,0x40,0x29,0x9f,0x57,0x40,0x2e,0x87,0xb,0xc0,0x9,0x14,0xa1,0xbf,0x6b,0x6a,0x98,0xc0,0x20,0xe,0xb8,0xbd,0x96,0xfa,0x70,0xc0,0x8a,0xd5,0x76,0xc0,0x14,0xe,0x8d,0xbe,0x88,0x2f,0x40,0x3f,0xb8,0xc,0x3,0xc0,0x7e,0xe1,0x3d,0x40,0x86,0xbb,0x42,0xc0,0xe1,0x2d,0x91,0x40,0xc4,0x4b,0x5b,0x40,0xde,0xec,0x86,0xc0,0x35,0x49,0x9f,0xbf,0x20,0x7,0x67,0x3e,0xde,0xc0,0x3a,0x3f,0xa2,0xca,0x97,0x3f,0x73,0x27,0xfb,0x3f,0x2c,0x58,0x99,0x3e,0x20,0x23,0x1c,0xc0,0xa4,0x6b,0x17,0x40,0xd6,0x7a,0x99,0xc0,0x88,0xaa,0x3d,0xc0,0xb,0x36,0xa0,0xbf,0x54,0xe0,0x1b,0xc0,0xb3,0xe4,0xdf,0xbf,0xb4,0x23,0x83,0xc0,0x40,0x23,0x88,0xbf,0xdb,0xcd,0x88,0x3f,0x14,0x78,0x50,0xc0 }); + + + // [[ 2.3481288 6.7771616 6.8402214 -2.9642653 -2.5680203 5.8490067 -1.89 + Tensor *golden = NN_tensor(2, (size_t[]){ 6, 7 }, DTYPE_F32, (uint8_t[]){ 0xbe,0x47,0x16,0x40,0x82,0xde,0xd8,0x40,0x18,0xe3,0xda,0x40,0x86,0xb6,0x3d,0xc0,0x72,0x5a,0x24,0xc0,0x10,0x2b,0xbb,0x40,0x71,0xe1,0xf2,0xbf,0x2e,0xff,0x3d,0xc0,0x14,0x2e,0xd8,0xc0,0x20,0x81,0x9e,0x3f,0x8c,0x42,0x49,0x3f,0x40,0x6d,0xa8,0x3d,0xda,0x9b,0x40,0x3f,0x2d,0x31,0xf7,0xc0,0x58,0xd8,0xb5,0x3f,0x98,0x9d,0x82,0xbf,0xa2,0x9c,0x8f,0xc0,0xb0,0x3d,0xad,0xbd,0x44,0x62,0xf4,0x3f,0x10,0xf1,0x86,0x3f,0x4c,0x92,0xf8,0x40,0x81,0xaa,0xdc,0xc0,0x8e,0x16,0x2d,0x40,0x92,0x87,0xac,0x40,0x0,0xdf,0x96,0xbd,0xc8,0xd2,0x46,0x40,0x8e,0x65,0x94,0x40,0xfa,0xbe,0xdc,0x3f,0xe5,0x5e,0x4a,0xc0,0xc0,0x3,0x1b,0x40,0x92,0x6,0x35,0xc0,0x68,0x2e,0xe3,0xc0,0x79,0xde,0xd9,0x40,0x0,0x94,0x7e,0xbf,0x3,0x70,0xfe,0xc0,0x18,0xaf,0xa1,0xbe,0x92,0xc8,0x51,0xc0,0x33,0x9b,0x24,0xc0,0x6d,0x61,0xcc,0xc0,0xde,0xf4,0x5b,0x3f,0x27,0x45,0xf2,0xbf,0xd5,0x51,0xb6,0xbf }); + Tensor *actual = NN_zeros(2, (size_t[]){ 6, 7 }, DTYPE_F32); + + cycles = read_cycles(); + NN_add(actual, a, b); + cycles = read_cycles() - cycles; + printf("%s (%lu cycles)\n", compare_tensor(golden, actual, 1e-4) ? "PASS" : "FAIL", cycles); + + NN_delete_tensor(a); + NN_delete_tensor(b); + + NN_delete_tensor(golden); + NN_free_tensor_data(actual); + NN_delete_tensor(actual); + } + + { + printf("add: "); + + // [[-0.2565968 3.5792542 -0.51400125 0.13896108 -0.4313445 1.0119069 3.17 + Tensor *a = NN_tensor(2, (size_t[]){ 6, 7 }, DTYPE_F32, (uint8_t[]){ 0xa8,0x60,0x83,0xbe,0x80,0x12,0x65,0x40,0x96,0x95,0x3,0xbf,0xd0,0x4b,0xe,0x3e,0x30,0xd9,0xdc,0xbe,0x2a,0x86,0x81,0x3f,0xf8,0x77,0x4b,0x40,0x34,0x8f,0x97,0x40,0xc8,0x37,0x4b,0x40,0xfa,0xe7,0x97,0x40,0xb8,0x24,0xb9,0xbe,0x40,0xbb,0x8f,0xc0,0x68,0xb4,0x17,0xc0,0xc2,0xe3,0x59,0x40,0xe0,0xc2,0x4,0xbd,0xa,0xe,0x1f,0xc0,0x42,0x38,0x75,0xc0,0x80,0xbc,0x95,0xc0,0x94,0xa,0x87,0xc0,0xc6,0xd0,0x81,0xbf,0x6c,0x7d,0x2f,0x40,0x51,0x1,0x2d,0x40,0x21,0x4f,0x9a,0xc0,0x3a,0x9c,0x47,0x40,0x2c,0x67,0x7a,0xc0,0x76,0x4d,0x87,0xbf,0x52,0xc0,0x1,0xc0,0x2c,0x8c,0x76,0xbf,0x94,0x51,0x7b,0xbf,0x74,0x93,0x8f,0xc0,0x6a,0x26,0x8a,0xc0,0x32,0x4b,0x48,0xbf,0xf0,0x6c,0x84,0x3d,0x33,0x5e,0x11,0xc0,0x66,0x16,0xf1,0x3f,0x64,0x2,0x90,0xc0,0x70,0xc4,0xac,0xbe,0x5,0xb5,0x8c,0x40,0x83,0x86,0x2,0xc0,0x2,0x7b,0x90,0x40,0x46,0xc7,0xe7,0x3f,0xcd,0x64,0x90,0xc0 }); + // [[ 3.1634867 -0.57697237 -2.2320342 3.9982665 -4.040476 0.53652465 -1.0 + Tensor *b = NN_tensor(2, (size_t[]){ 1, 7 }, DTYPE_F32, (uint8_t[]){ 0x91,0x76,0x4a,0x40,0x76,0xb4,0x13,0xbf,0xa6,0xd9,0xe,0xc0,0x99,0xe3,0x7f,0x40,0x94,0x4b,0x81,0xc0,0xae,0x59,0x9,0x3f,0xf8,0xfe,0x85,0xbf }); + + + // [[ 2.90689 3.0022817 -2.7460356 4.1372275 -4.4718204 1.5484315 2.13 + Tensor *golden = NN_tensor(2, (size_t[]){ 6, 7 }, DTYPE_F32, (uint8_t[]){ 0x7c,0xa,0x3a,0x40,0x62,0x25,0x40,0x40,0xc,0xbf,0x2f,0xc0,0x2b,0x64,0x84,0x40,0x27,0x19,0x8f,0xc0,0x1,0x33,0xc6,0x3f,0x7c,0x78,0x8,0x40,0x7c,0xca,0xfc,0x40,0xaa,0x4a,0x26,0x40,0x4e,0xf6,0x20,0x40,0x2,0xbf,0x68,0x40,0x6a,0x83,0x8,0xc1,0xf9,0xbb,0xea,0xbf,0x46,0xe4,0x16,0x40,0x86,0x63,0x48,0x40,0x28,0xfb,0x43,0xc0,0xf4,0x8,0xc2,0xc0,0x9c,0x55,0x2e,0xbf,0x14,0x2b,0x4,0xc1,0xbc,0x8f,0xf4,0xbe,0xe0,0xfb,0xd8,0x3f,0xf1,0xbb,0xbb,0x40,0xb0,0xc5,0xac,0xc0,0x50,0xa,0x63,0x3f,0xa0,0x8d,0xaf,0x3d,0xf2,0x1e,0xa3,0xc0,0xcd,0xd3,0xbe,0xbf,0x87,0xa2,0x0,0xc0,0x2c,0xa2,0xb,0x40,0x3,0xa,0xa2,0xc0,0x3d,0x93,0xd1,0xc0,0xcc,0xd0,0x4d,0x40,0xc0,0x73,0x7e,0xc0,0x8f,0xf,0xde,0xbf,0xdc,0x2e,0x56,0x3f,0x6e,0x1c,0xab,0xbf,0xae,0x16,0x6a,0xbf,0x64,0x90,0xa,0x40,0x2c,0xba,0xfa,0x3f,0xe0,0xf6,0xf2,0x3e,0xe,0x3a,0x16,0x40,0x8b,0xe4,0xb1,0xc0 }); + Tensor *actual = NN_zeros(2, (size_t[]){ 6, 7 }, DTYPE_F32); + + cycles = read_cycles(); + NN_add(actual, a, b); + cycles = read_cycles() - cycles; + printf("%s (%lu cycles)\n", compare_tensor(golden, actual, 1e-4) ? "PASS" : "FAIL", cycles); + + NN_delete_tensor(a); + NN_delete_tensor(b); + + NN_delete_tensor(golden); + NN_free_tensor_data(actual); + NN_delete_tensor(actual); + } + + { + printf("abs: "); + + // [[-0.9893 -0.248 -0.7 0.0781 -0.9688 0.1777 0.125 ]] + Tensor *a = NN_tensor(2, (size_t[]){ 1, 7 }, DTYPE_F16, (uint8_t[]){ 0xea,0xbb,0xf0,0xb3,0x9a,0xb9,0x0,0x2d,0xc0,0xbb,0xb0,0x31,0x0,0x30 }); + + + // [[0.9893 0.248 0.7 0.0781 0.9688 0.1777 0.125 ]] + Tensor *golden = NN_tensor(2, (size_t[]){ 1, 7 }, DTYPE_F16, (uint8_t[]){ 0xea,0x3b,0xf0,0x33,0x9a,0x39,0x0,0x2d,0xc0,0x3b,0xb0,0x31,0x0,0x30 }); Tensor *actual = NN_zeros(2, (size_t[]){ 1, 7 }, DTYPE_F16); cycles = read_cycles(); @@ -39,14 +114,14 @@ int main() { { printf("add: "); - // [[ 0.3506 0.00879 0.706 -0.7295 0.7363 0.785 -0.415 ] [ 0.06836 0. - Tensor *a = NN_tensor(2, (size_t[]){ 6, 7 }, DTYPE_F16, (uint8_t[]){ 0x9c,0x35,0x80,0x20,0xa6,0x39,0xd6,0xb9,0xe4,0x39,0x48,0x3a,0xa4,0xb6,0x60,0x2c,0x60,0x37,0xa0,0xb6,0x30,0x36,0x8c,0xb9,0xfc,0xb4,0x98,0x37,0x64,0xb7,0x52,0xbb,0xa4,0xba,0xb0,0x38,0x78,0xb1,0x4a,0x39,0x9c,0xb7,0x98,0xb1,0x70,0xbb,0xb8,0xb3,0x28,0x3b,0x1a,0xbb,0x0,0xaa,0x34,0xb4,0x8a,0x39,0xfc,0x3b,0x9e,0x3a,0xbc,0x36,0x80,0xb8,0x70,0xb1,0x3a,0xbb,0xb0,0x3b,0x88,0x31,0x34,0xb4,0x18,0xb3,0xb4,0xb5,0x98,0x30,0x20,0xaf }); - // [[-0.587 0.2812 0.9385 0.2588 -0.3193 -0.376 -0.4688 ] [-0.4697 -0. - Tensor *b = NN_tensor(2, (size_t[]){ 6, 7 }, DTYPE_F16, (uint8_t[]){ 0xb2,0xb8,0x80,0x34,0x82,0x3b,0x24,0x34,0x1c,0xb5,0x4,0xb6,0x80,0xb7,0x84,0xb7,0xd8,0xb4,0x18,0xba,0xd2,0xba,0x74,0xb5,0x4,0xb8,0x2c,0x37,0x70,0xb0,0xb8,0x31,0xc8,0xbb,0xf0,0xb2,0x0,0xbb,0x0,0xbb,0x48,0x3b,0xa0,0x2a,0xa,0x3b,0x4c,0x38,0xa0,0x37,0x30,0xb4,0xde,0xb9,0x62,0xb9,0xf8,0xb8,0xd2,0x38,0x40,0x29,0xe8,0x36,0x84,0xb7,0x40,0xb0,0xfe,0xb9,0x4,0x35,0xce,0x3b,0x52,0x3b,0x8e,0xbb,0xba,0xb9,0xcc,0x3a,0x70,0x2f }); + // [[-0.2129 -0.7314 0.1699 0.541 0.3623 0.1797 -0.5664 ] [-0.52 + Tensor *a = NN_tensor(2, (size_t[]){ 6, 7 }, DTYPE_F16, (uint8_t[]){ 0xd0,0xb2,0xda,0xb9,0x70,0x31,0x54,0x38,0xcc,0x35,0xc0,0x31,0x88,0xb8,0x30,0xb8,0x9a,0x38,0xc4,0xb9,0x60,0x34,0xc,0xb6,0xf0,0xb3,0x6,0x38,0x44,0xbb,0x10,0x33,0xd6,0x3a,0x34,0x34,0xe0,0x3a,0xb0,0xb9,0x20,0x35,0xc0,0x24,0x84,0xb6,0x90,0x3a,0x68,0x36,0x7c,0xb8,0xc0,0x33,0x98,0xba,0x7a,0xb9,0x0,0xa5,0x7a,0x3a,0x1c,0x3a,0xc0,0x3a,0x10,0x34,0x86,0x3b,0x4c,0xb4,0xea,0xba,0x0,0x9c,0xa8,0xb6,0x34,0x37,0x38,0xb0,0xda,0x38 }); + // [[-0.1768 -0.3203 0.5156 0.1484 -0.0967 -0.8545 0.1074 ] [-0.9756 0. + Tensor *b = NN_tensor(2, (size_t[]){ 6, 7 }, DTYPE_F16, (uint8_t[]){ 0xa8,0xb1,0x20,0xb5,0x20,0x38,0xc0,0x30,0x30,0xae,0xd6,0xba,0xe0,0x2e,0xce,0xbb,0x40,0x37,0x40,0xac,0xf2,0x3a,0x50,0xb0,0x50,0x2f,0xf4,0x36,0xa6,0x38,0x7c,0xb5,0xd0,0x3a,0x0,0xae,0x20,0x33,0xec,0x37,0x14,0xb4,0xe,0xbb,0x18,0x35,0x56,0xb8,0xc2,0xb9,0xcc,0xb7,0x8e,0x3a,0x70,0x39,0xc0,0x30,0xc4,0xb6,0xae,0xbb,0xdc,0xb9,0x50,0x38,0xd8,0x36,0x62,0xba,0xa8,0xb3,0xb4,0xba,0x22,0xbb,0x74,0x35,0xf2,0x3b,0x8,0x30,0x84,0xb4 }); - // [[-0.2363 0.29 1.645 -0.4707 0.417 0.4092 -0.884 ] [-0.40 - Tensor *golden = NN_tensor(2, (size_t[]){ 6, 7 }, DTYPE_F16, (uint8_t[]){ 0x90,0xb3,0xa4,0x34,0x94,0x3e,0x88,0xb7,0xac,0x36,0x8c,0x36,0x12,0xbb,0x6c,0xb6,0x10,0x31,0xb4,0xbc,0x74,0xb7,0x23,0xbc,0x82,0xba,0x62,0x3b,0xce,0xb8,0xe4,0xb9,0x36,0xbf,0xe8,0x35,0x2f,0xbc,0xd8,0xb2,0xf4,0x36,0xe0,0xaf,0x60,0xaa,0xbc,0x34,0x7c,0x3d,0x99,0xbc,0x3e,0xba,0x7c,0xbb,0x90,0x2c,0x67,0x3e,0xf2,0x3a,0xd2,0x3a,0x21,0xbc,0xd8,0xb4,0x9c,0xbe,0x19,0x3d,0x98,0x3c,0x38,0x39,0xaa,0xbc,0x4a,0xbc,0xf2,0x3b,0x0,0x1d }); + // [[-0.3896 -1.052 0.6855 0.6895 0.2656 -0.675 -0.459 ] [-1.499 1. + Tensor *golden = NN_tensor(2, (size_t[]){ 6, 7 }, DTYPE_F16, (uint8_t[]){ 0x3c,0xb6,0x35,0xbc,0x7c,0x39,0x84,0x39,0x40,0x34,0x66,0xb9,0x58,0xb7,0xff,0xbd,0x1d,0x3c,0x4c,0xba,0x91,0x3c,0x1a,0xb8,0x48,0xb0,0x80,0x3b,0x3c,0xb5,0xd0,0xaf,0xd3,0x3e,0x68,0x31,0x54,0x3c,0xe8,0xb2,0x30,0x2c,0xe8,0xba,0xb0,0xad,0x74,0x34,0x1c,0xb5,0x31,0xbc,0x3f,0x3c,0xa0,0xb0,0x4a,0xb8,0x14,0xb7,0xd0,0xb0,0x0,0x28,0x88,0x3d,0x74,0x39,0x90,0x30,0x10,0xb8,0xcf,0xbe,0x2a,0xbb,0xd0,0xac,0xc6,0x3d,0x0,0x9e,0x30,0x35 }); Tensor *actual = NN_zeros(2, (size_t[]){ 6, 7 }, DTYPE_F16); cycles = read_cycles(); @@ -54,6 +129,9 @@ int main() { cycles = read_cycles() - cycles; printf("%s (%lu cycles)\n", compare_tensor(golden, actual, 1e-2) ? "PASS" : "FAIL", cycles); + NN_printf(golden); + NN_printf(actual); + NN_delete_tensor(a); NN_delete_tensor(b); @@ -65,14 +143,14 @@ int main() { { printf("matmul_t: "); - // [[-0.2393 -0.58 0.0801 -0.911 0.875 -0.6113 -0.4033 ] [ 0.552 -0. - Tensor *a = NN_tensor(2, (size_t[]){ 6, 7 }, DTYPE_F16, (uint8_t[]){ 0xa8,0xb3,0xa4,0xb8,0x20,0x2d,0x4a,0xbb,0x0,0x3b,0xe4,0xb8,0x74,0xb6,0x6a,0x38,0x40,0xaf,0x1c,0xb6,0x54,0x3b,0x58,0xbb,0x6a,0xba,0x78,0xb9,0xd0,0xb3,0x80,0xab,0xe0,0x29,0x4,0xb6,0xe8,0x3b,0x18,0x30,0x80,0xaa,0xe0,0xb0,0xa0,0x31,0xd0,0x3b,0x9c,0x3a,0x78,0x30,0x28,0x39,0x18,0x33,0x60,0xac,0x48,0xb3,0xc4,0xb4,0x30,0xaf,0x16,0xb9,0xaa,0x3a,0x40,0xb7,0xc4,0x34,0x8a,0x38,0xae,0xba,0x46,0x39,0x0,0x37,0xf0,0x2d,0x28,0x32 }); - // [[ 0.592 -0.75 0.8604 0.674 0.2852 0.908 -0.2031 ] [ 0.841 -0. - Tensor *b = NN_tensor(2, (size_t[]){ 5, 7 }, DTYPE_F16, (uint8_t[]){ 0xbc,0x38,0x0,0xba,0xe2,0x3a,0x64,0x39,0x90,0x34,0x44,0x3b,0x80,0xb2,0xba,0x3a,0xfa,0xb8,0xc4,0x38,0x54,0x38,0x60,0xaa,0x20,0xb9,0xce,0x3b,0xb0,0xae,0x6e,0xba,0x2,0xb9,0x0,0x38,0x14,0x3b,0x1c,0xb9,0x54,0xb7,0x60,0xac,0xfc,0x35,0xd2,0xbb,0x76,0x39,0xfc,0xba,0xe,0xb9,0x3c,0xbb,0x7c,0x38,0xd0,0xad,0x88,0xb4,0xa,0xbb,0x86,0x3b,0xb8,0xb6,0x5c,0x3b }); + // [[ 0.865 -0.207 -0.789 0.372 -0.9766 -0.9346 -0.04492 ] [-0.01 + Tensor *a = NN_tensor(2, (size_t[]){ 6, 7 }, DTYPE_F16, (uint8_t[]){ 0xec,0x3a,0xa0,0xb2,0x50,0xba,0xf4,0x35,0xd0,0xbb,0x7a,0xbb,0xc0,0xa9,0x40,0xa4,0x6,0x3a,0x2c,0xba,0x98,0x39,0xcc,0x3b,0xba,0xb9,0xac,0x39,0x0,0x98,0xc,0xb5,0x8a,0x39,0xa4,0xb4,0x54,0xb7,0xc0,0xbb,0x80,0x21,0xd0,0x38,0x58,0xba,0x50,0x30,0x6c,0x39,0xd6,0x3b,0x94,0x36,0xfa,0x38,0x38,0x39,0x44,0xb6,0xa0,0x37,0xf0,0xb3,0x36,0x38,0xa6,0x3b,0xc8,0x32,0xa4,0xb5,0x58,0xb2,0x9a,0xb9,0x70,0x31,0xa0,0x30,0xb0,0xac,0x3a,0x38 }); + // [[ 0.5654 -0.4658 -0.2119 0.3838 -0.9287 -0.71 -0.10254] [ 0.878 0. + Tensor *b = NN_tensor(2, (size_t[]){ 5, 7 }, DTYPE_F16, (uint8_t[]){ 0x86,0x38,0x74,0xb7,0xc8,0xb2,0x24,0x36,0x6e,0xbb,0xae,0xb9,0x90,0xae,0x6,0x3b,0x5c,0x3a,0x98,0xb4,0x64,0x3b,0xa0,0xb0,0x6,0x3a,0x3e,0x3a,0xb8,0xb3,0x28,0x36,0x36,0x38,0xa6,0xb8,0x72,0xba,0x9c,0x36,0xa0,0x2b,0x56,0xb9,0xf8,0xb0,0x80,0x29,0xf0,0xb2,0x44,0x3b,0x80,0x2d,0xbe,0xbb,0xec,0xb5,0x30,0xba,0x4,0xb4,0xb8,0xbb,0x0,0x3a,0x2c,0x37,0xbc,0xb9 }); - // [[-0.4753 -0.331 1.335 -0.9136 1.406 ] [-0.1509 0.695 0.743 2. - Tensor *golden = NN_tensor(2, (size_t[]){ 6, 5 }, DTYPE_F16, (uint8_t[]){ 0x9b,0xb7,0x4c,0xb5,0x57,0x3d,0x4f,0xbb,0xa0,0x3d,0xd4,0xb0,0x8f,0x39,0xf2,0x39,0xb0,0x41,0x23,0xbe,0x3,0x2e,0x34,0xb8,0x60,0x39,0xd1,0xbc,0x10,0x3c,0x5,0x3f,0xb4,0x38,0xb5,0xb9,0x2d,0xbc,0x29,0xbc,0x73,0x37,0x65,0xbc,0x89,0xb8,0x95,0x38,0xcc,0xbc,0xa8,0xb5,0x61,0xb0,0xd7,0x38,0xbf,0x3a,0x24,0x35 }); + // [[ 2.47 0.568 -0.522 -1.583 -1.44 ] [-0.398 1.325 -1.55 + Tensor *golden = NN_tensor(2, (size_t[]){ 6, 5 }, DTYPE_F16, (uint8_t[]){ 0xf1,0x40,0x8b,0x38,0x2d,0xb8,0x55,0xbe,0xc3,0xbd,0x5e,0xb6,0x4d,0x3d,0x3b,0xbe,0xe6,0xb0,0x9f,0xbc,0x0,0x3c,0x7f,0xbd,0x1b,0x36,0xde,0xb5,0xf4,0xb6,0x30,0xb5,0x8e,0x3c,0x6c,0xbd,0x2b,0xae,0xa1,0x31,0xad,0xba,0xa3,0x39,0x82,0x2c,0xd,0x2b,0xd2,0x3a,0xa1,0xa7,0x45,0x33,0x97,0xb8,0xff,0xb1,0xb8,0x9f }); Tensor *actual = NN_zeros(2, (size_t[]){ 6, 5 }, DTYPE_F16); cycles = read_cycles(); @@ -91,14 +169,14 @@ int main() { { printf("matmul: "); - // [[-0.2783 0.1445 -0.796 -0.4512 0.4014 -0.2363 0.04004] [ 0.05664 -0. - Tensor *a = NN_tensor(2, (size_t[]){ 6, 7 }, DTYPE_F16, (uint8_t[]){ 0x74,0xb4,0xa0,0x30,0x5e,0xba,0x38,0xb7,0x6c,0x36,0x90,0xb3,0x20,0x29,0x40,0x2b,0xfc,0xb4,0x80,0x28,0xb0,0xb3,0x54,0xbb,0x60,0x29,0xc0,0xb0,0xea,0xbb,0xf0,0xb3,0x9a,0xb9,0x0,0x2d,0xc0,0xbb,0xb0,0x31,0x0,0x30,0xd0,0xb2,0xda,0xb9,0x70,0x31,0x54,0x38,0xcc,0x35,0xc0,0x31,0x88,0xb8,0x30,0xb8,0x9a,0x38,0xc4,0xb9,0x60,0x34,0xc,0xb6,0xf0,0xb3,0x6,0x38,0x44,0xbb,0x10,0x33,0xd6,0x3a,0x34,0x34,0xe0,0x3a,0xb0,0xb9,0x20,0x35 }); - // [[ 0.01855 -0.4072 0.8203 0.4004 -0.5605 ] [ 0.2422 -0.824 -0.68 - Tensor *b = NN_tensor(2, (size_t[]){ 7, 5 }, DTYPE_F16, (uint8_t[]){ 0xc0,0x24,0x84,0xb6,0x90,0x3a,0x68,0x36,0x7c,0xb8,0xc0,0x33,0x98,0xba,0x7a,0xb9,0x0,0xa5,0x7a,0x3a,0x1c,0x3a,0xc0,0x3a,0x10,0x34,0x86,0x3b,0x4c,0xb4,0xea,0xba,0x0,0x9c,0xa8,0xb6,0x34,0x37,0x38,0xb0,0xda,0x38,0xa8,0xb1,0x20,0xb5,0x20,0x38,0xc0,0x30,0x30,0xae,0xd6,0xba,0xe0,0x2e,0xce,0xbb,0x40,0x37,0x40,0xac,0xf2,0x3a,0x50,0xb0,0x50,0x2f,0xf4,0x36 }); + // [[-0.8076 -0.127 0.927 0.248 0.0781 0.4355 -0.867 ] [-0.8154 -0. + Tensor *a = NN_tensor(2, (size_t[]){ 6, 7 }, DTYPE_F16, (uint8_t[]){ 0x76,0xba,0x10,0xb0,0x6a,0x3b,0xf0,0x33,0x0,0x2d,0xf8,0x36,0xf0,0xba,0x86,0xba,0xfe,0xba,0x5e,0xba,0xc0,0x35,0xba,0xb9,0xe0,0x35,0x6c,0x35,0xb0,0xba,0xe8,0x3a,0xe0,0xb2,0xa0,0xba,0x32,0x38,0x7a,0xb9,0xce,0x3a,0x8,0xb8,0xe8,0xb2,0x20,0x2f,0x3c,0x3a,0x40,0x27,0xe2,0x39,0x84,0x34,0xdc,0xba,0x44,0x34,0x46,0xba,0x58,0xb9,0x6,0xb8,0xf8,0xb7,0x76,0xbb,0x94,0x35,0x40,0xaf,0x50,0xb7,0x58,0xb0,0xc,0xb4,0x8,0x35,0xde,0x38 }); + // [[-0.911 0.333 -0.587 0.538 0.948 ] [ 0.6465 0.4043 0.6416 -0. + Tensor *b = NN_tensor(2, (size_t[]){ 7, 5 }, DTYPE_F16, (uint8_t[]){ 0x4a,0xbb,0x54,0x35,0xb2,0xb8,0x4e,0x38,0x96,0x3b,0x2c,0x39,0x78,0x36,0x22,0x39,0xe8,0xb4,0x20,0xab,0xdc,0xb9,0x20,0xb1,0xaa,0xbb,0x30,0x2d,0x9e,0xb8,0xb8,0xb2,0x46,0xbb,0x70,0x31,0x54,0x36,0x6e,0xba,0xb2,0x3a,0x1c,0xb8,0x40,0xb8,0xb6,0x3b,0x6e,0xb9,0x38,0x38,0xd6,0x3b,0x5e,0xba,0x5c,0xb6,0x74,0x3b,0x0,0x3b,0xac,0x3b,0x7e,0x38,0x0,0x24,0x2c,0xbb }); - // [[ 0.07556 -0.51 -0.501 -0.6235 0.516 ] [-0.3896 0.2615 0.6865 -0. - Tensor *golden = NN_tensor(2, (size_t[]){ 6, 5 }, DTYPE_F16, (uint8_t[]){ 0xd6,0x2c,0x14,0xb8,0x2,0xb8,0xfd,0xb8,0x21,0x38,0x3c,0xb6,0x2f,0x34,0x7e,0x39,0x9d,0xb8,0x17,0xb7,0x2d,0xbd,0x9c,0x30,0x51,0xb8,0xb1,0xbe,0x2e,0x38,0x77,0xb4,0xc7,0x2f,0xeb,0x2f,0x78,0x34,0x9b,0xb9,0x2a,0xbb,0xf3,0xb0,0x5f,0xbc,0x5e,0xb9,0xbc,0x3b,0x1f,0x3c,0x91,0x3e,0xbc,0xbc,0xe9,0x3e,0xe4,0x35 }); + // [[-0.541 -1.14 -1.328 -0.3337 -0.3628 ] [ 0.5767 0.2281 1.02 + Tensor *golden = NN_tensor(2, (size_t[]){ 6, 5 }, DTYPE_F16, (uint8_t[]){ 0x54,0xb8,0x8f,0xbc,0x50,0xbd,0x57,0xb5,0xce,0xb5,0x9d,0x38,0x4d,0x33,0x14,0x3c,0x64,0xbb,0xa9,0xa7,0xf2,0x40,0xdf,0x39,0x6a,0x3f,0x4c,0xb4,0x3b,0xbf,0xdd,0x39,0x28,0x9d,0x24,0xb4,0xbf,0xb0,0xf3,0xb9,0x65,0x31,0x8d,0xb8,0xcf,0x3d,0xb0,0xbc,0x0,0x3b,0x57,0x37,0x27,0x3d,0xd0,0x35,0x49,0xb3,0x8,0x39 }); Tensor *actual = NN_zeros(2, (size_t[]){ 6, 5 }, DTYPE_F16); cycles = read_cycles(); @@ -117,16 +195,16 @@ int main() { { printf("linear: "); - // [[ 0.581 -0.3428 0.8516 -0.09375 0.2227 0.495 -0.255 ] [-0.882 0. - Tensor *x = NN_tensor(2, (size_t[]){ 6, 7 }, DTYPE_F16, (uint8_t[]){ 0xa6,0x38,0x7c,0xb5,0xd0,0x3a,0x0,0xae,0x20,0x33,0xec,0x37,0x14,0xb4,0xe,0xbb,0x18,0x35,0x56,0xb8,0xc2,0xb9,0xcc,0xb7,0x8e,0x3a,0x70,0x39,0xc0,0x30,0xc4,0xb6,0xae,0xbb,0xdc,0xb9,0x50,0x38,0xd8,0x36,0x62,0xba,0xa8,0xb3,0xb4,0xba,0x22,0xbb,0x74,0x35,0xf2,0x3b,0x8,0x30,0x84,0xb4,0xec,0x3a,0xa0,0xb2,0x50,0xba,0xf4,0x35,0xd0,0xbb,0x7a,0xbb,0xc0,0xa9,0x40,0xa4,0x6,0x3a,0x2c,0xba,0x98,0x39,0xcc,0x3b,0xba,0xb9,0xac,0x39 }); - // [[-0.001953 -0.3154 0.6924 -0.29 -0.458 -0.9688 0.01074 ] [ 0.60 - Tensor *w = NN_tensor(2, (size_t[]){ 5, 7 }, DTYPE_F16, (uint8_t[]){ 0x0,0x98,0xc,0xb5,0x8a,0x39,0xa4,0xb4,0x54,0xb7,0xc0,0xbb,0x80,0x21,0xd0,0x38,0x58,0xba,0x50,0x30,0x6c,0x39,0xd6,0x3b,0x94,0x36,0xfa,0x38,0x38,0x39,0x44,0xb6,0xa0,0x37,0xf0,0xb3,0x36,0x38,0xa6,0x3b,0xc8,0x32,0xa4,0xb5,0x58,0xb2,0x9a,0xb9,0x70,0x31,0xa0,0x30,0xb0,0xac,0x3a,0x38,0x86,0x38,0x74,0xb7,0xc8,0xb2,0x24,0x36,0x6e,0xbb,0xae,0xb9,0x90,0xae }); - // [[ 0.878 0.795 -0.287 0.924 -0.1445]] - Tensor *b = NN_tensor(2, (size_t[]){ 1, 5 }, DTYPE_F16, (uint8_t[]){ 0x6,0x3b,0x5c,0x3a,0x98,0xb4,0x64,0x3b,0xa0,0xb0 }); + // [[-0.84 -0.4082 0.5234 -0.3867 0.1865 0.1904 0.2998 ] [-0.86 + Tensor *x = NN_tensor(2, (size_t[]){ 6, 7 }, DTYPE_F16, (uint8_t[]){ 0xb8,0xba,0x88,0xb6,0x30,0x38,0x30,0xb6,0xf8,0x31,0x18,0x32,0xcc,0x34,0xf0,0xba,0x80,0xac,0x28,0xb1,0xd0,0x2d,0xf6,0x3a,0x48,0xb4,0x70,0x2d,0xc0,0xba,0xda,0xba,0xe0,0xb6,0x72,0xb8,0x70,0x2d,0x80,0x22,0xe8,0x34,0xa2,0x38,0x80,0x2f,0xe8,0x3a,0x90,0xac,0x0,0xb2,0xd4,0xb4,0x90,0xb4,0xc0,0xad,0xce,0xb9,0x0,0xb3,0xa8,0x36,0x1c,0x3a,0x54,0xb8,0x70,0x34,0x50,0x34,0xa4,0x3b,0x10,0x35,0x2c,0x38,0x18,0x33,0x30,0xb0,0xb4,0xb6 }); + // [[-0.3682 0.9453 -0.4404 -0.3623 0.505 -0.75 0.1328 ] [ 0.20 + Tensor *w = NN_tensor(2, (size_t[]){ 5, 7 }, DTYPE_F16, (uint8_t[]){ 0xe4,0xb5,0x90,0x3b,0xc,0xb7,0xcc,0xb5,0xa,0x38,0x0,0xba,0x40,0x30,0x78,0x32,0x62,0xb8,0x6a,0x3b,0x58,0x30,0x0,0x1c,0xb2,0xb8,0x48,0xb9,0x30,0xad,0x68,0x34,0xd8,0xb6,0x68,0x3a,0x80,0xa4,0xc4,0x36,0xd8,0x32,0x68,0xb2,0x74,0xb4,0xb8,0xb0,0x70,0xb3,0xd4,0x35,0x88,0x34,0x66,0x38,0x3c,0x39,0x96,0xb8,0x74,0x3a,0x56,0x3b,0x6e,0x3a,0xf0,0x37,0x0,0x9c }); + // [[-0.2324 -0.08105 -0.165 -0.5615 0.3184 ]] + Tensor *b = NN_tensor(2, (size_t[]){ 1, 5 }, DTYPE_F16, (uint8_t[]){ 0x70,0xb3,0x30,0xad,0x48,0xb1,0x7e,0xb8,0x18,0x35 }); - // [[ 1.018 1.73 1.191 0.036 -0.405 ] [ 0.04947 -0.2664 -0.396 1. - Tensor *golden = NN_tensor(2, (size_t[]){ 6, 5 }, DTYPE_F16, (uint8_t[]){ 0x12,0x3c,0xec,0x3e,0xc4,0x3c,0x9c,0x28,0x7b,0xb6,0x55,0x2a,0x43,0xb4,0x56,0xb6,0xa1,0x3e,0x9b,0xbc,0x1b,0xaf,0x69,0x3a,0x24,0x33,0x83,0x3c,0x4f,0xb9,0xe9,0xb0,0x8d,0x40,0x43,0xa9,0x5e,0x3f,0x6c,0xb8,0x8f,0x3e,0x1b,0x34,0x1c,0xbe,0xb7,0x3c,0xa7,0x40,0x10,0x31,0xa3,0x3e,0x9f,0xbc,0x4,0x40,0x57,0xb8 }); + // [[-0.4084 0.09644 -0.6016 0.01962 0.3137 ] [ 0.7095 -0.2505 -0.08276 -0. + Tensor *golden = NN_tensor(2, (size_t[]){ 6, 5 }, DTYPE_F16, (uint8_t[]){ 0x89,0xb6,0x2c,0x2e,0xd0,0xb8,0x6,0x25,0x5,0x35,0xad,0x39,0x2,0xb4,0x4c,0xad,0xfb,0xac,0xf9,0x34,0x45,0xb4,0x73,0xb7,0x32,0xb8,0xba,0x33,0x34,0xb8,0xc3,0xb8,0x82,0x3c,0x55,0xba,0x86,0xbc,0xb2,0x3b,0x22,0xaf,0xa2,0x34,0x48,0xaf,0x1d,0xb0,0xe6,0x3c,0x5b,0x36,0x64,0x31,0xb5,0x32,0xf1,0xbc,0x5d,0x3a }); Tensor *actual = NN_zeros(2, (size_t[]){ 6, 5 }, DTYPE_F16); cycles = read_cycles(); @@ -146,12 +224,12 @@ int main() { { printf("relu: "); - // [[ 0.753 0.7803 -0.2412 0.3848 0.5264 -0.581 -0.8057 ] [ 0.413 0. - Tensor *x = NN_tensor(2, (size_t[]){ 7, 7 }, DTYPE_F16, (uint8_t[]){ 0x6,0x3a,0x3e,0x3a,0xb8,0xb3,0x28,0x36,0x36,0x38,0xa6,0xb8,0x72,0xba,0x9c,0x36,0xa0,0x2b,0x56,0xb9,0xf8,0xb0,0x80,0x29,0xf0,0xb2,0x44,0x3b,0x80,0x2d,0xbe,0xbb,0xec,0xb5,0x30,0xba,0x4,0xb4,0xb8,0xbb,0x0,0x3a,0x2c,0x37,0xbc,0xb9,0x76,0xba,0x10,0xb0,0x6a,0x3b,0xf0,0x33,0x0,0x2d,0xf8,0x36,0xf0,0xba,0x86,0xba,0xfe,0xba,0x5e,0xba,0xc0,0x35,0xba,0xb9,0xe0,0x35,0x6c,0x35,0xb0,0xba,0xe8,0x3a,0xe0,0xb2,0xa0,0xba,0x32,0x38,0x7a,0xb9,0xce,0x3a,0x8,0xb8,0xe8,0xb2,0x20,0x2f,0x3c,0x3a,0x40,0x27 }); + // [[ 0.4785 0.05176 -0.2031 0.0918 -0.9424 -0.672 0.6504 ] [ 0.62 + Tensor *x = NN_tensor(2, (size_t[]){ 7, 7 }, DTYPE_F16, (uint8_t[]){ 0xa8,0x37,0xa0,0x2a,0x80,0xb2,0xe0,0x2d,0x8a,0xbb,0x60,0xb9,0x34,0x39,0xf8,0x38,0xba,0xba,0x74,0x38,0xf0,0xac,0xa0,0x2e,0x6e,0xba,0xb0,0x34,0x1a,0x3a,0x38,0xb0,0x8c,0x3a,0x68,0xb7,0x4e,0x39,0x10,0x39,0x80,0x22,0xf0,0x3b,0x90,0xaf,0xa0,0x39,0x0,0xa0,0xa8,0xb7,0x10,0xb8,0x9e,0x3a,0xb2,0x3b,0x10,0x3a,0xc6,0x39,0xc,0x3a,0x88,0x32,0x1c,0x37,0x58,0xb8,0x64,0x37,0x84,0x3b,0x78,0x38,0xe0,0xb8,0x0,0x2b,0x70,0xb0,0xda,0x39,0xa4,0xb5,0xd0,0xb9,0x0,0x1c,0x70,0xb6,0x0,0xa5,0x9e,0xb9,0x52,0xb9 }); - // [[0.753 0.7803 0. 0.3848 0.5264 0. 0. ] [0.413 0.05957 0. - Tensor *golden = NN_tensor(2, (size_t[]){ 7, 7 }, DTYPE_F16, (uint8_t[]){ 0x6,0x3a,0x3e,0x3a,0x0,0x0,0x28,0x36,0x36,0x38,0x0,0x0,0x0,0x0,0x9c,0x36,0xa0,0x2b,0x0,0x0,0x0,0x0,0x80,0x29,0x0,0x0,0x44,0x3b,0x80,0x2d,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3a,0x2c,0x37,0x0,0x0,0x0,0x0,0x0,0x0,0x6a,0x3b,0xf0,0x33,0x0,0x2d,0xf8,0x36,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0x35,0x0,0x0,0xe0,0x35,0x6c,0x35,0x0,0x0,0xe8,0x3a,0x0,0x0,0x0,0x0,0x32,0x38,0x0,0x0,0xce,0x3a,0x0,0x0,0x0,0x0,0x20,0x2f,0x3c,0x3a,0x40,0x27 }); + // [[0.4785 0.05176 0. 0.0918 0. 0. 0.6504 ] [0.621 0. + Tensor *golden = NN_tensor(2, (size_t[]){ 7, 7 }, DTYPE_F16, (uint8_t[]){ 0xa8,0x37,0xa0,0x2a,0x0,0x0,0xe0,0x2d,0x0,0x0,0x0,0x0,0x34,0x39,0xf8,0x38,0x0,0x0,0x74,0x38,0x0,0x0,0xa0,0x2e,0x0,0x0,0xb0,0x34,0x1a,0x3a,0x0,0x0,0x8c,0x3a,0x0,0x0,0x4e,0x39,0x10,0x39,0x80,0x22,0xf0,0x3b,0x0,0x0,0xa0,0x39,0x0,0x0,0x0,0x0,0x0,0x0,0x9e,0x3a,0xb2,0x3b,0x10,0x3a,0xc6,0x39,0xc,0x3a,0x88,0x32,0x1c,0x37,0x0,0x0,0x64,0x37,0x84,0x3b,0x78,0x38,0x0,0x0,0x0,0x2b,0x0,0x0,0xda,0x39,0x0,0x0,0x0,0x0,0x0,0x1c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 }); Tensor *actual = NN_zeros(2, (size_t[]){ 7, 7 }, DTYPE_F16); cycles = read_cycles(); diff --git a/tests/src/unittest.h b/tests/src/unittest.h index fbcc469..d762154 100644 --- a/tests/src/unittest.h +++ b/tests/src/unittest.h @@ -20,7 +20,7 @@ static void enable_accelerator_features() { // enable vector operation unsigned long mstatus; asm volatile("csrr %0, mstatus" : "=r"(mstatus)); - mstatus |= 0x00000600 | 0x00006000 | 0x00018000; + mstatus |= 0x00000400 | 0x00004000 | 0x00010000; asm volatile("csrw mstatus, %0"::"r"(mstatus)); #endif }