4 swizzle needs a MV. see below for a potential way to use the funct7 to do a swizzle in rs2.
6 +---------------+-------------+-------+----------+----------+--------+----------+--------+--------+
7 | Encoding | 31:27 | 26:25 | 24:20 | 19:15 | 14:12 | 11:7 | 6:2 | 1:0 |
8 +---------------+-------------+-------+----------+----------+--------+----------+--------+--------+
9 | RV32-I-type + imm[11:0] + rs1[4:0] + funct3 | rd[4:0] + opcode + 0b11 |
10 +---------------+-------------+-------+----------+----------+--------+----------+--------+--------+
11 | RV32-I-type + fn4[3:0] + swizzle[7:0] + rs1[4:0] + 0b000 | rd[4:0] + OP-V + 0b11 |
12 +---------------+-------------+-------+----------+----------+--------+----------+--------+--------+
14 * funct3 = MV: 0b000 for FP, 0b001 for INT
16 * fn4 = 4 bit function.
17 * fn4 = 0b0000 - MV-SWIZZLE
18 * fn4 = 0bNN01 - MV-X, NN=elwidth (default/8/16/32)
19 * fn4 = 0bNN11 - MV-X.SUBVL NN=elwidth (default/8/16/32)
21 swizzle (only active on SV or P48/P64 when SUBVL!=0):
23 +-----+-----+-----+-----+
24 | 7:6 | 5:4 | 3:2 | 1:0 |
25 +-----+-----+-----+-----+
27 +-----+-----+-----+-----+
29 MV.X has two modes: SUBVL mode applies the element offsets only within a SUBVL inner loop. This can be used for transposition.
34 for j in range(SUBVL):
35 regs[rd] = regs[rd+regs[rs+j]]
37 Normal mode will apply the element offsets incrementally:
42 for j in range(SUBVL):
43 regs[rd] = regs[rd+regs[rs+k]]
47 Pseudocode for element width part of MV.X:
51 def mv_x(rd, rs1, funct4):
52 elwidth = (funct4>>2) & 0x3
53 bitwidth = {0:XLEN, 1:8, 2:16, 3:32}[elwidth] # get bits per el
54 bytewidth = bitwidth / 8 # get bytes per el
56 addr = (unsigned char *)®s[rs1]
57 offset = addr + bytewidth # get offset within regfile as SRAM
58 # TODO, actually, needs to respect rd and rs1 element width,
59 # here, as well. this pseudocode just illustrates that the
60 # MV.X operation contains a way to compact the indices into
62 regs[rd] = (unsigned char*)(regs)[offset]
64 The idea here is to allow 8-bit indices to be stored inside XLEN-sized
65 registers, such that rather than doing this:
72 {SVP.VL=4} MV.X x3, x8, elwidth=default
74 The alternative is this:
78 {SVP.VL=4} MV.X x3, x8, elwidth=8
80 Thus compacting four indices into the one register. x3 and x8's element
81 width are *independent* of the MV.X elwidth, thus allowing both source
82 and element element widths of the *elements* to be moved to be over-ridden,
83 whilst *at the same time* allowing the *indices* to be compacted, as well.
87 potential MV.X? register-version of MV-swizzle?
89 +-------------+-------+-------+----------+----------+--------+----------+--------+--------+
90 | Encoding | 31:27 | 26:25 | 24:20 | 19:15 | 14:12 | 11:7 | 6:2 | 1:0 |
91 +-------------+-------+-------+----------+----------+--------+----------+--------+--------+
92 | RV32-R-type + funct7 + rs2[4:0] + rs1[4:0] + funct3 | rd[4:0] + opcode + 0b11 |
93 +-------------+-------+-------+----------+----------+--------+----------+--------+--------+
94 | RV32-R-type + 0b0000000 + rs2[4:0] + rs1[4:0] + 0b001 | rd[4:0] + OP-V + 0b11 |
95 +-------------+-------+-------+----------+----------+--------+----------+--------+--------+
99 * funct7 = 0b000NN00 - INT MV.X, elwidth=NN (default/8/16/32)
100 * funct7 = 0b000NN10 - FP MV.X, elwidth=NN (default/8/16/32)
101 * funct7 = 0b0000001 - INT MV.swizzle to say that rs2 is a swizzle argument?
102 * funct7 = 0b0000011 - FP MV.swizzle to say that rs2 is a swizzle argument?
104 question: do we need a swizzle MV.X as well?
109 there is the potential for macro-op fusion of mv-swizzle with the following instruction and/or preceding instruction.
110 <http://lists.libre-riscv.org/pipermail/libre-riscv-dev/2019-August/002486.html>
115 additional idea: a VBLOCK context that says that if a given register is used, it indicates that the
116 register is to be "swizzled", and the VBLOCK swizzle context contains the swizzling to be carried out.
121 __m128 _mm_shuffle_ps(__m128 lo,__m128 hi,
122 _MM_SHUFFLE(hi3,hi2,lo1,lo0))
123 Interleave inputs into low 2 floats and high 2 floats of output. Basically
129 For example, _mm_shuffle_ps(a,a,_MM_SHUFFLE(i,i,i,i)) copies the float
130 a[i] into all 4 output floats.
135 assuming a vector of 4x4 matrixes is stored as 4 separate vectors with subvl=4 in struct-of-array-of-struct form (the form I've been planning on using):
136 using standard (4+4) -> 4 swizzle instructions with 2 input vectors with subvl=4 and 1 output vector with subvl, a vectorized matrix transpose operation can be done in 2 steps with 4 instructions per step to give 8 instructions in total:
144 transpose 4 corner 2x2 matrices