mirror of
https://github.com/JayDDee/cpuminer-opt.git
synced 2025-09-17 23:44:27 +00:00
Initial upload v3.4.7
This commit is contained in:
Jay D Dee
292
algo/cubehash/sse2/cubehash_sse2.c.broke
Normal file
292
algo/cubehash/sse2/cubehash_sse2.c.broke
Normal file
@@ -0,0 +1,292 @@
|
||||
/* 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 "algo/sha3/sha3-defs.h"
|
||||
|
||||
//enum { SUCCESS = 0, FAIL = 1, BAD_HASHBITLEN = 2 };
|
||||
|
||||
//#if defined(OPTIMIZE_SSE2)
|
||||
|
||||
static inline void transform( cubehashParam *sp )
|
||||
{
|
||||
int r;
|
||||
|
||||
#ifdef __AVX2__
|
||||
|
||||
__m256i x0, x1, x2, x3, y0, y1;
|
||||
#ifdef UNUSED
|
||||
__m256i y2, y3;
|
||||
#endif
|
||||
|
||||
x0 = _mm256_loadu_si256( 0 + sp->x );
|
||||
x1 = _mm256_loadu_si256( 2 + sp->x );
|
||||
x2 = _mm256_loadu_si256( 4 + sp->x );
|
||||
x3 = _mm256_loadu_si256( 6 + sp->x );
|
||||
|
||||
for ( r = 0; r < sp->rounds; ++r )
|
||||
{
|
||||
x2 = _mm256_add_epi32( x0, x2 );
|
||||
x3 = _mm256_add_epi32( x1, x3 );
|
||||
y0 = x1;
|
||||
y1 = x0;
|
||||
x0 = _mm256_xor_si256( _mm256_slli_epi32( y0, 7 ),
|
||||
_mm256_srli_epi32( y0, 25 ) );
|
||||
x1 = _mm256_xor_si256( _mm256_slli_epi32( y1, 7 ),
|
||||
_mm256_srli_epi32( y1, 25 ) );
|
||||
x0 = _mm256_xor_si256( x0, x2 );
|
||||
x1 = _mm256_xor_si256( x1, x3 );
|
||||
x2 = _mm256_shuffle_epi32( x2, 0x4e );
|
||||
x3 = _mm256_shuffle_epi32( x3, 0x4e );
|
||||
x2 = _mm256_add_epi32( x0, x2 );
|
||||
x3 = _mm256_add_epi32( x1, x3 );
|
||||
y0 = _mm256_permute2f128_si256( x0, x0, 1 );
|
||||
y1 = _mm256_permute2f128_si256( x1, x1, 1 );
|
||||
x0 = _mm256_xor_si256( _mm256_slli_epi32( y0, 11 ),
|
||||
_mm256_srli_epi32( y0, 21 ) );
|
||||
x1 = _mm256_xor_si256( _mm256_slli_epi32( y1, 11 ),
|
||||
_mm256_srli_epi32( y1, 21 ) );
|
||||
x0 = _mm256_xor_si256( x0, x2 );
|
||||
x1 = _mm256_xor_si256( x1, x3 );
|
||||
x2 = _mm256_shuffle_epi32( x2, 0xb1 );
|
||||
x3 = _mm256_shuffle_epi32( x3, 0xb1 );
|
||||
}
|
||||
|
||||
_mm256_storeu_si256( 0 + sp->x, x0 );
|
||||
_mm256_storeu_si256( 2 + sp->x, x1 );
|
||||
_mm256_storeu_si256( 4 + sp->x, x2 );
|
||||
_mm256_storeu_si256( 6 + sp->x, x3 );
|
||||
|
||||
#elif defined OPTIMIZE_SSE2
|
||||
|
||||
__m128i x0, x1, x2, x3, x4, x5, x6, x7, y0, y1, y2, y3;
|
||||
#ifdef UNUSED
|
||||
__m128i y4, y5, y6, y7;
|
||||
#endif
|
||||
|
||||
x0 = _mm_load_si128(0 + sp->x);
|
||||
x1 = _mm_load_si128(1 + sp->x);
|
||||
x2 = _mm_load_si128(2 + sp->x);
|
||||
x3 = _mm_load_si128(3 + sp->x);
|
||||
x4 = _mm_load_si128(4 + sp->x);
|
||||
x5 = _mm_load_si128(5 + sp->x);
|
||||
x6 = _mm_load_si128(6 + sp->x);
|
||||
x7 = _mm_load_si128(7 + sp->x);
|
||||
|
||||
for (r = 0; r < sp->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);
|
||||
y0 = x2;
|
||||
y1 = x3;
|
||||
y2 = x0;
|
||||
y3 = x1;
|
||||
x0 = _mm_xor_si128(_mm_slli_epi32(y0, 7), _mm_srli_epi32(y0, 25));
|
||||
x1 = _mm_xor_si128(_mm_slli_epi32(y1, 7), _mm_srli_epi32(y1, 25));
|
||||
x2 = _mm_xor_si128(_mm_slli_epi32(y2, 7), _mm_srli_epi32(y2, 25));
|
||||
x3 = _mm_xor_si128(_mm_slli_epi32(y3, 7), _mm_srli_epi32(y3, 25));
|
||||
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);
|
||||
y0 = x1;
|
||||
y1 = x0;
|
||||
y2 = x3;
|
||||
y3 = x2;
|
||||
x0 = _mm_xor_si128(_mm_slli_epi32(y0, 11), _mm_srli_epi32(y0, 21));
|
||||
x1 = _mm_xor_si128(_mm_slli_epi32(y1, 11), _mm_srli_epi32(y1, 21));
|
||||
x2 = _mm_xor_si128(_mm_slli_epi32(y2, 11), _mm_srli_epi32(y2, 21));
|
||||
x3 = _mm_xor_si128(_mm_slli_epi32(y3, 11), _mm_srli_epi32(y3, 21));
|
||||
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);
|
||||
}
|
||||
|
||||
_mm_store_si128(0 + sp->x, x0);
|
||||
_mm_store_si128(1 + sp->x, x1);
|
||||
_mm_store_si128(2 + sp->x, x2);
|
||||
_mm_store_si128(3 + sp->x, x3);
|
||||
_mm_store_si128(4 + sp->x, x4);
|
||||
_mm_store_si128(5 + sp->x, x5);
|
||||
_mm_store_si128(6 + sp->x, x6);
|
||||
_mm_store_si128(7 + sp->x, x7);
|
||||
|
||||
#else /* OPTIMIZE_SSE2 */
|
||||
// Tis code probably not used, sph used instead for uniptoimized mining.
|
||||
|
||||
#define ROTATE(a,b) (((a) << (b)) | ((a) >> (32 - b)))
|
||||
|
||||
uint32_t y[16];
|
||||
int i;
|
||||
|
||||
for (r = 0; r < sp->rounds; ++r) {
|
||||
|
||||
for (i = 0; i < 16; ++i) sp->x[i + 16] += sp->x[i];
|
||||
|
||||
for (i = 0; i < 16; ++i) sp->x[i] = ROTATE(y[i],7);
|
||||
|
||||
for (i = 0; i < 16; ++i) sp->x[i] ^= sp->x[i + 16];
|
||||
|
||||
for (i = 0; i < 16; ++i) y[i ^ 2] = sp->x[i + 16];
|
||||
|
||||
for (i = 0; i < 16; ++i) sp->x[i + 16] = y[i];
|
||||
|
||||
for (i = 0; i < 16; ++i) sp->x[i + 16] += sp->x[i];
|
||||
|
||||
for (i = 0; i < 16; ++i) y[i ^ 4] = sp->x[i];
|
||||
|
||||
for (i = 0; i < 16; ++i) sp->x[i] = ROTATE(y[i],11);
|
||||
|
||||
for (i = 0; i < 16; ++i) sp->x[i] ^= sp->x[i + 16];
|
||||
|
||||
for (i = 0; i < 16; ++i) y[i ^ 1] = sp->x[i + 16];
|
||||
|
||||
for (i = 0; i < 16; ++i) sp->x[i + 16] = y[i];
|
||||
|
||||
}
|
||||
#endif
|
||||
} // transform
|
||||
|
||||
int cubehashInit(cubehashParam *sp, int hashbitlen, int rounds, int blockbytes)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (hashbitlen < 8) return BAD_HASHBITLEN;
|
||||
if (hashbitlen > 512) return BAD_HASHBITLEN;
|
||||
if (hashbitlen != 8 * (hashbitlen / 8)) return BAD_HASHBITLEN;
|
||||
|
||||
/* Sanity checks */
|
||||
if (rounds <= 0 || rounds > 32) rounds = CUBEHASH_ROUNDS;
|
||||
if (blockbytes <= 0 || blockbytes >= 256) blockbytes = CUBEHASH_BLOCKBYTES;
|
||||
|
||||
sp->hashbitlen = hashbitlen;
|
||||
sp->rounds = rounds;
|
||||
sp->blockbytes = blockbytes;
|
||||
#if defined __AVX2__
|
||||
for (i = 0; i < 4; ++i) sp->x[i] = _mm256_set_epi64x( 0, 0, 0, 0 );
|
||||
// try swapping
|
||||
sp->x[0] = _mm256_set_epi32( 0, sp->rounds, sp->blockbytes, hashbitlen / 8,
|
||||
0, 0, 0, 0);
|
||||
// sp->x[0] = _mm256_set_epi32( 0, 0, 0, 0,
|
||||
// 0, sp->rounds, sp->blockbytes, hashbitlen / 8 );
|
||||
#elif defined(OPTIMIZE_SSE2)
|
||||
for (i = 0; i < 8; ++i) sp->x[i] = _mm_set_epi32(0, 0, 0, 0);
|
||||
sp->x[0] = _mm_set_epi32(0, sp->rounds, sp->blockbytes, hashbitlen / 8);
|
||||
#else
|
||||
for (i = 0; i < 32; ++i) sp->x[i] = 0;
|
||||
sp->x[0] = hashbitlen / 8;
|
||||
sp->x[1] = sp->blockbytes;
|
||||
sp->x[2] = sp->rounds;
|
||||
#endif
|
||||
for (i = 0; i < 10; ++i) transform(sp);
|
||||
sp->pos = 0;
|
||||
return SUCCESS;
|
||||
}
|
||||
|
||||
int
|
||||
cubehashReset(cubehashParam *sp)
|
||||
{
|
||||
return cubehashInit(sp, sp->hashbitlen, sp->rounds, sp->blockbytes);
|
||||
}
|
||||
|
||||
int cubehashUpdate(cubehashParam *sp, const byte *data, size_t size)
|
||||
{
|
||||
uint64_t databitlen = 8 * size;
|
||||
|
||||
/* caller promises us that previous data had integral number of bytes */
|
||||
/* so sp->pos is a multiple of 8 */
|
||||
|
||||
while (databitlen >= 8) {
|
||||
#if defined __AVX2__
|
||||
((unsigned char *) sp->x)[sp->pos / 8] ^= *data;
|
||||
#elif defined(OPTIMIZE_SSE2)
|
||||
((unsigned char *) sp->x)[sp->pos / 8] ^= *data;
|
||||
#else
|
||||
uint32_t u = *data;
|
||||
u <<= 8 * ((sp->pos / 8) % 4);
|
||||
sp->x[sp->pos / 32] ^= u;
|
||||
#endif
|
||||
data += 1;
|
||||
databitlen -= 8;
|
||||
sp->pos += 8;
|
||||
if (sp->pos == 8 * sp->blockbytes) {
|
||||
transform(sp);
|
||||
sp->pos = 0;
|
||||
}
|
||||
}
|
||||
if (databitlen > 0) {
|
||||
#if defined __AVX2__
|
||||
((unsigned char *) sp->x)[sp->pos / 8] ^= *data;
|
||||
#elif defined(OPTIMIZE_SSE2)
|
||||
((unsigned char *) sp->x)[sp->pos / 8] ^= *data;
|
||||
#else
|
||||
uint32_t u = *data;
|
||||
u <<= 8 * ((sp->pos / 8) % 4);
|
||||
sp->x[sp->pos / 32] ^= u;
|
||||
#endif
|
||||
sp->pos += databitlen;
|
||||
}
|
||||
return SUCCESS;
|
||||
}
|
||||
|
||||
int cubehashDigest(cubehashParam *sp, byte *digest)
|
||||
{
|
||||
int i;
|
||||
#if defined __AVX2__
|
||||
((unsigned char *) sp->x)[sp->pos / 8] ^= (128 >> (sp->pos % 8));
|
||||
__m128i t;
|
||||
transform(sp);
|
||||
// try control 0
|
||||
// t = _mm256_extracti128_si256( sp->x[7], 1 );
|
||||
t = _mm256_extracti128_si256( sp->x[7], 0 );
|
||||
t = _mm_xor_si128( t, _mm_set_epi32(1, 0, 0, 0) );
|
||||
// _mm256_inserti128_si256( sp->x[7], t, 1 );
|
||||
_mm256_inserti128_si256( sp->x[7], t, 0 );
|
||||
|
||||
for (i = 0; i < 10; ++i) transform(sp);
|
||||
for (i = 0; i < sp->hashbitlen / 8; ++i)
|
||||
digest[i] = ((unsigned char *) sp->x)[i];
|
||||
|
||||
#elif defined(OPTIMIZE_SSE2)
|
||||
((unsigned char *) sp->x)[sp->pos / 8] ^= (128 >> (sp->pos % 8));
|
||||
transform(sp);
|
||||
sp->x[7] = _mm_xor_si128(sp->x[7], _mm_set_epi32(1, 0, 0, 0));
|
||||
for (i = 0; i < 10; ++i) transform(sp);
|
||||
for (i = 0; i < sp->hashbitlen / 8; ++i)
|
||||
digest[i] = ((unsigned char *) sp->x)[i];
|
||||
#else
|
||||
uint32_t u;
|
||||
|
||||
u = (128 >> (sp->pos % 8));
|
||||
u <<= 8 * ((sp->pos / 8) % 4);
|
||||
sp->x[sp->pos / 32] ^= u;
|
||||
transform(sp);
|
||||
sp->x[31] ^= 1;
|
||||
for (i = 0; i < 10; ++i) transform(sp);
|
||||
for (i = 0; i < sp->hashbitlen / 8; ++i)
|
||||
digest[i] = sp->x[i / 4] >> (8 * (i % 4));
|
||||
#endif
|
||||
|
||||
return SUCCESS;
|
||||
}
|
||||
Reference in New Issue
Block a user