From a6daac4ce684dc77a3a2a9e9c016cc52f6a22926 Mon Sep 17 00:00:00 2001 From: Leo Vasanko Date: Sat, 28 Oct 2023 15:23:30 +0000 Subject: [PATCH] Arrayized the variables, no change in performance but a lot less code. --- src/u8-stream.h | 382 +++++++++++++++++++++++------------------------- 1 file changed, 181 insertions(+), 201 deletions(-) diff --git a/src/u8-stream.h b/src/u8-stream.h index e1dc73f..5edf085 100644 --- a/src/u8-stream.h +++ b/src/u8-stream.h @@ -1,38 +1,39 @@ -#define VEC8_ROT(A, IMM) \ +#define VEC8_ROT(A, IMM) \ _mm256_or_si256(_mm256_slli_epi32(A, IMM), _mm256_srli_epi32(A, (32 - IMM))) /* same, but replace 2 of the shift/shift/or "rotation" by byte shuffles (8 & * 16) (better) */ -#define VEC8_QUARTERROUND(A, B, C, D) \ - x_##A = _mm256_add_epi32(x_##A, x_##B); \ - t_##A = _mm256_xor_si256(x_##D, x_##A); \ - x_##D = _mm256_shuffle_epi8(t_##A, rot16); \ - x_##C = _mm256_add_epi32(x_##C, x_##D); \ - t_##C = _mm256_xor_si256(x_##B, x_##C); \ - x_##B = VEC8_ROT(t_##C, 12); \ - x_##A = _mm256_add_epi32(x_##A, x_##B); \ - t_##A = _mm256_xor_si256(x_##D, x_##A); \ - x_##D = _mm256_shuffle_epi8(t_##A, rot8); \ - x_##C = _mm256_add_epi32(x_##C, x_##D); \ - t_##C = _mm256_xor_si256(x_##B, x_##C); \ - x_##B = VEC8_ROT(t_##C, 7) +#define VEC8_QUARTERROUND(A, B, C, D) \ + x[A] = _mm256_add_epi32(x[A], x[B]); \ + t[A] = _mm256_xor_si256(x[D], x[A]); \ + x[D] = _mm256_shuffle_epi8(t[A], rot16); \ + x[C] = _mm256_add_epi32(x[C], x[D]); \ + t[C] = _mm256_xor_si256(x[B], x[C]); \ + x[B] = VEC8_ROT(t[C], 12); \ + x[A] = _mm256_add_epi32(x[A], x[B]); \ + t[A] = _mm256_xor_si256(x[D], x[A]); \ + x[D] = _mm256_shuffle_epi8(t[A], rot8); \ + x[C] = _mm256_add_epi32(x[C], x[D]); \ + t[C] = _mm256_xor_si256(x[B], x[C]); \ + x[B] = VEC8_ROT(t[C], 7) -#define VEC8_LINE1(A, B, C, D) \ - x_##A = _mm256_add_epi32(x_##A, x_##B); \ - x_##D = _mm256_shuffle_epi8(_mm256_xor_si256(x_##D, x_##A), rot16) -#define VEC8_LINE2(A, B, C, D) \ - x_##C = _mm256_add_epi32(x_##C, x_##D); \ - x_##B = VEC8_ROT(_mm256_xor_si256(x_##B, x_##C), 12) -#define VEC8_LINE3(A, B, C, D) \ - x_##A = _mm256_add_epi32(x_##A, x_##B); \ - x_##D = _mm256_shuffle_epi8(_mm256_xor_si256(x_##D, x_##A), rot8) -#define VEC8_LINE4(A, B, C, D) \ - x_##C = _mm256_add_epi32(x_##C, x_##D); \ - x_##B = VEC8_ROT(_mm256_xor_si256(x_##B, x_##C), 7) +#define VEC8_LINE1(A, B, C, D) \ + x[A] = _mm256_add_epi32(x[A], x[B]); \ + x[D] = _mm256_shuffle_epi8(_mm256_xor_si256(x[D], x[A]), rot16) +#define VEC8_LINE2(A, B, C, D) \ + x[C] = _mm256_add_epi32(x[C], x[D]); \ + x[B] = VEC8_ROT(_mm256_xor_si256(x[B], x[C]), 12) +#define VEC8_LINE3(A, B, C, D) \ + x[A] = _mm256_add_epi32(x[A], x[B]); \ + x[D] = _mm256_shuffle_epi8(_mm256_xor_si256(x[D], x[A]), rot8) +#define VEC8_LINE4(A, B, C, D) \ + x[C] = _mm256_add_epi32(x[C], x[D]); \ + x[B] = VEC8_ROT(_mm256_xor_si256(x[B], x[C]), 7) -#define VEC8_ROUND_SEQ(A1, B1, C1, D1, A2, B2, C2, D2, A3, B3, C3, D3, A4, B4, \ - C4, D4) \ +#define VEC8_ROUND_SEQ( \ + A1, B1, C1, D1, A2, B2, C2, D2, A3, B3, C3, D3, A4, B4, C4, D4 \ +) \ VEC8_LINE1(A1, B1, C1, D1); \ VEC8_LINE1(A2, B2, C2, D2); \ VEC8_LINE1(A3, B3, C3, D3); \ @@ -50,27 +51,29 @@ VEC8_LINE4(A3, B3, C3, D3); \ VEC8_LINE4(A4, B4, C4, D4) -#define VEC8_ROUND_HALF(A1, B1, C1, D1, A2, B2, C2, D2, A3, B3, C3, D3, A4, \ - B4, C4, D4) \ - VEC8_LINE1(A1, B1, C1, D1); \ - VEC8_LINE1(A2, B2, C2, D2); \ - VEC8_LINE2(A1, B1, C1, D1); \ - VEC8_LINE2(A2, B2, C2, D2); \ - VEC8_LINE3(A1, B1, C1, D1); \ - VEC8_LINE3(A2, B2, C2, D2); \ - VEC8_LINE4(A1, B1, C1, D1); \ - VEC8_LINE4(A2, B2, C2, D2); \ - VEC8_LINE1(A3, B3, C3, D3); \ - VEC8_LINE1(A4, B4, C4, D4); \ - VEC8_LINE2(A3, B3, C3, D3); \ - VEC8_LINE2(A4, B4, C4, D4); \ - VEC8_LINE3(A3, B3, C3, D3); \ - VEC8_LINE3(A4, B4, C4, D4); \ - VEC8_LINE4(A3, B3, C3, D3); \ +#define VEC8_ROUND_HALF( \ + A1, B1, C1, D1, A2, B2, C2, D2, A3, B3, C3, D3, A4, B4, C4, D4 \ +) \ + VEC8_LINE1(A1, B1, C1, D1); \ + VEC8_LINE1(A2, B2, C2, D2); \ + VEC8_LINE2(A1, B1, C1, D1); \ + VEC8_LINE2(A2, B2, C2, D2); \ + VEC8_LINE3(A1, B1, C1, D1); \ + VEC8_LINE3(A2, B2, C2, D2); \ + VEC8_LINE4(A1, B1, C1, D1); \ + VEC8_LINE4(A2, B2, C2, D2); \ + VEC8_LINE1(A3, B3, C3, D3); \ + VEC8_LINE1(A4, B4, C4, D4); \ + VEC8_LINE2(A3, B3, C3, D3); \ + VEC8_LINE2(A4, B4, C4, D4); \ + VEC8_LINE3(A3, B3, C3, D3); \ + VEC8_LINE3(A4, B4, C4, D4); \ + VEC8_LINE4(A3, B3, C3, D3); \ VEC8_LINE4(A4, B4, C4, D4) -#define VEC8_ROUND_HALFANDHALF(A1, B1, C1, D1, A2, B2, C2, D2, A3, B3, C3, D3, \ - A4, B4, C4, D4) \ +#define VEC8_ROUND_HALFANDHALF( \ + A1, B1, C1, D1, A2, B2, C2, D2, A3, B3, C3, D3, A4, B4, C4, D4 \ +) \ VEC8_LINE1(A1, B1, C1, D1); \ VEC8_LINE1(A2, B2, C2, D2); \ VEC8_LINE2(A1, B1, C1, D1); \ @@ -88,175 +91,152 @@ VEC8_LINE4(A3, B3, C3, D3); \ VEC8_LINE4(A4, B4, C4, D4) -#define VEC8_ROUND(A1, B1, C1, D1, A2, B2, C2, D2, A3, B3, C3, D3, A4, B4, C4, \ - D4) \ - VEC8_ROUND_SEQ(A1, B1, C1, D1, A2, B2, C2, D2, A3, B3, C3, D3, A4, B4, C4, \ - D4) +#define VEC8_ROUND( \ + A1, B1, C1, D1, A2, B2, C2, D2, A3, B3, C3, D3, A4, B4, C4, D4 \ +) \ + VEC8_ROUND_SEQ( \ + A1, B1, C1, D1, A2, B2, C2, D2, A3, B3, C3, D3, A4, B4, C4, D4 \ + ) -if (bytes >= 512) -{ - /* constant for shuffling bytes (replacing multiple-of-8 rotates) */ - __m256i rot16 = - _mm256_set_epi8(13, 12, 15, 14, 9, 8, 11, 10, 5, 4, 7, 6, 1, 0, 3, 2, - 13, 12, 15, 14, 9, 8, 11, 10, 5, 4, 7, 6, 1, 0, 3, 2); - __m256i rot8 = - _mm256_set_epi8(14, 13, 12, 15, 10, 9, 8, 11, 6, 5, 4, 7, 2, 1, 0, 3, - 14, 13, 12, 15, 10, 9, 8, 11, 6, 5, 4, 7, 2, 1, 0, 3); - - /* the naive way seems as fast (if not a bit faster) than the vector way */ - __m256i x_0 = _mm256_set1_epi32(x[0]); - __m256i x_1 = _mm256_set1_epi32(x[1]); - __m256i x_2 = _mm256_set1_epi32(x[2]); - __m256i x_3 = _mm256_set1_epi32(x[3]); - __m256i x_4 = _mm256_set1_epi32(x[4]); - __m256i x_5 = _mm256_set1_epi32(x[5]); - __m256i x_6 = _mm256_set1_epi32(x[6]); - __m256i x_7 = _mm256_set1_epi32(x[7]); - __m256i x_8 = _mm256_set1_epi32(x[8]); - __m256i x_9 = _mm256_set1_epi32(x[9]); - __m256i x_10 = _mm256_set1_epi32(x[10]); - __m256i x_11 = _mm256_set1_epi32(x[11]); - __m256i x_12; - __m256i x_13; - __m256i x_14 = _mm256_set1_epi32(x[14]); - __m256i x_15 = _mm256_set1_epi32(x[15]); - - __m256i orig0 = x_0; - __m256i orig1 = x_1; - __m256i orig2 = x_2; - __m256i orig3 = x_3; - __m256i orig4 = x_4; - __m256i orig5 = x_5; - __m256i orig6 = x_6; - __m256i orig7 = x_7; - __m256i orig8 = x_8; - __m256i orig9 = x_9; - __m256i orig10 = x_10; - __m256i orig11 = x_11; - __m256i orig12; - __m256i orig13; - __m256i orig14 = x_14; - __m256i orig15 = x_15; - __m256i t_0, t_1, t_2, t_3, t_4, t_5, t_6, t_7, t_8, t_9, t_10, t_11, t_12, - t_13, t_14, t_15; - const __m256i addv12 = _mm256_set_epi64x(3, 2, 1, 0); - const __m256i addv13 = _mm256_set_epi64x(7, 6, 5, 4); - - while (bytes >= 512) - { - __m256i t12, t13; - - x_0 = orig0; - x_1 = orig1; - x_2 = orig2; - x_3 = orig3; - x_4 = orig4; - x_5 = orig5; - x_6 = orig6; - x_7 = orig7; - x_8 = orig8; - x_9 = orig9; - x_10 = orig10; - x_11 = orig11; - x_14 = orig14; - x_15 = orig15; - - // Calculate the eight parallel counters on x_12 and x_13 - uint64_t *counter = (uint64_t *)(x + 12); - t13 = _mm256_broadcastq_epi64(_mm_cvtsi64_si128(*counter)); - t12 = _mm256_add_epi64(addv12, t13); - t13 = _mm256_add_epi64(addv13, t13); - x_12 = _mm256_unpacklo_epi32(t12, t13); - x_13 = _mm256_unpackhi_epi32(t12, t13); - t12 = _mm256_unpacklo_epi32(x_12, x_13); - t13 = _mm256_unpackhi_epi32(x_12, x_13); - - /* required because unpack* are intra-lane */ - const __m256i permute = _mm256_set_epi32(7, 6, 3, 2, 5, 4, 1, 0); - x_12 = _mm256_permutevar8x32_epi32(t12, permute); - x_13 = _mm256_permutevar8x32_epi32(t13, permute); - - orig12 = x_12; - orig13 = x_13; - - for (int i = 0; i < 10; ++i) - { - VEC8_ROUND(0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15); - VEC8_ROUND(0, 5, 10, 15, 1, 6, 11, 12, 2, 7, 8, 13, 3, 4, 9, 14); - } - -#define ONEQUAD_TRANSPOSE(A, B, C, D) \ - { \ - __m128i t0, t1, t2, t3; \ - x_##A = _mm256_add_epi32(x_##A, orig##A); \ - x_##B = _mm256_add_epi32(x_##B, orig##B); \ - x_##C = _mm256_add_epi32(x_##C, orig##C); \ - x_##D = _mm256_add_epi32(x_##D, orig##D); \ - t_##A = _mm256_unpacklo_epi32(x_##A, x_##B); \ - t_##B = _mm256_unpacklo_epi32(x_##C, x_##D); \ - t_##C = _mm256_unpackhi_epi32(x_##A, x_##B); \ - t_##D = _mm256_unpackhi_epi32(x_##C, x_##D); \ - x_##A = _mm256_unpacklo_epi64(t_##A, t_##B); \ - x_##B = _mm256_unpackhi_epi64(t_##A, t_##B); \ - x_##C = _mm256_unpacklo_epi64(t_##C, t_##D); \ - x_##D = _mm256_unpackhi_epi64(t_##C, t_##D); \ - _mm_storeu_si128((__m128i *)(c + 0), _mm256_extracti128_si256(x_##A, 0)); \ - _mm_storeu_si128((__m128i *)(c + 64), _mm256_extracti128_si256(x_##B, 0)); \ - _mm_storeu_si128((__m128i *)(c + 128), _mm256_extracti128_si256(x_##C, 0)); \ - _mm_storeu_si128((__m128i *)(c + 192), _mm256_extracti128_si256(x_##D, 0)); \ - _mm_storeu_si128((__m128i *)(c + 256), _mm256_extracti128_si256(x_##A, 1)); \ - _mm_storeu_si128((__m128i *)(c + 320), _mm256_extracti128_si256(x_##B, 1)); \ - _mm_storeu_si128((__m128i *)(c + 384), _mm256_extracti128_si256(x_##C, 1)); \ - _mm_storeu_si128((__m128i *)(c + 448), _mm256_extracti128_si256(x_##D, 1)); \ +#define ONEQUAD_TRANSPOSE(A, B, C, D) \ + { \ + __m128i t0, t1, t2, t3; \ + x[A] = _mm256_add_epi32(x[A], orig[A]); \ + x[B] = _mm256_add_epi32(x[B], orig[B]); \ + x[C] = _mm256_add_epi32(x[C], orig[C]); \ + x[D] = _mm256_add_epi32(x[D], orig[D]); \ + t[A] = _mm256_unpacklo_epi32(x[A], x[B]); \ + t[B] = _mm256_unpacklo_epi32(x[C], x[D]); \ + t[C] = _mm256_unpackhi_epi32(x[A], x[B]); \ + t[D] = _mm256_unpackhi_epi32(x[C], x[D]); \ + x[A] = _mm256_unpacklo_epi64(t[A], t[B]); \ + x[B] = _mm256_unpackhi_epi64(t[A], t[B]); \ + x[C] = _mm256_unpacklo_epi64(t[C], t[D]); \ + x[D] = _mm256_unpackhi_epi64(t[C], t[D]); \ + _mm_storeu_si128( \ + (__m128i*)(c + 0), _mm256_extracti128_si256(x[A], 0) \ + ); \ + _mm_storeu_si128( \ + (__m128i*)(c + 64), _mm256_extracti128_si256(x[B], 0) \ + ); \ + _mm_storeu_si128( \ + (__m128i*)(c + 128), _mm256_extracti128_si256(x[C], 0) \ + ); \ + _mm_storeu_si128( \ + (__m128i*)(c + 192), _mm256_extracti128_si256(x[D], 0) \ + ); \ + _mm_storeu_si128( \ + (__m128i*)(c + 256), _mm256_extracti128_si256(x[A], 1) \ + ); \ + _mm_storeu_si128( \ + (__m128i*)(c + 320), _mm256_extracti128_si256(x[B], 1) \ + ); \ + _mm_storeu_si128( \ + (__m128i*)(c + 384), _mm256_extracti128_si256(x[C], 1) \ + ); \ + _mm_storeu_si128( \ + (__m128i*)(c + 448), _mm256_extracti128_si256(x[D], 1) \ + ); \ } #define ONEQUAD(A, B, C, D) ONEQUAD_TRANSPOSE(A, B, C, D) -#define ONEQUAD_UNPCK(A, B, C, D) \ - { \ - x_##A = _mm256_add_epi32(x_##A, orig##A); \ - x_##B = _mm256_add_epi32(x_##B, orig##B); \ - x_##C = _mm256_add_epi32(x_##C, orig##C); \ - x_##D = _mm256_add_epi32(x_##D, orig##D); \ - t_##A = _mm256_unpacklo_epi32(x_##A, x_##B); \ - t_##B = _mm256_unpacklo_epi32(x_##C, x_##D); \ - t_##C = _mm256_unpackhi_epi32(x_##A, x_##B); \ - t_##D = _mm256_unpackhi_epi32(x_##C, x_##D); \ - x_##A = _mm256_unpacklo_epi64(t_##A, t_##B); \ - x_##B = _mm256_unpackhi_epi64(t_##A, t_##B); \ - x_##C = _mm256_unpacklo_epi64(t_##C, t_##D); \ - x_##D = _mm256_unpackhi_epi64(t_##C, t_##D); \ +#define ONEQUAD_UNPCK(A, B, C, D) \ + { \ + x[A] = _mm256_add_epi32(x[A], orig[A]); \ + x[B] = _mm256_add_epi32(x[B], orig[B]); \ + x[C] = _mm256_add_epi32(x[C], orig[C]); \ + x[D] = _mm256_add_epi32(x[D], orig[D]); \ + t[A] = _mm256_unpacklo_epi32(x[A], x[B]); \ + t[B] = _mm256_unpacklo_epi32(x[C], x[D]); \ + t[C] = _mm256_unpackhi_epi32(x[A], x[B]); \ + t[D] = _mm256_unpackhi_epi32(x[C], x[D]); \ + x[A] = _mm256_unpacklo_epi64(t[A], t[B]); \ + x[B] = _mm256_unpackhi_epi64(t[A], t[B]); \ + x[C] = _mm256_unpacklo_epi64(t[C], t[D]); \ + x[D] = _mm256_unpackhi_epi64(t[C], t[D]); \ } -#define ONEOCTO(A, B, C, D, A2, B2, C2, D2, c) \ - { \ - ONEQUAD_UNPCK(A, B, C, D); \ - ONEQUAD_UNPCK(A2, B2, C2, D2); \ - t_##A = _mm256_permute2x128_si256(x_##A, x_##A2, 0x20); \ - t_##A2 = _mm256_permute2x128_si256(x_##A, x_##A2, 0x31); \ - t_##B = _mm256_permute2x128_si256(x_##B, x_##B2, 0x20); \ - t_##B2 = _mm256_permute2x128_si256(x_##B, x_##B2, 0x31); \ - t_##C = _mm256_permute2x128_si256(x_##C, x_##C2, 0x20); \ - t_##C2 = _mm256_permute2x128_si256(x_##C, x_##C2, 0x31); \ - t_##D = _mm256_permute2x128_si256(x_##D, x_##D2, 0x20); \ - t_##D2 = _mm256_permute2x128_si256(x_##D, x_##D2, 0x31); \ - _mm256_storeu_si256((__m256i *)(c + 0), t_##A); \ - _mm256_storeu_si256((__m256i *)(c + 64), t_##B); \ - _mm256_storeu_si256((__m256i *)(c + 128), t_##C); \ - _mm256_storeu_si256((__m256i *)(c + 192), t_##D); \ - _mm256_storeu_si256((__m256i *)(c + 256), t_##A2); \ - _mm256_storeu_si256((__m256i *)(c + 320), t_##B2); \ - _mm256_storeu_si256((__m256i *)(c + 384), t_##C2); \ - _mm256_storeu_si256((__m256i *)(c + 448), t_##D2); \ +#define ONEOCTO(A, B, C, D, A2, B2, C2, D2, c) \ + { \ + ONEQUAD_UNPCK(A, B, C, D); \ + ONEQUAD_UNPCK(A2, B2, C2, D2); \ + t[A] = _mm256_permute2x128_si256(x[A], x[A2], 0x20); \ + t[A2] = _mm256_permute2x128_si256(x[A], x[A2], 0x31); \ + t[B] = _mm256_permute2x128_si256(x[B], x[B2], 0x20); \ + t[B2] = _mm256_permute2x128_si256(x[B], x[B2], 0x31); \ + t[C] = _mm256_permute2x128_si256(x[C], x[C2], 0x20); \ + t[C2] = _mm256_permute2x128_si256(x[C], x[C2], 0x31); \ + t[D] = _mm256_permute2x128_si256(x[D], x[D2], 0x20); \ + t[D2] = _mm256_permute2x128_si256(x[D], x[D2], 0x31); \ + _mm256_storeu_si256((__m256i*)(c + 0), t[A]); \ + _mm256_storeu_si256((__m256i*)(c + 64), t[B]); \ + _mm256_storeu_si256((__m256i*)(c + 128), t[C]); \ + _mm256_storeu_si256((__m256i*)(c + 192), t[D]); \ + _mm256_storeu_si256((__m256i*)(c + 256), t[A2]); \ + _mm256_storeu_si256((__m256i*)(c + 320), t[B2]); \ + _mm256_storeu_si256((__m256i*)(c + 384), t[C2]); \ + _mm256_storeu_si256((__m256i*)(c + 448), t[D2]); \ } +static inline uint64_t +_cha_8block(uint32_t* state, uint8_t* begin, uint8_t* end) { + if (end - begin < 512) + return 0; + + uint8_t* c = begin; + /* constant for shuffling bytes (replacing multiple-of-8 rotates) */ + __m256i rot16 = _mm256_set_epi8( + 13, 12, 15, 14, 9, 8, 11, 10, 5, 4, 7, 6, 1, 0, 3, 2, 13, 12, 15, 14, 9, + 8, 11, 10, 5, 4, 7, 6, 1, 0, 3, 2 + ); + __m256i rot8 = _mm256_set_epi8( + 14, 13, 12, 15, 10, 9, 8, 11, 6, 5, 4, 7, 2, 1, 0, 3, 14, 13, 12, 15, 10, + 9, 8, 11, 6, 5, 4, 7, 2, 1, 0, 3 + ); + + /* the naive way seems as fast (if not a bit faster) than the vector way */ + __m256i x[16], orig[16], t[16]; + for (int i = 0; i < 16; ++i) + orig[i] = _mm256_set1_epi32(state[i]); + + const __m256i addv12 = _mm256_set_epi64x(3, 2, 1, 0); + const __m256i addv13 = _mm256_set_epi64x(7, 6, 5, 4); + + while (end - c >= 512) { + for (int i = 0; i < 16; ++i) + x[i] = orig[i]; + + // Calculate the eight parallel counters on x_12 and x_13 + uint64_t* counter = (uint64_t*)(x + 12); + t[13] = _mm256_broadcastq_epi64(_mm_cvtsi64_si128(*counter)); + t[12] = _mm256_add_epi64(addv12, t[13]); + t[13] = _mm256_add_epi64(addv13, t[13]); + x[12] = _mm256_unpacklo_epi32(t[12], t[13]); + x[13] = _mm256_unpackhi_epi32(t[12], t[13]); + t[12] = _mm256_unpacklo_epi32(x[12], x[13]); + t[13] = _mm256_unpackhi_epi32(x[12], x[13]); + + /* required because unpack* are intra-lane */ + const __m256i permute = _mm256_set_epi32(7, 6, 3, 2, 5, 4, 1, 0); + x[12] = _mm256_permutevar8x32_epi32(t[12], permute); + x[13] = _mm256_permutevar8x32_epi32(t[13], permute); + + orig[12] = x[12]; + orig[13] = x[13]; + + for (int i = 0; i < 10; ++i) { + VEC8_ROUND(0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15); + VEC8_ROUND(0, 5, 10, 15, 1, 6, 11, 12, 2, 7, 8, 13, 3, 4, 9, 14); + } + ONEOCTO(0, 1, 2, 3, 4, 5, 6, 7, c); ONEOCTO(8, 9, 10, 11, 12, 13, 14, 15, c + 32); *counter += 8; - bytes -= 512; c += 512; } + return c - begin; } #undef ONEQUAD