test/vector.c 10.7 KiB raw
1
#include <assert.h>
2
#include <string.h>
3
4
#include "vector.h"
5
6
/* Transfer a checked element in test memory. */
7
static bool mem(void *ctx, u64 address, u32 size, bool store, u64 *value) {
8
    u8 *bytes = ctx;
9
    if (address > 4096 || size > 4096 - address)
10
        return false;
11
    if (!store)
12
        *value = 0;
13
    for (u32 j = 0; j < size; j++) {
14
        if (store)
15
            bytes[address + j] = *value >> (j * 8);
16
        else
17
            *value |= (u64)bytes[address + j] << (j * 8);
18
    }
19
    return true;
20
}
21
22
/* Set one little-endian element in a register group. */
23
static void put(struct vector_state *v, u32 r, u32 i, u32 bits, u64 n) {
24
    u8 *p = &v->reg[r][0] + i * (bits / 8);
25
    for (u32 j = 0; j < bits / 8; j++)
26
        p[j] = n >> (8 * j);
27
}
28
29
/* Read one little-endian element in a register group. */
30
static u64 get(struct vector_state *v, u32 r, u32 i, u32 bits) {
31
    u64 n = 0;
32
    u8 *p = &v->reg[r][0] + i * (bits / 8);
33
    for (u32 j = 0; j < bits / 8; j++)
34
        n |= (u64)p[j] << (8 * j);
35
    return n;
36
}
37
38
/* Construct OP-V operands independently of the instruction catalog. */
39
static u32 alu(u32 fn, u32 form, u32 d, u32 a, u32 b, bool mask) {
40
    return fn << 26 | (!mask) << 25 | a << 20 | b << 15 | form << 12 | d << 7 |
41
           0x57;
42
}
43
44
/* Check rotations, masking and tail preservation for each element width. */
45
static void rotations(void) {
46
    for (u32 bits = 8, sew = 0; bits <= 64; bits *= 2, sew++) {
47
        struct vector_state v           = { 0 };
48
        u64                 x[32]       = { 0 };
49
        u8                  bytes[4096] = { 0 };
50
        v.vtype                         = sew << 3;
51
        v.vl                            = 3;
52
        u64 mask = bits == 64 ? ~0ULL : (1ULL << bits) - 1;
53
        u64 a    = 0x81a53c779e0142ffULL & mask;
54
        for (u32 i = 0; i < 4; i++) {
55
            put(&v, 8, i, bits, 0x55);
56
            put(&v, 16, i, bits, a);
57
        }
58
        for (u32 n = 0; n < 64; n++) {
59
            u32 ins = alu(0x14 | (n >> 5), 3, 8, 16, n & 31, false);
60
            assert(vector_execute(&v, x, ins, mem, bytes) == VECTOR_OK);
61
            u32 k        = n & (bits - 1);
62
            u64 expected = k ? ((a >> k) | (a << (bits - k))) & mask : a;
63
            assert(get(&v, 8, 0, bits) == expected);
64
            assert(get(&v, 8, 3, bits) == 0x55);
65
        }
66
        v.reg[0][0] = 5;
67
        put(&v, 8, 1, bits, 0x55);
68
        assert(
69
            vector_execute(&v, x, alu(0, 0, 8, 16, 16, true), mem, bytes) ==
70
            VECTOR_OK
71
        );
72
        assert(get(&v, 8, 0, bits) == ((a + a) & mask));
73
        assert(get(&v, 8, 1, bits) == 0x55);
74
        assert(get(&v, 8, 2, bits) == ((a + a) & mask));
75
    }
76
}
77
78
/* Check memory restart, fault-only-first loads and segmented addressing. */
79
static void memory_cases(void) {
80
    struct vector_state v           = { 0 };
81
    u64                 x[32]       = { 0 };
82
    u8                  bytes[4096] = { 0 };
83
    v.vtype                         = 16;
84
    v.vl                            = 4;
85
    x[10]                           = 4092;
86
    bytes[4092]                     = 17;
87
    u32 load                        = 0x02056407; /* vle32.v v8, (a0) */
88
    assert(vector_execute(&v, x, load, mem, bytes) == VECTOR_FAULT);
89
    assert(v.vstart == 1 && get(&v, 8, 0, 32) == 17);
90
    x[10]    = 0;
91
    bytes[4] = 19;
92
    assert(vector_execute(&v, x, load, mem, bytes) == VECTOR_OK);
93
    assert(v.vstart == 0 && get(&v, 8, 0, 32) == 17 && get(&v, 8, 1, 32) == 19);
94
    x[10] = 4092;
95
    assert(vector_execute(&v, x, load | (16 << 20), mem, bytes) == VECTOR_OK);
96
    assert(v.vl == 1 && v.vstart == 0);
97
    x[10]     = 0;
98
    v.vl      = 2;
99
    bytes[0]  = 1;
100
    bytes[4]  = 2;
101
    bytes[8]  = 3;
102
    bytes[12] = 4;
103
    assert(vector_execute(&v, x, load | (1u << 29), mem, bytes) == VECTOR_OK);
104
    assert(get(&v, 8, 0, 32) == 1 && get(&v, 9, 0, 32) == 2);
105
    assert(get(&v, 8, 1, 32) == 3 && get(&v, 9, 1, 32) == 4);
106
}
107
108
/* Check fixed-point saturation, extension and packed mask reductions. */
109
static void integer_cases(void) {
110
    struct vector_state v           = { 0 };
111
    u64                 x[32]       = { 0 };
112
    u8                  bytes[4096] = { 0 };
113
    v.vl                            = 4;
114
    put(&v, 16, 0, 8, 255);
115
    put(&v, 24, 0, 8, 1);
116
    assert(
117
        vector_execute(&v, x, alu(32, 0, 8, 16, 24, false), mem, bytes) ==
118
        VECTOR_OK
119
    );
120
    assert(get(&v, 8, 0, 8) == 255 && v.vxsat == 1);
121
    put(&v, 16, 0, 8, 127);
122
    put(&v, 24, 0, 8, 1);
123
    assert(
124
        vector_execute(&v, x, alu(33, 0, 8, 16, 24, false), mem, bytes) ==
125
        VECTOR_OK
126
    );
127
    assert(get(&v, 8, 0, 8) == 127);
128
    v.vtype      = 16;
129
    v.reg[31][0] = 0x80;
130
    assert(
131
        vector_execute(&v, x, alu(18, 2, 8, 31, 5, false), mem, bytes) ==
132
        VECTOR_OK
133
    );
134
    assert(get(&v, 8, 0, 32) == 0xffffff80);
135
    v.vtype = 3;
136
    v.vl    = 256;
137
    memset(v.reg[31], 255, VECTOR_BYTES);
138
    assert(
139
        vector_execute(&v, x, alu(16, 2, 10, 31, 16, false), mem, bytes) ==
140
        VECTOR_OK
141
    );
142
    assert(x[10] == 256);
143
    assert(
144
        vector_execute(&v, x, alu(16, 2, 10, 31, 17, false), mem, bytes) ==
145
        VECTOR_OK
146
    );
147
    assert(x[10] == 0);
148
    /* Destination alignment is checked before a register group is written. */
149
    struct vector_state before = v;
150
    assert(
151
        vector_execute(&v, x, alu(0, 0, 31, 16, 24, false), mem, bytes) ==
152
        VECTOR_ILLEGAL
153
    );
154
    assert(memcmp(&before, &v, sizeof(v)) == 0);
155
}
156
157
/* Check each unary Zvbb operation against fixed element results. */
158
static void bit_operations(void) {
159
    struct vector_state v           = { 0 };
160
    u64                 x[32]       = { 0 };
161
    u8                  bytes[4096] = { 0 };
162
    const u32           selectors[] = { 8, 9, 10, 12, 13, 14 };
163
    const u32 expected[] = { 0x808040c0, 0x03020101, 0xc0408080, 7, 0, 5 };
164
    v.vtype              = 16;
165
    v.vl                 = 1;
166
    put(&v, 16, 0, 32, 0x01010203);
167
    for (u32 i = 0; i < 6; i++) {
168
        assert(
169
            vector_execute(
170
                &v, x, alu(18, 2, 8, 16, selectors[i], false), mem, bytes
171
            ) == VECTOR_OK
172
        );
173
        assert(get(&v, 8, 0, 32) == expected[i]);
174
    }
175
    v.vtype = 16;
176
    put(&v, 16, 0, 32, 1);
177
    assert(
178
        vector_execute(&v, x, alu(53, 3, 8, 16, 31, false), mem, bytes) ==
179
        VECTOR_OK
180
    );
181
    assert(get(&v, 8, 0, 64) == 1ULL << 31);
182
}
183
184
/* Mask results and scalar moves occupy one register for every LMUL. */
185
static void mask_registers(void) {
186
    struct vector_state v           = { 0 };
187
    u64                 x[32]       = { 0 };
188
    u8                  bytes[4096] = { 0 };
189
    v.vtype                         = 3;
190
    v.vl                            = 8;
191
    v.reg[31][0]                    = 4;
192
    assert(
193
        vector_execute(&v, x, alu(20, 2, 3, 31, 1, false), mem, bytes) ==
194
        VECTOR_OK
195
    );
196
    assert(v.reg[3][0] == 3);
197
    assert(
198
        vector_execute(&v, x, alu(20, 2, 31, 31, 1, false), mem, bytes) ==
199
        VECTOR_ILLEGAL
200
    );
201
    assert(
202
        vector_execute(&v, x, alu(20, 2, 8, 8, 16, false), mem, bytes) ==
203
        VECTOR_ILLEGAL
204
    );
205
    x[10] = 23;
206
    assert(
207
        vector_execute(&v, x, alu(16, 6, 3, 0, 10, false), mem, bytes) ==
208
        VECTOR_OK
209
    );
210
    assert(v.reg[3][0] == 23);
211
}
212
213
/* Check SIMD register groups, aliases, masks, tails and restart positions. */
214
static void native_lanes(void) {
215
    const u32 lms[] = { 0, 1, 2, 3, 5, 6, 7 };
216
    for (u32 w = 0; w < 4; w++) {
217
        u32 bits = 8u << w;
218
        u64 mask = bits == 64 ? ~0ULL : (1ULL << bits) - 1;
219
        for (u32 lm = 0; lm < sizeof(lms) / sizeof(lms[0]); lm++) {
220
            u32 bytes = lms[lm] < 4 ? VECTOR_BYTES << lms[lm]
221
                                    : VECTOR_BYTES >> (8 - lms[lm]);
222
            u32 max   = bytes * 8 / bits;
223
            if (!max)
224
                continue;
225
            for (u32 k = 0; k < 4; k++)
226
                for (u32 mode = 0; mode < 8; mode++) {
227
                    struct vector_state v     = { 0 };
228
                    u64                 x[32] = { 0 };
229
                    for (u32 j = 0; j < sizeof(v.reg); j++)
230
                        ((u8 *)v.reg)[j] = j * 37 + 129;
231
                    v.vtype     = w * 8 + lms[lm];
232
                    v.vl        = mode & 1 ? max : max - 1;
233
                    v.vstart    = mode & 2 ? max / 3 : 0;
234
                    bool masked = mode & 4;
235
                    u32  d      = mode & 1 ? 24 : 8;
236
                    u32  ops[]  = {
237
                         alu(0, 0, d, 24, 16, masked),
238
                         alu(37, 2, d, 24, 16, masked),
239
                         alu(20, 4, d, 24, 10, masked),
240
                         alu(18, 2, d, 24, 14, masked),
241
                    };
242
                    x[10]                    = bits - 1;
243
                    struct vector_state want = v;
244
                    for (u32 i = v.vstart; i < v.vl; i++) {
245
                        if (masked && !((v.reg[0][i / 8] >> (i % 8)) & 1))
246
                            continue;
247
                        u64 a = get(&v, 24, i, bits);
248
                        u64 b = get(&v, 16, i, bits);
249
                        u64 z = k == 0   ? a + b
250
                                : k == 1 ? a * b
251
                                : k == 2 ? (a >> (bits - 1)) | (a << 1)
252
                                         : (u64)__builtin_popcountll(a);
253
                        put(&want, d, i, bits, z & mask);
254
                    }
255
                    want.vstart = 0;
256
                    assert(
257
                        vector_execute(&v, x, ops[k], mem, NULL) == VECTOR_OK
258
                    );
259
                    assert(memcmp(&v, &want, sizeof(v)) == 0);
260
                }
261
        }
262
    }
263
}
264
265
/* Exercise integer vector execution without host image loading. */
266
int main(void) {
267
    native_lanes();
268
    mask_registers();
269
    bit_operations();
270
    rotations();
271
    memory_cases();
272
    integer_cases();
273
    struct vector_state shift    = { 0 };
274
    u64                 sx[32]   = { 0 };
275
    u8                  sm[4096] = { 0 };
276
    shift.vtype                  = 24;
277
    shift.vl                     = 1;
278
    put(&shift, 16, 0, 64, 1);
279
    assert(
280
        vector_execute(&shift, sx, alu(37, 3, 8, 16, 31, false), mem, sm) ==
281
        VECTOR_OK
282
    );
283
    assert(get(&shift, 8, 0, 64) == 1ULL << 31);
284
    struct vector_state v           = { 0 };
285
    u64                 x[32]       = { 0 };
286
    u8                  bytes[4096] = { 0 };
287
    assert(vector_execute(&v, x, 0xc1027557, mem, bytes) == VECTOR_OK);
288
    assert(v.vl == 4 && v.vtype == 16 && x[10] == 4);
289
    for (int i = 0; i < 4; i++) {
290
        v.reg[9][i * 4]  = i + 1;
291
        v.reg[10][i * 4] = 10;
292
    }
293
    assert(vector_execute(&v, x, 0x02950457, mem, bytes) == VECTOR_OK);
294
    for (int i = 0; i < 4; i++)
295
        assert(v.reg[8][i * 4] == i + 11);
296
    assert(vector_execute(&v, x, 0x52943457, mem, bytes) == VECTOR_OK);
297
    assert(v.reg[8][0] == 0 && v.reg[8][3] == 1);
298
    return 0;
299
}