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.12.6.1

Browse Source
This commit is contained in:
Jay D Dee
2020-03-07 14:11:06 -05:00
parent c0aadbcc99
commit 6e8b8ed34f
29 changed files with 294 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
algo/x16/hex.c
View File

@@ -77,7 +77,7 @@ typedef union _hex_context_overlay hex_context_overlay;
static __thread x16r_context_overlay hex_ctx;
void hex_hash( void* output, const void* input )
int hex_hash( void* output, const void* input, int thrid )
{
uint32_t _ALIGN(128) hash[16];
x16r_context_overlay ctx;
@@ -214,11 +214,15 @@ void hex_hash( void* output, const void* input )
SHA512_Final( (unsigned char*) hash, &ctx.sha512 );
break;
}
if ( work_restart[thrid].restart ) return 0;
algo = (uint8_t)hash[0] % X16R_HASH_FUNC_COUNT;
in = (void*) hash;
size = 64;
}
memcpy(output, hash, 32);
return 1;
}
int scanhash_hex( struct work *work, uint32_t max_nonce,
@@ -286,8 +290,7 @@ int scanhash_hex( struct work *work, uint32_t max_nonce,
do
{
edata[19] = nonce;
hex_hash( hash32, edata );
if ( hex_hash( hash32, edata, thr_id ) );
if ( unlikely( valid_hash( hash32, ptarget ) && !bench ) )
{
be32enc( &pdata[19], nonce );

35
algo/x16/x16r-4way.c
View File

@@ -80,7 +80,7 @@ void x16r_8way_prehash( void *vdata, void *pdata )
// Called by wrapper hash function to optionally continue hashing and
// convert to final hash.
void x16r_8way_hash_generic( void* output, const void* input )
int x16r_8way_hash_generic( void* output, const void* input, int thrid )
{
uint32_t vhash[20*8] __attribute__ ((aligned (128)));
uint32_t hash0[20] __attribute__ ((aligned (64)));
@@ -424,6 +424,9 @@ void x16r_8way_hash_generic( void* output, const void* input )
hash7, vhash );
break;
}
if ( work_restart[thrid].restart ) return 0;
size = 64;
}
@@ -435,14 +438,17 @@ void x16r_8way_hash_generic( void* output, const void* input )
memcpy( output+320, hash5, 64 );
memcpy( output+384, hash6, 64 );
memcpy( output+448, hash7, 64 );
return 1;
}
// x16-r,-s,-rt wrapper called directly by scanhash to repackage 512 bit
// hash to 256 bit final hash.
void x16r_8way_hash( void* output, const void* input )
int x16r_8way_hash( void* output, const void* input, int thrid )
{
uint8_t hash[64*8] __attribute__ ((aligned (128)));
x16r_8way_hash_generic( hash, input );
if ( !x16r_8way_hash_generic( hash, input, thrid ) )
return 0;
memcpy( output, hash, 32 );
memcpy( output+32, hash+64, 32 );
@@ -452,7 +458,9 @@ void x16r_8way_hash( void* output, const void* input )
memcpy( output+160, hash+320, 32 );
memcpy( output+192, hash+384, 32 );
memcpy( output+224, hash+448, 32 );
}
return 1;
}
// x16r only
int scanhash_x16r_8way( struct work *work, uint32_t max_nonce,
@@ -492,8 +500,7 @@ int scanhash_x16r_8way( struct work *work, uint32_t max_nonce,
n+3, 0, n+2, 0, n+1, 0, n, 0 ), *noncev );
do
{
x16r_8way_hash( hash, vdata );
if( x16r_8way_hash( hash, vdata, thr_id ) );
for ( int i = 0; i < 8; i++ )
if ( unlikely( valid_hash( hash + (i<<3), ptarget ) && !bench ) )
{
@@ -565,7 +572,7 @@ void x16r_4way_prehash( void *vdata, void *pdata )
}
}
void x16r_4way_hash_generic( void* output, const void* input )
int x16r_4way_hash_generic( void* output, const void* input, int thrid )
{
uint32_t vhash[20*4] __attribute__ ((aligned (128)));
uint32_t hash0[20] __attribute__ ((aligned (64)));
@@ -794,23 +801,31 @@ void x16r_4way_hash_generic( void* output, const void* input )
dintrlv_4x64_512( hash0, hash1, hash2, hash3, vhash );
break;
}
if ( work_restart[thrid].restart ) return 0;
size = 64;
}
memcpy( output, hash0, 64 );
memcpy( output+64, hash1, 64 );
memcpy( output+128, hash2, 64 );
memcpy( output+192, hash3, 64 );
return 1;
}
void x16r_4way_hash( void* output, const void* input )
int x16r_4way_hash( void* output, const void* input, int thrid )
{
uint8_t hash[64*4] __attribute__ ((aligned (64)));
x16r_4way_hash_generic( hash, input );
if ( !x16r_4way_hash_generic( hash, input, thrid ) )
return 0;
memcpy( output, hash, 32 );
memcpy( output+32, hash+64, 32 );
memcpy( output+64, hash+128, 32 );
memcpy( output+96, hash+192, 32 );
return 1;
}
int scanhash_x16r_4way( struct work *work, uint32_t max_nonce,
@@ -849,7 +864,7 @@ int scanhash_x16r_4way( struct work *work, uint32_t max_nonce,
_mm256_set_epi32( n+3, 0, n+2, 0, n+1, 0, n, 0 ), *noncev );
do
{
x16r_4way_hash( hash, vdata );
if ( x16r_4way_hash( hash, vdata, thr_id ) );
for ( int i = 0; i < 4; i++ )
if ( unlikely( valid_hash( hash + (i<<3), ptarget ) && !bench ) )
{

24
algo/x16/x16r-gate.h
View File

@@ -131,8 +131,8 @@ typedef union _x16r_8way_context_overlay x16r_8way_context_overlay;
extern __thread x16r_8way_context_overlay x16r_ctx;
void x16r_8way_prehash( void *, void * );
void x16r_8way_hash_generic( void *, const void * );
void x16r_8way_hash( void *, const void * );
int x16r_8way_hash_generic( void *, const void *, int );
int x16r_8way_hash( void *, const void *, int );
int scanhash_x16r_8way( struct work *, uint32_t ,
uint64_t *, struct thr_info * );
extern __thread x16r_8way_context_overlay x16r_ctx;
@@ -166,8 +166,8 @@ typedef union _x16r_4way_context_overlay x16r_4way_context_overlay;
extern __thread x16r_4way_context_overlay x16r_ctx;
void x16r_4way_prehash( void *, void * );
void x16r_4way_hash_generic( void *, const void * );
void x16r_4way_hash( void *, const void * );
int x16r_4way_hash_generic( void *, const void *, int );
int x16r_4way_hash( void *, const void *, int );
int scanhash_x16r_4way( struct work *, uint32_t,
uint64_t *, struct thr_info * );
extern __thread x16r_4way_context_overlay x16r_ctx;
@@ -205,26 +205,26 @@ typedef union _x16r_context_overlay x16r_context_overlay;
extern __thread x16r_context_overlay x16_ctx;
void x16r_prehash( void *, void * );
void x16r_hash_generic( void *, const void * );
void x16r_hash( void *, const void * );
int x16r_hash_generic( void *, const void *, int );
int x16r_hash( void *, const void *, int );
int scanhash_x16r( struct work *, uint32_t, uint64_t *, struct thr_info * );
// x16Rv2
#if defined(X16RV2_8WAY)
void x16rv2_8way_hash( void *state, const void *input );
int x16rv2_8way_hash( void *state, const void *input, int thrid );
int scanhash_x16rv2_8way( struct work *work, uint32_t max_nonce,
uint64_t *hashes_done, struct thr_info *mythr );
#elif defined(X16RV2_4WAY)
void x16rv2_4way_hash( void *state, const void *input );
int x16rv2_4way_hash( void *state, const void *input, int thrid );
int scanhash_x16rv2_4way( struct work *work, uint32_t max_nonce,
uint64_t *hashes_done, struct thr_info *mythr );
#else
void x16rv2_hash( void *state, const void *input );
int x16rv2_hash( void *state, const void *input, int thr_id );
int scanhash_x16rv2( struct work *work, uint32_t max_nonce,
uint64_t *hashes_done, struct thr_info *mythr );
@@ -254,21 +254,21 @@ int scanhash_x16rt( struct work *work, uint32_t max_nonce,
// x21s
#if defined(X16R_8WAY)
void x21s_8way_hash( void *state, const void *input );
int x21s_8way_hash( void *state, const void *input, int thrid );
int scanhash_x21s_8way( struct work *work, uint32_t max_nonce,
uint64_t *hashes_done, struct thr_info *mythr );
bool x21s_8way_thread_init();
#elif defined(X16R_4WAY)
void x21s_4way_hash( void *state, const void *input );
int x21s_4way_hash( void *state, const void *input, int thrid );
int scanhash_x21s_4way( struct work *work, uint32_t max_nonce,
uint64_t *hashes_done, struct thr_info *mythr );
bool x21s_4way_thread_init();
#else
void x21s_hash( void *state, const void *input );
int x21s_hash( void *state, const void *input, int thr_id );
int scanhash_x21s( struct work *work, uint32_t max_nonce,
uint64_t *hashes_done, struct thr_info *mythr );
bool x21s_thread_init();

17
algo/x16/x16r.c
View File

@@ -48,7 +48,7 @@ void x16r_prehash( void *edata, void *pdata )
}
}
void x16r_hash_generic( void* output, const void* input )
int x16r_hash_generic( void* output, const void* input, int thrid )
{
uint32_t _ALIGN(128) hash[16];
x16r_context_overlay ctx;
@@ -178,18 +178,24 @@ void x16r_hash_generic( void* output, const void* input )
SHA512_Final( (unsigned char*) hash, &ctx.sha512 );
break;
}
if ( work_restart[thrid].restart ) return 0;
in = (void*) hash;
size = 64;
}
memcpy( output, hash, 64 );
return true;
}
void x16r_hash( void* output, const void* input )
int x16r_hash( void* output, const void* input, int thrid )
{
uint8_t hash[64] __attribute__ ((aligned (64)));
x16r_hash_generic( hash, input );
if ( !x16r_hash_generic( hash, input, thrid ) )
return 0;
memcpy( output, hash, 32 );
memcpy( output, hash, 32 );
return 1;
}
int scanhash_x16r( struct work *work, uint32_t max_nonce,
@@ -223,8 +229,7 @@ int scanhash_x16r( struct work *work, uint32_t max_nonce,
do
{
edata[19] = nonce;
x16r_hash( hash32, edata );
if ( x16r_hash( hash32, edata, thr_id ) )
if ( unlikely( valid_hash( hash32, ptarget ) && !bench ) )
{
pdata[19] = bswap_32( nonce );

5
algo/x16/x16rt-4way.c
View File

@@ -41,8 +41,7 @@ int scanhash_x16rt_8way( struct work *work, uint32_t max_nonce,
n+3, 0, n+2, 0, n+1, 0, n, 0 ), *noncev );
do
{
x16r_8way_hash( hash, vdata );
if ( x16r_8way_hash( hash, vdata, thr_id ) )
for ( int i = 0; i < 8; i++ )
if ( unlikely( valid_hash( hash + (i<<3), ptarget ) && !bench ) )
{
@@ -95,7 +94,7 @@ int scanhash_x16rt_4way( struct work *work, uint32_t max_nonce,
_mm256_set_epi32( n+3, 0, n+2, 0, n+1, 0, n, 0 ), *noncev );
do
{
x16r_4way_hash( hash, vdata );
if ( x16r_4way_hash( hash, vdata, thr_id ) )
for ( int i = 0; i < 4; i++ )
if ( unlikely( valid_hash( hash + (i<<3), ptarget ) && !bench ) )
{

3
algo/x16/x16rt.c
View File

@@ -36,8 +36,7 @@ int scanhash_x16rt( struct work *work, uint32_t max_nonce,
do
{
edata[19] = nonce;
x16r_hash( hash32, edata );
if ( x16r_hash( hash32, edata, thr_id ) )
if ( valid_hash( hash32, ptarget ) && !bench )
{
pdata[19] = bswap_32( nonce );

17
algo/x16/x16rv2-4way.c
View File

@@ -65,7 +65,7 @@ union _x16rv2_8way_context_overlay
typedef union _x16rv2_8way_context_overlay x16rv2_8way_context_overlay;
static __thread x16rv2_8way_context_overlay x16rv2_ctx;
void x16rv2_8way_hash( void* output, const void* input )
int x16rv2_8way_hash( void* output, const void* input, int thrid )
{
uint32_t vhash[24*8] __attribute__ ((aligned (128)));
uint32_t hash0[24] __attribute__ ((aligned (64)));
@@ -563,6 +563,9 @@ void x16rv2_8way_hash( void* output, const void* input )
hash7, vhash );
break;
}
if ( work_restart[thrid].restart ) return 0;
size = 64;
}
@@ -574,6 +577,7 @@ void x16rv2_8way_hash( void* output, const void* input )
memcpy( output+160, hash5, 32 );
memcpy( output+192, hash6, 32 );
memcpy( output+224, hash7, 32 );
return 1;
}
int scanhash_x16rv2_8way( struct work *work, uint32_t max_nonce,
@@ -669,8 +673,7 @@ int scanhash_x16rv2_8way( struct work *work, uint32_t max_nonce,
n+3, 0, n+2, 0, n+1, 0, n, 0 ), *noncev );
do
{
x16rv2_8way_hash( hash, vdata );
if ( x16rv2_8way_hash( hash, vdata, thr_id ) )
for ( int i = 0; i < 8; i++ )
if ( unlikely( valid_hash( hash + (i<<3), ptarget ) && !bench ) )
{
@@ -718,7 +721,7 @@ inline void padtiger512( uint32_t* hash )
for ( int i = 6; i < 16; i++ ) hash[i] = 0;
}
void x16rv2_4way_hash( void* output, const void* input )
int x16rv2_4way_hash( void* output, const void* input, int thrid )
{
uint32_t hash0[20] __attribute__ ((aligned (64)));
uint32_t hash1[20] __attribute__ ((aligned (64)));
@@ -1023,12 +1026,16 @@ void x16rv2_4way_hash( void* output, const void* input )
dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
break;
}
if ( work_restart[thrid].restart ) return 0;
size = 64;
}
memcpy( output, hash0, 32 );
memcpy( output+32, hash1, 32 );
memcpy( output+64, hash2, 32 );
memcpy( output+96, hash3, 32 );
return 1;
}
int scanhash_x16rv2_4way( struct work *work, uint32_t max_nonce,
@@ -1119,7 +1126,7 @@ int scanhash_x16rv2_4way( struct work *work, uint32_t max_nonce,
do
{
x16rv2_4way_hash( hash, vdata );
if ( x16rv2_4way_hash( hash, vdata, thr_id ) )
for ( int i = 0; i < 4; i++ )
if ( unlikely( valid_hash( hash + (i<<3), ptarget ) && !bench ) )
{

9
algo/x16/x16rv2.c
View File

@@ -67,7 +67,7 @@ inline void padtiger512(uint32_t* hash) {
for (int i = (24/4); i < (64/4); i++) hash[i] = 0;
}
void x16rv2_hash( void* output, const void* input )
int x16rv2_hash( void* output, const void* input, int thrid )
{
uint32_t _ALIGN(128) hash[16];
x16rv2_context_overlay ctx;
@@ -180,10 +180,14 @@ void x16rv2_hash( void* output, const void* input )
SHA512_Final( (unsigned char*) hash, &ctx.sha512 );
break;
}
if ( work_restart[thrid].restart ) return 0;
in = (void*) hash;
size = 64;
}
memcpy(output, hash, 32);
return 1;
}
int scanhash_x16rv2( struct work *work, uint32_t max_nonce,
@@ -221,8 +225,7 @@ int scanhash_x16rv2( struct work *work, uint32_t max_nonce,
do
{
edata[19] = nonce;
x16rv2_hash( hash32, edata );
if ( x16rv2_hash( hash32, edata, thr_id ) )
if ( unlikely( valid_hash( hash32, ptarget ) && !bench ) )
{
pdata[19] = bswap_32( nonce );

21
algo/x16/x21s-4way.c
View File

@@ -30,7 +30,7 @@ union _x21s_8way_context_overlay
typedef union _x21s_8way_context_overlay x21s_8way_context_overlay;
void x21s_8way_hash( void* output, const void* input )
int x21s_8way_hash( void* output, const void* input, int thrid )
{
uint32_t vhash[16*8] __attribute__ ((aligned (128)));
uint8_t shash[64*8] __attribute__ ((aligned (64)));
@@ -44,7 +44,8 @@ void x21s_8way_hash( void* output, const void* input )
uint32_t *hash7 = (uint32_t*)( shash+448 );
x21s_8way_context_overlay ctx;
x16r_8way_hash_generic( shash, input );
if ( !x16r_8way_hash_generic( shash, input, thrid ) )
return 0;
intrlv_8x32_512( vhash, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
hash7 );
@@ -124,6 +125,8 @@ void x21s_8way_hash( void* output, const void* input )
sha256_8way_init( &ctx.sha256 );
sha256_8way_update( &ctx.sha256, vhash, 64 );
sha256_8way_close( &ctx.sha256, output );
return 1;
}
int scanhash_x21s_8way( struct work *work, uint32_t max_nonce,
@@ -166,8 +169,7 @@ int scanhash_x21s_8way( struct work *work, uint32_t max_nonce,
n+3, 0, n+2, 0, n+1, 0, n, 0 ), *noncev );
do
{
x21s_8way_hash( hash, vdata );
if ( x21s_8way_hash( hash, vdata, thr_id ) )
for ( int lane = 0; lane < 8; lane++ )
if ( unlikely( hash7[lane] <= Htarg ) )
{
@@ -215,7 +217,7 @@ union _x21s_4way_context_overlay
typedef union _x21s_4way_context_overlay x21s_4way_context_overlay;
void x21s_4way_hash( void* output, const void* input )
int x21s_4way_hash( void* output, const void* input, int thrid )
{
uint32_t vhash[16*4] __attribute__ ((aligned (64)));
uint8_t shash[64*4] __attribute__ ((aligned (64)));
@@ -225,8 +227,9 @@ void x21s_4way_hash( void* output, const void* input )
uint32_t *hash2 = (uint32_t*)( shash+128 );
uint32_t *hash3 = (uint32_t*)( shash+192 );
x16r_4way_hash_generic( shash, input );
if ( !x16r_4way_hash_generic( shash, input, thrid ) )
return 0;
intrlv_4x32( vhash, hash0, hash1, hash2, hash3, 512 );
haval256_5_4way_init( &ctx.haval );
@@ -299,6 +302,8 @@ void x21s_4way_hash( void* output, const void* input )
dintrlv_4x32( output, output+32, output+64,output+96, vhash, 256 );
#endif
return 1;
}
int scanhash_x21s_4way( struct work *work, uint32_t max_nonce,
@@ -337,7 +342,7 @@ int scanhash_x21s_4way( struct work *work, uint32_t max_nonce,
_mm256_set_epi32( n+3, 0, n+2, 0, n+1, 0, n, 0 ), *noncev );
do
{
x21s_4way_hash( hash, vdata );
if ( x21s_4way_hash( hash, vdata, thr_id ) )
for ( int i = 0; i < 4; i++ )
if ( unlikely( valid_hash( hash + (i<<3), ptarget ) && !bench ) )
{

10
algo/x16/x21s.c
View File

@@ -27,12 +27,13 @@ union _x21s_context_overlay
};
typedef union _x21s_context_overlay x21s_context_overlay;
void x21s_hash( void* output, const void* input )
int x21s_hash( void* output, const void* input, int thrid )
{
uint32_t _ALIGN(128) hash[16];
x21s_context_overlay ctx;
x16r_hash_generic( hash, input );
if ( !x16r_hash_generic( hash, input, thrid ) )
return 0;
sph_haval256_5_init( &ctx.haval );
sph_haval256_5( &ctx.haval, (const void*) hash, 64) ;
@@ -54,6 +55,8 @@ void x21s_hash( void* output, const void* input )
SHA256_Final( (unsigned char*)hash, &ctx.sha256 );
memcpy( output, hash, 32 );
return 1;
}
int scanhash_x21s( struct work *work, uint32_t max_nonce,
@@ -87,8 +90,7 @@ int scanhash_x21s( struct work *work, uint32_t max_nonce,
do
{
edata[19] = nonce;
x21s_hash( hash32, edata );
if ( x21s_hash( hash32, edata, thr_id ) )
if ( unlikely( valid_hash( hash32, ptarget ) && !bench ) )
{
pdata[19] = bswap_32( nonce );