mirror of
https://github.com/GOSTSec/sgminer
synced 2025-03-10 04:31:03 +00:00
Merge branch 'altivec'
This commit is contained in:
Con Kolivas
commit
a2072d7304
@ -24,6 +24,7 @@ cgminer_SOURCES = elist.h miner.h compat.h bench_block.h \
|
||||
sha256_generic.c sha256_4way.c sha256_via.c \
|
||||
sha256_cryptopp.c sha256_sse2_amd64.c \
|
||||
sha256_sse4_amd64.c sha256_sse2_i386.c \
|
||||
sha256_altivec_4way.c \
|
||||
adl.c adl.h adl_functions.h \
|
||||
phatk110817.cl poclbm110817.cl \
|
||||
sha2.c sha2.h
|
||||
|
||||
@ -83,6 +83,11 @@ case $target in
|
||||
DLOPEN_FLAGS=""
|
||||
WS2_LIBS="-lws2_32"
|
||||
;;
|
||||
powerpc-*-darwin*)
|
||||
CFLAGS="$CFLAGS -faltivec"
|
||||
OPENCL_LIBS=""
|
||||
PTHREAD_FLAGS=""
|
||||
;;
|
||||
*-*-darwin*)
|
||||
OPENCL_LIBS="-framework OpenCL"
|
||||
;;
|
||||
|
||||
46
main.c
46
main.c
@ -106,6 +106,7 @@ enum sha256_algos {
|
||||
ALGO_SSE2_32, /* SSE2 for x86_32 */
|
||||
ALGO_SSE2_64, /* SSE2 for x86_64 */
|
||||
ALGO_SSE4_64, /* SSE4 for x86_64 */
|
||||
ALGO_ALTIVEC_4WAY, /* parallel Altivec */
|
||||
};
|
||||
|
||||
enum pool_strategy {
|
||||
@ -149,6 +150,9 @@ static const char *algo_names[] = {
|
||||
#ifdef WANT_X8664_SSE4
|
||||
[ALGO_SSE4_64] = "sse4_64",
|
||||
#endif
|
||||
#ifdef WANT_ALTIVEC_4WAY
|
||||
[ALGO_ALTIVEC_4WAY] = "altivec_4way",
|
||||
#endif
|
||||
};
|
||||
|
||||
typedef void (*sha256_func)();
|
||||
@ -157,6 +161,9 @@ static const sha256_func sha256_funcs[] = {
|
||||
#ifdef WANT_SSE2_4WAY
|
||||
[ALGO_4WAY] = (sha256_func)ScanHash_4WaySSE2,
|
||||
#endif
|
||||
#ifdef WANT_ALTIVEC_4WAY
|
||||
[ALGO_ALTIVEC_4WAY] = (sha256_func) ScanHash_altivec_4way,
|
||||
#endif
|
||||
#ifdef WANT_VIA_PADLOCK
|
||||
[ALGO_VIA] = (sha256_func)scanhash_via,
|
||||
#endif
|
||||
@ -896,6 +903,10 @@ static enum sha256_algos pick_fastest_algo()
|
||||
bench_algo(&best_rate, &best_algo, ALGO_SSE4_64);
|
||||
#endif
|
||||
|
||||
#if defined(WANT_ALTIVEC_4WAY)
|
||||
bench_algo(&best_rate, &best_algo, ALGO_ALTIVEC_4WAY);
|
||||
#endif
|
||||
|
||||
size_t n = max_name_len - strlen(algo_names[best_algo]);
|
||||
memset(name_spaces_pad, ' ', n);
|
||||
name_spaces_pad[n] = 0;
|
||||
@ -1451,6 +1462,9 @@ static struct opt_table opt_config_table[] = {
|
||||
#endif
|
||||
#ifdef WANT_X8664_SSE4
|
||||
"\n\tsse4_64\t\tSSE4.1 64 bit implementation for x86_64 machines"
|
||||
#endif
|
||||
#ifdef WANT_ALTIVEC_4WAY
|
||||
"\n\taltivec_4way\tAltivec implementation for PowerPC G4 and G5 machines"
|
||||
#endif
|
||||
),
|
||||
#ifdef HAVE_ADL
|
||||
@ -1787,6 +1801,19 @@ static bool work_decode(const json_t *val, struct work *work)
|
||||
}
|
||||
|
||||
memset(work->hash, 0, sizeof(work->hash));
|
||||
|
||||
#ifdef __BIG_ENDIAN__
|
||||
int swapcounter = 0;
|
||||
for (swapcounter = 0; swapcounter < 32; swapcounter++)
|
||||
(((uint32_t*) (work->data))[swapcounter]) = swab32(((uint32_t*) (work->data))[swapcounter]);
|
||||
for (swapcounter = 0; swapcounter < 16; swapcounter++)
|
||||
(((uint32_t*) (work->hash1))[swapcounter]) = swab32(((uint32_t*) (work->hash1))[swapcounter]);
|
||||
for (swapcounter = 0; swapcounter < 8; swapcounter++)
|
||||
(((uint32_t*) (work->midstate))[swapcounter]) = swab32(((uint32_t*) (work->midstate))[swapcounter]);
|
||||
for (swapcounter = 0; swapcounter < 8; swapcounter++)
|
||||
(((uint32_t*) (work->target))[swapcounter]) = swab32(((uint32_t*) (work->target))[swapcounter]);
|
||||
#endif
|
||||
|
||||
gettimeofday(&work->tv_staged, NULL);
|
||||
|
||||
return true;
|
||||
@ -2141,6 +2168,12 @@ static bool submit_upstream_work(const struct work *work)
|
||||
return rc;
|
||||
}
|
||||
|
||||
#ifdef __BIG_ENDIAN__
|
||||
int swapcounter = 0;
|
||||
for (swapcounter = 0; swapcounter < 32; swapcounter++)
|
||||
(((uint32_t*) (work->data))[swapcounter]) = swab32(((uint32_t*) (work->data))[swapcounter]);
|
||||
#endif
|
||||
|
||||
/* build hex string */
|
||||
hexstr = bin2hex(work->data, sizeof(work->data));
|
||||
if (unlikely(!hexstr)) {
|
||||
@ -4101,6 +4134,19 @@ static void *miner_thread(void *userdata)
|
||||
break;
|
||||
#endif
|
||||
|
||||
#ifdef WANT_ALTIVEC_4WAY
|
||||
case ALGO_ALTIVEC_4WAY:
|
||||
{
|
||||
unsigned int rc4 = ScanHash_altivec_4way(thr_id, work->midstate, work->data + 64,
|
||||
work->hash1, work->hash,
|
||||
work->target,
|
||||
max_nonce, &hashes_done,
|
||||
work->blk.nonce);
|
||||
rc = (rc4 == -1) ? false : true;
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
|
||||
#ifdef WANT_VIA_PADLOCK
|
||||
case ALGO_VIA:
|
||||
rc = scanhash_via(thr_id, work->data, work->target,
|
||||
|
||||
13
miner.h
13
miner.h
@ -64,6 +64,10 @@ void *alloca (size_t);
|
||||
#define WANT_SSE2_4WAY 1
|
||||
#endif
|
||||
|
||||
#ifdef __ALTIVEC__
|
||||
#define WANT_ALTIVEC_4WAY 1
|
||||
#endif
|
||||
|
||||
#if defined(__i386__) && defined(HAS_YASM) && defined(__SSE2__)
|
||||
#define WANT_X8632_SSE2 1
|
||||
#endif
|
||||
@ -329,6 +333,12 @@ extern unsigned int ScanHash_4WaySSE2(int, const unsigned char *pmidstate,
|
||||
const unsigned char *ptarget,
|
||||
uint32_t max_nonce, unsigned long *nHashesDone, uint32_t nonce);
|
||||
|
||||
extern unsigned int ScanHash_altivec_4way(int thr_id, const unsigned char *pmidstate,
|
||||
unsigned char *pdata,
|
||||
unsigned char *phash1, unsigned char *phash,
|
||||
const unsigned char *ptarget,
|
||||
uint32_t max_nonce, unsigned long *nHashesDone, uint32_t nonce);
|
||||
|
||||
extern unsigned int scanhash_sse2_amd64(int, const unsigned char *pmidstate,
|
||||
unsigned char *pdata, unsigned char *phash1, unsigned char *phash,
|
||||
const unsigned char *ptarget,
|
||||
@ -342,14 +352,17 @@ extern bool scanhash_c(int, const unsigned char *midstate, unsigned char *data,
|
||||
unsigned char *hash1, unsigned char *hash,
|
||||
const unsigned char *target,
|
||||
uint32_t max_nonce, unsigned long *hashes_done, uint32_t n);
|
||||
|
||||
extern bool scanhash_cryptopp(int, const unsigned char *midstate,unsigned char *data,
|
||||
unsigned char *hash1, unsigned char *hash,
|
||||
const unsigned char *target,
|
||||
uint32_t max_nonce, unsigned long *hashes_done, uint32_t n);
|
||||
|
||||
extern bool scanhash_asm32(int, const unsigned char *midstate,unsigned char *data,
|
||||
unsigned char *hash1, unsigned char *hash,
|
||||
const unsigned char *target,
|
||||
uint32_t max_nonce, unsigned long *hashes_done, uint32_t nonce);
|
||||
|
||||
extern int scanhash_sse2_64(int, const unsigned char *pmidstate, unsigned char *pdata,
|
||||
unsigned char *phash1, unsigned char *phash,
|
||||
const unsigned char *ptarget,
|
||||
|
||||
469
sha256_altivec_4way.c
Normal file
469
sha256_altivec_4way.c
Normal file
@ -0,0 +1,469 @@
|
||||
// Copyright (c) 2010 Satoshi Nakamoto
|
||||
// Copyright (c) 2011 Gilles Risch
|
||||
// Distributed under the MIT/X11 software license, see the accompanying
|
||||
// file license.txt or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
|
||||
// 4-way 128-bit Altivec SHA-256,
|
||||
// based on tcatm's 4-way 128-bit SSE2 SHA-256
|
||||
//
|
||||
|
||||
|
||||
//#include "config.h"
|
||||
#include "miner.h"
|
||||
|
||||
#ifdef WANT_ALTIVEC_4WAY
|
||||
|
||||
#include <string.h>
|
||||
#include <assert.h>
|
||||
|
||||
//#include <altivec.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#define NPAR 32
|
||||
|
||||
static void DoubleBlockSHA256(const void* pin, void* pout, const void* pinit, unsigned int hash[8][NPAR], const void* init2);
|
||||
|
||||
static const unsigned int sha256_consts[] = {
|
||||
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, /* 0 */
|
||||
0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
|
||||
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, /* 8 */
|
||||
0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
|
||||
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, /* 16 */
|
||||
0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
|
||||
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, /* 24 */
|
||||
0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
|
||||
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, /* 32 */
|
||||
0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
|
||||
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, /* 40 */
|
||||
0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
|
||||
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, /* 48 */
|
||||
0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
|
||||
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, /* 56 */
|
||||
0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
|
||||
};
|
||||
|
||||
|
||||
static inline vector unsigned int Ch(const vector unsigned int b, const vector unsigned int c, const vector unsigned int d) {
|
||||
return vec_sel(d,c,b);
|
||||
}
|
||||
|
||||
static inline vector unsigned int Maj(const vector unsigned int b, const vector unsigned int c, const vector unsigned int d) {
|
||||
return vec_sel(b,c, vec_xor(b,d));
|
||||
}
|
||||
|
||||
/* RotateRight(x, n) := RotateLeft(x, 32-n) */
|
||||
/* SHA256 Functions */
|
||||
#define BIGSIGMA0_256(x) (vec_xor(vec_xor(vec_rl((x), (vector unsigned int)(32-2)),vec_rl((x), (vector unsigned int)(32-13))),vec_rl((x), (vector unsigned int)(32-22))))
|
||||
#define BIGSIGMA1_256(x) (vec_xor(vec_xor(vec_rl((x), (vector unsigned int)(32-6)),vec_rl((x), (vector unsigned int)(32-11))),vec_rl((x), (vector unsigned int)(32-25))))
|
||||
|
||||
#define SIGMA0_256(x) (vec_xor(vec_xor(vec_rl((x), (vector unsigned int)(32- 7)),vec_rl((x), (vector unsigned int)(32-18))), vec_sr((x), (vector unsigned int)(3 ))))
|
||||
#define SIGMA1_256(x) (vec_xor(vec_xor(vec_rl((x), (vector unsigned int)(32-17)),vec_rl((x), (vector unsigned int)(32-19))), vec_sr((x), (vector unsigned int)(10))))
|
||||
|
||||
#define add4(x0, x1, x2, x3) vec_add(vec_add(x0, x1),vec_add( x2,x3))
|
||||
#define add5(x0, x1, x2, x3, x4) vec_add(add4(x0, x1, x2, x3), x4)
|
||||
|
||||
#define SHA256ROUND(a, b, c, d, e, f, g, h, i, w) \
|
||||
T1 = add5(h, BIGSIGMA1_256(e), Ch(e, f, g), (vector unsigned int)(sha256_consts[i],sha256_consts[i],sha256_consts[i],sha256_consts[i]), w); \
|
||||
d = vec_add(d, T1); \
|
||||
h = vec_add(T1, vec_add(BIGSIGMA0_256(a), Maj(a, b, c)));
|
||||
|
||||
|
||||
static const unsigned int pSHA256InitState[8] =
|
||||
{0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};
|
||||
|
||||
|
||||
unsigned int ScanHash_altivec_4way(int thr_id, const unsigned char *pmidstate,
|
||||
unsigned char *pdata,
|
||||
unsigned char *phash1, unsigned char *phash,
|
||||
const unsigned char *ptarget,
|
||||
uint32_t max_nonce, unsigned long *nHashesDone,
|
||||
uint32_t nonce)
|
||||
{
|
||||
unsigned int *nNonce_p = (unsigned int*)(pdata + 12);
|
||||
|
||||
work_restart[thr_id].restart = 0;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
unsigned int thash[9][NPAR] __attribute__((aligned(128)));
|
||||
int j;
|
||||
|
||||
*nNonce_p = nonce;
|
||||
|
||||
DoubleBlockSHA256(pdata, phash1, pmidstate, thash, pSHA256InitState);
|
||||
|
||||
for (j = 0; j < NPAR; j++)
|
||||
{
|
||||
if (unlikely(thash[7][j] == 0))
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 32/4; i++)
|
||||
((unsigned int*)phash)[i] = thash[i][j];
|
||||
|
||||
if (fulltest(phash, ptarget)) {
|
||||
*nHashesDone = nonce;
|
||||
*nNonce_p = nonce + j;
|
||||
return nonce + j;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ((nonce >= max_nonce) || work_restart[thr_id].restart)
|
||||
{
|
||||
*nHashesDone = nonce;
|
||||
return -1;
|
||||
}
|
||||
|
||||
nonce += NPAR;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void DoubleBlockSHA256(const void* pin, void* pad, const void *pre, unsigned int thash[9][NPAR], const void *init)
|
||||
{
|
||||
unsigned int* In = (unsigned int*)pin;
|
||||
unsigned int* Pad = (unsigned int*)pad;
|
||||
unsigned int* hPre = (unsigned int*)pre;
|
||||
unsigned int* hInit = (unsigned int*)init;
|
||||
unsigned int /* i, j, */ k;
|
||||
|
||||
/* vectors used in calculation */
|
||||
vector unsigned int w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
|
||||
vector unsigned int T1;
|
||||
vector unsigned int a, b, c, d, e, f, g, h;
|
||||
vector unsigned int nonce, preNonce;
|
||||
|
||||
/* nonce offset for vector */
|
||||
vector unsigned int offset = (vector unsigned int)(0, 1, 2, 3);
|
||||
|
||||
preNonce = vec_add((vector unsigned int)(In[3],In[3],In[3],In[3]), offset);
|
||||
|
||||
for(k = 0; k<NPAR; k+=4)
|
||||
{
|
||||
w0 = (vector unsigned int)(In[0],In[0],In[0],In[0]);
|
||||
w1 = (vector unsigned int)(In[1],In[1],In[1],In[1]);
|
||||
w2 = (vector unsigned int)(In[2],In[2],In[2],In[2]);
|
||||
//w3 = (vector unsigned int)(In[3],In[3],In[3],In[3]); nonce will be later hacked into the hash
|
||||
w4 = (vector unsigned int)(In[4],In[4],In[4],In[4]);
|
||||
w5 = (vector unsigned int)(In[5],In[5],In[5],In[5]);
|
||||
w6 = (vector unsigned int)(In[6],In[6],In[6],In[6]);
|
||||
w7 = (vector unsigned int)(In[7],In[7],In[7],In[7]);
|
||||
w8 = (vector unsigned int)(In[8],In[8],In[8],In[8]);
|
||||
w9 = (vector unsigned int)(In[9],In[9],In[9],In[9]);
|
||||
w10 = (vector unsigned int)(In[10],In[10],In[10],In[10]);
|
||||
w11 = (vector unsigned int)(In[11],In[11],In[11],In[11]);
|
||||
w12 = (vector unsigned int)(In[12],In[12],In[12],In[12]);
|
||||
w13 = (vector unsigned int)(In[13],In[13],In[13],In[13]);
|
||||
w14 = (vector unsigned int)(In[14],In[14],In[14],In[14]);
|
||||
w15 = (vector unsigned int)(In[15],In[15],In[15],In[15]);
|
||||
|
||||
/* hack nonce into lowest byte of w3 */
|
||||
nonce = vec_add(preNonce, (vector unsigned int)(k,k,k,k));
|
||||
|
||||
w3 = nonce;
|
||||
//printf ("W3: %08vlx\n", w3);
|
||||
|
||||
a = (vector unsigned int)(hPre[0],hPre[0],hPre[0],hPre[0]);
|
||||
b = (vector unsigned int)(hPre[1],hPre[1],hPre[1],hPre[1]);
|
||||
c = (vector unsigned int)(hPre[2],hPre[2],hPre[2],hPre[2]);
|
||||
d = (vector unsigned int)(hPre[3],hPre[3],hPre[3],hPre[3]);
|
||||
e = (vector unsigned int)(hPre[4],hPre[4],hPre[4],hPre[4]);
|
||||
f = (vector unsigned int)(hPre[5],hPre[5],hPre[5],hPre[5]);
|
||||
g = (vector unsigned int)(hPre[6],hPre[6],hPre[6],hPre[6]);
|
||||
h = (vector unsigned int)(hPre[7],hPre[7],hPre[7],hPre[7]);
|
||||
|
||||
SHA256ROUND(a, b, c, d, e, f, g, h, 0, w0);
|
||||
SHA256ROUND(h, a, b, c, d, e, f, g, 1, w1);
|
||||
SHA256ROUND(g, h, a, b, c, d, e, f, 2, w2);
|
||||
SHA256ROUND(f, g, h, a, b, c, d, e, 3, w3);
|
||||
SHA256ROUND(e, f, g, h, a, b, c, d, 4, w4);
|
||||
SHA256ROUND(d, e, f, g, h, a, b, c, 5, w5);
|
||||
SHA256ROUND(c, d, e, f, g, h, a, b, 6, w6);
|
||||
SHA256ROUND(b, c, d, e, f, g, h, a, 7, w7);
|
||||
SHA256ROUND(a, b, c, d, e, f, g, h, 8, w8);
|
||||
SHA256ROUND(h, a, b, c, d, e, f, g, 9, w9);
|
||||
SHA256ROUND(g, h, a, b, c, d, e, f, 10, w10);
|
||||
SHA256ROUND(f, g, h, a, b, c, d, e, 11, w11);
|
||||
SHA256ROUND(e, f, g, h, a, b, c, d, 12, w12);
|
||||
SHA256ROUND(d, e, f, g, h, a, b, c, 13, w13);
|
||||
SHA256ROUND(c, d, e, f, g, h, a, b, 14, w14);
|
||||
SHA256ROUND(b, c, d, e, f, g, h, a, 15, w15);
|
||||
|
||||
w0 = add4(SIGMA1_256(w14), w9, SIGMA0_256(w1), w0);
|
||||
SHA256ROUND(a, b, c, d, e, f, g, h, 16, w0);
|
||||
w1 = add4(SIGMA1_256(w15), w10, SIGMA0_256(w2), w1);
|
||||
SHA256ROUND(h, a, b, c, d, e, f, g, 17, w1);
|
||||
w2 = add4(SIGMA1_256(w0), w11, SIGMA0_256(w3), w2);
|
||||
SHA256ROUND(g, h, a, b, c, d, e, f, 18, w2);
|
||||
w3 = add4(SIGMA1_256(w1), w12, SIGMA0_256(w4), w3);
|
||||
SHA256ROUND(f, g, h, a, b, c, d, e, 19, w3);
|
||||
w4 = add4(SIGMA1_256(w2), w13, SIGMA0_256(w5), w4);
|
||||
SHA256ROUND(e, f, g, h, a, b, c, d, 20, w4);
|
||||
w5 = add4(SIGMA1_256(w3), w14, SIGMA0_256(w6), w5);
|
||||
SHA256ROUND(d, e, f, g, h, a, b, c, 21, w5);
|
||||
w6 = add4(SIGMA1_256(w4), w15, SIGMA0_256(w7), w6);
|
||||
SHA256ROUND(c, d, e, f, g, h, a, b, 22, w6);
|
||||
w7 = add4(SIGMA1_256(w5), w0, SIGMA0_256(w8), w7);
|
||||
SHA256ROUND(b, c, d, e, f, g, h, a, 23, w7);
|
||||
w8 = add4(SIGMA1_256(w6), w1, SIGMA0_256(w9), w8);
|
||||
SHA256ROUND(a, b, c, d, e, f, g, h, 24, w8);
|
||||
w9 = add4(SIGMA1_256(w7), w2, SIGMA0_256(w10), w9);
|
||||
SHA256ROUND(h, a, b, c, d, e, f, g, 25, w9);
|
||||
w10 = add4(SIGMA1_256(w8), w3, SIGMA0_256(w11), w10);
|
||||
SHA256ROUND(g, h, a, b, c, d, e, f, 26, w10);
|
||||
w11 = add4(SIGMA1_256(w9), w4, SIGMA0_256(w12), w11);
|
||||
SHA256ROUND(f, g, h, a, b, c, d, e, 27, w11);
|
||||
w12 = add4(SIGMA1_256(w10), w5, SIGMA0_256(w13), w12);
|
||||
SHA256ROUND(e, f, g, h, a, b, c, d, 28, w12);
|
||||
w13 = add4(SIGMA1_256(w11), w6, SIGMA0_256(w14), w13);
|
||||
SHA256ROUND(d, e, f, g, h, a, b, c, 29, w13);
|
||||
w14 = add4(SIGMA1_256(w12), w7, SIGMA0_256(w15), w14);
|
||||
SHA256ROUND(c, d, e, f, g, h, a, b, 30, w14);
|
||||
w15 = add4(SIGMA1_256(w13), w8, SIGMA0_256(w0), w15);
|
||||
SHA256ROUND(b, c, d, e, f, g, h, a, 31, w15);
|
||||
|
||||
w0 = add4(SIGMA1_256(w14), w9, SIGMA0_256(w1), w0);
|
||||
SHA256ROUND(a, b, c, d, e, f, g, h, 32, w0);
|
||||
w1 = add4(SIGMA1_256(w15), w10, SIGMA0_256(w2), w1);
|
||||
SHA256ROUND(h, a, b, c, d, e, f, g, 33, w1);
|
||||
w2 = add4(SIGMA1_256(w0), w11, SIGMA0_256(w3), w2);
|
||||
SHA256ROUND(g, h, a, b, c, d, e, f, 34, w2);
|
||||
w3 = add4(SIGMA1_256(w1), w12, SIGMA0_256(w4), w3);
|
||||
SHA256ROUND(f, g, h, a, b, c, d, e, 35, w3);
|
||||
w4 = add4(SIGMA1_256(w2), w13, SIGMA0_256(w5), w4);
|
||||
SHA256ROUND(e, f, g, h, a, b, c, d, 36, w4);
|
||||
w5 = add4(SIGMA1_256(w3), w14, SIGMA0_256(w6), w5);
|
||||
SHA256ROUND(d, e, f, g, h, a, b, c, 37, w5);
|
||||
w6 = add4(SIGMA1_256(w4), w15, SIGMA0_256(w7), w6);
|
||||
SHA256ROUND(c, d, e, f, g, h, a, b, 38, w6);
|
||||
w7 = add4(SIGMA1_256(w5), w0, SIGMA0_256(w8), w7);
|
||||
SHA256ROUND(b, c, d, e, f, g, h, a, 39, w7);
|
||||
w8 = add4(SIGMA1_256(w6), w1, SIGMA0_256(w9), w8);
|
||||
SHA256ROUND(a, b, c, d, e, f, g, h, 40, w8);
|
||||
w9 = add4(SIGMA1_256(w7), w2, SIGMA0_256(w10), w9);
|
||||
SHA256ROUND(h, a, b, c, d, e, f, g, 41, w9);
|
||||
w10 = add4(SIGMA1_256(w8), w3, SIGMA0_256(w11), w10);
|
||||
SHA256ROUND(g, h, a, b, c, d, e, f, 42, w10);
|
||||
w11 = add4(SIGMA1_256(w9), w4, SIGMA0_256(w12), w11);
|
||||
SHA256ROUND(f, g, h, a, b, c, d, e, 43, w11);
|
||||
w12 = add4(SIGMA1_256(w10), w5, SIGMA0_256(w13), w12);
|
||||
SHA256ROUND(e, f, g, h, a, b, c, d, 44, w12);
|
||||
w13 = add4(SIGMA1_256(w11), w6, SIGMA0_256(w14), w13);
|
||||
SHA256ROUND(d, e, f, g, h, a, b, c, 45, w13);
|
||||
w14 = add4(SIGMA1_256(w12), w7, SIGMA0_256(w15), w14);
|
||||
SHA256ROUND(c, d, e, f, g, h, a, b, 46, w14);
|
||||
w15 = add4(SIGMA1_256(w13), w8, SIGMA0_256(w0), w15);
|
||||
SHA256ROUND(b, c, d, e, f, g, h, a, 47, w15);
|
||||
|
||||
w0 = add4(SIGMA1_256(w14), w9, SIGMA0_256(w1), w0);
|
||||
SHA256ROUND(a, b, c, d, e, f, g, h, 48, w0);
|
||||
w1 = add4(SIGMA1_256(w15), w10, SIGMA0_256(w2), w1);
|
||||
SHA256ROUND(h, a, b, c, d, e, f, g, 49, w1);
|
||||
w2 = add4(SIGMA1_256(w0), w11, SIGMA0_256(w3), w2);
|
||||
SHA256ROUND(g, h, a, b, c, d, e, f, 50, w2);
|
||||
w3 = add4(SIGMA1_256(w1), w12, SIGMA0_256(w4), w3);
|
||||
SHA256ROUND(f, g, h, a, b, c, d, e, 51, w3);
|
||||
w4 = add4(SIGMA1_256(w2), w13, SIGMA0_256(w5), w4);
|
||||
SHA256ROUND(e, f, g, h, a, b, c, d, 52, w4);
|
||||
w5 = add4(SIGMA1_256(w3), w14, SIGMA0_256(w6), w5);
|
||||
SHA256ROUND(d, e, f, g, h, a, b, c, 53, w5);
|
||||
w6 = add4(SIGMA1_256(w4), w15, SIGMA0_256(w7), w6);
|
||||
SHA256ROUND(c, d, e, f, g, h, a, b, 54, w6);
|
||||
w7 = add4(SIGMA1_256(w5), w0, SIGMA0_256(w8), w7);
|
||||
SHA256ROUND(b, c, d, e, f, g, h, a, 55, w7);
|
||||
w8 = add4(SIGMA1_256(w6), w1, SIGMA0_256(w9), w8);
|
||||
SHA256ROUND(a, b, c, d, e, f, g, h, 56, w8);
|
||||
w9 = add4(SIGMA1_256(w7), w2, SIGMA0_256(w10), w9);
|
||||
SHA256ROUND(h, a, b, c, d, e, f, g, 57, w9);
|
||||
w10 = add4(SIGMA1_256(w8), w3, SIGMA0_256(w11), w10);
|
||||
SHA256ROUND(g, h, a, b, c, d, e, f, 58, w10);
|
||||
w11 = add4(SIGMA1_256(w9), w4, SIGMA0_256(w12), w11);
|
||||
SHA256ROUND(f, g, h, a, b, c, d, e, 59, w11);
|
||||
w12 = add4(SIGMA1_256(w10), w5, SIGMA0_256(w13), w12);
|
||||
SHA256ROUND(e, f, g, h, a, b, c, d, 60, w12);
|
||||
w13 = add4(SIGMA1_256(w11), w6, SIGMA0_256(w14), w13);
|
||||
SHA256ROUND(d, e, f, g, h, a, b, c, 61, w13);
|
||||
w14 = add4(SIGMA1_256(w12), w7, SIGMA0_256(w15), w14);
|
||||
SHA256ROUND(c, d, e, f, g, h, a, b, 62, w14);
|
||||
w15 = add4(SIGMA1_256(w13), w8, SIGMA0_256(w0), w15);
|
||||
SHA256ROUND(b, c, d, e, f, g, h, a, 63, w15);
|
||||
|
||||
#define store_load(x, i, dest) \
|
||||
T1 = (vector unsigned int)((hPre)[i],(hPre)[i],(hPre)[i],(hPre)[i]); \
|
||||
dest = vec_add(T1, x);
|
||||
|
||||
store_load(a, 0, w0);
|
||||
store_load(b, 1, w1);
|
||||
store_load(c, 2, w2);
|
||||
store_load(d, 3, w3);
|
||||
store_load(e, 4, w4);
|
||||
store_load(f, 5, w5);
|
||||
store_load(g, 6, w6);
|
||||
store_load(h, 7, w7);
|
||||
|
||||
/* end of first SHA256 round */
|
||||
|
||||
w8 = (vector unsigned int)(Pad[8],Pad[8],Pad[8],Pad[8]);
|
||||
w9 = (vector unsigned int)(Pad[9],Pad[9],Pad[9],Pad[9]);
|
||||
w10 = (vector unsigned int)(Pad[10],Pad[10],Pad[10],Pad[10]);
|
||||
w11 = (vector unsigned int)(Pad[11],Pad[11],Pad[11],Pad[11]);
|
||||
w12 = (vector unsigned int)(Pad[12],Pad[12],Pad[12],Pad[12]);
|
||||
w13 = (vector unsigned int)(Pad[13],Pad[13],Pad[13],Pad[13]);
|
||||
w14 = (vector unsigned int)(Pad[14],Pad[14],Pad[14],Pad[14]);
|
||||
w15 = (vector unsigned int)(Pad[15],Pad[15],Pad[15],Pad[15]);
|
||||
|
||||
a = (vector unsigned int)(hInit[0],hInit[0],hInit[0],hInit[0]);
|
||||
b = (vector unsigned int)(hInit[1],hInit[1],hInit[1],hInit[1]);
|
||||
c = (vector unsigned int)(hInit[2],hInit[2],hInit[2],hInit[2]);
|
||||
d = (vector unsigned int)(hInit[3],hInit[3],hInit[3],hInit[3]);
|
||||
e = (vector unsigned int)(hInit[4],hInit[4],hInit[4],hInit[4]);
|
||||
f = (vector unsigned int)(hInit[5],hInit[5],hInit[5],hInit[5]);
|
||||
g = (vector unsigned int)(hInit[6],hInit[6],hInit[6],hInit[6]);
|
||||
h = (vector unsigned int)(hInit[7],hInit[7],hInit[7],hInit[7]);
|
||||
|
||||
SHA256ROUND(a, b, c, d, e, f, g, h, 0, w0);
|
||||
SHA256ROUND(h, a, b, c, d, e, f, g, 1, w1);
|
||||
SHA256ROUND(g, h, a, b, c, d, e, f, 2, w2);
|
||||
SHA256ROUND(f, g, h, a, b, c, d, e, 3, w3);
|
||||
SHA256ROUND(e, f, g, h, a, b, c, d, 4, w4);
|
||||
SHA256ROUND(d, e, f, g, h, a, b, c, 5, w5);
|
||||
SHA256ROUND(c, d, e, f, g, h, a, b, 6, w6);
|
||||
SHA256ROUND(b, c, d, e, f, g, h, a, 7, w7);
|
||||
SHA256ROUND(a, b, c, d, e, f, g, h, 8, w8);
|
||||
SHA256ROUND(h, a, b, c, d, e, f, g, 9, w9);
|
||||
SHA256ROUND(g, h, a, b, c, d, e, f, 10, w10);
|
||||
SHA256ROUND(f, g, h, a, b, c, d, e, 11, w11);
|
||||
SHA256ROUND(e, f, g, h, a, b, c, d, 12, w12);
|
||||
SHA256ROUND(d, e, f, g, h, a, b, c, 13, w13);
|
||||
SHA256ROUND(c, d, e, f, g, h, a, b, 14, w14);
|
||||
SHA256ROUND(b, c, d, e, f, g, h, a, 15, w15);
|
||||
|
||||
w0 = add4(SIGMA1_256(w14), w9, SIGMA0_256(w1), w0);
|
||||
SHA256ROUND(a, b, c, d, e, f, g, h, 16, w0);
|
||||
w1 = add4(SIGMA1_256(w15), w10, SIGMA0_256(w2), w1);
|
||||
SHA256ROUND(h, a, b, c, d, e, f, g, 17, w1);
|
||||
w2 = add4(SIGMA1_256(w0), w11, SIGMA0_256(w3), w2);
|
||||
SHA256ROUND(g, h, a, b, c, d, e, f, 18, w2);
|
||||
w3 = add4(SIGMA1_256(w1), w12, SIGMA0_256(w4), w3);
|
||||
SHA256ROUND(f, g, h, a, b, c, d, e, 19, w3);
|
||||
w4 = add4(SIGMA1_256(w2), w13, SIGMA0_256(w5), w4);
|
||||
SHA256ROUND(e, f, g, h, a, b, c, d, 20, w4);
|
||||
w5 = add4(SIGMA1_256(w3), w14, SIGMA0_256(w6), w5);
|
||||
SHA256ROUND(d, e, f, g, h, a, b, c, 21, w5);
|
||||
w6 = add4(SIGMA1_256(w4), w15, SIGMA0_256(w7), w6);
|
||||
SHA256ROUND(c, d, e, f, g, h, a, b, 22, w6);
|
||||
w7 = add4(SIGMA1_256(w5), w0, SIGMA0_256(w8), w7);
|
||||
SHA256ROUND(b, c, d, e, f, g, h, a, 23, w7);
|
||||
w8 = add4(SIGMA1_256(w6), w1, SIGMA0_256(w9), w8);
|
||||
SHA256ROUND(a, b, c, d, e, f, g, h, 24, w8);
|
||||
w9 = add4(SIGMA1_256(w7), w2, SIGMA0_256(w10), w9);
|
||||
SHA256ROUND(h, a, b, c, d, e, f, g, 25, w9);
|
||||
w10 = add4(SIGMA1_256(w8), w3, SIGMA0_256(w11), w10);
|
||||
SHA256ROUND(g, h, a, b, c, d, e, f, 26, w10);
|
||||
w11 = add4(SIGMA1_256(w9), w4, SIGMA0_256(w12), w11);
|
||||
SHA256ROUND(f, g, h, a, b, c, d, e, 27, w11);
|
||||
w12 = add4(SIGMA1_256(w10), w5, SIGMA0_256(w13), w12);
|
||||
SHA256ROUND(e, f, g, h, a, b, c, d, 28, w12);
|
||||
w13 = add4(SIGMA1_256(w11), w6, SIGMA0_256(w14), w13);
|
||||
SHA256ROUND(d, e, f, g, h, a, b, c, 29, w13);
|
||||
w14 = add4(SIGMA1_256(w12), w7, SIGMA0_256(w15), w14);
|
||||
SHA256ROUND(c, d, e, f, g, h, a, b, 30, w14);
|
||||
w15 = add4(SIGMA1_256(w13), w8, SIGMA0_256(w0), w15);
|
||||
SHA256ROUND(b, c, d, e, f, g, h, a, 31, w15);
|
||||
|
||||
w0 = add4(SIGMA1_256(w14), w9, SIGMA0_256(w1), w0);
|
||||
SHA256ROUND(a, b, c, d, e, f, g, h, 32, w0);
|
||||
w1 = add4(SIGMA1_256(w15), w10, SIGMA0_256(w2), w1);
|
||||
SHA256ROUND(h, a, b, c, d, e, f, g, 33, w1);
|
||||
w2 = add4(SIGMA1_256(w0), w11, SIGMA0_256(w3), w2);
|
||||
SHA256ROUND(g, h, a, b, c, d, e, f, 34, w2);
|
||||
w3 = add4(SIGMA1_256(w1), w12, SIGMA0_256(w4), w3);
|
||||
SHA256ROUND(f, g, h, a, b, c, d, e, 35, w3);
|
||||
w4 = add4(SIGMA1_256(w2), w13, SIGMA0_256(w5), w4);
|
||||
SHA256ROUND(e, f, g, h, a, b, c, d, 36, w4);
|
||||
w5 = add4(SIGMA1_256(w3), w14, SIGMA0_256(w6), w5);
|
||||
SHA256ROUND(d, e, f, g, h, a, b, c, 37, w5);
|
||||
w6 = add4(SIGMA1_256(w4), w15, SIGMA0_256(w7), w6);
|
||||
SHA256ROUND(c, d, e, f, g, h, a, b, 38, w6);
|
||||
w7 = add4(SIGMA1_256(w5), w0, SIGMA0_256(w8), w7);
|
||||
SHA256ROUND(b, c, d, e, f, g, h, a, 39, w7);
|
||||
w8 = add4(SIGMA1_256(w6), w1, SIGMA0_256(w9), w8);
|
||||
SHA256ROUND(a, b, c, d, e, f, g, h, 40, w8);
|
||||
w9 = add4(SIGMA1_256(w7), w2, SIGMA0_256(w10), w9);
|
||||
SHA256ROUND(h, a, b, c, d, e, f, g, 41, w9);
|
||||
w10 = add4(SIGMA1_256(w8), w3, SIGMA0_256(w11), w10);
|
||||
SHA256ROUND(g, h, a, b, c, d, e, f, 42, w10);
|
||||
w11 = add4(SIGMA1_256(w9), w4, SIGMA0_256(w12), w11);
|
||||
SHA256ROUND(f, g, h, a, b, c, d, e, 43, w11);
|
||||
w12 = add4(SIGMA1_256(w10), w5, SIGMA0_256(w13), w12);
|
||||
SHA256ROUND(e, f, g, h, a, b, c, d, 44, w12);
|
||||
w13 = add4(SIGMA1_256(w11), w6, SIGMA0_256(w14), w13);
|
||||
SHA256ROUND(d, e, f, g, h, a, b, c, 45, w13);
|
||||
w14 = add4(SIGMA1_256(w12), w7, SIGMA0_256(w15), w14);
|
||||
SHA256ROUND(c, d, e, f, g, h, a, b, 46, w14);
|
||||
w15 = add4(SIGMA1_256(w13), w8, SIGMA0_256(w0), w15);
|
||||
SHA256ROUND(b, c, d, e, f, g, h, a, 47, w15);
|
||||
|
||||
w0 = add4(SIGMA1_256(w14), w9, SIGMA0_256(w1), w0);
|
||||
SHA256ROUND(a, b, c, d, e, f, g, h, 48, w0);
|
||||
w1 = add4(SIGMA1_256(w15), w10, SIGMA0_256(w2), w1);
|
||||
SHA256ROUND(h, a, b, c, d, e, f, g, 49, w1);
|
||||
w2 = add4(SIGMA1_256(w0), w11, SIGMA0_256(w3), w2);
|
||||
SHA256ROUND(g, h, a, b, c, d, e, f, 50, w2);
|
||||
w3 = add4(SIGMA1_256(w1), w12, SIGMA0_256(w4), w3);
|
||||
SHA256ROUND(f, g, h, a, b, c, d, e, 51, w3);
|
||||
w4 = add4(SIGMA1_256(w2), w13, SIGMA0_256(w5), w4);
|
||||
SHA256ROUND(e, f, g, h, a, b, c, d, 52, w4);
|
||||
w5 = add4(SIGMA1_256(w3), w14, SIGMA0_256(w6), w5);
|
||||
SHA256ROUND(d, e, f, g, h, a, b, c, 53, w5);
|
||||
w6 = add4(SIGMA1_256(w4), w15, SIGMA0_256(w7), w6);
|
||||
SHA256ROUND(c, d, e, f, g, h, a, b, 54, w6);
|
||||
w7 = add4(SIGMA1_256(w5), w0, SIGMA0_256(w8), w7);
|
||||
SHA256ROUND(b, c, d, e, f, g, h, a, 55, w7);
|
||||
w8 = add4(SIGMA1_256(w6), w1, SIGMA0_256(w9), w8);
|
||||
SHA256ROUND(a, b, c, d, e, f, g, h, 56, w8);
|
||||
w9 = add4(SIGMA1_256(w7), w2, SIGMA0_256(w10), w9);
|
||||
SHA256ROUND(h, a, b, c, d, e, f, g, 57, w9);
|
||||
w10 = add4(SIGMA1_256(w8), w3, SIGMA0_256(w11), w10);
|
||||
SHA256ROUND(g, h, a, b, c, d, e, f, 58, w10);
|
||||
w11 = add4(SIGMA1_256(w9), w4, SIGMA0_256(w12), w11);
|
||||
SHA256ROUND(f, g, h, a, b, c, d, e, 59, w11);
|
||||
w12 = add4(SIGMA1_256(w10), w5, SIGMA0_256(w13), w12);
|
||||
SHA256ROUND(e, f, g, h, a, b, c, d, 60, w12);
|
||||
|
||||
/* Skip last 3-rounds; not necessary for H==0 */
|
||||
/*#if 0
|
||||
w13 = add4(SIGMA1_256(w11), w6, SIGMA0_256(w14), w13);
|
||||
SHA256ROUND(d, e, f, g, h, a, b, c, 61, w13);
|
||||
w14 = add4(SIGMA1_256(w12), w7, SIGMA0_256(w15), w14);
|
||||
SHA256ROUND(c, d, e, f, g, h, a, b, 62, w14);
|
||||
w15 = add4(SIGMA1_256(w13), w8, SIGMA0_256(w0), w15);
|
||||
SHA256ROUND(b, c, d, e, f, g, h, a, 63, w15);
|
||||
#endif*/
|
||||
|
||||
/* store resulsts directly in thash */
|
||||
#define store_2(x,i) \
|
||||
w0 = (vector unsigned int)(hInit[i],hInit[i],hInit[i],hInit[i]); \
|
||||
vec_st(vec_add(w0, x), 0 ,&thash[i][k]);
|
||||
|
||||
store_2(a, 0);
|
||||
store_2(b, 1);
|
||||
store_2(c, 2);
|
||||
store_2(d, 3);
|
||||
store_2(e, 4);
|
||||
store_2(f, 5);
|
||||
store_2(g, 6);
|
||||
store_2(h, 7);
|
||||
|
||||
vec_st(nonce, 0 ,&thash[8][k]);
|
||||
/* writing the results into the array is time intensive */
|
||||
/* -> try if it´s faster to compare the results with the target inside this function */
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif /* WANT_ALTIVEC_4WAY */
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user