/* * Calculate the checksum of data that is 16 byte aligned and a multiple of * 16 bytes . * * The first step is to reduce it to 1024 bits . We do this in 8 parallel * chunks in order to mask the latency of the vpmsum instructions . If we * have more than 32 kB of data to checksum we repeat this step multiple * times , passing in the previous 1024 bits . * * The next step is to reduce the 1024 bits to 64 bits . This step adds * 32 bits of 0 s to the end - this matches what a CRC does . We just * calculate constants that land the data in this 32 bits . * * We then use fixed point Barrett reduction to compute a mod n over GF ( 2 ) * for n = CRC using POWER8 instructions . We use x = 32 . * * http : //en.wikipedia.org/wiki/Barrett_reduction * * This code uses gcc vector builtins instead using assembly directly . * * Copyright ( C ) 2017 Rogerio Alves < rogealve @ br . ibm . com > , IBM * * This program is free software ; you can redistribute it and / or * modify it under the terms of either : * * a ) the GNU General Public License as published by the Free Software * Foundation ; either version 2 of the License , or ( at your option ) * any later version , or * b ) the Apache License , Version 2 . 0
#include <stddef.h>
#include <altivec.h>
#define VMX_ALIGN
16
#define VMX_ALIGN_MASK (VMX_ALIGN-
1 )
#ifdef REFLECT
static unsigned int crc32_align(
unsigned int crc,
const unsigned char *p,
unsigned long len)
{
while (len--)
crc = crc_table[(crc ^ *p++) &
0 xff] ^ (crc >>
8 );
return crc;
}
#else
static unsigned int crc32_align(
unsigned int crc,
const unsigned char *p,
unsigned long len)
{
while (len--)
crc = crc_table[((crc >>
24 ) ^ *p++) &
0 xff] ^ (crc <<
8 );
return crc;
}
#endif
static unsigned int __attribute__ ((aligned (
32 )))
__crc32_vpmsum(
unsigned int crc,
const void * p,
unsigned long len);
unsigned CRC32_FUNCTION(
unsigned crc,
const void *buffer, size_t len)
{
unsigned int prealign;
unsigned int tail;
const unsigned char *p = buffer;
#ifdef CRC_XOR
crc ^=
0 xffffffff;
#endif
if (len < VMX_ALIGN + VMX_ALIGN_MASK) {
crc = crc32_align(crc, p, len);
goto out;
}
if ((
unsigned long )p & VMX_ALIGN_MASK) {
prealign = VMX_ALIGN - ((
unsigned long )p & VMX_ALIGN_MASK);
crc = crc32_align(crc, p, prealign);
len -= prealign;
p += prealign;
}
crc = __crc32_vpmsum(crc, p, len & ~VMX_ALIGN_MASK);
tail = len & VMX_ALIGN_MASK;
if (tail) {
p += len & ~VMX_ALIGN_MASK;
crc = crc32_align(crc, p, tail);
}
out:
#ifdef CRC_XOR
crc ^=
0 xffffffff;
#endif
return crc;
}
#if defined (__clang__)
#include "clang_workaround.h"
#else
#define __builtin_pack_vector(a, b) __builtin_pack_vector_int128 ((a), (b))
#define __builtin_unpack_vector_0(a) __builtin_unpack_vector_int128 ((vector __int12
8_t)(a), 0 )#define __builtin_unpack_vector_1(a) __builtin_unpack_vector_int128 ((vector __int128_t)(a), 1 )#endif /* When we have a load-store in a single-dispatch group and address overlap * such that forward is not allowed ( load - hit - store ) the group must be flushed . * A group ending NOP prevents the flush . #define GROUP_ENDING_NOP asm ("ori 2,2,0" ::: "memory" )#if defined (__BIG_ENDIAN__) && defined (REFLECT)#define BYTESWAP_DATA#elif defined (__LITTLE_ENDIAN__) && !defined (REFLECT)#define BYTESWAP_DATA#endif #ifdef BYTESWAP_DATA#define VEC_PERM(vr, va, vb, vc) vr = vec_perm(va, vb,\unsigned char ) vc)#if defined (__LITTLE_ENDIAN__)/* Byte reverse permute constant LE. */ static const __vector unsigned long long vperm_const16 ))) = { 0 x08090A0B0C0D0E0FUL,0 x0001020304050607UL };#else static const __vector unsigned long long vperm_const16 ))) = { 0 x0F0E0D0C0B0A0908UL,0 X0706050403020100UL };#endif #else #define VEC_PERM(vr, va, vb, vc)#endif static unsigned int __attribute__ ((aligned (32 )))unsigned int crc, const void * p, unsigned long len) {const __vector unsigned long long vzero = {0 ,0 };const __vector unsigned long long vones = {0 xffffffffffffffffUL,0 xffffffffffffffffUL};#ifdef REFLECTunsigned char vsht_splat;const __vector unsigned long long vmask_32bit =unsigned long long )vec_sld((__vector unsigned char )vzero,unsigned char )vones, 4 );#endif const __vector unsigned long long vmask_64bit =unsigned long long )vec_sld((__vector unsigned char )vzero,unsigned char )vones, 8 );unsigned long long vcrc;unsigned long long vconst1, vconst2;/* vdata0-vdata7 will contain our data (p). */ unsigned long long vdata0, vdata1, vdata2, vdata3, vdata4,/* v0-v7 will contain our checksums */ unsigned long long v0 = {0 ,0 };unsigned long long v1 = {0 ,0 };unsigned long long v2 = {0 ,0 };unsigned long long v3 = {0 ,0 };unsigned long long v4 = {0 ,0 };unsigned long long v5 = {0 ,0 };unsigned long long v6 = {0 ,0 };unsigned long long v7 = {0 ,0 };/* Vector auxiliary variables. */ unsigned long long va0, va1, va2, va3, va4, va5, va6, va7;unsigned int result = 0 ;unsigned int offset; /* Constant table offset. */ unsigned long i; /* Counter. */ unsigned long chunks;unsigned long block_size;int next_block = 0 ;/* Align by 128 bits. The last 128 bit block will be processed at end. */ unsigned long length = len & 0 xFFFFFFFFFFFFFF80UL;#ifdef REFLECTunsigned long long )__builtin_pack_vector(0 UL, crc);#else unsigned long long )__builtin_pack_vector(crc, 0 UL);/* Shift into top 32 bits */ unsigned long long )vec_sld((__vector unsigned char )vcrc,unsigned char )vzero, 4 );#endif /* Short version. */ if (len < 256 ) {/* Calculate where in the constant table we need to start. */ 256 - len;0 , (__vector unsigned long long *) p);/* xor initial value*/ unsigned long long ) __builtin_crypto_vpmsumwunsigned int )vdata0, (__vector unsigned int )vconst1);for (i = 16 ; i < len; i += 16 ) {unsigned long long *) p);unsigned long long ) __builtin_crypto_vpmsumwunsigned int )vdata0, (__vector unsigned int )vconst1);else {/* Load initial values. */ 0 , (__vector unsigned long long *) p);16 , (__vector unsigned long long *) p);32 , (__vector unsigned long long *) p);48 , (__vector unsigned long long *) p);64 , (__vector unsigned long long *) p);80 , (__vector unsigned long long *) p);96 , (__vector unsigned long long *) p);112 , (__vector unsigned long long *) p);/* xor in initial value */ char *)p + 128 ;do {/* Checksum in blocks of MAX_SIZE. */ if (block_size > MAX_SIZE) {/* * Work out the offset into the constants table to start at . Each * constant is 16 bytes , and it is used against 128 bytes of input * data - 128 / 16 = 8 8 ) - (block_size/8 );/* We reduce our final 128 bytes in a separate step */ 128 )-1 ;unsigned long long )vdata0,unsigned long long )vconst1);unsigned long long )vdata1,unsigned long long )vconst1);unsigned long long )vdata2,unsigned long long )vconst1);unsigned long long )vdata3,unsigned long long )vconst1);unsigned long long )vdata4,unsigned long long )vconst1);unsigned long long )vdata5,unsigned long long )vconst1);unsigned long long )vdata6,unsigned long long )vconst1);unsigned long long )vdata7,unsigned long long )vconst1);if (chunks > 1 ) {16 ;0 , (__vector unsigned long long *) p);16 , (__vector unsigned long long *) p);32 , (__vector unsigned long long *) p);48 , (__vector unsigned long long *) p);64 , (__vector unsigned long long *) p);80 , (__vector unsigned long long *) p);96 , (__vector unsigned long long *) p);112 , (__vector unsigned long long *) p);char *)p + 128 ;/* * main loop . We modulo schedule it such that it takes three * iterations to complete - first iteration load , second * iteration vpmsum , third iteration xor . for (i = 0 ; i < chunks-2 ; i++) {16 ;unsigned long long )vdata0, (__vector unsigned long long )vconst2);0 , (__vector unsigned long long *) p);unsigned long long )vdata1, (__vector unsigned long long )vconst2);16 , (__vector unsigned long long *) p);unsigned long long )vdata2, (__vector unsigned long long )vconst2);32 , (__vector unsigned long long *) p);unsigned long long )vdata3, (__vector unsigned long long )vconst2);48 , (__vector unsigned long long *) p);unsigned long long )vdata4, (__vector unsigned long long )vconst1);64 , (__vector unsigned long long *) p);unsigned long long )vdata5, (__vector unsigned long long )vconst1);80 , (__vector unsigned long long *) p);unsigned long long )vdata6, (__vector unsigned long long )vconst1);96 , (__vector unsigned long long *) p);unsigned long long )vdata7, (__vector unsigned long long )vconst1);112 , (__vector unsigned long long *) p);char *)p + 128 ;/* First cool down*/ 16 ;unsigned long long )vdata0, (__vector unsigned long long )vconst1);unsigned long long )vdata1, (__vector unsigned long long )vconst1);unsigned long long )vdata2, (__vector unsigned long long )vconst1);unsigned long long )vdata3, (__vector unsigned long long )vconst1);unsigned long long )vdata4, (__vector unsigned long long )vconst1);unsigned long long )vdata5, (__vector unsigned long long )vconst1);unsigned long long )vdata6, (__vector unsigned long long )vconst1);unsigned long long )vdata7, (__vector unsigned long long )vconst1);/* else */ /* Second cool down. */ #ifdef REFLECT/* * vpmsumd produces a 96 bit result in the least significant bits * of the register . Since we are bit reflected we have to shift it * left 32 bits so it occupies the least significant bits in the * bit reflected domain . unsigned long long )vec_sld((__vector unsigned char )v0,unsigned char )vzero, 4 );unsigned long long )vec_sld((__vector unsigned char )v1,unsigned char )vzero, 4 );unsigned long long )vec_sld((__vector unsigned char )v2,unsigned char )vzero, 4 );unsigned long long )vec_sld((__vector unsigned char )v3,unsigned char )vzero, 4 );unsigned long long )vec_sld((__vector unsigned char )v4,unsigned char )vzero, 4 );unsigned long long )vec_sld((__vector unsigned char )v5,unsigned char )vzero, 4 );unsigned long long )vec_sld((__vector unsigned char )v6,unsigned char )vzero, 4 );unsigned long long )vec_sld((__vector unsigned char )v7,unsigned char )vzero, 4 );#endif /* xor with the last 1024 bits. */ 0 , (__vector unsigned long long *) p);16 , (__vector unsigned long long *) p);32 , (__vector unsigned long long *) p);48 , (__vector unsigned long long *) p);64 , (__vector unsigned long long *) p);80 , (__vector unsigned long long *) p);96 , (__vector unsigned long long *) p);112 , (__vector unsigned long long *) p);char *)p + 128 ;/* Check if we have more blocks to process */ 0 ;if (length != 0 ) {1 ;/* zero v0-v7 */ 128 ;while (next_block);/* Calculate how many bytes we have left. */ 127 );/* Calculate where in (short) constant table we need to start. */ 128 - length;16 , vcrc_short_const);32 , vcrc_short_const);48 , vcrc_short_const);64 , vcrc_short_const);80 , vcrc_short_const);96 , vcrc_short_const);112 , vcrc_short_const);128 ;unsigned long long )__builtin_crypto_vpmsumw (unsigned int )vdata0,(__vector unsigned int )v0);unsigned long long )__builtin_crypto_vpmsumw (unsigned int )vdata1,(__vector unsigned int )v1);unsigned long long )__builtin_crypto_vpmsumw (unsigned int )vdata2,(__vector unsigned int )v2);unsigned long long )__builtin_crypto_vpmsumw (unsigned int )vdata3,(__vector unsigned int )v3);unsigned long long )__builtin_crypto_vpmsumw (unsigned int )vdata4,(__vector unsigned int )v4);unsigned long long )__builtin_crypto_vpmsumw (unsigned int )vdata5,(__vector unsigned int )v5);unsigned long long )__builtin_crypto_vpmsumw (unsigned int )vdata6,(__vector unsigned int )v6);unsigned long long )__builtin_crypto_vpmsumw (unsigned int )vdata7,(__vector unsigned int )v7);/* Now reduce the tail (0-112 bytes). */ for (i = 0 ; i < length; i+=16 ) {unsigned long long *)p);unsigned long long )__builtin_crypto_vpmsumw (unsigned int )vdata0,(__vector unsigned int )va0);/* xor all parallel chunks together. */ /* Barrett Reduction */ 0 , v_Barrett_const);16 , v_Barrett_const);unsigned long long )vec_sld((__vector unsigned char )v0,unsigned char )v0, 8 );#ifdef REFLECT/* shift left one bit */ 1 );unsigned long long )vec_sll ((__vector unsigned char )v0,#endif #ifndef REFLECT/* * Now for the actual algorithm . The idea is to calculate q , * the multiple of our polynomial that we need to subtract . By * doing the computation 2 x bits higher ( ie 64 bits ) and shifting the * result back down 2 x bits , we round down to the nearest multiple . /* ma */ unsigned long long )v0,unsigned long long )vconst1);/* q = floor(ma/(2^64)) */ unsigned long long )vec_sld ((__vector unsigned char )vzero,unsigned char )v1, 8 );/* qn */ unsigned long long )v1,unsigned long long )vconst2);/* a - qn, subtraction is xor in GF(2) */ /* * Get the result into r3 . We need to shift it left 8 bytes : * V0 [ 0 1 2 X ] * V0 [ 0 X 2 3 ] #else /* * The reflected version of Barrett reduction . Instead of bit * reflecting our data ( which is expensive to do ) , we bit reflect our * constants and our algorithm , which means the intermediate data in * our vector registers goes from 0 - 63 instead of 63 - 0 . We can reflect * the algorithm because we don ' t carry in mod 2 arithmetic . /* bottom 32 bits of a */ /* ma */ unsigned long long )v1,unsigned long long )vconst1);/* bottom 32bits of ma */ /* qn */ unsigned long long )v1,unsigned long long )vconst2);/* a - qn, subtraction is xor in GF(2) */ /* * Since we are bit reflected , the result ( ie the low 32 bits ) is in * the high 32 bits . We just need to shift it left 4 bytes * V0 [ 0 1 X 3 ] * V0 [ 0 X 2 3 ] /* shift result into top 64 bits of */ unsigned long long )vec_sld((__vector unsigned char )v0,unsigned char )vzero, 4 );#endif return result; Messung V0.5 in Prozent C=94 H=98 G=95
¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen0.70Angebot
(Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-10-08)
¤ *Eine klare Vorstellung vom Zielzustand
