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

Browse Source
This commit is contained in:
Jay D Dee
2016-11-10 21:06:01 -05:00
parent c6ffb951f5
commit c551fb4a25
7 changed files with 51 additions and 353 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
RELEASE_ANNOUNCEMENT
View File

@@ -7,9 +7,10 @@ CPUs with AES_NI for even greater performance, including the Intel
Westbridge and newer and AMD equivalent. See the performance Westbridge and newer and AMD equivalent. See the performance
comparison below. comparison below.
New in 3.4.10 New in 3.4.11
- xevan AES optimized +35% - groestl algo AES optimized +200%
- myr-gr algo AES optimized +100%
Users with non-SSE2 CPUs or who want to mine algos not supported by Users with non-SSE2 CPUs or who want to mine algos not supported by
cpuminer-opt may find cpuminer-multi by TPruvot useful. cpuminer-opt may find cpuminer-multi by TPruvot useful.

7
algo-gate-api.c
View File

@@ -72,7 +72,8 @@ void *return_null () { return NULL; }
void algo_not_tested() void algo_not_tested()
{ {
applog(LOG_WARNING,"Algo %s has not been tested live. It may not work",algo_names[opt_algo]); applog( LOG_WARNING,"Algo %s has not been tested live. It may not work",
algo_names[opt_algo] );
applog(LOG_WARNING,"and bad things may happen. Use at your own risk."); applog(LOG_WARNING,"and bad things may happen. Use at your own risk.");
} }
@@ -248,8 +249,8 @@ void exec_hash_function( int algo, void *output, const void *pdata )
#define ALIAS (0) #define ALIAS (0)
// The only difference between the alias and the proper algo name is the // The only difference between the alias and the proper algo name is the
// proper name must be unique and defined in ALGO_NAMES, there may be // proper name s the one that is defined in ALGO_NAMES, there may be
// multiple aliases but are not defined in ALGO_NAMES. // multiple aliases that map to the same proper name.
// New aliases can be added anywhere in the array as long as NULL is last. // New aliases can be added anywhere in the array as long as NULL is last.
// Alphabetic order of alias is recommended. // Alphabetic order of alias is recommended.
const char* const algo_alias_map[][2] = const char* const algo_alias_map[][2] =

292
algo/cubehash/sse2/cubehash_sse2.c.broke
View File

