popov/cpuminer-opt-gpu
1
0
Fork 0
mirror of https://github.com/JayDDee/cpuminer-opt.git synced 2025-09-17 23:44:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

v3.23.4

Browse Source
This commit is contained in:
Jay D Dee
2023-10-06 22:18:09 -04:00
parent bc5a5c6df8
commit 31c4dedf59
144 changed files with 5931 additions and 3746 deletions
Download Patch File Download Diff File Expand all files Collapse all files

236
algo/cubehash/cubehash_sse2.c
View File

@@ -1,13 +1,6 @@
/* CubeHash 16/32 is recommended for SHA-3 "normal", 16/1 for "formal" */
#define CUBEHASH_ROUNDS 16
#define CUBEHASH_BLOCKBYTES 32
#define OPTIMIZE_SSE2
#if defined(OPTIMIZE_SSE2)
#include <emmintrin.h>
#endif
#ifdef __AVX2__
#include <immintrin.h>
#endif
#include "cubehash_sse2.h"
#include <stdbool.h>
#include <unistd.h>
@@ -80,70 +73,73 @@ static void transform( cubehashParam *sp )
_mm256_store_si256( (__m256i*)sp->x + 2, x2 );
_mm256_store_si256( (__m256i*)sp->x + 3, x3 );
#else
__m128i x0, x1, x2, x3, x4, x5, x6, x7, y0, y1, y2, y3;
#else // AVX, SSE2, NEON
x0 = _mm_load_si128( (__m128i*)sp->x );
x1 = _mm_load_si128( (__m128i*)sp->x + 1 );
x2 = _mm_load_si128( (__m128i*)sp->x + 2 );
x3 = _mm_load_si128( (__m128i*)sp->x + 3 );
x4 = _mm_load_si128( (__m128i*)sp->x + 4 );
x5 = _mm_load_si128( (__m128i*)sp->x + 5 );
x6 = _mm_load_si128( (__m128i*)sp->x + 6 );
x7 = _mm_load_si128( (__m128i*)sp->x + 7 );
#pragma message "NEON for Cubehash"
v128_t x0, x1, x2, x3, x4, x5, x6, x7, y0, y1, y2, y3;
x0 = casti_v128( sp->x, 0 );
x1 = casti_v128( sp->x, 1 );
x2 = casti_v128( sp->x, 2 );
x3 = casti_v128( sp->x, 3 );
x4 = casti_v128( sp->x, 4 );
x5 = casti_v128( sp->x, 5 );
x6 = casti_v128( sp->x, 6 );
x7 = casti_v128( sp->x, 7 );
for ( r = 0; r < rounds; ++r )
{
x4 = _mm_add_epi32( x0, x4 );
x5 = _mm_add_epi32( x1, x5 );
x6 = _mm_add_epi32( x2, x6 );
x7 = _mm_add_epi32( x3, x7 );
x4 = v128_add32( x0, x4 );
x5 = v128_add32( x1, x5 );
x6 = v128_add32( x2, x6 );
x7 = v128_add32( x3, x7 );
y0 = x2;
y1 = x3;
y2 = x0;
y3 = x1;
x0 = mm128_rol_32( y0, 7 );
x1 = mm128_rol_32( y1, 7 );
x2 = mm128_rol_32( y2, 7 );
x3 = mm128_rol_32( y3, 7 );
x0 = _mm_xor_si128( x0, x4 );
x1 = _mm_xor_si128( x1, x5 );
x2 = _mm_xor_si128( x2, x6 );
x3 = _mm_xor_si128( x3, x7 );
x4 = _mm_shuffle_epi32( x4, 0x4e );
x5 = _mm_shuffle_epi32( x5, 0x4e );
x6 = _mm_shuffle_epi32( x6, 0x4e );
x7 = _mm_shuffle_epi32( x7, 0x4e );
x4 = _mm_add_epi32( x0, x4 );
x5 = _mm_add_epi32( x1, x5 );
x6 = _mm_add_epi32( x2, x6 );
x7 = _mm_add_epi32( x3, x7 );
x0 = v128_rol32( y0, 7 );
x1 = v128_rol32( y1, 7 );
x2 = v128_rol32( y2, 7 );
x3 = v128_rol32( y3, 7 );
x0 = v128_xor( x0, x4 );
x1 = v128_xor( x1, x5 );
x2 = v128_xor( x2, x6 );
x3 = v128_xor( x3, x7 );
x4 = v128_swap64( x4 );
x5 = v128_swap64( x5 );
x6 = v128_swap64( x6 );
x7 = v128_swap64( x7 );
x4 = v128_add32( x0, x4 );
x5 = v128_add32( x1, x5 );
x6 = v128_add32( x2, x6 );
x7 = v128_add32( x3, x7 );
y0 = x1;
y1 = x0;
y2 = x3;
y3 = x2;
x0 = mm128_rol_32( y0, 11 );
x1 = mm128_rol_32( y1, 11 );
x2 = mm128_rol_32( y2, 11 );
x3 = mm128_rol_32( y3, 11 );
x0 = _mm_xor_si128( x0, x4 );
x1 = _mm_xor_si128( x1, x5 );
x2 = _mm_xor_si128( x2, x6 );
x3 = _mm_xor_si128( x3, x7 );
x4 = _mm_shuffle_epi32( x4, 0xb1 );
x5 = _mm_shuffle_epi32( x5, 0xb1 );
x6 = _mm_shuffle_epi32( x6, 0xb1 );
x7 = _mm_shuffle_epi32( x7, 0xb1 );
x0 = v128_rol32( y0, 11 );
x1 = v128_rol32( y1, 11 );
x2 = v128_rol32( y2, 11 );
x3 = v128_rol32( y3, 11 );
x0 = v128_xor( x0, x4 );
x1 = v128_xor( x1, x5 );
x2 = v128_xor( x2, x6 );
x3 = v128_xor( x3, x7 );
x4 = v128_swap64_32( x4 );
x5 = v128_swap64_32( x5 );
x6 = v128_swap64_32( x6 );
x7 = v128_swap64_32( x7 );
}
_mm_store_si128( (__m128i*)sp->x, x0 );
_mm_store_si128( (__m128i*)sp->x + 1, x1 );
_mm_store_si128( (__m128i*)sp->x + 2, x2 );
_mm_store_si128( (__m128i*)sp->x + 3, x3 );
_mm_store_si128( (__m128i*)sp->x + 4, x4 );
_mm_store_si128( (__m128i*)sp->x + 5, x5 );
_mm_store_si128( (__m128i*)sp->x + 6, x6 );
_mm_store_si128( (__m128i*)sp->x + 7, x7 );
casti_v128( sp->x, 0 ) = x0;
casti_v128( sp->x, 1 ) = x1;
casti_v128( sp->x, 2 ) = x2;
casti_v128( sp->x, 3 ) = x3;
casti_v128( sp->x, 4 ) = x4;
casti_v128( sp->x, 5 ) = x5;
casti_v128( sp->x, 6 ) = x6;
casti_v128( sp->x, 7 ) = x7;
#endif
} // transform
@@ -170,7 +166,7 @@ static const uint64_t IV512[] =
int cubehashInit(cubehashParam *sp, int hashbitlen, int rounds, int blockbytes)
{
__m128i *x = (__m128i*)sp->x;
v128_t *x = (v128_t*)sp->x;
sp->hashlen = hashbitlen/128;
sp->blocksize = blockbytes/16;
sp->rounds = rounds;
@@ -179,34 +175,34 @@ int cubehashInit(cubehashParam *sp, int hashbitlen, int rounds, int blockbytes)
if ( hashbitlen == 512 )
{
x[0] = _mm_set_epi64x( 0x4167D83E2D538B8B, 0x50F494D42AEA2A61 );
x[1] = _mm_set_epi64x( 0x50AC5695CC39968E, 0xC701CF8C3FEE2313 );
x[2] = _mm_set_epi64x( 0x825B453797CF0BEF, 0xA647A8B34D42C787 );
x[3] = _mm_set_epi64x( 0xA23911AED0E5CD33, 0xF22090C4EEF864D2 );
x[4] = _mm_set_epi64x( 0xB64445321B017BEF, 0x148FE485FCD398D9 );
x[5] = _mm_set_epi64x( 0x0DBADEA991FA7934, 0x2FF5781C6A536159 );
x[6] = _mm_set_epi64x( 0xBC796576B1C62456, 0xA5A70E75D65C8A2B );
x[7] = _mm_set_epi64x( 0xD43E3B447795D246, 0xE7989AF11921C8F7 );
x[0] = v128_set_64( 0x4167D83E2D538B8B, 0x50F494D42AEA2A61 );
x[1] = v128_set_64( 0x50AC5695CC39968E, 0xC701CF8C3FEE2313 );
x[2] = v128_set_64( 0x825B453797CF0BEF, 0xA647A8B34D42C787 );
x[3] = v128_set_64( 0xA23911AED0E5CD33, 0xF22090C4EEF864D2 );
x[4] = v128_set_64( 0xB64445321B017BEF, 0x148FE485FCD398D9 );
x[5] = v128_set_64( 0x0DBADEA991FA7934, 0x2FF5781C6A536159 );
x[6] = v128_set_64( 0xBC796576B1C62456, 0xA5A70E75D65C8A2B );
x[7] = v128_set_64( 0xD43E3B447795D246, 0xE7989AF11921C8F7 );
}
else
{
x[0] = _mm_set_epi64x( 0x35481EAE63117E71, 0xCCD6F29FEA2BD4B4 );
x[1] = _mm_set_epi64x( 0xF4CC12BE7E624131, 0xE5D94E6322512D5B );
x[2] = _mm_set_epi64x( 0x3361DA8CD0720C35, 0x42AF2070C2D0B696 );
x[3] = _mm_set_epi64x( 0x40E5FBAB4680AC00, 0x8EF8AD8328CCECA4 );
x[4] = _mm_set_epi64x( 0xF0B266796C859D41, 0x6107FBD5D89041C3 );
x[5] = _mm_set_epi64x( 0x93CB628565C892FD, 0x5FA2560309392549 );
x[6] = _mm_set_epi64x( 0x85254725774ABFDD, 0x9E4B4E602AF2B5AE );
x[7] = _mm_set_epi64x( 0xD6032C0A9CDAF8AF, 0x4AB6AAD615815AEB );
x[0] = v128_set_64( 0x35481EAE63117E71, 0xCCD6F29FEA2BD4B4 );
x[1] = v128_set_64( 0xF4CC12BE7E624131, 0xE5D94E6322512D5B );
x[2] = v128_set_64( 0x3361DA8CD0720C35, 0x42AF2070C2D0B696 );
x[3] = v128_set_64( 0x40E5FBAB4680AC00, 0x8EF8AD8328CCECA4 );
x[4] = v128_set_64( 0xF0B266796C859D41, 0x6107FBD5D89041C3 );
x[5] = v128_set_64( 0x93CB628565C892FD, 0x5FA2560309392549 );
x[6] = v128_set_64( 0x85254725774ABFDD, 0x9E4B4E602AF2B5AE );
x[7] = v128_set_64( 0xD6032C0A9CDAF8AF, 0x4AB6AAD615815AEB );
}
return SUCCESS;
return 0;
}
int cubehashUpdate( cubehashParam *sp, const byte *data, size_t size )
int cubehashUpdate( cubehashParam *sp, const void *data, size_t size )
{
const int len = size / 16;
const __m128i* in = (__m128i*)data;
const v128_t* in = (v128_t*)data;
int i;
// It is assumed data is aligned to 256 bits and is a multiple of 128 bits.
@@ -214,7 +210,7 @@ int cubehashUpdate( cubehashParam *sp, const byte *data, size_t size )
for ( i = 0; i < len; i++ )
{
sp->x[ sp->pos ] = _mm_xor_si128( sp->x[ sp->pos ], in[i] );
sp->x[ sp->pos ] = v128_xor( sp->x[ sp->pos ], in[i] );
sp->pos++;
if ( sp->pos == sp->blocksize )
{
@@ -223,20 +219,20 @@ int cubehashUpdate( cubehashParam *sp, const byte *data, size_t size )
}
}
return SUCCESS;
return 0;
}
int cubehashDigest( cubehashParam *sp, byte *digest )
int cubehashDigest( cubehashParam *sp, void *digest )
{
__m128i* hash = (__m128i*)digest;
v128_t* hash = (v128_t*)digest;
int i;
// pos is zero for 64 byte data, 1 for 80 byte data.
sp->x[ sp->pos ] = _mm_xor_si128( sp->x[ sp->pos ],
_mm_set_epi64x( 0, 0x80 ) );
sp->x[ sp->pos ] = v128_xor( sp->x[ sp->pos ],
v128_set_64( 0, 0x80 ) );
transform( sp );
sp->x[7] = _mm_xor_si128( sp->x[7], _mm_set_epi64x( 0x100000000, 0 ) );
sp->x[7] = v128_xor( sp->x[7], v128_set_64( 0x100000000, 0 ) );
transform( sp );
transform( sp );
transform( sp );
@@ -251,15 +247,15 @@ int cubehashDigest( cubehashParam *sp, byte *digest )
for ( i = 0; i < sp->hashlen; i++ )
hash[i] = sp->x[i];
return SUCCESS;
return 0;
}
int cubehashUpdateDigest( cubehashParam *sp, byte *digest,
const byte *data, size_t size )
int cubehashUpdateDigest( cubehashParam *sp, void *digest,
const void *data, size_t size )
{
const int len = size / 16;
const __m128i* in = (__m128i*)data;
__m128i* hash = (__m128i*)digest;
const v128_t* in = (v128_t*)data;
v128_t* hash = (v128_t*)digest;
int i;
// It is assumed data is aligned to 256 bits and is a multiple of 128 bits.
@@ -267,7 +263,7 @@ int cubehashUpdateDigest( cubehashParam *sp, byte *digest,
for ( i = 0; i < len; i++ )
{
sp->x[ sp->pos ] = _mm_xor_si128( sp->x[ sp->pos ], in[i] );
sp->x[ sp->pos ] = v128_xor( sp->x[ sp->pos ], in[i] );
sp->pos++;
if ( sp->pos == sp->blocksize )
{
@@ -277,11 +273,11 @@ int cubehashUpdateDigest( cubehashParam *sp, byte *digest,
}
// pos is zero for 64 byte data, 1 for 80 byte data.
sp->x[ sp->pos ] = _mm_xor_si128( sp->x[ sp->pos ],
_mm_set_epi64x( 0, 0x80 ) );
sp->x[ sp->pos ] = v128_xor( sp->x[ sp->pos ],
v128_set_64( 0, 0x80 ) );
transform( sp );
sp->x[7] = _mm_xor_si128( sp->x[7], _mm_set_epi64x( 0x100000000, 0 ) );
sp->x[7] = v128_xor( sp->x[7], v128_set_64( 0x100000000, 0 ) );
transform( sp );
transform( sp );
@@ -297,13 +293,13 @@ int cubehashUpdateDigest( cubehashParam *sp, byte *digest,
for ( i = 0; i < sp->hashlen; i++ )
hash[i] = sp->x[i];
return SUCCESS;
return 0;
}
int cubehash_full( cubehashParam *sp, byte *digest, int hashbitlen,
const byte *data, size_t size )
int cubehash_full( cubehashParam *sp, void *digest, int hashbitlen,
const void *data, size_t size )
{
__m128i *x = (__m128i*)sp->x;
v128_t *x = (v128_t*)sp->x;
sp->hashlen = hashbitlen/128;
sp->blocksize = 32/16;
sp->rounds = 16;
@@ -312,33 +308,33 @@ int cubehash_full( cubehashParam *sp, byte *digest, int hashbitlen,
if ( hashbitlen == 512 )
{
x[0] = _mm_set_epi64x( 0x4167D83E2D538B8B, 0x50F494D42AEA2A61 );
x[1] = _mm_set_epi64x( 0x50AC5695CC39968E, 0xC701CF8C3FEE2313 );
x[2] = _mm_set_epi64x( 0x825B453797CF0BEF, 0xA647A8B34D42C787 );
x[3] = _mm_set_epi64x( 0xA23911AED0E5CD33, 0xF22090C4EEF864D2 );
x[4] = _mm_set_epi64x( 0xB64445321B017BEF, 0x148FE485FCD398D9 );
x[5] = _mm_set_epi64x( 0x0DBADEA991FA7934, 0x2FF5781C6A536159 );
x[6] = _mm_set_epi64x( 0xBC796576B1C62456, 0xA5A70E75D65C8A2B );
x[7] = _mm_set_epi64x( 0xD43E3B447795D246, 0xE7989AF11921C8F7 );
x[0] = v128_set_64( 0x4167D83E2D538B8B, 0x50F494D42AEA2A61 );
x[1] = v128_set_64( 0x50AC5695CC39968E, 0xC701CF8C3FEE2313 );
x[2] = v128_set_64( 0x825B453797CF0BEF, 0xA647A8B34D42C787 );
x[3] = v128_set_64( 0xA23911AED0E5CD33, 0xF22090C4EEF864D2 );
x[4] = v128_set_64( 0xB64445321B017BEF, 0x148FE485FCD398D9 );
x[5] = v128_set_64( 0x0DBADEA991FA7934, 0x2FF5781C6A536159 );
x[6] = v128_set_64( 0xBC796576B1C62456, 0xA5A70E75D65C8A2B );
x[7] = v128_set_64( 0xD43E3B447795D246, 0xE7989AF11921C8F7 );
}
else
{
x[0] = _mm_set_epi64x( 0x35481EAE63117E71, 0xCCD6F29FEA2BD4B4 );
x[1] = _mm_set_epi64x( 0xF4CC12BE7E624131, 0xE5D94E6322512D5B );
x[2] = _mm_set_epi64x( 0x3361DA8CD0720C35, 0x42AF2070C2D0B696 );
x[3] = _mm_set_epi64x( 0x40E5FBAB4680AC00, 0x8EF8AD8328CCECA4 );
x[4] = _mm_set_epi64x( 0xF0B266796C859D41, 0x6107FBD5D89041C3 );
x[5] = _mm_set_epi64x( 0x93CB628565C892FD, 0x5FA2560309392549 );
x[6] = _mm_set_epi64x( 0x85254725774ABFDD, 0x9E4B4E602AF2B5AE );
x[7] = _mm_set_epi64x( 0xD6032C0A9CDAF8AF, 0x4AB6AAD615815AEB );
x[0] = v128_set_64( 0x35481EAE63117E71, 0xCCD6F29FEA2BD4B4 );
x[1] = v128_set_64( 0xF4CC12BE7E624131, 0xE5D94E6322512D5B );
x[2] = v128_set_64( 0x3361DA8CD0720C35, 0x42AF2070C2D0B696 );
x[3] = v128_set_64( 0x40E5FBAB4680AC00, 0x8EF8AD8328CCECA4 );
x[4] = v128_set_64( 0xF0B266796C859D41, 0x6107FBD5D89041C3 );
x[5] = v128_set_64( 0x93CB628565C892FD, 0x5FA2560309392549 );
x[6] = v128_set_64( 0x85254725774ABFDD, 0x9E4B4E602AF2B5AE );
x[7] = v128_set_64( 0xD6032C0A9CDAF8AF, 0x4AB6AAD615815AEB );
}
const int len = size / 16;
const __m128i* in = (__m128i*)data;
__m128i* hash = (__m128i*)digest;
const v128_t* in = (v128_t*)data;
v128_t* hash = (v128_t*)digest;
int i;
// It is assumed data is aligned to 256 bits and is a multiple of 128 bits.
@@ -346,7 +342,7 @@ int cubehash_full( cubehashParam *sp, byte *digest, int hashbitlen,
for ( i = 0; i < len; i++ )
{
sp->x[ sp->pos ] = _mm_xor_si128( sp->x[ sp->pos ], in[i] );
sp->x[ sp->pos ] = v128_xor( sp->x[ sp->pos ], in[i] );
sp->pos++;
if ( sp->pos == sp->blocksize )
{
@@ -356,11 +352,11 @@ int cubehash_full( cubehashParam *sp, byte *digest, int hashbitlen,
}
// pos is zero for 64 byte data, 1 for 80 byte data.
sp->x[ sp->pos ] = _mm_xor_si128( sp->x[ sp->pos ],
_mm_set_epi64x( 0, 0x80 ) );
sp->x[ sp->pos ] = v128_xor( sp->x[ sp->pos ],
v128_set_64( 0, 0x80 ) );
transform( sp );
sp->x[7] = _mm_xor_si128( sp->x[7], _mm_set_epi64x( 0x100000000, 0 ) );
sp->x[7] = v128_xor( sp->x[7], v128_set_64( 0x100000000, 0 ) );
transform( sp );
transform( sp );
@@ -376,6 +372,6 @@ int cubehash_full( cubehashParam *sp, byte *digest, int hashbitlen,
for ( i = 0; i < sp->hashlen; i++ )
hash[i] = sp->x[i];
return SUCCESS;
return 0;
}