char-fork/llama.cpp

git clone https://git.t4t.associates/char-fork/llama.cpp

nullnameggml-hexagon: flash-attention and reduce-sum optimizations (#19141)89f10baad

char/aliceai-t5-moe
brancheschar/aliceai-t5-moeall refs →
3.1 KiB129 linesraw
1#ifndef HVX_DUMP_H
2#define HVX_DUMP_H
3
4#include <HAP_farf.h>
5
6#include <stdbool.h>
7#include <stdint.h>
8
9#include "hex-utils.h"
10#include "hvx-types.h"
11
12static void hvx_vec_dump_f16_n(char * pref, HVX_Vector v, uint32_t n) {
13    HVX_VectorAlias u = { .v = v };
14
15    const uint32_t n0 = n / 16;
16    const uint32_t n1 = n % 16;
17    int            i  = 0;
18    for (; i < n0; i++) {
19        hex_dump_f16_line(pref, u.fp16 + (16 * i), 16);
20    }
21    if (n1) {
22        hex_dump_f16_line(pref, u.fp16 + (16 * i), n1);
23    }
24}
25
26static void hvx_vec_dump_f16(char * pref, HVX_Vector v) {
27    hvx_vec_dump_f16_n(pref, v, 64);
28}
29
30static void hvx_vec_dump_f32_n(char * pref, HVX_Vector v, uint32_t n) {
31    HVX_VectorAlias u = { .v = v };
32
33    const uint32_t n0 = n / 16;
34    const uint32_t n1 = n % 16;
35    int            i  = 0;
36    for (; i < n0; i++) {
37        hex_dump_f32_line(pref, u.fp32 + (16 * i), 16);
38    }
39    if (n1) {
40        hex_dump_f32_line(pref, u.fp32 + (16 * i), n1);
41    }
42}
43
44static void hvx_vec_dump_f32_hmt(char * pref, HVX_Vector v) {
45    union {
46        HVX_Vector v;
47        float      d[32];
48    } u = { .v = v };
49
50    FARF(HIGH, "%s: %.6f %.6f %.6f %.6f ...  %.6f %.6f %.6f %.6f ... %.6f %.6f %.6f %.6f\n", pref, u.d[0], u.d[1],
51         u.d[2], u.d[3], u.d[12], u.d[13], u.d[14], u.d[15], u.d[28], u.d[29], u.d[30], u.d[31]);
52}
53
54static void hvx_vec_dump_f32(char * pref, HVX_Vector v) {
55    hvx_vec_dump_f32_n(pref, v, 32);
56}
57
58static void hvx_vec_dump_int32(char * pref, HVX_Vector v) {
59    union {
60        HVX_Vector v;
61        int32_t    d[32];
62    } u = { .v = v };
63
64    for (int i = 0; i < 32 / 16; i++) {
65        hex_dump_int32_line(pref, u.d + (16 * i), 16);
66    }
67}
68
69static void hvx_vec_dump_int32_hmt(char * pref, HVX_Vector v) {
70    union {
71        HVX_Vector v;
72        int32_t    d[32];
73    } u = { .v = v };
74
75    FARF(HIGH, "%s: %d %d %d %d ... %d %d %d %d ... %d %d %d %d\n", pref, u.d[0], u.d[1], u.d[2], u.d[3], u.d[12],
76         u.d[13], u.d[14], u.d[15], u.d[28], u.d[29], u.d[30], u.d[31]);
77}
78
79static void hvx_vec_dump_int8_hmt(char * pref, HVX_Vector v) {
80    union {
81        HVX_Vector v;
82        int8_t     d[128];
83    } u = { .v = v };
84
85    FARF(HIGH, "%s: %d %d %d %d ... %d %d %d %d ... %d %d %d %d\n", pref, u.d[0], u.d[1], u.d[2], u.d[3], u.d[60],
86         u.d[61], u.d[62], u.d[63], u.d[124], u.d[125], u.d[126], u.d[127]);
87}
88
89static void hvx_vec_dump_int8(char * pref, HVX_Vector v) {
90    union {
91        HVX_Vector v;
92        int8_t     d[128];
93    } u = { .v = v };
94
95    for (int i = 0; i < 128 / 16; i++) {
96        hex_dump_int8_line(pref, u.d + (16 * i), 16);
97    }
98}
99
100static void hvx_vec_dump_uint8(char * pref, HVX_Vector v) {
101    union {
102        HVX_Vector v;
103        uint8_t    d[128];
104    } u = { .v = v };
105
106    for (int i = 0; i < 128 / 16; i++) {
107        hex_dump_uint8_line(pref, u.d + (16 * i), 16);
108    }
109}
110
111static bool hvx_vec_eq(HVX_Vector v0, HVX_Vector v1, size_t n) {
112    typedef union {
113        HVX_Vector v;
114        int8_t     d[128];
115    } U;
116
117    U u0 = { .v = v0 };
118    U u1 = { .v = v1 };
119
120    for (int i = 0; i < n; i++) {
121        if (u0.d[i] != u1.d[i]) {
122            return false;
123        }
124    }
125
126    return true;
127}
128
129#endif /* HVX_DUMP_H */