@@ -1,292 +0,0 @@
/* 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;
}

36
algo/groestl/groestl.c
View File

@@ -6,21 +6,18 @@
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
#include "sph_groestl.h" #ifdef NO_AES_NI
#include "sph_groestl.h"
// local override #else
#define NO_AES_NI
#ifndef NO_AES_NI
#include "algo/groestl/aes_ni/hash-groestl.h" #include "algo/groestl/aes_ni/hash-groestl.h"
#endif #endif
typedef struct typedef struct
{ {
#ifndef NO_AES_NI #ifdef NO_AES_NI
hashState_groestl groestl1, groestl2;
#else
sph_groestl512_context groestl; sph_groestl512_context groestl;
#else
hashState_groestl groestl1, groestl2;
#endif #endif
} groestl_ctx_holder; } groestl_ctx_holder;
@@ -29,11 +26,11 @@ static groestl_ctx_holder groestl_ctx;
void init_groestl_ctx() void init_groestl_ctx()
{ {
#ifndef NO_AES_NI #ifdef NO_AES_NI
sph_groestl512_init( &groestl_ctx.groestl );
#else
init_groestl( &groestl_ctx.groestl1 ); init_groestl( &groestl_ctx.groestl1 );
init_groestl( &groestl_ctx.groestl2 ); init_groestl( &groestl_ctx.groestl2 );
#else
sph_groestl512_init( &groestl_ctx.groestl );
#endif #endif
} }
@@ -45,18 +42,18 @@ void groestlhash(void *output, const void *input)
// memset(&hash[0], 0, sizeof(hash)); // memset(&hash[0], 0, sizeof(hash));
#ifndef NO_AES_NI #ifdef NO_AES_NI
update_groestl( &ctx.groestl1, (char*)input, 80 );
final_groestl( &ctx.groestl1,(char*)hash);
update_groestl( &ctx.groestl2, (char*)hash, 64 );
final_groestl( &ctx.groestl2, (char*)hash);
#else
sph_groestl512(&ctx.groestl, input, 80); sph_groestl512(&ctx.groestl, input, 80);
sph_groestl512_close(&ctx.groestl, hash); sph_groestl512_close(&ctx.groestl, hash);
sph_groestl512(&ctx.groestl, hash, 64); sph_groestl512(&ctx.groestl, hash, 64);
sph_groestl512_close(&ctx.groestl, hash); sph_groestl512_close(&ctx.groestl, hash);
#else
update_groestl( &ctx.groestl1, (char*)input, 640 );
final_groestl( &ctx.groestl1,(char*)hash);
update_groestl( &ctx.groestl2, (char*)hash, 512 );
final_groestl( &ctx.groestl2, (char*)hash);
#endif #endif
memcpy(output, hash, 32); memcpy(output, hash, 32);
} }
@@ -106,6 +103,7 @@ void groestl_set_target( struct work* work, double job_diff )
bool register_groestl_algo( algo_gate_t* gate ) bool register_groestl_algo( algo_gate_t* gate )
{ {
init_groestl_ctx(); init_groestl_ctx();
gate->optimizations = SSE2_OPT | AES_OPT;
gate->scanhash = (void*)&scanhash_groestl; gate->scanhash = (void*)&scanhash_groestl;
gate->hash = (void*)&groestlhash; gate->hash = (void*)&groestlhash;
gate->hash_alt = (void*)&groestlhash; gate->hash_alt = (void*)&groestlhash;

40
algo/groestl/myr-groestl.c
View File

@@ -6,19 +6,19 @@
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
//#ifdef NO_AES_NI #ifdef NO_AES_NI
#include "sph_groestl.h" #include "sph_groestl.h"
//#else #else
// #include "aes_ni/hash-groestl.h" #include "aes_ni/hash-groestl.h"
//#endif #endif
#include "algo/sha3/sph_sha2.h" #include "algo/sha3/sph_sha2.h"
typedef struct { typedef struct {
//#ifdef NO_AES_NI #ifdef NO_AES_NI
sph_groestl512_context groestl; sph_groestl512_context groestl;
//#else #else
// hashState_groestl groestl; hashState_groestl groestl;
//#endif #endif
sph_sha256_context sha; sph_sha256_context sha;
} myrgr_ctx_holder; } myrgr_ctx_holder;
@@ -26,28 +26,28 @@ myrgr_ctx_holder myrgr_ctx;
void init_myrgr_ctx() void init_myrgr_ctx()
{ {
//#ifdef NO_AES_NI #ifdef NO_AES_NI
sph_groestl512_init( &myrgr_ctx.groestl ); sph_groestl512_init( &myrgr_ctx.groestl );
//#else #else
// init_groestl (&myrgr_ctx.groestl ); init_groestl (&myrgr_ctx.groestl );
//#endif #endif
sph_sha256_init(&myrgr_ctx.sha); sph_sha256_init(&myrgr_ctx.sha);
} }
void myriadhash(void *output, const void *input) void myriadhash(void *output, const void *input)
{ {
myrgr_ctx_holder ctx; myrgr_ctx_holder ctx;
memcpy( &ctx, &myrgr_ctx, sizeof(myrgr_ctx) ); memcpy( &ctx, &myrgr_ctx, sizeof(myrgr_ctx) );
uint32_t _ALIGN(32) hash[16]; uint32_t _ALIGN(32) hash[16];
//#ifdef NO_AES_NI #ifdef NO_AES_NI
sph_groestl512(&ctx.groestl, input, 80); sph_groestl512(&ctx.groestl, input, 80);
sph_groestl512_close(&ctx.groestl, hash); sph_groestl512_close(&ctx.groestl, hash);
//#else #else
// update_groestl( &ctx.groestl, (char*)hash,512); update_groestl( &ctx.groestl, (char*)input, 640 );
// final_groestl( &ctx.groestl, (char*)hash); final_groestl( &ctx.groestl, (char*)hash);
//#endif #endif
sph_sha256(&ctx.sha, hash, 64); sph_sha256(&ctx.sha, hash, 64);
sph_sha256_close(&ctx.sha, hash); sph_sha256_close(&ctx.sha, hash);
@@ -92,7 +92,7 @@ int scanhash_myriad(int thr_id, struct work *work,
bool register_myriad_algo( algo_gate_t* gate ) bool register_myriad_algo( algo_gate_t* gate )
{ {
// gate->optimizations = SSE2_OPT | AES_OPT; gate->optimizations = SSE2_OPT | AES_OPT;
init_myrgr_ctx(); init_myrgr_ctx();
gate->scanhash = (void*)&scanhash_myriad; gate->scanhash = (void*)&scanhash_myriad;
gate->hash = (void*)&myriadhash; gate->hash = (void*)&myriadhash;

22
algo/xevan.c
View File

@@ -13,13 +13,14 @@
#include "algo/skein/sph_skein.h" #include "algo/skein/sph_skein.h"
#include "algo/shavite/sph_shavite.h" #include "algo/shavite/sph_shavite.h"
#include "algo/luffa/sph_luffa.h" #include "algo/luffa/sph_luffa.h"
#include "algo/simd/sph_simd.h"
#include "algo/hamsi/sph_hamsi.h" #include "algo/hamsi/sph_hamsi.h"
#include "algo/fugue/sph_fugue.h" #include "algo/fugue/sph_fugue.h"
#include "algo/shabal/sph_shabal.h" #include "algo/shabal/sph_shabal.h"
#include "algo/whirlpool/sph_whirlpool.h" #include "algo/whirlpool/sph_whirlpool.h"
#include "algo/sha3/sph_sha2.h" #include "algo/sha3/sph_sha2.h"
#include "algo/haval/sph-haval.h" #include "algo/haval/sph-haval.h"
#include "algo/simd/sse2/nist.h"
#include "algo/cubehash/sse2/cubehash_sse2.h"
#ifdef NO_AES_NI #ifdef NO_AES_NI
#include "algo/groestl/sph_groestl.h" #include "algo/groestl/sph_groestl.h"
@@ -29,9 +30,6 @@
#include "algo/echo/aes_ni/hash_api.h" #include "algo/echo/aes_ni/hash_api.h"
#endif #endif
#include "algo/cubehash/sse2/cubehash_sse2.h"
#include "algo/simd/sse2/nist.h"
typedef struct { typedef struct {
sph_blake512_context blake; sph_blake512_context blake;
sph_bmw512_context bmw; sph_bmw512_context bmw;
@@ -39,11 +37,9 @@ typedef struct {
sph_jh512_context jh; sph_jh512_context jh;
sph_keccak512_context keccak; sph_keccak512_context keccak;
sph_luffa512_context luffa; sph_luffa512_context luffa;
// hashState_luffa luffa;
cubehashParam cubehash; cubehashParam cubehash;
sph_shavite512_context shavite; sph_shavite512_context shavite;
// sph_simd512_context simd; hashState_sd simd;
hashState_sd simd;
sph_hamsi512_context hamsi; sph_hamsi512_context hamsi;
sph_fugue512_context fugue; sph_fugue512_context fugue;
sph_shabal512_context shabal; sph_shabal512_context shabal;
@@ -69,11 +65,9 @@ void init_xevan_ctx()
sph_jh512_init(&xevan_ctx.jh); sph_jh512_init(&xevan_ctx.jh);
sph_keccak512_init(&xevan_ctx.keccak); sph_keccak512_init(&xevan_ctx.keccak);
sph_luffa512_init(&xevan_ctx.luffa); sph_luffa512_init(&xevan_ctx.luffa);
// init_luffa( &xevan_ctx.luffa, 512 );
cubehashInit( &xevan_ctx.cubehash, 512, 16, 32 ); cubehashInit( &xevan_ctx.cubehash, 512, 16, 32 );
sph_shavite512_init( &xevan_ctx.shavite ); sph_shavite512_init( &xevan_ctx.shavite );
// sph_simd512_init(&xevan_ctx.simd); init_sd( &xevan_ctx.simd, 512 );
init_sd( &xevan_ctx.simd, 512 );
sph_hamsi512_init( &xevan_ctx.hamsi ); sph_hamsi512_init( &xevan_ctx.hamsi );
sph_fugue512_init( &xevan_ctx.fugue ); sph_fugue512_init( &xevan_ctx.fugue );
sph_shabal512_init( &xevan_ctx.shabal ); sph_shabal512_init( &xevan_ctx.shabal );
@@ -270,17 +264,13 @@ void xevan_set_target( struct work* work, double job_diff )
work_set_target( work, job_diff / (256.0 * opt_diff_factor) ); work_set_target( work, job_diff / (256.0 * opt_diff_factor) );
} }
//int64_t xevan_get_max64() { return 0xffffLL; }
bool register_xevan_algo( algo_gate_t* gate ) bool register_xevan_algo( algo_gate_t* gate )
{ {
gate->optimizations = SSE2_OPT | AES_OPT | AVX_OPT | AVX2_OPT; gate->optimizations = SSE2_OPT | AES_OPT | AVX_OPT | AVX2_OPT;
init_xevan_ctx(); init_xevan_ctx();
gate->scanhash = (void*)&scanhash_xevan; gate->scanhash = (void*)&scanhash_xevan;
gate->hash = (void*)&xevan_hash; gate->hash = (void*)&xevan_hash;
// gate->hash_alt = (void*)&xevanhash_alt;
gate->set_target = (void*)&xevan_set_target; gate->set_target = (void*)&xevan_set_target;
// gate->get_max64 = (void*)&xevan_get_max64;
gate->get_max64 = (void*)&get_max64_0xffffLL; gate->get_max64 = (void*)&get_max64_0xffffLL;
return true; return true;
}; };

2
configure.ac
View File

@@ -1,4 +1,4 @@
AC_INIT([cpuminer-opt], [3.4.10]) AC_INIT([cpuminer-opt], [3.4.11])
AC_PREREQ([2.59c]) AC_PREREQ([2.59c])
AC_CANONICAL_SYSTEM AC_CANONICAL_SYSTEM