![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to accel_avx2.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Isaki's NoNo m68k/m88k emulator] / nono / vm|
Return to accel_avx2.cpp CVS log | Up to [Isaki's NoNo m68k/m88k emulator] / nono / vm |
1.1 root 1: //
2: // nono
3: // Copyright (C) 2024 nono project
4: // Licensed under nono-license.txt
5: //
6:
7: //
8: // AVX2
9: //
10:
11: #include "accel_avx2.h"
12: #include "planevram.h"
13: #include "renderer.h"
14: #include "videoctlr.h"
15: #include <x86intrin.h>
16:
17: // ホスト CPU、OS が AVX2 をサポートしていれば true を返す。
18: bool
19: DetectAVX2()
20: {
21: uint32 ebx;
22: uint32 ecx;
23: uint32 edx;
24:
25: // CPUID(eax=0x07, ecx=0) で ebx の bit5 が立っていれば、
26: // CPU は AVX2 をサポートしている。
27: __asm__ __volatile__(
28: "cpuid"
29: : // output
30: "=b" (ebx),
31: "=c" (ecx),
32: "=d" (edx)
33: : // input
34: "a" (0x7),
35: "c" (0x0)
36: );
37: bool has_avx2 = ebx & (1U << 5);
38:
39: // CPUID(eax=0x01) で ecx の bit27 (OSXSAVE) が立っていれば、
40: // OS が XSAVE を有効にしている。
41: __asm__ __volatile__(
42: "cpuid"
43: : // output
44: "=b" (ebx),
45: "=c" (ecx),
46: "=d" (edx)
47: : // input
48: "a" (0x1)
49: );
50: bool has_osxsave = ecx & (1U << 27);
51:
52: if (has_avx2 && has_osxsave) {
53: // XSAVE で保存するレジスタセットは XGETBV(0) で読み出せる
54: // XCR0 レジスタに入っていて、
55: // これの bit1 が SSE(XMM?)、bit2 が AVX(YMM?) のようだ。
56: uint32 xcr0;
57: __asm__ __volatile__(
58: "xgetbv"
59: : // output
60: "=a" (xcr0)
61: : // input
62: "c" (0)
63: : // used
64: "edx"
65: );
66: if ((xcr0 & 6) == 6) {
67: return true;
68: }
69: }
70:
71: return false;
72: }
73:
74: // I8 から RGBX への変換。
75: void
76: PlaneVRAMDevice::RenderI8toRGBX_avx2(BitmapRGBX& dst, const BitmapI8& view,
77: const std::vector<uint8>& view_mod)
78: {
79: for (int y = 0; y < view_mod.size(); y++) {
80: if (view_mod[y] == 0) {
81: continue;
82: }
83:
84: const uint8 *s8 = view.GetRowPtr(y);
85: uint32 *d = (uint32 *)dst.GetRowPtr(y);
86:
87: const uint32 *s = (const uint32 *)s8;
88: const uint32 *send = (const uint32 *)(s8 + view.GetWidth());
89: for (; s < send;) {
90: // 8ピクセルずつ処理する
91:
92: // s は BitmapI8 なのでビッグエンディアン並びに相当。
93: // idx0 = $00000000'00000000'I7I6I5I4'I3I2I1I0
94: __m128i idx0 = _mm_loadl_epi64((const __m128i *)s);
95: s += 2;
96:
97: // idx = $000000I7'000000I6'000000I5'000000I4'
98: // 000000I3'000000I2'000000I1'000000I0
99: __m256i idx = _mm256_cvtepu8_epi32(idx0);
100:
101: // 8個の 32bit インデックスから XBGR を取得
102: // c = $00B7G7R7'00B6G6R6'00B5G5R5'00B4G4R4'
103: // 00B3G3R3'00B2G2R2'00B1G1R1'00B0G0R0
104: __m256i c = _mm256_i32gather_epi32(
105: (const int *)palette, idx, 4);
106:
107: _mm256_storeu_si256((__m256i *)d, c);
108: d += 8;
109: }
110: }
111: }
112:
113: // RGBX から RGB への変換。
114: /*static*/ void
115: Renderer::RGBXtoRGB_avx2(BitmapRGB& dst, const BitmapRGBX& src)
116: {
117: for (int y = 0, yend = src.GetHeight(); y < yend; y++) {
118: const uint32 *s = (const uint32 *)src.GetRowPtr(y);
119: uint32 *d = (uint32 *)dst.GetRowPtr(y);
120:
121: const uint32 *send = s + src.GetWidth();
122: for (; s < send; ) {
123: // 8ピクセルずつ処理する
124:
125: // c = $x7B7G7R7'x6B6G6R6'x5B5G5R5'x4B4G4R4'
126: // x3B3G3R3'x2B2G2R2'x1B1G1R1'x0B0G0R0
127: __m256i c = _mm256_loadu_si256((const __m256i *)s);
128: s += 8;
129:
130: // 256bit リニアに使えれば下詰めで済んだんだが、
131: // 上位 128bit と下位 128bit をまたいでシャッフルは
132: // 出来なくて、かつこの後のストアは連続領域への
133: // 書き込みになるので、中央でつなげておく。うーん。
134: // c = $00000000'B7G7R7B6'G6R6B5G5'R5B4G4R4'
135: // B3G3R3B2'G2R2B1G1'R1B0G0R0'00000000
136: __m256i shuff = _mm256_set_epi8(
137: -1,-1,-1,-1, 14,13,12,10, 9, 8, 6, 5, 4, 2, 1, 0,
138: 14,13,12,10, 9, 8, 6, 5, 4, 2, 1, 0, -1,-1,-1,-1
139: );
140: __m256i res = _mm256_shuffle_epi8(c, shuff);
141:
142: // 先頭(下位)と末尾(上位)の 32bit ずつを除いたところを
143: // 書き出す。
144: __m256i mask = _mm256_set_epi32(
145: 0, -1, -1, -1, -1, -1, -1, 0
146: );
147: _mm256_maskstore_epi32((int *)(d - 1), mask, res);
148: d += 6;
149: }
150: }
151: }
152:
153: // コントラスト (0-254) を適用。
154: /*static*/ void
155: VideoCtlrDevice::RenderContrast_avx2(BitmapRGBX& dst, const BitmapRGBX& src,
156: uint32 contrast)
157: {
158: #define USE_NEW
159:
160: #if defined(USE_NEW)
161: // 8ビットのまま、筆算の掛け算と固定小数点の要領で、
162: // ビットが立っている桁だけ右シフトしたものを足していく。
163: // 例えば $b7(%1011'0111) を %1001'0000/256 (= 0.562) 倍する場合、
164: // 除数の
165: // b7=%1 なので $b7 >> 1 = %0101'1011
166: // b4=%1 なので $b7 >> 4 = %0000'1011
167: // : +
168: // ----------
169: // 結果は %0110'0110 (= $66)
170: //
171: // 立っているビット数が増えると演算回数で不利になるので、5 ビット
172: // 以上立っている場合は被除数を反転して計算して元の値から引く。
173: int n = contrast == 0 ? 0 : __builtin_popcount(contrast);
174: bool use_sub;
175: if (n <= 4) {
176: use_sub = false;
177: } else {
178: contrast = (uint32)-contrast;
179: use_sub = true;
180: }
181: std::array<int, 4> shift_count;
182: __m256i shift_mask[4];
183: n = 0;
184: for (int i = 0; i < 8; i++) {
185: if ((contrast & (0x80 >> i)) != 0) {
186: shift_count[n] = i + 1;
187: shift_mask[n] = _mm256_set1_epi8(0xffU >> shift_count[n]);
188: n++;
189: }
190: }
191: #else
192: const __m256i vcontrast = _mm256_set1_epi16(contrast);
193: const __m256i idxh = _mm256_set_epi32(-1, -1, -1, -1, 7, 6, 3, 2);
194: const __m256i idxl = _mm256_set_epi32(-1, -1, -1, -1, 5, 4, 1, 0);
195: #endif
196:
197: for (int y = 0, yend = src.GetHeight(); y < yend; y++) {
198: const uint32 *s = (const uint32 *)src.GetRowPtr(y);
199: uint32 *d = (uint32 *)dst.GetRowPtr(y);
200:
201: const uint32 *send = s + src.GetWidth();
202: for (; s < send; ) {
203: // 8ピクセルずつ処理する
204:
205: __m256i a = _mm256_loadu_si256((const __m256i *)s);
206: s += 8;
207: #if defined(USE_NEW)
208: // 144 usec
209:
210: __m256i r;
211: if (__predict_false(n == 0)) {
212: r = _mm256_setzero_si256();
213: } else {
214: // AVX には 8 ビットのシフト演算がないので、16 ビット
215: // 単位で右シフトして、右にはみ出た分をマスクする…。
216: auto b0 = _mm256_srli_epi16(a, shift_count[0]);
217: r = _mm256_and_si256(b0, shift_mask[0]);
218:
219: if (n >= 2) {
220: auto b1 = _mm256_srli_epi16(a, shift_count[1]);
221: auto c1 = _mm256_and_si256(b1, shift_mask[1]);
222: r = _mm256_add_epi8(r, c1);
223:
224: if (n >= 3) {
225: auto b2 = _mm256_srli_epi16(a, shift_count[2]);
226: auto c2 = _mm256_and_si256(b2, shift_mask[2]);
227: r = _mm256_add_epi8(r, c2);
228:
229: if (n >= 4) {
230: auto b3 = _mm256_srli_epi16(a, shift_count[3]);
231: auto c3 = _mm256_and_si256(b3, shift_mask[3]);
232: r = _mm256_add_epi8(r, c3);
233: }
234: }
235: }
236: }
237: if (use_sub) {
238: r = _mm256_sub_epi8(a, r);
239: }
240: #else
241: // 146 usec
242:
243: // a = $x7B7G7R7'x6B6G6R6'x5B5G5R5'x4B4G4R4'
244: // x3B3G3R3'x2B2G2R2'x1B1G1R1'x0B0G0R0
245:
246: // 上位 128bit を下位 128bit に持っていく必要がどうせあるし、
247: // 最後に packus 一発で元に戻せる位置に permute する。
248: // ah = $...'x7B7G7R7'x6B6G6R6'x3B3G3R3'x2B2G2R2
249: // al = $...'x5B5G5R5'x4B4G4R4'x1B1G1R1'x0B0G0R0
250: __m256i ah = _mm256_permutevar8x32_epi32(a, idxh);
251: __m256i al = _mm256_permutevar8x32_epi32(a, idxl);
252:
253: // bh = $00x700B7'00G700R7'00x600B6'00G600R6'
254: // 00x300B3'00G300R3'00x200B2'00G200R2
255: // bl = $00x500B5'00G500R5'00x400B4'00G400R4'
256: // 00x100B1'00G100R1'00x000B0'00G000R0
257: __m256i bh = _mm256_cvtepu8_epi16(_mm256_castsi256_si128(ah));
258: __m256i bl = _mm256_cvtepu8_epi16(_mm256_castsi256_si128(al));
259:
260: __m256i ch = _mm256_mullo_epi16(bh, vcontrast);
261: __m256i cl = _mm256_mullo_epi16(bl, vcontrast);
262:
263: __m256i sh = _mm256_srli_epi16(ch, 8);
264: __m256i sl = _mm256_srli_epi16(cl, 8);
265:
266: // r = $x7B7G7R7'x6B6G6R6'x5B5G5R5'x4B4G4R4'
267: // x3B3G3R3'x2B2G2R2'x1B1G1R1'x0B0G0R0
268: __m256i r = _mm256_packus_epi16(sl, sh);
269: #endif
270: _mm256_storeu_si256((__m256i *)d, r);
271: d += 8;
272: }
273: }
274: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.