Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
5fd8c32b4e | ||
|
|
94a04aea96 | ||
|
|
8ce8961e06 | ||
|
|
34c04cfb80 | ||
|
|
6c101af7a2 | ||
|
|
e606887e7a | ||
|
|
d4191d3188 | ||
|
|
a20dc6a658 | ||
|
|
69852a2874 | ||
|
|
ee9c821525 | ||
|
|
6fd935c369 | ||
|
|
2d6b3fddf6 | ||
|
|
0e6168ed52 | ||
|
|
a9d3c1ffdb | ||
|
|
a63f0024f3 | ||
|
|
adda14b22e | ||
|
|
e1a0274b01 | ||
|
|
1a30450ad2 | ||
|
|
e3922c7a33 | ||
|
|
312bd90541 | ||
|
|
d4a9428fef | ||
|
|
d840d683ec | ||
|
|
d6c29b1f7f |
No files matched your search
+13
-10
@@ -15,7 +15,7 @@ static __device__ uint64_t cuda_swab32ll(uint64_t x) {
|
||||
return MAKE_ULONGLONG(cuda_swab32(_LODWORD(x)), cuda_swab32(_HIDWORD(x)));
|
||||
}
|
||||
|
||||
__constant__ static uint32_t c_data[3+1];
|
||||
__constant__ static uint32_t c_data[20];
|
||||
|
||||
__constant__ static uint32_t sigma[16][16];
|
||||
static uint32_t c_sigma[16][16] = {
|
||||
@@ -195,16 +195,17 @@ void blake256_gpu_hash_80(const uint32_t threads, const uint32_t startNonce, uin
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
const uint32_t nonce = startNonce + thread;
|
||||
uint32_t h[8];
|
||||
uint32_t input[4];
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 0; i < 8; i++) h[i] = cpu_h[i];
|
||||
#pragma unroll 8
|
||||
for (int i = 0; i<8; i++) { h[i] = cpu_h[i];}
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 0; i < 3; ++i) input[i] = c_data[i];
|
||||
#pragma unroll 3
|
||||
for (int i = 0; i < 3; ++i) input[i] = c_data[16 + i];
|
||||
|
||||
input[3] = startNonce + thread;
|
||||
input[3] = nonce;
|
||||
blake256_compress2nd(h, input, 640);
|
||||
|
||||
#pragma unroll
|
||||
@@ -229,14 +230,16 @@ void blake256_cpu_hash_80(const int thr_id, const uint32_t threads, const uint32
|
||||
__host__
|
||||
void blake256_cpu_setBlock_80(uint32_t *pdata)
|
||||
{
|
||||
uint32_t h[8], data[20];
|
||||
|
||||
uint32_t h[8];
|
||||
uint32_t data[20];
|
||||
memcpy(data, pdata, 80);
|
||||
memcpy(h, c_IV256, sizeof(c_IV256));
|
||||
for (int i = 0; i<8; i++) {
|
||||
h[i] = c_IV256[i];
|
||||
}
|
||||
blake256_compress1st(h, pdata, 512);
|
||||
|
||||
cudaMemcpyToSymbol(cpu_h, h, sizeof(h), 0, cudaMemcpyHostToDevice);
|
||||
cudaMemcpyToSymbol(c_data, &data[16], sizeof(c_data), 0, cudaMemcpyHostToDevice);
|
||||
cudaMemcpyToSymbol(c_data, data, sizeof(data), 0, cudaMemcpyHostToDevice);
|
||||
}
|
||||
|
||||
__host__
|
||||
|
||||
+116
-99
@@ -20,17 +20,21 @@ static __constant__ uint2 vSKEIN_IV512_256[8] = {
|
||||
{ 0x33EDFC13, 0x3EEDBA18 }
|
||||
};
|
||||
|
||||
static __constant__ int8_t ROT256[8][4] = {
|
||||
46, 36, 19, 37,
|
||||
33, 27, 14, 42,
|
||||
17, 49, 36, 39,
|
||||
44, 9, 54, 56,
|
||||
39, 30, 34, 24,
|
||||
13, 50, 10, 17,
|
||||
25, 29, 39, 43,
|
||||
8, 35, 56, 22,
|
||||
static __constant__ int ROT256[8][4] =
|
||||
{
|
||||
46,36, 19, 37,
|
||||
33,27, 14, 42,
|
||||
17,49, 36, 39,
|
||||
44, 9, 54, 56,
|
||||
39,30, 34, 24,
|
||||
13,50, 10, 17,
|
||||
25,29, 39, 43,
|
||||
8, 35, 56, 22,
|
||||
};
|
||||
|
||||
static __constant__ uint2 skein_ks_parity = { 0xA9FC1A22,0x1BD11BDA};
|
||||
static __constant__ uint64_t skein_ks_parity64 = 0x1BD11BDAA9FC1A22ull;
|
||||
|
||||
static __constant__ uint2 t12[6] = {
|
||||
{ 0x20, 0 },
|
||||
{ 0, 0xf0000000 },
|
||||
@@ -40,19 +44,25 @@ static __constant__ uint2 t12[6] = {
|
||||
{ 0x08, 0xff000000 }
|
||||
};
|
||||
|
||||
static __constant__ uint2 skein_ks_parity = { 0xA9FC1A22, 0x1BD11BDA };
|
||||
static __constant__ uint64_t skein_ks_parity64 = 0x1BD11BDAA9FC1A22ull;
|
||||
|
||||
static __constant__ uint64_t t12_30[6] = {
|
||||
0x20,
|
||||
0xf000000000000000,
|
||||
0xf000000000000020,
|
||||
0x08,
|
||||
0xff00000000000000,
|
||||
0xff00000000000008
|
||||
};
|
||||
|
||||
static __forceinline__ __device__
|
||||
void Round512v35(uint2 &p0, uint2 &p1, uint2 &p2, uint2 &p3, uint2 &p4, uint2 &p5, uint2 &p6, uint2 &p7, int ROT)
|
||||
{
|
||||
p0 += p1; p1 = ROL2(p1, ROT256[ROT][0]) ^ p0;
|
||||
p2 += p3; p3 = ROL2(p3, ROT256[ROT][1]) ^ p2;
|
||||
p4 += p5; p5 = ROL2(p5, ROT256[ROT][2]) ^ p4;
|
||||
p6 += p7; p7 = ROL2(p7, ROT256[ROT][3]) ^ p6;
|
||||
p0 += p1; p1 = ROL2(p1, ROT256[ROT][0]); p1 ^= p0;
|
||||
p2 += p3; p3 = ROL2(p3, ROT256[ROT][1]); p3 ^= p2;
|
||||
p4 += p5; p5 = ROL2(p5, ROT256[ROT][2]); p5 ^= p4;
|
||||
p6 += p7; p7 = ROL2(p7, ROT256[ROT][3]); p7 ^= p6;
|
||||
}
|
||||
|
||||
|
||||
static __forceinline__ __device__
|
||||
void Round_8_512v35(uint2 *ks, uint2 *ts,
|
||||
uint2 &p0, uint2 &p1, uint2 &p2, uint2 &p3,
|
||||
@@ -62,36 +72,39 @@ void Round_8_512v35(uint2 *ks, uint2 *ts,
|
||||
Round512v35(p2, p1, p4, p7, p6, p5, p0, p3, 1);
|
||||
Round512v35(p4, p1, p6, p3, p0, p5, p2, p7, 2);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 3);
|
||||
p0 += ks[(R+0) % 9]; /* inject the key schedule value */
|
||||
p1 += ks[(R+1) % 9];
|
||||
p2 += ks[(R+2) % 9];
|
||||
p3 += ks[(R+3) % 9];
|
||||
p4 += ks[(R+4) % 9];
|
||||
p5 += ks[(R+5) % 9] + ts[(R+0) % 3];
|
||||
p6 += ks[(R+6) % 9] + ts[(R+1) % 3];
|
||||
p7 += ks[(R+7) % 9] + make_uint2((R),0);
|
||||
p0 += ks[((R)+0) % 9]; /* inject the key schedule value */
|
||||
p1 += ks[((R)+1) % 9];
|
||||
p2 += ks[((R)+2) % 9];
|
||||
p3 += ks[((R)+3) % 9];
|
||||
p4 += ks[((R)+4) % 9];
|
||||
p5 += ks[((R)+5) % 9] + ts[((R)+0) % 3];
|
||||
p6 += ks[((R)+6) % 9] + ts[((R)+1) % 3];
|
||||
p7 += ks[((R)+7) % 9] + make_uint2((R),0);
|
||||
Round512v35(p0, p1, p2, p3, p4, p5, p6, p7, 4);
|
||||
Round512v35(p2, p1, p4, p7, p6, p5, p0, p3, 5);
|
||||
Round512v35(p4, p1, p6, p3, p0, p5, p2, p7, 6);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 7);
|
||||
p0 += ks[(R+1) % 9]; /* inject the key schedule value */
|
||||
p1 += ks[(R+2) % 9];
|
||||
p2 += ks[(R+3) % 9];
|
||||
p3 += ks[(R+4) % 9];
|
||||
p4 += ks[(R+5) % 9];
|
||||
p5 += ks[(R+6) % 9] + ts[(R+1) % 3];
|
||||
p6 += ks[(R+7) % 9] + ts[(R+2) % 3];
|
||||
p7 += ks[(R+8) % 9] + make_uint2(R+1, 0);
|
||||
p0 += ks[((R)+1) % 9]; /* inject the key schedule value */
|
||||
p1 += ks[((R)+2) % 9];
|
||||
p2 += ks[((R)+3) % 9];
|
||||
p3 += ks[((R)+4) % 9];
|
||||
p4 += ks[((R)+5) % 9];
|
||||
p5 += ks[((R)+6) % 9] + ts[((R)+1) % 3];
|
||||
p6 += ks[((R)+7) % 9] + ts[((R)+2) % 3];
|
||||
p7 += ks[((R)+8) % 9] + make_uint2((R)+1, 0);
|
||||
}
|
||||
|
||||
|
||||
__global__ __launch_bounds__(256,3)
|
||||
void skein256_gpu_hash_32(uint32_t threads, uint32_t startNounce, uint64_t *outputHash)
|
||||
{
|
||||
const uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
uint2 h[9], t[3] = { t12[0], t12[1], t12[2] };
|
||||
uint2 h[9];
|
||||
uint2 t[3];
|
||||
uint2 dt0,dt1,dt2,dt3;
|
||||
uint2 p0, p1, p2, p3, p4, p5, p6, p7;
|
||||
|
||||
h[8] = skein_ks_parity;
|
||||
for (int i = 0; i<8; i++) {
|
||||
@@ -99,23 +112,27 @@ void skein256_gpu_hash_32(uint32_t threads, uint32_t startNounce, uint64_t *outp
|
||||
h[8] ^= h[i];
|
||||
}
|
||||
|
||||
uint2 dt0 = vectorize(outputHash[thread]);
|
||||
uint2 dt1 = vectorize(outputHash[threads + thread]);
|
||||
uint2 dt2 = vectorize(outputHash[threads*2 + thread]);
|
||||
uint2 dt3 = vectorize(outputHash[threads*3 + thread]);
|
||||
t[0]=t12[0];
|
||||
t[1]=t12[1];
|
||||
t[2]=t12[2];
|
||||
|
||||
uint2 p0 = h[0] + dt0;
|
||||
uint2 p1 = h[1] + dt1;
|
||||
uint2 p2 = h[2] + dt2;
|
||||
uint2 p3 = h[3] + dt3;
|
||||
uint2 p4 = h[4];
|
||||
uint2 p5 = h[5] + t[0];
|
||||
uint2 p6 = h[6] + t[1];
|
||||
uint2 p7 = h[7];
|
||||
LOHI(dt0.x,dt0.y,outputHash[thread]);
|
||||
LOHI(dt1.x,dt1.y,outputHash[threads+thread]);
|
||||
LOHI(dt2.x,dt2.y,outputHash[2*threads+thread]);
|
||||
LOHI(dt3.x,dt3.y,outputHash[3*threads+thread]);
|
||||
|
||||
#pragma unroll 9
|
||||
p0 = h[0] + dt0;
|
||||
p1 = h[1] + dt1;
|
||||
p2 = h[2] + dt2;
|
||||
p3 = h[3] + dt3;
|
||||
p4 = h[4];
|
||||
p5 = h[5] + t[0];
|
||||
p6 = h[6] + t[1];
|
||||
p7 = h[7];
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 1; i<19; i+=2) {
|
||||
Round_8_512v35(h, t, p0, p1, p2, p3, p4, p5, p6, p7, i);
|
||||
Round_8_512v35(h,t,p0,p1,p2,p3,p4,p5,p6,p7,i);
|
||||
}
|
||||
|
||||
p0 ^= dt0;
|
||||
@@ -141,19 +158,18 @@ void skein256_gpu_hash_32(uint32_t threads, uint32_t startNounce, uint64_t *outp
|
||||
t[0] = t12[3];
|
||||
t[1] = t12[4];
|
||||
t[2] = t12[5];
|
||||
|
||||
p5 += t[0];
|
||||
p5 += t[0]; //p5 already equal h[5]
|
||||
p6 += t[1];
|
||||
|
||||
#pragma unroll 9
|
||||
#pragma unroll
|
||||
for (int i = 1; i<19; i+=2) {
|
||||
Round_8_512v35(h, t, p0, p1, p2, p3, p4, p5, p6, p7, i);
|
||||
}
|
||||
|
||||
outputHash[thread] = devectorize(p0);
|
||||
outputHash[threads + thread] = devectorize(p1);
|
||||
outputHash[threads*2 + thread] = devectorize(p2);
|
||||
outputHash[threads*3 + thread] = devectorize(p3);
|
||||
outputHash[thread] = devectorize(p0);
|
||||
outputHash[threads+thread] = devectorize(p1);
|
||||
outputHash[2*threads+thread] = devectorize(p2);
|
||||
outputHash[3*threads+thread] = devectorize(p3);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -161,10 +177,10 @@ static __forceinline__ __device__
|
||||
void Round512v30(uint64_t &p0, uint64_t &p1, uint64_t &p2, uint64_t &p3,
|
||||
uint64_t &p4, uint64_t &p5, uint64_t &p6, uint64_t &p7, int ROT)
|
||||
{
|
||||
p0 += p1; p1 = ROTL64(p1, ROT256[ROT][0]) ^ p0;
|
||||
p2 += p3; p3 = ROTL64(p3, ROT256[ROT][1]) ^ p2;
|
||||
p4 += p5; p5 = ROTL64(p5, ROT256[ROT][2]) ^ p4;
|
||||
p6 += p7; p7 = ROTL64(p7, ROT256[ROT][3]) ^ p6;
|
||||
p0 += p1; p1 = ROTL64(p1, ROT256[ROT][0]); p1 ^= p0;
|
||||
p2 += p3; p3 = ROTL64(p3, ROT256[ROT][1]); p3 ^= p2;
|
||||
p4 += p5; p5 = ROTL64(p5, ROT256[ROT][2]); p5 ^= p4;
|
||||
p6 += p7; p7 = ROTL64(p7, ROT256[ROT][3]); p7 ^= p6;
|
||||
}
|
||||
|
||||
static __forceinline__ __device__
|
||||
@@ -175,36 +191,38 @@ void Round_8_512v30(uint64_t *ks, uint64_t *ts, uint64_t &p0, uint64_t &p1, uint
|
||||
Round512v30(p2, p1, p4, p7, p6, p5, p0, p3, 1);
|
||||
Round512v30(p4, p1, p6, p3, p0, p5, p2, p7, 2);
|
||||
Round512v30(p6, p1, p0, p7, p2, p5, p4, p3, 3);
|
||||
p0 += ks[(R+0) % 9]; /* inject the key schedule value */
|
||||
p1 += ks[(R+1) % 9];
|
||||
p2 += ks[(R+2) % 9];
|
||||
p3 += ks[(R+3) % 9];
|
||||
p4 += ks[(R+4) % 9];
|
||||
p5 += ks[(R+5) % 9] + ts[(R+0) % 3];
|
||||
p6 += ks[(R+6) % 9] + ts[(R+1) % 3];
|
||||
p7 += ks[(R+7) % 9] + R;
|
||||
p0 += ks[((R)+0) % 9]; /* inject the key schedule value */
|
||||
p1 += ks[((R)+1) % 9];
|
||||
p2 += ks[((R)+2) % 9];
|
||||
p3 += ks[((R)+3) % 9];
|
||||
p4 += ks[((R)+4) % 9];
|
||||
p5 += ks[((R)+5) % 9] + ts[((R)+0) % 3];
|
||||
p6 += ks[((R)+6) % 9] + ts[((R)+1) % 3];
|
||||
p7 += ks[((R)+7) % 9] + R;
|
||||
Round512v30(p0, p1, p2, p3, p4, p5, p6, p7, 4);
|
||||
Round512v30(p2, p1, p4, p7, p6, p5, p0, p3, 5);
|
||||
Round512v30(p4, p1, p6, p3, p0, p5, p2, p7, 6);
|
||||
Round512v30(p6, p1, p0, p7, p2, p5, p4, p3, 7);
|
||||
p0 += ks[(R+1) % 9]; /* inject the key schedule value */
|
||||
p1 += ks[(R+2) % 9];
|
||||
p2 += ks[(R+3) % 9];
|
||||
p3 += ks[(R+4) % 9];
|
||||
p4 += ks[(R+5) % 9];
|
||||
p5 += ks[(R+6) % 9] + ts[(R+1) % 3];
|
||||
p6 += ks[(R+7) % 9] + ts[(R+2) % 3];
|
||||
p7 += ks[(R+8) % 9] + R+1;
|
||||
p0 += ks[((R)+1) % 9]; /* inject the key schedule value */
|
||||
p1 += ks[((R)+2) % 9];
|
||||
p2 += ks[((R)+3) % 9];
|
||||
p3 += ks[((R)+4) % 9];
|
||||
p4 += ks[((R)+5) % 9];
|
||||
p5 += ks[((R)+6) % 9] + ts[((R)+1) % 3];
|
||||
p6 += ks[((R)+7) % 9] + ts[((R)+2) % 3];
|
||||
p7 += ks[((R)+8) % 9] + (R)+1;
|
||||
}
|
||||
|
||||
__global__ __launch_bounds__(256, 3)
|
||||
void skein256_gpu_hash_32_v30(uint32_t threads, uint32_t startNounce, uint64_t *outputHash)
|
||||
{
|
||||
const uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
uint64_t h[9], t[3];
|
||||
|
||||
uint64_t h[9];
|
||||
uint64_t t[3];
|
||||
uint64_t dt0, dt1, dt2, dt3;
|
||||
uint64_t p0, p1, p2, p3, p4, p5, p6, p7;
|
||||
h[8] = skein_ks_parity64;
|
||||
for (int i = 0; i<8; i++) {
|
||||
h[i] = SKEIN_IV512_256[i];
|
||||
@@ -215,21 +233,21 @@ void skein256_gpu_hash_32_v30(uint32_t threads, uint32_t startNounce, uint64_t *
|
||||
t[1] = devectorize(t12[1]);
|
||||
t[2] = devectorize(t12[2]);
|
||||
|
||||
uint64_t dt0 = outputHash[thread];
|
||||
uint64_t dt1 = outputHash[threads + thread];
|
||||
uint64_t dt2 = outputHash[threads*2 + thread];
|
||||
uint64_t dt3 = outputHash[threads*3 + thread];
|
||||
dt0 = outputHash[thread];
|
||||
dt1 = outputHash[threads+thread];
|
||||
dt2 = outputHash[2*threads+thread];
|
||||
dt3 = outputHash[3*threads+thread];
|
||||
|
||||
uint64_t p0 = h[0] + dt0;
|
||||
uint64_t p1 = h[1] + dt1;
|
||||
uint64_t p2 = h[2] + dt2;
|
||||
uint64_t p3 = h[3] + dt3;
|
||||
uint64_t p4 = h[4];
|
||||
uint64_t p5 = h[5] + t[0];
|
||||
uint64_t p6 = h[6] + t[1];
|
||||
uint64_t p7 = h[7];
|
||||
p0 = h[0] + dt0;
|
||||
p1 = h[1] + dt1;
|
||||
p2 = h[2] + dt2;
|
||||
p3 = h[3] + dt3;
|
||||
p4 = h[4];
|
||||
p5 = h[5] + t[0];
|
||||
p6 = h[6] + t[1];
|
||||
p7 = h[7];
|
||||
|
||||
#pragma unroll 9
|
||||
#pragma unroll
|
||||
for (int i = 1; i<19; i += 2) {
|
||||
Round_8_512v30(h, t, p0, p1, p2, p3, p4, p5, p6, p7, i);
|
||||
}
|
||||
@@ -254,22 +272,22 @@ void skein256_gpu_hash_32_v30(uint32_t threads, uint32_t startNounce, uint64_t *
|
||||
h[8] ^= h[i];
|
||||
}
|
||||
|
||||
t[0] = devectorize(t12[3]);
|
||||
t[1] = devectorize(t12[4]);
|
||||
t[2] = devectorize(t12[5]);
|
||||
t[0] = t12_30[3];
|
||||
t[1] = t12_30[4];
|
||||
t[2] = t12_30[5];
|
||||
|
||||
p5 += t[0]; //p5 already equal h[5]
|
||||
p6 += t[1];
|
||||
|
||||
#pragma unroll 9
|
||||
#pragma unroll
|
||||
for (int i = 1; i<19; i += 2) {
|
||||
Round_8_512v30(h, t, p0, p1, p2, p3, p4, p5, p6, p7, i);
|
||||
}
|
||||
|
||||
outputHash[thread] = p0;
|
||||
outputHash[threads + thread] = p1;
|
||||
outputHash[threads*2 + thread] = p2;
|
||||
outputHash[threads*3 + thread] = p3;
|
||||
outputHash[threads + thread] = p1;
|
||||
outputHash[2 * threads + thread] = p2;
|
||||
outputHash[3 * threads + thread] = p3;
|
||||
|
||||
} //thread
|
||||
}
|
||||
@@ -288,7 +306,6 @@ void skein256_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNounce, ui
|
||||
dim3 grid((threads + threadsperblock - 1) / threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
|
||||
// only 1kH/s perf change between kernels on a 960...
|
||||
if (device_sm[device_map[thr_id]] > 300 && cuda_arch[device_map[thr_id]] > 300)
|
||||
skein256_gpu_hash_32<<<grid, block>>>(threads, startNounce, d_outputHash);
|
||||
else
|
||||
|
||||
@@ -8,35 +8,4 @@ need to be installed on your system for autogen.sh to work)
|
||||
where your CUDA 6.5 toolkit is installed (usually /usr/local/cuda,
|
||||
but some distros may have a different default location)
|
||||
|
||||
|
||||
** How to compile on Fedora 22 (2015) **
|
||||
|
||||
# Step 1: gcc and dependencies
|
||||
dnf install gcc gcc-c++ automake
|
||||
dnf install jansson-devel openssl-devel libcurl-devel zlib-devel pciutils-devel
|
||||
|
||||
# Step 2: nvidia drivers (Download common linux drivers from nvidia site)
|
||||
dnf install kernel-devel
|
||||
modprobe -r nouveau
|
||||
./NVIDIA-Linux-x86_64-346.72.run
|
||||
|
||||
# Step 3: CUDA SDK (Download from nvidia archive)
|
||||
dnf install cuda-repo-fedora20-6-5-prod-6.5-19.x86_64.rpm
|
||||
dnf install cuda-minimal-build-6-5.x86_64
|
||||
|
||||
# add the nvcc binary path to the system
|
||||
ln -s /usr/local/cuda-6.5 /usr/local/cuda
|
||||
echo 'export PATH=$PATH:/usr/local/cuda/bin' > /etc/profile.d/cuda.sh
|
||||
|
||||
# add the cudart library path to the system
|
||||
echo /usr/local/cuda/lib64 > /etc/ld.so.conf.d/cuda.conf
|
||||
ldconfig
|
||||
|
||||
# Step 4: Fix the toolkit warning with gcc 5.1
|
||||
edit the file /usr/local/cuda/include/host_config.h
|
||||
and comment/delete the line 82 : #error -- unsupported GNU version! gcc 4.9
|
||||
|
||||
./build.sh
|
||||
|
||||
./ccminer -n
|
||||
|
||||
See README.txt
|
||||
@@ -2,7 +2,6 @@
|
||||
#include <memory.h>
|
||||
|
||||
#include "cuda_helper.h"
|
||||
#include "miner.h"
|
||||
|
||||
// ZR5
|
||||
__constant__ uint32_t d_OriginalData[20];
|
||||
@@ -10,6 +9,9 @@ __constant__ uint32_t d_OriginalData[20];
|
||||
__constant__ uint32_t c_PaddedMessage[18];
|
||||
__constant__ uint64_t c_State[25];
|
||||
|
||||
#define POK_DATA_MASK 0xFFFF0000
|
||||
#define POK_VERSION 0x1
|
||||
|
||||
#define U32TO64_LE(p) \
|
||||
(((uint64_t)(*p)) | (((uint64_t)(*(p + 1))) << 32))
|
||||
|
||||
@@ -655,7 +657,7 @@ __host__
|
||||
void zr5_keccak512_cpu_hash_pok(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t* pdata, uint32_t *d_hash, uint16_t *d_poks)
|
||||
{
|
||||
const uint32_t threadsperblock = 256;
|
||||
const uint32_t version = (pdata[0] & (~POK_DATA_MASK)) | (use_pok ? POK_BOOL_MASK : 0);
|
||||
const uint32_t version = pdata[0] & (~POK_DATA_MASK);
|
||||
|
||||
dim3 grid((threads + threadsperblock-1)/threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
|
||||
+12
-13
@@ -19,9 +19,8 @@ ccminer_SOURCES = elist.h miner.h compat.h \
|
||||
compat/inttypes.h compat/stdbool.h compat/unistd.h \
|
||||
compat/sys/time.h compat/getopt/getopt.h \
|
||||
crc32.c hefty1.c \
|
||||
ccminer.cpp pools.cpp util.cpp bignum.cpp \
|
||||
ccminer.cpp util.cpp \
|
||||
api.cpp hashlog.cpp nvml.cpp stats.cpp sysinfos.cpp cuda.cpp \
|
||||
ethash/etherpc.cpp ethash/ethash.cu \
|
||||
heavy/heavy.cu \
|
||||
heavy/cuda_blake512.cu heavy/cuda_blake512.h \
|
||||
heavy/cuda_combine.cu heavy/cuda_combine.h \
|
||||
@@ -48,15 +47,15 @@ ccminer_SOURCES = elist.h miner.h compat.h \
|
||||
sph/cubehash.c sph/echo.c sph/luffa.c sph/sha2.c sph/shavite.c sph/simd.c \
|
||||
sph/hamsi.c sph/hamsi_helper.c sph/sph_hamsi.h \
|
||||
sph/shabal.c sph/whirlpool.c sph/sha2big.c sph/haval.c \
|
||||
qubit/qubit.cu qubit/qubit_luffa512.cu qubit/deep.cu qubit/luffa.cu \
|
||||
pluck/pluck.cu pluck/cuda_pluck.cu \
|
||||
qubit/qubit.cu qubit/qubit_luffa512.cu qubit/deep.cu qubit/doom.cu \
|
||||
x11/x11.cu x11/fresh.cu x11/cuda_x11_luffa512.cu x11/cuda_x11_cubehash512.cu \
|
||||
x11/cuda_x11_shavite512.cu x11/cuda_x11_simd512.cu x11/cuda_x11_echo.cu \
|
||||
x11/cuda_x11_luffa512_Cubehash.cu \
|
||||
x13/x13.cu x13/cuda_x13_hamsi512.cu x13/cuda_x13_fugue512.cu \
|
||||
x15/x14.cu x15/x15.cu x15/cuda_x14_shabal512.cu x15/cuda_x15_whirlpool.cu \
|
||||
x15/whirlpoolx.cu x15/cuda_whirlpoolx.cu \
|
||||
x17/x17.cu x17/cuda_x17_haval512.cu x17/cuda_x17_sha512.cu \
|
||||
x11/c11.cu x11/s3.cu
|
||||
x11/s3.cu
|
||||
|
||||
# scrypt
|
||||
ccminer_SOURCES += scrypt.cpp scrypt-jane.cpp \
|
||||
@@ -75,8 +74,8 @@ ccminer_SOURCES += compat/winansi.c
|
||||
endif
|
||||
|
||||
ccminer_LDFLAGS = $(PTHREAD_FLAGS) @CUDA_LDFLAGS@
|
||||
ccminer_LDADD = @LIBCURL@ @JANSSON_LIBS@ @PTHREAD_LIBS@ @WS2_LIBS@ @CUDA_LIBS@ @PCILIB@ @OPENMP_CFLAGS@ @LIBS@ $(nvml_libs)
|
||||
ccminer_CPPFLAGS = @LIBCURL_CPPFLAGS@ @PCIFLAGS@ @OPENMP_CFLAGS@ $(CPPFLAGS) $(PTHREAD_FLAGS) -fno-strict-aliasing $(JANSSON_INCLUDES) $(DEF_INCLUDES) $(nvml_defs)
|
||||
ccminer_LDADD = @LIBCURL@ @JANSSON_LIBS@ @PTHREAD_LIBS@ @WS2_LIBS@ @CUDA_LIBS@ @OPENMP_CFLAGS@ @LIBS@ $(nvml_libs)
|
||||
ccminer_CPPFLAGS = @LIBCURL_CPPFLAGS@ @OPENMP_CFLAGS@ $(CPPFLAGS) $(PTHREAD_FLAGS) -fno-strict-aliasing $(JANSSON_INCLUDES) $(DEF_INCLUDES) $(nvml_defs) -DSCRYPT_KECCAK512 -DSCRYPT_CHACHA -DSCRYPT_CHOOSE_COMPILETIME
|
||||
|
||||
nvcc_ARCH = -gencode=arch=compute_50,code=\"sm_50,compute_50\"
|
||||
|
||||
@@ -106,7 +105,7 @@ x11/cuda_x11_luffa512.o: x11/cuda_x11_luffa512.cu
|
||||
$(NVCC) $(nvcc_FLAGS) --maxrregcount=80 -o $@ -c $<
|
||||
|
||||
x11/cuda_x11_luffa512_Cubehash.o: x11/cuda_x11_luffa512_Cubehash.cu
|
||||
$(NVCC) $(nvcc_FLAGS) --maxrregcount=76 -o $@ -c $<
|
||||
$(NVCC) $(nvcc_FLAGS) --maxrregcount=80 -o $@ -c $<
|
||||
|
||||
x13/cuda_x13_hamsi512.o: x13/cuda_x13_hamsi512.cu
|
||||
$(NVCC) $(nvcc_FLAGS) --maxrregcount=72 -o $@ -c $<
|
||||
@@ -128,21 +127,21 @@ JHA/cuda_jha_compactionTest.o: JHA/cuda_jha_compactionTest.cu
|
||||
|
||||
# This object does not use cuda device code but call the different kernels (autotune)
|
||||
scrypt/salsa_kernel.o: scrypt/salsa_kernel.cu
|
||||
$(NVCC) $(JANSSON_INCLUDES) -I. @CUDA_INCLUDES@ @CUDA_CFLAGS@ -gencode=arch=compute_20,code=\"sm_21,compute_20\" -o $@ -c $<
|
||||
$(NVCC) -I. @CUDA_INCLUDES@ @CUDA_CFLAGS@ -gencode=arch=compute_20,code=\"sm_21,compute_20\" -o $@ -c $<
|
||||
|
||||
# These kernels are for older devices (SM)
|
||||
|
||||
scrypt/test_kernel.o: scrypt/test_kernel.cu
|
||||
$(NVCC) $(JANSSON_INCLUDES) -I. @CUDA_INCLUDES@ @CUDA_CFLAGS@ -gencode=arch=compute_20,code=\"sm_20,compute_20\" -o $@ -c $<
|
||||
$(NVCC) -I. @CUDA_INCLUDES@ @CUDA_CFLAGS@ -gencode=arch=compute_20,code=\"sm_20,compute_20\" -o $@ -c $<
|
||||
|
||||
scrypt/fermi_kernel.o: scrypt/fermi_kernel.cu
|
||||
$(NVCC) $(JANSSON_INCLUDES) -I. @CUDA_INCLUDES@ @CUDA_CFLAGS@ -gencode=arch=compute_20,code=\"sm_21,compute_20\" -o $@ -c $<
|
||||
$(NVCC) -I. @CUDA_INCLUDES@ @CUDA_CFLAGS@ -gencode=arch=compute_20,code=\"sm_21,compute_20\" -o $@ -c $<
|
||||
|
||||
scrypt/kepler_kernel.o: scrypt/kepler_kernel.cu
|
||||
$(NVCC) $(JANSSON_INCLUDES) -I. @CUDA_INCLUDES@ @CUDA_CFLAGS@ -gencode=arch=compute_30,code=\"sm_30,compute_30\" -o $@ -c $<
|
||||
$(NVCC) -I. @CUDA_INCLUDES@ @CUDA_CFLAGS@ -gencode=arch=compute_30,code=\"sm_30,compute_30\" -o $@ -c $<
|
||||
|
||||
scrypt/nv_kernel.o: scrypt/nv_kernel.cu
|
||||
$(NVCC) $(JANSSON_INCLUDES) -I. @CUDA_INCLUDES@ @CUDA_CFLAGS@ -gencode=arch=compute_30,code=\"sm_30,compute_30\" -o $@ -c $<
|
||||
$(NVCC) -I. @CUDA_INCLUDES@ @CUDA_CFLAGS@ -gencode=arch=compute_30,code=\"sm_30,compute_30\" -o $@ -c $<
|
||||
|
||||
scrypt/titan_kernel.o: scrypt/titan_kernel.cu
|
||||
$(NVCC) $(nvcc_FLAGS) -gencode=arch=compute_35,code=\"sm_35,compute_35\" -o $@ -c $<
|
||||
|
||||
+7
-33
@@ -1,5 +1,5 @@
|
||||
|
||||
ccMiner release 1.6.5-C11 (Jul 2015) "Special for Chaincoin C11"
|
||||
ccMiner release 1.6.4-tpruvot (May 2015) - "Multi-pools config"
|
||||
---------------------------------------------------------------
|
||||
|
||||
***************************************************************
|
||||
@@ -31,11 +31,9 @@ JackpotCoin
|
||||
QuarkCoin family & AnimeCoin
|
||||
TalkCoin
|
||||
DarkCoin and other X11 coins
|
||||
Chaincoin and Flaxscript (C11)
|
||||
Saffroncoin blake (256 14-rounds)
|
||||
BlakeCoin (256 8-rounds)
|
||||
Qubit (Digibyte, ...)
|
||||
Luffa (Joincoin)
|
||||
Deep, Doom and Qubit
|
||||
Keccak (Maxcoin)
|
||||
Pentablake (Blake 512 x5)
|
||||
1Coin Triple S
|
||||
@@ -67,7 +65,6 @@ its command line interface and options.
|
||||
anime use to mine Animecoin
|
||||
blake use to mine Saffroncoin (Blake 256)
|
||||
blakecoin use to mine Old Blake 256
|
||||
c11/flax use to mine Chaincoin and Flax
|
||||
deep use to mine Deepcoin
|
||||
dmd-gr use to mine Diamond-Groestl
|
||||
fresh use to mine Freshcoin
|
||||
@@ -76,13 +73,14 @@ its command line interface and options.
|
||||
heavy use to mine Heavycoin
|
||||
jackpot use to mine Jackpotcoin
|
||||
keccak use to mine Maxcoin
|
||||
luffa use to mine Joincoin
|
||||
luffa use to mine Doomcoin
|
||||
lyra2 use to mine Vertcoin
|
||||
mjollnir use to mine Mjollnircoin
|
||||
myr-gr use to mine Myriad-Groest
|
||||
neoscrypt use to mine FeatherCoin
|
||||
nist5 use to mine TalkCoin
|
||||
penta use to mine Joincoin / Pentablake
|
||||
pluck use to mine Supcoin
|
||||
quark use to mine Quarkcoin
|
||||
qubit use to mine Qubit
|
||||
scrypt use to mine Scrypt coins
|
||||
@@ -95,7 +93,6 @@ its command line interface and options.
|
||||
x14 use to mine X14Coin
|
||||
x15 use to mine Halcyon
|
||||
x17 use to mine X17
|
||||
whirlpoolx use to mine Vanilla
|
||||
zr5 use to mine ZiftrCoin
|
||||
|
||||
-d, --devices gives a comma separated list of CUDA device IDs
|
||||
@@ -105,10 +102,8 @@ its command line interface and options.
|
||||
|
||||
-i, --intensity=N[,N] GPU threads per call 8-25 (2^N + F, default: 0=auto)
|
||||
Decimals and multiple values are allowed for fine tuning
|
||||
-f, --diff-factor Divide difficulty by this factor (default 1.0)
|
||||
-m, --diff-multiplier Multiply difficulty by this value (default 1.0)
|
||||
--vote=VOTE block reward vote (for HeavyCoin)
|
||||
--trust-pool trust the max block reward vote (maxvote) sent by the pool
|
||||
-f, --diff Divide difficulty by this factor (std is 1)
|
||||
-v, --vote Heavycoin block vote (default: 512)
|
||||
-o, --url=URL URL of mining server
|
||||
-O, --userpass=U:P username:password pair for mining server
|
||||
-u, --user=USERNAME username for mining server
|
||||
@@ -137,9 +132,6 @@ its command line interface and options.
|
||||
--max-temp=N Only mine if gpu temp is less than specified value
|
||||
--max-rate=N[KMG] Only mine if net hashrate is less than specified value
|
||||
--max-diff=N Only mine if net difficulty is less than specified value
|
||||
--pstate=0 will force the Geforce 9xx to run in P0 P-State
|
||||
--plimit=150W set the gpu power limit, allow multiple values for N cards
|
||||
--keep-clocks prevent reset clocks and/or power limit on exit
|
||||
-B, --background run the miner in the background
|
||||
--benchmark run in offline benchmark mode
|
||||
--cputest debug hashes from cpu algorithms
|
||||
@@ -223,25 +215,7 @@ features.
|
||||
|
||||
>>> RELEASE HISTORY <<<
|
||||
|
||||
August 2015...
|
||||
Restore WhirlpoolX algo
|
||||
|
||||
July 06th 2015 v1.6.5-C11
|
||||
Nvml api power limits
|
||||
Add chaincoin c11 algo (used by Flaxscript too)
|
||||
Remove pluck algo
|
||||
|
||||
June 23th 2015 v1.6.5
|
||||
Handle Ziftrcoin PoK solo mining
|
||||
Basic compatibility with CUDA 7.0 (generally slower hashrate)
|
||||
Show gpus vendor names on linux (windows test branch is pciutils)
|
||||
Remove -v and -m short params specific to heavycoin
|
||||
Add --diff-multiplier (-m) and rename --diff to --diff-factor (-f)
|
||||
First steps to handle nvml application clocks and P0 on the GTX9xx
|
||||
Various improvements on multipool and cmdline parameters
|
||||
Optimize a bit qubit, deep, luffa, x11 and quark algos
|
||||
|
||||
May 26th 2015 v1.6.4
|
||||
May 21th 2015 v1.6.4
|
||||
Implement multi-pool support (failover and time rotate)
|
||||
try "ccminer -c pools.conf" to test the sample config
|
||||
Update the API to allow remote pool switching and pool stats
|
||||
|
||||
@@ -8,7 +8,7 @@
|
||||
* Software Foundation; either version 2 of the License, or (at your option)
|
||||
* any later version. See COPYING for more details.
|
||||
*/
|
||||
#define APIVERSION "1.6"
|
||||
#define APIVERSION "1.5"
|
||||
|
||||
#ifdef WIN32
|
||||
# define _WINSOCK_DEPRECATED_NO_WARNINGS
|
||||
@@ -124,7 +124,6 @@ static void gpustatus(int thr_id)
|
||||
cgpu->gpu_temp = gpu_temp(cgpu);
|
||||
cgpu->gpu_fan = (uint16_t) gpu_fanpercent(cgpu);
|
||||
cgpu->gpu_fan_rpm = (uint16_t) gpu_fanrpm(cgpu);
|
||||
cgpu->gpu_power = gpu_power(cgpu);
|
||||
#endif
|
||||
cuda_gpu_clocks(cgpu);
|
||||
|
||||
@@ -136,11 +135,10 @@ static void gpustatus(int thr_id)
|
||||
|
||||
card = device_name[gpuid];
|
||||
|
||||
snprintf(buf, sizeof(buf), "GPU=%d;BUS=%hd;CARD=%s;TEMP=%.1f;"
|
||||
"POWER=%u;FAN=%hu;RPM=%hu;FREQ=%d;KHS=%.2f;HWF=%d;I=%.1f;THR=%u|",
|
||||
gpuid, cgpu->gpu_bus, card, cgpu->gpu_temp,
|
||||
cgpu->gpu_power, cgpu->gpu_fan, cgpu->gpu_fan_rpm,
|
||||
cgpu->gpu_clock, cgpu->khashes,
|
||||
snprintf(buf, sizeof(buf), "GPU=%d;BUS=%hd;CARD=%s;"
|
||||
"TEMP=%.1f;FAN=%hu;RPM=%hu;FREQ=%d;KHS=%.2f;HWF=%d;I=%.1f;THR=%u|",
|
||||
gpuid, cgpu->gpu_bus, card, cgpu->gpu_temp, cgpu->gpu_fan,
|
||||
cgpu->gpu_fan_rpm, cgpu->gpu_clock, cgpu->khashes,
|
||||
cgpu->hw_errors, cgpu->intensity, cgpu->throughput);
|
||||
|
||||
// append to buffer for multi gpus
|
||||
@@ -171,9 +169,9 @@ static char *getsummary(char *params)
|
||||
double accps, uptime = difftime(ts, startup);
|
||||
uint32_t wait_time = 0, accepted_count = 0, rejected_count = 0;
|
||||
for (int p = 0; p < num_pools; p++) {
|
||||
wait_time += pools[p].wait_time;
|
||||
accepted_count += pools[p].accepted_count;
|
||||
rejected_count += pools[p].rejected_count;
|
||||
wait_time += pools[cur_pooln].wait_time;
|
||||
accepted_count += pools[cur_pooln].accepted_count;
|
||||
rejected_count += pools[cur_pooln].rejected_count;
|
||||
}
|
||||
accps = (60.0 * accepted_count) / (uptime ? uptime : 1.0);
|
||||
|
||||
@@ -182,12 +180,12 @@ static char *getsummary(char *params)
|
||||
*buffer = '\0';
|
||||
sprintf(buffer, "NAME=%s;VER=%s;API=%s;"
|
||||
"ALGO=%s;GPUS=%d;KHS=%.2f;ACC=%d;REJ=%d;"
|
||||
"ACCMN=%.3f;DIFF=%.6f;NETKHS=%.0f;"
|
||||
"ACCMN=%.3f;DIFF=%.6f;NETKHS=%.2f;"
|
||||
"POOLS=%u;WAIT=%u;UPTIME=%.0f;TS=%u|",
|
||||
PACKAGE_NAME, PACKAGE_VERSION, APIVERSION,
|
||||
algo, active_gpus, (double)global_hashrate / 1000.,
|
||||
accepted_count, rejected_count,
|
||||
accps, net_diff > 1e-6 ? net_diff : stratum_diff, (double)net_hashrate / 1000.,
|
||||
accps, net_diff > 0. ? net_diff : stratum_diff, (double)net_hashrate / 1000.,
|
||||
num_pools, wait_time, uptime, (uint32_t) ts);
|
||||
return buffer;
|
||||
}
|
||||
@@ -200,8 +198,7 @@ static char *getpoolnfo(char *params)
|
||||
char *s = buffer;
|
||||
char jobid[128] = { 0 };
|
||||
char nonce[128] = { 0 };
|
||||
int pooln = params ? atoi(params) % num_pools : cur_pooln;
|
||||
struct pool_infos *p = &pools[pooln];
|
||||
struct pool_infos *p = &pools[cur_pooln];
|
||||
|
||||
*s = '\0';
|
||||
|
||||
@@ -249,8 +246,7 @@ static void gpuhwinfos(int gpu_id)
|
||||
cgpu->gpu_temp = gpu_temp(cgpu);
|
||||
cgpu->gpu_fan = (uint16_t) gpu_fanpercent(cgpu);
|
||||
cgpu->gpu_fan_rpm = (uint16_t) gpu_fanrpm(cgpu);
|
||||
cgpu->gpu_pstate = (int16_t) gpu_pstate(cgpu);
|
||||
cgpu->gpu_power = gpu_power(cgpu);
|
||||
cgpu->gpu_pstate = gpu_pstate(cgpu);
|
||||
gpu_info(cgpu);
|
||||
#endif
|
||||
|
||||
@@ -258,18 +254,17 @@ static void gpuhwinfos(int gpu_id)
|
||||
|
||||
memset(pstate, 0, sizeof(pstate));
|
||||
if (cgpu->gpu_pstate != -1)
|
||||
snprintf(pstate, sizeof(pstate), "P%d", (int) cgpu->gpu_pstate);
|
||||
snprintf(pstate, sizeof(pstate), "P%hu", cgpu->gpu_pstate);
|
||||
|
||||
card = device_name[gpu_id];
|
||||
|
||||
snprintf(buf, sizeof(buf), "GPU=%d;BUS=%hd;CARD=%s;SM=%u;MEM=%lu;"
|
||||
"TEMP=%.1f;FAN=%hu;RPM=%hu;FREQ=%d;MEMFREQ=%d;PST=%s;POWER=%u;"
|
||||
"TEMP=%.1f;FAN=%hu;RPM=%hu;FREQ=%d;MEMFREQ=%d;PST=%s;"
|
||||
"VID=%hx;PID=%hx;NVML=%d;NVAPI=%d;SN=%s;BIOS=%s|",
|
||||
gpu_id, cgpu->gpu_bus, card, cgpu->gpu_arch, cgpu->gpu_mem,
|
||||
cgpu->gpu_temp, cgpu->gpu_fan, cgpu->gpu_fan_rpm,
|
||||
cgpu->gpu_clock, cgpu->gpu_memclock,
|
||||
pstate, cgpu->gpu_power,
|
||||
cgpu->gpu_vid, cgpu->gpu_pid, cgpu->nvml_id, cgpu->nvapi_id,
|
||||
pstate, cgpu->gpu_vid, cgpu->gpu_pid, cgpu->nvml_id, cgpu->nvapi_id,
|
||||
cgpu->gpu_sn, cgpu->gpu_desc);
|
||||
|
||||
strcat(buffer, buf);
|
||||
|
||||
@@ -62,7 +62,6 @@ function translateField($key)
|
||||
$intl['TEMP'] = 'T°c';
|
||||
$intl['FAN'] = 'Fan %';
|
||||
$intl['FREQ'] = 'Freq.';
|
||||
$intl['POWER'] = 'Power';
|
||||
$intl['PST'] = 'P-State';
|
||||
|
||||
// pool infos
|
||||
@@ -97,9 +96,6 @@ function translateValue($key,$val,$data=array())
|
||||
case 'FREQ':
|
||||
$val = sprintf("%d MHz", round(floatval($val)/1000.0));
|
||||
break;
|
||||
case 'POWER':
|
||||
$val = sprintf("%d W", round(floatval($val)/1000.0));
|
||||
break;
|
||||
case 'TS':
|
||||
$val = strftime("%H:%M:%S", (int) $val);
|
||||
break;
|
||||
|
||||
-26
@@ -1,26 +0,0 @@
|
||||
/**
|
||||
* Wrapper to OpenSSL BIGNUM used by net diff (nBits)
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include "uint256.h"
|
||||
#include "bignum.hpp"
|
||||
|
||||
#include "miner.h" // hex2bin
|
||||
|
||||
extern "C" double bn_convert_nbits(const uint32_t nBits)
|
||||
{
|
||||
uint256 bn = CBigNum().SetCompact(nBits).getuint256();
|
||||
return bn.getdouble();
|
||||
}
|
||||
|
||||
// copy the big number to 32-bytes uchar
|
||||
extern "C" void bn_nbits_to_uchar(const uint32_t nBits, unsigned char *target)
|
||||
{
|
||||
char buff[65];
|
||||
uint256 bn = CBigNum().SetCompact(nBits).getuint256();
|
||||
|
||||
snprintf(buff, 65, "%s\n", bn.ToString().c_str()); buff[64] = '\0';
|
||||
hex2bin(target, buff, 32);
|
||||
}
|
||||
-602
@@ -1,602 +0,0 @@
|
||||
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
||||
// Copyright (c) 2009-2012 The Bitcoin developers
|
||||
// Distributed under the MIT/X11 software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
#ifndef BITCOIN_BIGNUM_H
|
||||
#define BITCOIN_BIGNUM_H
|
||||
|
||||
#ifndef PROTOCOL_VERSION
|
||||
#define PROTOCOL_VERSION 70001
|
||||
#endif
|
||||
|
||||
#include <map>
|
||||
#include <limits>
|
||||
#include <algorithm>
|
||||
#include <stdexcept>
|
||||
#include <vector>
|
||||
|
||||
#include "uint256.h"
|
||||
|
||||
#include <openssl/bn.h>
|
||||
|
||||
#include "serialize.hpp"
|
||||
|
||||
using namespace std;
|
||||
|
||||
/** Errors thrown by the bignum class */
|
||||
class bignum_error : public std::runtime_error
|
||||
{
|
||||
public:
|
||||
explicit bignum_error(const std::string& str) : std::runtime_error(str) {}
|
||||
};
|
||||
|
||||
|
||||
/** RAII encapsulated BN_CTX (OpenSSL bignum context) */
|
||||
class CAutoBN_CTX
|
||||
{
|
||||
protected:
|
||||
BN_CTX* pctx;
|
||||
BN_CTX* operator=(BN_CTX* pnew) { return pctx = pnew; }
|
||||
|
||||
public:
|
||||
CAutoBN_CTX()
|
||||
{
|
||||
pctx = BN_CTX_new();
|
||||
if (pctx == NULL)
|
||||
throw bignum_error("CAutoBN_CTX : BN_CTX_new() returned NULL");
|
||||
}
|
||||
|
||||
~CAutoBN_CTX()
|
||||
{
|
||||
if (pctx != NULL)
|
||||
BN_CTX_free(pctx);
|
||||
}
|
||||
|
||||
operator BN_CTX*() { return pctx; }
|
||||
BN_CTX& operator*() { return *pctx; }
|
||||
BN_CTX** operator&() { return &pctx; }
|
||||
bool operator!() { return (pctx == NULL); }
|
||||
};
|
||||
|
||||
|
||||
/** C++ wrapper for BIGNUM (OpenSSL bignum) */
|
||||
class CBigNum : public BIGNUM
|
||||
{
|
||||
public:
|
||||
CBigNum()
|
||||
{
|
||||
BN_init(this);
|
||||
}
|
||||
|
||||
CBigNum(const CBigNum& b)
|
||||
{
|
||||
BN_init(this);
|
||||
if (!BN_copy(this, &b))
|
||||
{
|
||||
BN_clear_free(this);
|
||||
throw bignum_error("CBigNum::CBigNum(const CBigNum&) : BN_copy failed");
|
||||
}
|
||||
}
|
||||
|
||||
CBigNum& operator=(const CBigNum& b)
|
||||
{
|
||||
if (!BN_copy(this, &b))
|
||||
throw bignum_error("CBigNum::operator= : BN_copy failed");
|
||||
return (*this);
|
||||
}
|
||||
|
||||
~CBigNum()
|
||||
{
|
||||
BN_clear_free(this);
|
||||
}
|
||||
|
||||
//CBigNum(char n) is not portable. Use 'signed char' or 'unsigned char'.
|
||||
CBigNum(signed char n) { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
|
||||
CBigNum(short n) { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
|
||||
CBigNum(int n) { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
|
||||
CBigNum(long n) { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
|
||||
CBigNum(int64 n) { BN_init(this); setint64(n); }
|
||||
CBigNum(unsigned char n) { BN_init(this); setulong(n); }
|
||||
CBigNum(unsigned short n) { BN_init(this); setulong(n); }
|
||||
CBigNum(unsigned int n) { BN_init(this); setulong(n); }
|
||||
CBigNum(unsigned long n) { BN_init(this); setulong(n); }
|
||||
CBigNum(uint64 n) { BN_init(this); setuint64(n); }
|
||||
explicit CBigNum(uint256 n) { BN_init(this); setuint256(n); }
|
||||
|
||||
explicit CBigNum(const std::vector<unsigned char>& vch)
|
||||
{
|
||||
BN_init(this);
|
||||
setvch(vch);
|
||||
}
|
||||
|
||||
void setulong(unsigned long n)
|
||||
{
|
||||
if (!BN_set_word(this, n))
|
||||
throw bignum_error("CBigNum conversion from unsigned long : BN_set_word failed");
|
||||
}
|
||||
|
||||
unsigned long getulong() const
|
||||
{
|
||||
return BN_get_word(this);
|
||||
}
|
||||
|
||||
unsigned int getuint() const
|
||||
{
|
||||
return BN_get_word(this);
|
||||
}
|
||||
|
||||
int getint() const
|
||||
{
|
||||
unsigned long n = BN_get_word(this);
|
||||
if (!BN_is_negative(this))
|
||||
return (n > (unsigned long)std::numeric_limits<int>::max() ? std::numeric_limits<int>::max() : n);
|
||||
else
|
||||
return (n > (unsigned long)std::numeric_limits<int>::max() ? std::numeric_limits<int>::min() : -(int)n);
|
||||
}
|
||||
|
||||
void setint64(int64 sn)
|
||||
{
|
||||
unsigned char pch[sizeof(sn) + 6];
|
||||
unsigned char* p = pch + 4;
|
||||
bool fNegative;
|
||||
uint64 n;
|
||||
|
||||
if (sn < (int64)0)
|
||||
{
|
||||
// Since the minimum signed integer cannot be represented as positive so long as its type is signed,
|
||||
// and it's not well-defined what happens if you make it unsigned before negating it,
|
||||
// we instead increment the negative integer by 1, convert it, then increment the (now positive) unsigned integer by 1 to compensate
|
||||
n = -(sn + 1);
|
||||
++n;
|
||||
fNegative = true;
|
||||
} else {
|
||||
n = sn;
|
||||
fNegative = false;
|
||||
}
|
||||
|
||||
bool fLeadingZeroes = true;
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
unsigned char c = (n >> 56) & 0xff;
|
||||
n <<= 8;
|
||||
if (fLeadingZeroes)
|
||||
{
|
||||
if (c == 0)
|
||||
continue;
|
||||
if (c & 0x80)
|
||||
*p++ = (fNegative ? 0x80 : 0);
|
||||
else if (fNegative)
|
||||
c |= 0x80;
|
||||
fLeadingZeroes = false;
|
||||
}
|
||||
*p++ = c;
|
||||
}
|
||||
unsigned int nSize = p - (pch + 4);
|
||||
pch[0] = (nSize >> 24) & 0xff;
|
||||
pch[1] = (nSize >> 16) & 0xff;
|
||||
pch[2] = (nSize >> 8) & 0xff;
|
||||
pch[3] = (nSize) & 0xff;
|
||||
BN_mpi2bn(pch, p - pch, this);
|
||||
}
|
||||
|
||||
void setuint64(uint64 n)
|
||||
{
|
||||
unsigned char pch[sizeof(n) + 6];
|
||||
unsigned char* p = pch + 4;
|
||||
bool fLeadingZeroes = true;
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
unsigned char c = (n >> 56) & 0xff;
|
||||
n <<= 8;
|
||||
if (fLeadingZeroes)
|
||||
{
|
||||
if (c == 0)
|
||||
continue;
|
||||
if (c & 0x80)
|
||||
*p++ = 0;
|
||||
fLeadingZeroes = false;
|
||||
}
|
||||
*p++ = c;
|
||||
}
|
||||
unsigned int nSize = p - (pch + 4);
|
||||
pch[0] = (nSize >> 24) & 0xff;
|
||||
pch[1] = (nSize >> 16) & 0xff;
|
||||
pch[2] = (nSize >> 8) & 0xff;
|
||||
pch[3] = (nSize) & 0xff;
|
||||
BN_mpi2bn(pch, p - pch, this);
|
||||
}
|
||||
|
||||
void setuint256(uint256 n)
|
||||
{
|
||||
unsigned char pch[sizeof(n) + 6];
|
||||
unsigned char* p = pch + 4;
|
||||
bool fLeadingZeroes = true;
|
||||
unsigned char* pbegin = (unsigned char*)&n;
|
||||
unsigned char* psrc = pbegin + sizeof(n);
|
||||
while (psrc != pbegin)
|
||||
{
|
||||
unsigned char c = *(--psrc);
|
||||
if (fLeadingZeroes)
|
||||
{
|
||||
if (c == 0)
|
||||
continue;
|
||||
if (c & 0x80)
|
||||
*p++ = 0;
|
||||
fLeadingZeroes = false;
|
||||
}
|
||||
*p++ = c;
|
||||
}
|
||||
unsigned int nSize = p - (pch + 4);
|
||||
pch[0] = (nSize >> 24) & 0xff;
|
||||
pch[1] = (nSize >> 16) & 0xff;
|
||||
pch[2] = (nSize >> 8) & 0xff;
|
||||
pch[3] = (nSize >> 0) & 0xff;
|
||||
BN_mpi2bn(pch, p - pch, this);
|
||||
}
|
||||
|
||||
uint256 getuint256() const
|
||||
{
|
||||
unsigned int nSize = BN_bn2mpi(this, NULL);
|
||||
if (nSize < 4)
|
||||
return 0;
|
||||
std::vector<unsigned char> vch(nSize);
|
||||
BN_bn2mpi(this, &vch[0]);
|
||||
if (vch.size() > 4)
|
||||
vch[4] &= 0x7f;
|
||||
uint256 n = 0;
|
||||
for (unsigned int i = 0, j = vch.size()-1; i < sizeof(n) && j >= 4; i++, j--)
|
||||
((unsigned char*)&n)[i] = vch[j];
|
||||
return n;
|
||||
}
|
||||
|
||||
void setvch(const std::vector<unsigned char>& vch)
|
||||
{
|
||||
std::vector<unsigned char> vch2(vch.size() + 4);
|
||||
unsigned int nSize = vch.size();
|
||||
// BIGNUM's byte stream format expects 4 bytes of
|
||||
// big endian size data info at the front
|
||||
vch2[0] = (nSize >> 24) & 0xff;
|
||||
vch2[1] = (nSize >> 16) & 0xff;
|
||||
vch2[2] = (nSize >> 8) & 0xff;
|
||||
vch2[3] = (nSize >> 0) & 0xff;
|
||||
// swap data to big endian
|
||||
reverse_copy(vch.begin(), vch.end(), vch2.begin() + 4);
|
||||
BN_mpi2bn(&vch2[0], vch2.size(), this);
|
||||
}
|
||||
|
||||
std::vector<unsigned char> getvch() const
|
||||
{
|
||||
unsigned int nSize = BN_bn2mpi(this, NULL);
|
||||
if (nSize <= 4)
|
||||
return std::vector<unsigned char>();
|
||||
std::vector<unsigned char> vch(nSize);
|
||||
BN_bn2mpi(this, &vch[0]);
|
||||
vch.erase(vch.begin(), vch.begin() + 4);
|
||||
reverse(vch.begin(), vch.end());
|
||||
return vch;
|
||||
}
|
||||
|
||||
// The "compact" format is a representation of a whole
|
||||
// number N using an unsigned 32bit number similar to a
|
||||
// floating point format.
|
||||
// The most significant 8 bits are the unsigned exponent of base 256.
|
||||
// This exponent can be thought of as "number of bytes of N".
|
||||
// The lower 23 bits are the mantissa.
|
||||
// Bit number 24 (0x800000) represents the sign of N.
|
||||
// N = (-1^sign) * mantissa * 256^(exponent-3)
|
||||
//
|
||||
// Satoshi's original implementation used BN_bn2mpi() and BN_mpi2bn().
|
||||
// MPI uses the most significant bit of the first byte as sign.
|
||||
// Thus 0x1234560000 is compact (0x05123456)
|
||||
// and 0xc0de000000 is compact (0x0600c0de)
|
||||
// (0x05c0de00) would be -0x40de000000
|
||||
//
|
||||
// Bitcoin only uses this "compact" format for encoding difficulty
|
||||
// targets, which are unsigned 256bit quantities. Thus, all the
|
||||
// complexities of the sign bit and using base 256 are probably an
|
||||
// implementation accident.
|
||||
//
|
||||
// This implementation directly uses shifts instead of going
|
||||
// through an intermediate MPI representation.
|
||||
CBigNum& SetCompact(unsigned int nCompact)
|
||||
{
|
||||
unsigned int nSize = nCompact >> 24;
|
||||
bool fNegative =(nCompact & 0x00800000) != 0;
|
||||
unsigned int nWord = nCompact & 0x007fffff;
|
||||
if (nSize <= 3)
|
||||
{
|
||||
nWord >>= 8*(3-nSize);
|
||||
BN_set_word(this, nWord);
|
||||
}
|
||||
else
|
||||
{
|
||||
BN_set_word(this, nWord);
|
||||
BN_lshift(this, this, 8*(nSize-3));
|
||||
}
|
||||
BN_set_negative(this, fNegative);
|
||||
return *this;
|
||||
}
|
||||
|
||||
unsigned int GetCompact() const
|
||||
{
|
||||
unsigned int nSize = BN_num_bytes(this);
|
||||
unsigned int nCompact = 0;
|
||||
if (nSize <= 3)
|
||||
nCompact = BN_get_word(this) << 8*(3-nSize);
|
||||
else
|
||||
{
|
||||
CBigNum bn;
|
||||
BN_rshift(&bn, this, 8*(nSize-3));
|
||||
nCompact = BN_get_word(&bn);
|
||||
}
|
||||
// The 0x00800000 bit denotes the sign.
|
||||
// Thus, if it is already set, divide the mantissa by 256 and increase the exponent.
|
||||
if (nCompact & 0x00800000)
|
||||
{
|
||||
nCompact >>= 8;
|
||||
nSize++;
|
||||
}
|
||||
nCompact |= nSize << 24;
|
||||
nCompact |= (BN_is_negative(this) ? 0x00800000 : 0);
|
||||
return nCompact;
|
||||
}
|
||||
|
||||
void SetHex(const std::string& str)
|
||||
{
|
||||
// skip 0x
|
||||
const char* psz = str.c_str();
|
||||
while (isspace(*psz))
|
||||
psz++;
|
||||
bool fNegative = false;
|
||||
if (*psz == '-')
|
||||
{
|
||||
fNegative = true;
|
||||
psz++;
|
||||
}
|
||||
if (psz[0] == '0' && tolower(psz[1]) == 'x')
|
||||
psz += 2;
|
||||
while (isspace(*psz))
|
||||
psz++;
|
||||
|
||||
// hex string to bignum
|
||||
static const signed char phexdigit[256] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0, 0,0xa,0xb,0xc,0xd,0xe,0xf,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0xa,0xb,0xc,0xd,0xe,0xf,0,0,0,0,0,0,0,0,0 };
|
||||
*this = 0;
|
||||
while (isxdigit(*psz))
|
||||
{
|
||||
*this <<= 4;
|
||||
int n = phexdigit[(unsigned char)*psz++];
|
||||
*this += n;
|
||||
}
|
||||
if (fNegative)
|
||||
*this = 0 - *this;
|
||||
}
|
||||
|
||||
std::string ToString(int nBase=10) const
|
||||
{
|
||||
CAutoBN_CTX pctx;
|
||||
CBigNum bnBase = nBase;
|
||||
CBigNum bn0 = 0;
|
||||
std::string str;
|
||||
CBigNum bn = *this;
|
||||
BN_set_negative(&bn, false);
|
||||
CBigNum dv;
|
||||
CBigNum rem;
|
||||
if (BN_cmp(&bn, &bn0) == 0)
|
||||
return "0";
|
||||
while (BN_cmp(&bn, &bn0) > 0)
|
||||
{
|
||||
if (!BN_div(&dv, &rem, &bn, &bnBase, pctx))
|
||||
throw bignum_error("CBigNum::ToString() : BN_div failed");
|
||||
bn = dv;
|
||||
unsigned int c = rem.getulong();
|
||||
str += "0123456789abcdef"[c];
|
||||
}
|
||||
if (BN_is_negative(this))
|
||||
str += "-";
|
||||
reverse(str.begin(), str.end());
|
||||
return str;
|
||||
}
|
||||
|
||||
std::string GetHex() const
|
||||
{
|
||||
return ToString(16);
|
||||
}
|
||||
|
||||
unsigned int GetSerializeSize(int nType=0, int nVersion=PROTOCOL_VERSION) const
|
||||
{
|
||||
return ::GetSerializeSize(getvch(), nType, nVersion);
|
||||
}
|
||||
|
||||
template<typename Stream>
|
||||
void Serialize(Stream& s, int nType=0, int nVersion=PROTOCOL_VERSION) const
|
||||
{
|
||||
::Serialize(s, getvch(), nType, nVersion);
|
||||
}
|
||||
|
||||
template<typename Stream>
|
||||
void Unserialize(Stream& s, int nType=0, int nVersion=PROTOCOL_VERSION)
|
||||
{
|
||||
std::vector<unsigned char> vch;
|
||||
::Unserialize(s, vch, nType, nVersion);
|
||||
setvch(vch);
|
||||
}
|
||||
|
||||
|
||||
bool operator!() const
|
||||
{
|
||||
return BN_is_zero(this);
|
||||
}
|
||||
|
||||
CBigNum& operator+=(const CBigNum& b)
|
||||
{
|
||||
if (!BN_add(this, this, &b))
|
||||
throw bignum_error("CBigNum::operator+= : BN_add failed");
|
||||
return *this;
|
||||
}
|
||||
|
||||
CBigNum& operator-=(const CBigNum& b)
|
||||
{
|
||||
*this = *this - b;
|
||||
return *this;
|
||||
}
|
||||
|
||||
CBigNum& operator*=(const CBigNum& b)
|
||||
{
|
||||
CAutoBN_CTX pctx;
|
||||
if (!BN_mul(this, this, &b, pctx))
|
||||
throw bignum_error("CBigNum::operator*= : BN_mul failed");
|
||||
return *this;
|
||||
}
|
||||
|
||||
CBigNum& operator/=(const CBigNum& b)
|
||||
{
|
||||
*this = *this / b;
|
||||
return *this;
|
||||
}
|
||||
|
||||
CBigNum& operator%=(const CBigNum& b)
|
||||
{
|
||||
*this = *this % b;
|
||||
return *this;
|
||||
}
|
||||
|
||||
CBigNum& operator<<=(unsigned int shift)
|
||||
{
|
||||
if (!BN_lshift(this, this, shift))
|
||||
throw bignum_error("CBigNum:operator<<= : BN_lshift failed");
|
||||
return *this;
|
||||
}
|
||||
|
||||
CBigNum& operator>>=(unsigned int shift)
|
||||
{
|
||||
// Note: BN_rshift segfaults on 64-bit if 2^shift is greater than the number
|
||||
// if built on ubuntu 9.04 or 9.10, probably depends on version of OpenSSL
|
||||
CBigNum a = 1;
|
||||
a <<= shift;
|
||||
if (BN_cmp(&a, this) > 0)
|
||||
{
|
||||
*this = 0;
|
||||
return *this;
|
||||
}
|
||||
|
||||
if (!BN_rshift(this, this, shift))
|
||||
throw bignum_error("CBigNum:operator>>= : BN_rshift failed");
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
CBigNum& operator++()
|
||||
{
|
||||
// prefix operator
|
||||
if (!BN_add(this, this, BN_value_one()))
|
||||
throw bignum_error("CBigNum::operator++ : BN_add failed");
|
||||
return *this;
|
||||
}
|
||||
|
||||
const CBigNum operator++(int)
|
||||
{
|
||||
// postfix operator
|
||||
const CBigNum ret = *this;
|
||||
++(*this);
|
||||
return ret;
|
||||
}
|
||||
|
||||
CBigNum& operator--()
|
||||
{
|
||||
// prefix operator
|
||||
CBigNum r;
|
||||
if (!BN_sub(&r, this, BN_value_one()))
|
||||
throw bignum_error("CBigNum::operator-- : BN_sub failed");
|
||||
*this = r;
|
||||
return *this;
|
||||
}
|
||||
|
||||
const CBigNum operator--(int)
|
||||
{
|
||||
// postfix operator
|
||||
const CBigNum ret = *this;
|
||||
--(*this);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
friend inline const CBigNum operator-(const CBigNum& a, const CBigNum& b);
|
||||
friend inline const CBigNum operator/(const CBigNum& a, const CBigNum& b);
|
||||
friend inline const CBigNum operator%(const CBigNum& a, const CBigNum& b);
|
||||
};
|
||||
|
||||
|
||||
|
||||
inline const CBigNum operator+(const CBigNum& a, const CBigNum& b)
|
||||
{
|
||||
CBigNum r;
|
||||
if (!BN_add(&r, &a, &b))
|
||||
throw bignum_error("CBigNum::operator+ : BN_add failed");
|
||||
return r;
|
||||
}
|
||||
|
||||
inline const CBigNum operator-(const CBigNum& a, const CBigNum& b)
|
||||
{
|
||||
CBigNum r;
|
||||
if (!BN_sub(&r, &a, &b))
|
||||
throw bignum_error("CBigNum::operator- : BN_sub failed");
|
||||
return r;
|
||||
}
|
||||
|
||||
inline const CBigNum operator-(const CBigNum& a)
|
||||
{
|
||||
CBigNum r(a);
|
||||
BN_set_negative(&r, !BN_is_negative(&r));
|
||||
return r;
|
||||
}
|
||||
|
||||
inline const CBigNum operator*(const CBigNum& a, const CBigNum& b)
|
||||
{
|
||||
CAutoBN_CTX pctx;
|
||||
CBigNum r;
|
||||
if (!BN_mul(&r, &a, &b, pctx))
|
||||
throw bignum_error("CBigNum::operator* : BN_mul failed");
|
||||
return r;
|
||||
}
|
||||
|
||||
inline const CBigNum operator/(const CBigNum& a, const CBigNum& b)
|
||||
{
|
||||
CAutoBN_CTX pctx;
|
||||
CBigNum r;
|
||||
if (!BN_div(&r, NULL, &a, &b, pctx))
|
||||
throw bignum_error("CBigNum::operator/ : BN_div failed");
|
||||
return r;
|
||||
}
|
||||
|
||||
inline const CBigNum operator%(const CBigNum& a, const CBigNum& b)
|
||||
{
|
||||
CAutoBN_CTX pctx;
|
||||
CBigNum r;
|
||||
if (!BN_mod(&r, &a, &b, pctx))
|
||||
throw bignum_error("CBigNum::operator% : BN_div failed");
|
||||
return r;
|
||||
}
|
||||
|
||||
inline const CBigNum operator<<(const CBigNum& a, unsigned int shift)
|
||||
{
|
||||
CBigNum r;
|
||||
if (!BN_lshift(&r, &a, shift))
|
||||
throw bignum_error("CBigNum:operator<< : BN_lshift failed");
|
||||
return r;
|
||||
}
|
||||
|
||||
inline const CBigNum operator>>(const CBigNum& a, unsigned int shift)
|
||||
{
|
||||
CBigNum r = a;
|
||||
r >>= shift;
|
||||
return r;
|
||||
}
|
||||
|
||||
inline bool operator==(const CBigNum& a, const CBigNum& b) { return (BN_cmp(&a, &b) == 0); }
|
||||
inline bool operator!=(const CBigNum& a, const CBigNum& b) { return (BN_cmp(&a, &b) != 0); }
|
||||
inline bool operator<=(const CBigNum& a, const CBigNum& b) { return (BN_cmp(&a, &b) <= 0); }
|
||||
inline bool operator>=(const CBigNum& a, const CBigNum& b) { return (BN_cmp(&a, &b) >= 0); }
|
||||
inline bool operator<(const CBigNum& a, const CBigNum& b) { return (BN_cmp(&a, &b) < 0); }
|
||||
inline bool operator>(const CBigNum& a, const CBigNum& b) { return (BN_cmp(&a, &b) > 0); }
|
||||
|
||||
#endif
|
||||
+417
-269
File diff suppressed because it is too large.
Load diff
+50
-34
@@ -23,22 +23,34 @@
|
||||
<RootNamespace>ccminer</RootNamespace>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
||||
<PropertyGroup Condition="'$(Configuration)'=='Release'" Label="Configuration">
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<CharacterSet>MultiByte</CharacterSet>
|
||||
<PlatformToolset>v120</PlatformToolset>
|
||||
<CLRSupport>false</CLRSupport>
|
||||
<LinkIncremental>false</LinkIncremental>
|
||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)'=='Debug'" Label="Configuration">
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<CharacterSet>MultiByte</CharacterSet>
|
||||
<PlatformToolset>v120</PlatformToolset>
|
||||
<CLRSupport>false</CLRSupport>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<CharacterSet>MultiByte</CharacterSet>
|
||||
<PlatformToolset>v120</PlatformToolset>
|
||||
<CLRSupport>false</CLRSupport>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<CharacterSet>MultiByte</CharacterSet>
|
||||
<PlatformToolset>v120</PlatformToolset>
|
||||
<CLRSupport>false</CLRSupport>
|
||||
<LinkIncremental>false</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
|
||||
<ImportGroup Label="ExtensionSettings">
|
||||
@@ -56,6 +68,19 @@
|
||||
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
</ImportGroup>
|
||||
<PropertyGroup Label="UserMacros" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<LinkIncremental>true</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
|
||||
<LinkIncremental>false</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<LinkIncremental>false</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
|
||||
<LinkIncremental>false</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
@@ -66,7 +91,6 @@
|
||||
<AdditionalIncludeDirectories>.;compat;compat\curl-for-windows\curl\include;compat\jansson;compat\getopt;compat\pthreads;compat\curl-for-windows\openssl\openssl\include;compat\curl-for-windows\zlib;%(AdditionalIncludeDirectories);$(CudaToolkitIncludeDir)</AdditionalIncludeDirectories>
|
||||
<EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
|
||||
<MultiProcessorCompilation>true</MultiProcessorCompilation>
|
||||
<OpenMPSupport>true</OpenMPSupport>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
@@ -84,7 +108,6 @@
|
||||
<PtxAsOptionV>true</PtxAsOptionV>
|
||||
<Keep>true</Keep>
|
||||
<CodeGeneration>compute_50,sm_50</CodeGeneration>
|
||||
<Include>$(NVTOOLSEXT_PATH)\include;..\..\..\Common\C99</Include>
|
||||
</CudaCompile>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
|
||||
@@ -98,7 +121,6 @@
|
||||
<StructMemberAlignment>8Bytes</StructMemberAlignment>
|
||||
<EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
|
||||
<MultiProcessorCompilation>true</MultiProcessorCompilation>
|
||||
<OpenMPSupport>true</OpenMPSupport>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
@@ -137,7 +159,7 @@
|
||||
<AdditionalIncludeDirectories>.;compat;compat\curl-for-windows\curl\include;compat\jansson;compat\getopt;compat\pthreads;compat\curl-for-windows\openssl\openssl\include;compat\curl-for-windows\zlib;%(AdditionalIncludeDirectories);$(CudaToolkitIncludeDir)</AdditionalIncludeDirectories>
|
||||
<EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
|
||||
<MultiProcessorCompilation>true</MultiProcessorCompilation>
|
||||
<OpenMPSupport>true</OpenMPSupport>
|
||||
<ExceptionHandling>SyncCThrow</ExceptionHandling>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<GenerateDebugInformation>false</GenerateDebugInformation>
|
||||
@@ -157,13 +179,17 @@
|
||||
<MaxRegCount>80</MaxRegCount>
|
||||
<PtxAsOptionV>true</PtxAsOptionV>
|
||||
<Keep>true</Keep>
|
||||
<CodeGeneration>compute_50,sm_50;compute_52,sm_52;compute_30,sm_30;compute_35,sm_35</CodeGeneration>
|
||||
<CodeGeneration>compute_35,sm_35;compute_50,sm_50;compute_52,sm_52</CodeGeneration>
|
||||
<AdditionalOptions>--ptxas-options="-O2" %(AdditionalOptions)</AdditionalOptions>
|
||||
<Optimization>O2</Optimization>
|
||||
<Defines>
|
||||
</Defines>
|
||||
<Optimization>O3</Optimization>
|
||||
</CudaCompile>
|
||||
<CudaLink>
|
||||
<GPUDebugInfo>false</GPUDebugInfo>
|
||||
<Optimization>O3</Optimization>
|
||||
</CudaLink>
|
||||
<CudaLink>
|
||||
<Optimization>O2</Optimization>
|
||||
</CudaLink>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
|
||||
@@ -172,9 +198,7 @@
|
||||
<Optimization>MaxSpeed</Optimization>
|
||||
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
|
||||
<FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
|
||||
<EnableEnhancedInstructionSet>
|
||||
</EnableEnhancedInstructionSet>
|
||||
<OpenMPSupport>true</OpenMPSupport>
|
||||
<EnableEnhancedInstructionSet>AdvancedVectorExtensions</EnableEnhancedInstructionSet>
|
||||
<CompileAsManaged>false</CompileAsManaged>
|
||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
||||
<IntrinsicFunctions>true</IntrinsicFunctions>
|
||||
@@ -198,14 +222,13 @@
|
||||
<CInterleavedPTX>false</CInterleavedPTX>
|
||||
<MaxRegCount>80</MaxRegCount>
|
||||
<PtxAsOptionV>true</PtxAsOptionV>
|
||||
<Keep>true</Keep>
|
||||
<Keep>false</Keep>
|
||||
<CodeGeneration>compute_35,sm_35;compute_50,sm_50;compute_52,sm_52</CodeGeneration>
|
||||
<Include>$(NVTOOLSEXT_PATH)\include;..\..\..\Common\C99</Include>
|
||||
<Optimization>O3</Optimization>
|
||||
<Include>
|
||||
</Include>
|
||||
<TargetMachinePlatform>64</TargetMachinePlatform>
|
||||
</CudaCompile>
|
||||
<CudaLink>
|
||||
<Optimization>O3</Optimization>
|
||||
<PerformDeviceLink>false</PerformDeviceLink>
|
||||
</CudaLink>
|
||||
</ItemDefinitionGroup>
|
||||
@@ -227,10 +250,9 @@
|
||||
<TreatWChar_tAsBuiltInType>false</TreatWChar_tAsBuiltInType>
|
||||
<Optimization Condition="'$(Configuration)'=='Release'">Full</Optimization>
|
||||
</ClCompile>
|
||||
<ClCompile Include="pools.cpp" />
|
||||
<ClCompile Include="scrypt-jane.cpp" />
|
||||
<ClCompile Include="scrypt.cpp" />
|
||||
<ClCompile Include="util.cpp" />
|
||||
<ClCompile Include="bignum.cpp" />
|
||||
<ClInclude Include="bignum.hpp" />
|
||||
<ClCompile Include="fuguecoin.cpp" />
|
||||
<ClCompile Include="groestlcoin.cpp" />
|
||||
<ClCompile Include="hashlog.cpp" />
|
||||
@@ -248,8 +270,6 @@
|
||||
<ClCompile Include="neoscrypt\neoscrypt-cpu.c" />
|
||||
<ClInclude Include="neoscrypt\cuda_vectors.h" />
|
||||
<CudaCompile Include="neoscrypt\cuda_neoscrypt.cu" />
|
||||
<ClCompile Include="scrypt-jane.cpp" />
|
||||
<ClCompile Include="scrypt.cpp" />
|
||||
<ClCompile Include="skein2.cpp" />
|
||||
<ClCompile Include="sph\aes_helper.c" />
|
||||
<ClCompile Include="sph\blake.c" />
|
||||
@@ -421,6 +441,8 @@
|
||||
<AdditionalOptions Condition="'$(Configuration)'=='Release'">-Xptxas "-abi=yes" %(AdditionalOptions)</AdditionalOptions>
|
||||
<AdditionalOptions Condition="'$(Configuration)'=='Debug'">-Xptxas "-abi=yes" %(AdditionalOptions)</AdditionalOptions>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="pluck\pluck.cu" />
|
||||
<CudaCompile Include="pluck\cuda_pluck.cu" />
|
||||
<CudaCompile Include="quark\cuda_quark_groestl512.cu">
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="quark\cuda_quark_keccak512.cu">
|
||||
@@ -432,7 +454,7 @@
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="qubit\deep.cu">
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="qubit\luffa.cu">
|
||||
<CudaCompile Include="qubit\doom.cu">
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="qubit\qubit.cu">
|
||||
</CudaCompile>
|
||||
@@ -454,7 +476,7 @@
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x11\cuda_x11_luffa512.cu" />
|
||||
<CudaCompile Include="x11\cuda_x11_luffa512_Cubehash.cu">
|
||||
<MaxRegCount>76</MaxRegCount>
|
||||
<MaxRegCount>80</MaxRegCount>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x11\cuda_x11_shavite512.cu">
|
||||
<MaxRegCount>128</MaxRegCount>
|
||||
@@ -462,8 +484,8 @@
|
||||
<CudaCompile Include="x11\cuda_x11_simd512.cu">
|
||||
<MaxRegCount>64</MaxRegCount>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x11\c11.cu" />
|
||||
<CudaCompile Include="x11\fresh.cu" />
|
||||
<CudaCompile Include="x11\fresh.cu">
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x11\s3.cu" />
|
||||
<CudaCompile Include="x11\simd_functions.cu">
|
||||
<ExcludedFromBuild>true</ExcludedFromBuild>
|
||||
@@ -477,15 +499,9 @@
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x13\x13.cu">
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x15\x14.cu">
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x15\cuda_x14_shabal512.cu">
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x15\x15.cu">
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x15\cuda_whirlpoolx.cu" />
|
||||
<CudaCompile Include="x15\whirlpoolx.cu" />
|
||||
<CudaCompile Include="x17\x17.cu">
|
||||
<CudaCompile Include="x15\cuda_x15_whirlpool.cu">
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x17\cuda_x17_haval512.cu">
|
||||
</CudaCompile>
|
||||
|
||||
+7
-19
@@ -111,9 +111,6 @@
|
||||
<ClCompile Include="ccminer.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="pools.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="crc32.c">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
@@ -246,9 +243,6 @@
|
||||
<ClCompile Include="hefty1.c">
|
||||
<Filter>Source Files\CUDA\heavy</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="bignum.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="compat.h">
|
||||
@@ -410,9 +404,6 @@
|
||||
<ClInclude Include="hefty1.h">
|
||||
<Filter>Source Files\CUDA\heavy</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="bignum.hpp">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<CudaCompile Include="cuda.cpp">
|
||||
@@ -433,6 +424,12 @@
|
||||
<CudaCompile Include="JHA\cuda_jha_compactionTest.cu">
|
||||
<Filter>Source Files\CUDA\JHA</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="pluck\pluck.cu">
|
||||
<Filter>Source Files\CUDA</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="pluck\cuda_pluck.cu">
|
||||
<Filter>Source Files\CUDA</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="quark\cuda_jh512.cu">
|
||||
<Filter>Source Files\CUDA\quark</Filter>
|
||||
</CudaCompile>
|
||||
@@ -484,7 +481,7 @@
|
||||
<CudaCompile Include="qubit\deep.cu">
|
||||
<Filter>Source Files\CUDA\qubit</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="qubit\luffa.cu">
|
||||
<CudaCompile Include="qubit\doom.cu">
|
||||
<Filter>Source Files\CUDA\qubit</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="qubit\qubit.cu">
|
||||
@@ -517,9 +514,6 @@
|
||||
<CudaCompile Include="x11\cuda_x11_simd512.cu">
|
||||
<Filter>Source Files\CUDA\x11</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x11\c11.cu">
|
||||
<Filter>Source Files\CUDA\x11</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x11\fresh.cu">
|
||||
<Filter>Source Files\CUDA\x11</Filter>
|
||||
</CudaCompile>
|
||||
@@ -553,12 +547,6 @@
|
||||
<CudaCompile Include="x15\cuda_x15_whirlpool.cu">
|
||||
<Filter>Source Files\CUDA\x15</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x15\cuda_whirlpoolx.cu">
|
||||
<Filter>Source Files\CUDA\x15</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x15\whirlpoolx.cu">
|
||||
<Filter>Source Files\CUDA\x15</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x17\cuda_x17_haval512.cu">
|
||||
<Filter>Source Files\CUDA\x17</Filter>
|
||||
</CudaCompile>
|
||||
|
||||
@@ -1,902 +0,0 @@
|
||||
/* crypto/bn/bn.h */
|
||||
/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
* This package is an SSL implementation written
|
||||
* by Eric Young (eay@cryptsoft.com).
|
||||
* The implementation was written so as to conform with Netscapes SSL.
|
||||
*
|
||||
* This library is free for commercial and non-commercial use as long as
|
||||
* the following conditions are aheared to. The following conditions
|
||||
* apply to all code found in this distribution, be it the RC4, RSA,
|
||||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
|
||||
* included with this distribution is covered by the same copyright terms
|
||||
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
|
||||
*
|
||||
* Copyright remains Eric Young's, and as such any Copyright notices in
|
||||
* the code are not to be removed.
|
||||
* If this package is used in a product, Eric Young should be given attribution
|
||||
* as the author of the parts of the library used.
|
||||
* This can be in the form of a textual message at program startup or
|
||||
* in documentation (online or textual) provided with the package.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* "This product includes cryptographic software written by
|
||||
* Eric Young (eay@cryptsoft.com)"
|
||||
* The word 'cryptographic' can be left out if the rouines from the library
|
||||
* being used are not cryptographic related :-).
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* the apps directory (application code) you must include an acknowledgement:
|
||||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* The licence and distribution terms for any publically available version or
|
||||
* derivative of this code cannot be changed. i.e. this code cannot simply be
|
||||
* copied and put under another distribution licence
|
||||
* [including the GNU Public Licence.]
|
||||
*/
|
||||
/* ====================================================================
|
||||
* Copyright (c) 1998-2006 The OpenSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the OpenSSL Project
|
||||
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
|
||||
*
|
||||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
|
||||
* endorse or promote products derived from this software without
|
||||
* prior written permission. For written permission, please contact
|
||||
* openssl-core@openssl.org.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "OpenSSL"
|
||||
* nor may "OpenSSL" appear in their names without prior written
|
||||
* permission of the OpenSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the OpenSSL Project
|
||||
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*
|
||||
* This product includes cryptographic software written by Eric Young
|
||||
* (eay@cryptsoft.com). This product includes software written by Tim
|
||||
* Hudson (tjh@cryptsoft.com).
|
||||
*
|
||||
*/
|
||||
/* ====================================================================
|
||||
* Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
|
||||
*
|
||||
* Portions of the attached software ("Contribution") are developed by
|
||||
* SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
|
||||
*
|
||||
* The Contribution is licensed pursuant to the Eric Young open source
|
||||
* license provided above.
|
||||
*
|
||||
* The binary polynomial arithmetic software is originally written by
|
||||
* Sheueling Chang Shantz and Douglas Stebila of Sun Microsystems Laboratories.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef HEADER_BN_H
|
||||
#define HEADER_BN_H
|
||||
|
||||
#include <openssl/e_os2.h>
|
||||
#ifndef OPENSSL_NO_FP_API
|
||||
#include <stdio.h> /* FILE */
|
||||
#endif
|
||||
#include <openssl/ossl_typ.h>
|
||||
#include <openssl/crypto.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* These preprocessor symbols control various aspects of the bignum headers and
|
||||
* library code. They're not defined by any "normal" configuration, as they are
|
||||
* intended for development and testing purposes. NB: defining all three can be
|
||||
* useful for debugging application code as well as openssl itself.
|
||||
*
|
||||
* BN_DEBUG - turn on various debugging alterations to the bignum code
|
||||
* BN_DEBUG_RAND - uses random poisoning of unused words to trip up
|
||||
* mismanagement of bignum internals. You must also define BN_DEBUG.
|
||||
*/
|
||||
/* #define BN_DEBUG */
|
||||
/* #define BN_DEBUG_RAND */
|
||||
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
#define BN_MUL_COMBA
|
||||
#define BN_SQR_COMBA
|
||||
#define BN_RECURSION
|
||||
#endif
|
||||
|
||||
/* This next option uses the C libraries (2 word)/(1 word) function.
|
||||
* If it is not defined, I use my C version (which is slower).
|
||||
* The reason for this flag is that when the particular C compiler
|
||||
* library routine is used, and the library is linked with a different
|
||||
* compiler, the library is missing. This mostly happens when the
|
||||
* library is built with gcc and then linked using normal cc. This would
|
||||
* be a common occurrence because gcc normally produces code that is
|
||||
* 2 times faster than system compilers for the big number stuff.
|
||||
* For machines with only one compiler (or shared libraries), this should
|
||||
* be on. Again this in only really a problem on machines
|
||||
* using "long long's", are 32bit, and are not using my assembler code. */
|
||||
#if defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_WINDOWS) || \
|
||||
defined(OPENSSL_SYS_WIN32) || defined(linux)
|
||||
# ifndef BN_DIV2W
|
||||
# define BN_DIV2W
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* assuming long is 64bit - this is the DEC Alpha
|
||||
* unsigned long long is only 64 bits :-(, don't define
|
||||
* BN_LLONG for the DEC Alpha */
|
||||
#ifdef SIXTY_FOUR_BIT_LONG
|
||||
#define BN_ULLONG unsigned long long
|
||||
#define BN_ULONG unsigned long
|
||||
#define BN_LONG long
|
||||
#define BN_BITS 128
|
||||
#define BN_BYTES 8
|
||||
#define BN_BITS2 64
|
||||
#define BN_BITS4 32
|
||||
#define BN_MASK (0xffffffffffffffffffffffffffffffffLL)
|
||||
#define BN_MASK2 (0xffffffffffffffffL)
|
||||
#define BN_MASK2l (0xffffffffL)
|
||||
#define BN_MASK2h (0xffffffff00000000L)
|
||||
#define BN_MASK2h1 (0xffffffff80000000L)
|
||||
#define BN_TBIT (0x8000000000000000L)
|
||||
#define BN_DEC_CONV (10000000000000000000UL)
|
||||
#define BN_DEC_FMT1 "%lu"
|
||||
#define BN_DEC_FMT2 "%019lu"
|
||||
#define BN_DEC_NUM 19
|
||||
#define BN_HEX_FMT1 "%lX"
|
||||
#define BN_HEX_FMT2 "%016lX"
|
||||
#endif
|
||||
|
||||
/* This is where the long long data type is 64 bits, but long is 32.
|
||||
* For machines where there are 64bit registers, this is the mode to use.
|
||||
* IRIX, on R4000 and above should use this mode, along with the relevant
|
||||
* assembler code :-). Do NOT define BN_LLONG.
|
||||
*/
|
||||
#ifdef SIXTY_FOUR_BIT
|
||||
#undef BN_LLONG
|
||||
#undef BN_ULLONG
|
||||
#define BN_ULONG unsigned long long
|
||||
#define BN_LONG long long
|
||||
#define BN_BITS 128
|
||||
#define BN_BYTES 8
|
||||
#define BN_BITS2 64
|
||||
#define BN_BITS4 32
|
||||
#define BN_MASK2 (0xffffffffffffffffLL)
|
||||
#define BN_MASK2l (0xffffffffL)
|
||||
#define BN_MASK2h (0xffffffff00000000LL)
|
||||
#define BN_MASK2h1 (0xffffffff80000000LL)
|
||||
#define BN_TBIT (0x8000000000000000LL)
|
||||
#define BN_DEC_CONV (10000000000000000000ULL)
|
||||
#define BN_DEC_FMT1 "%llu"
|
||||
#define BN_DEC_FMT2 "%019llu"
|
||||
#define BN_DEC_NUM 19
|
||||
#define BN_HEX_FMT1 "%llX"
|
||||
#define BN_HEX_FMT2 "%016llX"
|
||||
#endif
|
||||
|
||||
#ifdef THIRTY_TWO_BIT
|
||||
#ifdef BN_LLONG
|
||||
# if defined(_WIN32) && !defined(__GNUC__)
|
||||
# define BN_ULLONG unsigned __int64
|
||||
# define BN_MASK (0xffffffffffffffffI64)
|
||||
# else
|
||||
# define BN_ULLONG unsigned long long
|
||||
# define BN_MASK (0xffffffffffffffffLL)
|
||||
# endif
|
||||
#endif
|
||||
#define BN_ULONG unsigned int
|
||||
#define BN_LONG int
|
||||
#define BN_BITS 64
|
||||
#define BN_BYTES 4
|
||||
#define BN_BITS2 32
|
||||
#define BN_BITS4 16
|
||||
#define BN_MASK2 (0xffffffffL)
|
||||
#define BN_MASK2l (0xffff)
|
||||
#define BN_MASK2h1 (0xffff8000L)
|
||||
#define BN_MASK2h (0xffff0000L)
|
||||
#define BN_TBIT (0x80000000L)
|
||||
#define BN_DEC_CONV (1000000000L)
|
||||
#define BN_DEC_FMT1 "%u"
|
||||
#define BN_DEC_FMT2 "%09u"
|
||||
#define BN_DEC_NUM 9
|
||||
#define BN_HEX_FMT1 "%X"
|
||||
#define BN_HEX_FMT2 "%08X"
|
||||
#endif
|
||||
|
||||
/* 2011-02-22 SMS.
|
||||
* In various places, a size_t variable or a type cast to size_t was
|
||||
* used to perform integer-only operations on pointers. This failed on
|
||||
* VMS with 64-bit pointers (CC /POINTER_SIZE = 64) because size_t is
|
||||
* still only 32 bits. What's needed in these cases is an integer type
|
||||
* with the same size as a pointer, which size_t is not certain to be.
|
||||
* The only fix here is VMS-specific.
|
||||
*/
|
||||
#if defined(OPENSSL_SYS_VMS)
|
||||
# if __INITIAL_POINTER_SIZE == 64
|
||||
# define PTR_SIZE_INT long long
|
||||
# else /* __INITIAL_POINTER_SIZE == 64 */
|
||||
# define PTR_SIZE_INT int
|
||||
# endif /* __INITIAL_POINTER_SIZE == 64 [else] */
|
||||
#else /* defined(OPENSSL_SYS_VMS) */
|
||||
# define PTR_SIZE_INT size_t
|
||||
#endif /* defined(OPENSSL_SYS_VMS) [else] */
|
||||
|
||||
#define BN_DEFAULT_BITS 1280
|
||||
|
||||
#define BN_FLG_MALLOCED 0x01
|
||||
#define BN_FLG_STATIC_DATA 0x02
|
||||
#define BN_FLG_CONSTTIME 0x04 /* avoid leaking exponent information through timing,
|
||||
* BN_mod_exp_mont() will call BN_mod_exp_mont_consttime,
|
||||
* BN_div() will call BN_div_no_branch,
|
||||
* BN_mod_inverse() will call BN_mod_inverse_no_branch.
|
||||
*/
|
||||
|
||||
#ifndef OPENSSL_NO_DEPRECATED
|
||||
#define BN_FLG_EXP_CONSTTIME BN_FLG_CONSTTIME /* deprecated name for the flag */
|
||||
/* avoid leaking exponent information through timings
|
||||
* (BN_mod_exp_mont() will call BN_mod_exp_mont_consttime) */
|
||||
#endif
|
||||
|
||||
#ifndef OPENSSL_NO_DEPRECATED
|
||||
#define BN_FLG_FREE 0x8000 /* used for debuging */
|
||||
#endif
|
||||
#define BN_set_flags(b,n) ((b)->flags|=(n))
|
||||
#define BN_get_flags(b,n) ((b)->flags&(n))
|
||||
|
||||
/* get a clone of a BIGNUM with changed flags, for *temporary* use only
|
||||
* (the two BIGNUMs cannot not be used in parallel!) */
|
||||
#define BN_with_flags(dest,b,n) ((dest)->d=(b)->d, \
|
||||
(dest)->top=(b)->top, \
|
||||
(dest)->dmax=(b)->dmax, \
|
||||
(dest)->neg=(b)->neg, \
|
||||
(dest)->flags=(((dest)->flags & BN_FLG_MALLOCED) \
|
||||
| ((b)->flags & ~BN_FLG_MALLOCED) \
|
||||
| BN_FLG_STATIC_DATA \
|
||||
| (n)))
|
||||
|
||||
/* Already declared in ossl_typ.h */
|
||||
#if 0
|
||||
typedef struct bignum_st BIGNUM;
|
||||
/* Used for temp variables (declaration hidden in bn_lcl.h) */
|
||||
typedef struct bignum_ctx BN_CTX;
|
||||
typedef struct bn_blinding_st BN_BLINDING;
|
||||
typedef struct bn_mont_ctx_st BN_MONT_CTX;
|
||||
typedef struct bn_recp_ctx_st BN_RECP_CTX;
|
||||
typedef struct bn_gencb_st BN_GENCB;
|
||||
#endif
|
||||
|
||||
struct bignum_st
|
||||
{
|
||||
BN_ULONG *d; /* Pointer to an array of 'BN_BITS2' bit chunks. */
|
||||
int top; /* Index of last used d +1. */
|
||||
/* The next are internal book keeping for bn_expand. */
|
||||
int dmax; /* Size of the d array. */
|
||||
int neg; /* one if the number is negative */
|
||||
int flags;
|
||||
};
|
||||
|
||||
/* Used for montgomery multiplication */
|
||||
struct bn_mont_ctx_st
|
||||
{
|
||||
int ri; /* number of bits in R */
|
||||
BIGNUM RR; /* used to convert to montgomery form */
|
||||
BIGNUM N; /* The modulus */
|
||||
BIGNUM Ni; /* R*(1/R mod N) - N*Ni = 1
|
||||
* (Ni is only stored for bignum algorithm) */
|
||||
BN_ULONG n0[2];/* least significant word(s) of Ni;
|
||||
(type changed with 0.9.9, was "BN_ULONG n0;" before) */
|
||||
int flags;
|
||||
};
|
||||
|
||||
/* Used for reciprocal division/mod functions
|
||||
* It cannot be shared between threads
|
||||
*/
|
||||
struct bn_recp_ctx_st
|
||||
{
|
||||
BIGNUM N; /* the divisor */
|
||||
BIGNUM Nr; /* the reciprocal */
|
||||
int num_bits;
|
||||
int shift;
|
||||
int flags;
|
||||
};
|
||||
|
||||
/* Used for slow "generation" functions. */
|
||||
struct bn_gencb_st
|
||||
{
|
||||
unsigned int ver; /* To handle binary (in)compatibility */
|
||||
void *arg; /* callback-specific data */
|
||||
union
|
||||
{
|
||||
/* if(ver==1) - handles old style callbacks */
|
||||
void (*cb_1)(int, int, void *);
|
||||
/* if(ver==2) - new callback style */
|
||||
int (*cb_2)(int, int, BN_GENCB *);
|
||||
} cb;
|
||||
};
|
||||
/* Wrapper function to make using BN_GENCB easier, */
|
||||
int BN_GENCB_call(BN_GENCB *cb, int a, int b);
|
||||
/* Macro to populate a BN_GENCB structure with an "old"-style callback */
|
||||
#define BN_GENCB_set_old(gencb, callback, cb_arg) { \
|
||||
BN_GENCB *tmp_gencb = (gencb); \
|
||||
tmp_gencb->ver = 1; \
|
||||
tmp_gencb->arg = (cb_arg); \
|
||||
tmp_gencb->cb.cb_1 = (callback); }
|
||||
/* Macro to populate a BN_GENCB structure with a "new"-style callback */
|
||||
#define BN_GENCB_set(gencb, callback, cb_arg) { \
|
||||
BN_GENCB *tmp_gencb = (gencb); \
|
||||
tmp_gencb->ver = 2; \
|
||||
tmp_gencb->arg = (cb_arg); \
|
||||
tmp_gencb->cb.cb_2 = (callback); }
|
||||
|
||||
#define BN_prime_checks 0 /* default: select number of iterations
|
||||
based on the size of the number */
|
||||
|
||||
/* number of Miller-Rabin iterations for an error rate of less than 2^-80
|
||||
* for random 'b'-bit input, b >= 100 (taken from table 4.4 in the Handbook
|
||||
* of Applied Cryptography [Menezes, van Oorschot, Vanstone; CRC Press 1996];
|
||||
* original paper: Damgaard, Landrock, Pomerance: Average case error estimates
|
||||
* for the strong probable prime test. -- Math. Comp. 61 (1993) 177-194) */
|
||||
#define BN_prime_checks_for_size(b) ((b) >= 1300 ? 2 : \
|
||||
(b) >= 850 ? 3 : \
|
||||
(b) >= 650 ? 4 : \
|
||||
(b) >= 550 ? 5 : \
|
||||
(b) >= 450 ? 6 : \
|
||||
(b) >= 400 ? 7 : \
|
||||
(b) >= 350 ? 8 : \
|
||||
(b) >= 300 ? 9 : \
|
||||
(b) >= 250 ? 12 : \
|
||||
(b) >= 200 ? 15 : \
|
||||
(b) >= 150 ? 18 : \
|
||||
/* b >= 100 */ 27)
|
||||
|
||||
#define BN_num_bytes(a) ((BN_num_bits(a)+7)/8)
|
||||
|
||||
/* Note that BN_abs_is_word didn't work reliably for w == 0 until 0.9.8 */
|
||||
#define BN_abs_is_word(a,w) ((((a)->top == 1) && ((a)->d[0] == (BN_ULONG)(w))) || \
|
||||
(((w) == 0) && ((a)->top == 0)))
|
||||
#define BN_is_zero(a) ((a)->top == 0)
|
||||
#define BN_is_one(a) (BN_abs_is_word((a),1) && !(a)->neg)
|
||||
#define BN_is_word(a,w) (BN_abs_is_word((a),(w)) && (!(w) || !(a)->neg))
|
||||
#define BN_is_odd(a) (((a)->top > 0) && ((a)->d[0] & 1))
|
||||
|
||||
#define BN_one(a) (BN_set_word((a),1))
|
||||
#define BN_zero_ex(a) \
|
||||
do { \
|
||||
BIGNUM *_tmp_bn = (a); \
|
||||
_tmp_bn->top = 0; \
|
||||
_tmp_bn->neg = 0; \
|
||||
} while(0)
|
||||
#ifdef OPENSSL_NO_DEPRECATED
|
||||
#define BN_zero(a) BN_zero_ex(a)
|
||||
#else
|
||||
#define BN_zero(a) (BN_set_word((a),0))
|
||||
#endif
|
||||
|
||||
const BIGNUM *BN_value_one(void);
|
||||
char * BN_options(void);
|
||||
BN_CTX *BN_CTX_new(void);
|
||||
#ifndef OPENSSL_NO_DEPRECATED
|
||||
void BN_CTX_init(BN_CTX *c);
|
||||
#endif
|
||||
void BN_CTX_free(BN_CTX *c);
|
||||
void BN_CTX_start(BN_CTX *ctx);
|
||||
BIGNUM *BN_CTX_get(BN_CTX *ctx);
|
||||
void BN_CTX_end(BN_CTX *ctx);
|
||||
int BN_rand(BIGNUM *rnd, int bits, int top,int bottom);
|
||||
int BN_pseudo_rand(BIGNUM *rnd, int bits, int top,int bottom);
|
||||
int BN_rand_range(BIGNUM *rnd, const BIGNUM *range);
|
||||
int BN_pseudo_rand_range(BIGNUM *rnd, const BIGNUM *range);
|
||||
int BN_num_bits(const BIGNUM *a);
|
||||
int BN_num_bits_word(BN_ULONG);
|
||||
BIGNUM *BN_new(void);
|
||||
void BN_init(BIGNUM *);
|
||||
void BN_clear_free(BIGNUM *a);
|
||||
BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b);
|
||||
void BN_swap(BIGNUM *a, BIGNUM *b);
|
||||
BIGNUM *BN_bin2bn(const unsigned char *s,int len,BIGNUM *ret);
|
||||
int BN_bn2bin(const BIGNUM *a, unsigned char *to);
|
||||
BIGNUM *BN_mpi2bn(const unsigned char *s,int len,BIGNUM *ret);
|
||||
int BN_bn2mpi(const BIGNUM *a, unsigned char *to);
|
||||
int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
|
||||
int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
|
||||
int BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
|
||||
int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
|
||||
int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
|
||||
int BN_sqr(BIGNUM *r, const BIGNUM *a,BN_CTX *ctx);
|
||||
/** BN_set_negative sets sign of a BIGNUM
|
||||
* \param b pointer to the BIGNUM object
|
||||
* \param n 0 if the BIGNUM b should be positive and a value != 0 otherwise
|
||||
*/
|
||||
void BN_set_negative(BIGNUM *b, int n);
|
||||
/** BN_is_negative returns 1 if the BIGNUM is negative
|
||||
* \param a pointer to the BIGNUM object
|
||||
* \return 1 if a < 0 and 0 otherwise
|
||||
*/
|
||||
#define BN_is_negative(a) ((a)->neg != 0)
|
||||
|
||||
int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d,
|
||||
BN_CTX *ctx);
|
||||
#define BN_mod(rem,m,d,ctx) BN_div(NULL,(rem),(m),(d),(ctx))
|
||||
int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx);
|
||||
int BN_mod_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, BN_CTX *ctx);
|
||||
int BN_mod_add_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m);
|
||||
int BN_mod_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, BN_CTX *ctx);
|
||||
int BN_mod_sub_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m);
|
||||
int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
|
||||
const BIGNUM *m, BN_CTX *ctx);
|
||||
int BN_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);
|
||||
int BN_mod_lshift1(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);
|
||||
int BN_mod_lshift1_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *m);
|
||||
int BN_mod_lshift(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m, BN_CTX *ctx);
|
||||
int BN_mod_lshift_quick(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m);
|
||||
|
||||
BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w);
|
||||
BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w);
|
||||
int BN_mul_word(BIGNUM *a, BN_ULONG w);
|
||||
int BN_add_word(BIGNUM *a, BN_ULONG w);
|
||||
int BN_sub_word(BIGNUM *a, BN_ULONG w);
|
||||
int BN_set_word(BIGNUM *a, BN_ULONG w);
|
||||
BN_ULONG BN_get_word(const BIGNUM *a);
|
||||
|
||||
int BN_cmp(const BIGNUM *a, const BIGNUM *b);
|
||||
void BN_free(BIGNUM *a);
|
||||
int BN_is_bit_set(const BIGNUM *a, int n);
|
||||
int BN_lshift(BIGNUM *r, const BIGNUM *a, int n);
|
||||
int BN_lshift1(BIGNUM *r, const BIGNUM *a);
|
||||
int BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,BN_CTX *ctx);
|
||||
|
||||
int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
||||
const BIGNUM *m,BN_CTX *ctx);
|
||||
int BN_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
||||
const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
|
||||
int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
|
||||
const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont);
|
||||
int BN_mod_exp_mont_word(BIGNUM *r, BN_ULONG a, const BIGNUM *p,
|
||||
const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
|
||||
int BN_mod_exp2_mont(BIGNUM *r, const BIGNUM *a1, const BIGNUM *p1,
|
||||
const BIGNUM *a2, const BIGNUM *p2,const BIGNUM *m,
|
||||
BN_CTX *ctx,BN_MONT_CTX *m_ctx);
|
||||
int BN_mod_exp_simple(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
||||
const BIGNUM *m,BN_CTX *ctx);
|
||||
|
||||
int BN_mask_bits(BIGNUM *a,int n);
|
||||
#ifndef OPENSSL_NO_FP_API
|
||||
int BN_print_fp(FILE *fp, const BIGNUM *a);
|
||||
#endif
|
||||
#ifdef HEADER_BIO_H
|
||||
int BN_print(BIO *fp, const BIGNUM *a);
|
||||
#else
|
||||
int BN_print(void *fp, const BIGNUM *a);
|
||||
#endif
|
||||
int BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx);
|
||||
int BN_rshift(BIGNUM *r, const BIGNUM *a, int n);
|
||||
int BN_rshift1(BIGNUM *r, const BIGNUM *a);
|
||||
void BN_clear(BIGNUM *a);
|
||||
BIGNUM *BN_dup(const BIGNUM *a);
|
||||
int BN_ucmp(const BIGNUM *a, const BIGNUM *b);
|
||||
int BN_set_bit(BIGNUM *a, int n);
|
||||
int BN_clear_bit(BIGNUM *a, int n);
|
||||
char * BN_bn2hex(const BIGNUM *a);
|
||||
char * BN_bn2dec(const BIGNUM *a);
|
||||
int BN_hex2bn(BIGNUM **a, const char *str);
|
||||
int BN_dec2bn(BIGNUM **a, const char *str);
|
||||
int BN_asc2bn(BIGNUM **a, const char *str);
|
||||
int BN_gcd(BIGNUM *r,const BIGNUM *a,const BIGNUM *b,BN_CTX *ctx);
|
||||
int BN_kronecker(const BIGNUM *a,const BIGNUM *b,BN_CTX *ctx); /* returns -2 for error */
|
||||
BIGNUM *BN_mod_inverse(BIGNUM *ret,
|
||||
const BIGNUM *a, const BIGNUM *n,BN_CTX *ctx);
|
||||
BIGNUM *BN_mod_sqrt(BIGNUM *ret,
|
||||
const BIGNUM *a, const BIGNUM *n,BN_CTX *ctx);
|
||||
|
||||
void BN_consttime_swap(BN_ULONG swap, BIGNUM *a, BIGNUM *b, int nwords);
|
||||
|
||||
/* Deprecated versions */
|
||||
#ifndef OPENSSL_NO_DEPRECATED
|
||||
BIGNUM *BN_generate_prime(BIGNUM *ret,int bits,int safe,
|
||||
const BIGNUM *add, const BIGNUM *rem,
|
||||
void (*callback)(int,int,void *),void *cb_arg);
|
||||
int BN_is_prime(const BIGNUM *p,int nchecks,
|
||||
void (*callback)(int,int,void *),
|
||||
BN_CTX *ctx,void *cb_arg);
|
||||
int BN_is_prime_fasttest(const BIGNUM *p,int nchecks,
|
||||
void (*callback)(int,int,void *),BN_CTX *ctx,void *cb_arg,
|
||||
int do_trial_division);
|
||||
#endif /* !defined(OPENSSL_NO_DEPRECATED) */
|
||||
|
||||
/* Newer versions */
|
||||
int BN_generate_prime_ex(BIGNUM *ret,int bits,int safe, const BIGNUM *add,
|
||||
const BIGNUM *rem, BN_GENCB *cb);
|
||||
int BN_is_prime_ex(const BIGNUM *p,int nchecks, BN_CTX *ctx, BN_GENCB *cb);
|
||||
int BN_is_prime_fasttest_ex(const BIGNUM *p,int nchecks, BN_CTX *ctx,
|
||||
int do_trial_division, BN_GENCB *cb);
|
||||
|
||||
int BN_X931_generate_Xpq(BIGNUM *Xp, BIGNUM *Xq, int nbits, BN_CTX *ctx);
|
||||
|
||||
int BN_X931_derive_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2,
|
||||
const BIGNUM *Xp, const BIGNUM *Xp1, const BIGNUM *Xp2,
|
||||
const BIGNUM *e, BN_CTX *ctx, BN_GENCB *cb);
|
||||
int BN_X931_generate_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2,
|
||||
BIGNUM *Xp1, BIGNUM *Xp2,
|
||||
const BIGNUM *Xp,
|
||||
const BIGNUM *e, BN_CTX *ctx,
|
||||
BN_GENCB *cb);
|
||||
|
||||
BN_MONT_CTX *BN_MONT_CTX_new(void );
|
||||
void BN_MONT_CTX_init(BN_MONT_CTX *ctx);
|
||||
int BN_mod_mul_montgomery(BIGNUM *r,const BIGNUM *a,const BIGNUM *b,
|
||||
BN_MONT_CTX *mont, BN_CTX *ctx);
|
||||
#define BN_to_montgomery(r,a,mont,ctx) BN_mod_mul_montgomery(\
|
||||
(r),(a),&((mont)->RR),(mont),(ctx))
|
||||
int BN_from_montgomery(BIGNUM *r,const BIGNUM *a,
|
||||
BN_MONT_CTX *mont, BN_CTX *ctx);
|
||||
void BN_MONT_CTX_free(BN_MONT_CTX *mont);
|
||||
int BN_MONT_CTX_set(BN_MONT_CTX *mont,const BIGNUM *mod,BN_CTX *ctx);
|
||||
BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to,BN_MONT_CTX *from);
|
||||
BN_MONT_CTX *BN_MONT_CTX_set_locked(BN_MONT_CTX **pmont, int lock,
|
||||
const BIGNUM *mod, BN_CTX *ctx);
|
||||
|
||||
/* BN_BLINDING flags */
|
||||
#define BN_BLINDING_NO_UPDATE 0x00000001
|
||||
#define BN_BLINDING_NO_RECREATE 0x00000002
|
||||
|
||||
BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod);
|
||||
void BN_BLINDING_free(BN_BLINDING *b);
|
||||
int BN_BLINDING_update(BN_BLINDING *b,BN_CTX *ctx);
|
||||
int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
|
||||
int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
|
||||
int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *);
|
||||
int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b, BN_CTX *);
|
||||
#ifndef OPENSSL_NO_DEPRECATED
|
||||
unsigned long BN_BLINDING_get_thread_id(const BN_BLINDING *);
|
||||
void BN_BLINDING_set_thread_id(BN_BLINDING *, unsigned long);
|
||||
#endif
|
||||
CRYPTO_THREADID *BN_BLINDING_thread_id(BN_BLINDING *);
|
||||
unsigned long BN_BLINDING_get_flags(const BN_BLINDING *);
|
||||
void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long);
|
||||
BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,
|
||||
const BIGNUM *e, BIGNUM *m, BN_CTX *ctx,
|
||||
int (*bn_mod_exp)(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
||||
const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx),
|
||||
BN_MONT_CTX *m_ctx);
|
||||
|
||||
#ifndef OPENSSL_NO_DEPRECATED
|
||||
void BN_set_params(int mul,int high,int low,int mont);
|
||||
int BN_get_params(int which); /* 0, mul, 1 high, 2 low, 3 mont */
|
||||
#endif
|
||||
|
||||
void BN_RECP_CTX_init(BN_RECP_CTX *recp);
|
||||
BN_RECP_CTX *BN_RECP_CTX_new(void);
|
||||
void BN_RECP_CTX_free(BN_RECP_CTX *recp);
|
||||
int BN_RECP_CTX_set(BN_RECP_CTX *recp,const BIGNUM *rdiv,BN_CTX *ctx);
|
||||
int BN_mod_mul_reciprocal(BIGNUM *r, const BIGNUM *x, const BIGNUM *y,
|
||||
BN_RECP_CTX *recp,BN_CTX *ctx);
|
||||
int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
||||
const BIGNUM *m, BN_CTX *ctx);
|
||||
int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m,
|
||||
BN_RECP_CTX *recp, BN_CTX *ctx);
|
||||
|
||||
#ifndef OPENSSL_NO_EC2M
|
||||
|
||||
/* Functions for arithmetic over binary polynomials represented by BIGNUMs.
|
||||
*
|
||||
* The BIGNUM::neg property of BIGNUMs representing binary polynomials is
|
||||
* ignored.
|
||||
*
|
||||
* Note that input arguments are not const so that their bit arrays can
|
||||
* be expanded to the appropriate size if needed.
|
||||
*/
|
||||
|
||||
int BN_GF2m_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); /*r = a + b*/
|
||||
#define BN_GF2m_sub(r, a, b) BN_GF2m_add(r, a, b)
|
||||
int BN_GF2m_mod(BIGNUM *r, const BIGNUM *a, const BIGNUM *p); /*r=a mod p*/
|
||||
int BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
|
||||
const BIGNUM *p, BN_CTX *ctx); /* r = (a * b) mod p */
|
||||
int BN_GF2m_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
||||
BN_CTX *ctx); /* r = (a * a) mod p */
|
||||
int BN_GF2m_mod_inv(BIGNUM *r, const BIGNUM *b, const BIGNUM *p,
|
||||
BN_CTX *ctx); /* r = (1 / b) mod p */
|
||||
int BN_GF2m_mod_div(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
|
||||
const BIGNUM *p, BN_CTX *ctx); /* r = (a / b) mod p */
|
||||
int BN_GF2m_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
|
||||
const BIGNUM *p, BN_CTX *ctx); /* r = (a ^ b) mod p */
|
||||
int BN_GF2m_mod_sqrt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
||||
BN_CTX *ctx); /* r = sqrt(a) mod p */
|
||||
int BN_GF2m_mod_solve_quad(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
||||
BN_CTX *ctx); /* r^2 + r = a mod p */
|
||||
#define BN_GF2m_cmp(a, b) BN_ucmp((a), (b))
|
||||
/* Some functions allow for representation of the irreducible polynomials
|
||||
* as an unsigned int[], say p. The irreducible f(t) is then of the form:
|
||||
* t^p[0] + t^p[1] + ... + t^p[k]
|
||||
* where m = p[0] > p[1] > ... > p[k] = 0.
|
||||
*/
|
||||
int BN_GF2m_mod_arr(BIGNUM *r, const BIGNUM *a, const int p[]);
|
||||
/* r = a mod p */
|
||||
int BN_GF2m_mod_mul_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
|
||||
const int p[], BN_CTX *ctx); /* r = (a * b) mod p */
|
||||
int BN_GF2m_mod_sqr_arr(BIGNUM *r, const BIGNUM *a, const int p[],
|
||||
BN_CTX *ctx); /* r = (a * a) mod p */
|
||||
int BN_GF2m_mod_inv_arr(BIGNUM *r, const BIGNUM *b, const int p[],
|
||||
BN_CTX *ctx); /* r = (1 / b) mod p */
|
||||
int BN_GF2m_mod_div_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
|
||||
const int p[], BN_CTX *ctx); /* r = (a / b) mod p */
|
||||
int BN_GF2m_mod_exp_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
|
||||
const int p[], BN_CTX *ctx); /* r = (a ^ b) mod p */
|
||||
int BN_GF2m_mod_sqrt_arr(BIGNUM *r, const BIGNUM *a,
|
||||
const int p[], BN_CTX *ctx); /* r = sqrt(a) mod p */
|
||||
int BN_GF2m_mod_solve_quad_arr(BIGNUM *r, const BIGNUM *a,
|
||||
const int p[], BN_CTX *ctx); /* r^2 + r = a mod p */
|
||||
int BN_GF2m_poly2arr(const BIGNUM *a, int p[], int max);
|
||||
int BN_GF2m_arr2poly(const int p[], BIGNUM *a);
|
||||
|
||||
#endif
|
||||
|
||||
/* faster mod functions for the 'NIST primes'
|
||||
* 0 <= a < p^2 */
|
||||
int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
|
||||
int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
|
||||
int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
|
||||
int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
|
||||
int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
|
||||
|
||||
const BIGNUM *BN_get0_nist_prime_192(void);
|
||||
const BIGNUM *BN_get0_nist_prime_224(void);
|
||||
const BIGNUM *BN_get0_nist_prime_256(void);
|
||||
const BIGNUM *BN_get0_nist_prime_384(void);
|
||||
const BIGNUM *BN_get0_nist_prime_521(void);
|
||||
|
||||
/* library internal functions */
|
||||
|
||||
#define bn_expand(a,bits) ((((((bits+BN_BITS2-1))/BN_BITS2)) <= (a)->dmax)?\
|
||||
(a):bn_expand2((a),(bits+BN_BITS2-1)/BN_BITS2))
|
||||
#define bn_wexpand(a,words) (((words) <= (a)->dmax)?(a):bn_expand2((a),(words)))
|
||||
BIGNUM *bn_expand2(BIGNUM *a, int words);
|
||||
#ifndef OPENSSL_NO_DEPRECATED
|
||||
BIGNUM *bn_dup_expand(const BIGNUM *a, int words); /* unused */
|
||||
#endif
|
||||
|
||||
/* Bignum consistency macros
|
||||
* There is one "API" macro, bn_fix_top(), for stripping leading zeroes from
|
||||
* bignum data after direct manipulations on the data. There is also an
|
||||
* "internal" macro, bn_check_top(), for verifying that there are no leading
|
||||
* zeroes. Unfortunately, some auditing is required due to the fact that
|
||||
* bn_fix_top() has become an overabused duct-tape because bignum data is
|
||||
* occasionally passed around in an inconsistent state. So the following
|
||||
* changes have been made to sort this out;
|
||||
* - bn_fix_top()s implementation has been moved to bn_correct_top()
|
||||
* - if BN_DEBUG isn't defined, bn_fix_top() maps to bn_correct_top(), and
|
||||
* bn_check_top() is as before.
|
||||
* - if BN_DEBUG *is* defined;
|
||||
* - bn_check_top() tries to pollute unused words even if the bignum 'top' is
|
||||
* consistent. (ed: only if BN_DEBUG_RAND is defined)
|
||||
* - bn_fix_top() maps to bn_check_top() rather than "fixing" anything.
|
||||
* The idea is to have debug builds flag up inconsistent bignums when they
|
||||
* occur. If that occurs in a bn_fix_top(), we examine the code in question; if
|
||||
* the use of bn_fix_top() was appropriate (ie. it follows directly after code
|
||||
* that manipulates the bignum) it is converted to bn_correct_top(), and if it
|
||||
* was not appropriate, we convert it permanently to bn_check_top() and track
|
||||
* down the cause of the bug. Eventually, no internal code should be using the
|
||||
* bn_fix_top() macro. External applications and libraries should try this with
|
||||
* their own code too, both in terms of building against the openssl headers
|
||||
* with BN_DEBUG defined *and* linking with a version of OpenSSL built with it
|
||||
* defined. This not only improves external code, it provides more test
|
||||
* coverage for openssl's own code.
|
||||
*/
|
||||
|
||||
#ifdef BN_DEBUG
|
||||
|
||||
/* We only need assert() when debugging */
|
||||
#include <assert.h>
|
||||
|
||||
#ifdef BN_DEBUG_RAND
|
||||
/* To avoid "make update" cvs wars due to BN_DEBUG, use some tricks */
|
||||
#ifndef RAND_pseudo_bytes
|
||||
int RAND_pseudo_bytes(unsigned char *buf,int num);
|
||||
#define BN_DEBUG_TRIX
|
||||
#endif
|
||||
#define bn_pollute(a) \
|
||||
do { \
|
||||
const BIGNUM *_bnum1 = (a); \
|
||||
if(_bnum1->top < _bnum1->dmax) { \
|
||||
unsigned char _tmp_char; \
|
||||
/* We cast away const without the compiler knowing, any \
|
||||
* *genuinely* constant variables that aren't mutable \
|
||||
* wouldn't be constructed with top!=dmax. */ \
|
||||
BN_ULONG *_not_const; \
|
||||
memcpy(&_not_const, &_bnum1->d, sizeof(BN_ULONG*)); \
|
||||
RAND_pseudo_bytes(&_tmp_char, 1); \
|
||||
memset((unsigned char *)(_not_const + _bnum1->top), _tmp_char, \
|
||||
(_bnum1->dmax - _bnum1->top) * sizeof(BN_ULONG)); \
|
||||
} \
|
||||
} while(0)
|
||||
#ifdef BN_DEBUG_TRIX
|
||||
#undef RAND_pseudo_bytes
|
||||
#endif
|
||||
#else
|
||||
#define bn_pollute(a)
|
||||
#endif
|
||||
#define bn_check_top(a) \
|
||||
do { \
|
||||
const BIGNUM *_bnum2 = (a); \
|
||||
if (_bnum2 != NULL) { \
|
||||
assert((_bnum2->top == 0) || \
|
||||
(_bnum2->d[_bnum2->top - 1] != 0)); \
|
||||
bn_pollute(_bnum2); \
|
||||
} \
|
||||
} while(0)
|
||||
|
||||
#define bn_fix_top(a) bn_check_top(a)
|
||||
|
||||
#define bn_check_size(bn, bits) bn_wcheck_size(bn, ((bits+BN_BITS2-1))/BN_BITS2)
|
||||
#define bn_wcheck_size(bn, words) \
|
||||
do { \
|
||||
const BIGNUM *_bnum2 = (bn); \
|
||||
assert(words <= (_bnum2)->dmax && words >= (_bnum2)->top); \
|
||||
} while(0)
|
||||
|
||||
#else /* !BN_DEBUG */
|
||||
|
||||
#define bn_pollute(a)
|
||||
#define bn_check_top(a)
|
||||
#define bn_fix_top(a) bn_correct_top(a)
|
||||
#define bn_check_size(bn, bits)
|
||||
#define bn_wcheck_size(bn, words)
|
||||
|
||||
#endif
|
||||
|
||||
#define bn_correct_top(a) \
|
||||
{ \
|
||||
BN_ULONG *ftl; \
|
||||
int tmp_top = (a)->top; \
|
||||
if (tmp_top > 0) \
|
||||
{ \
|
||||
for (ftl= &((a)->d[tmp_top-1]); tmp_top > 0; tmp_top--) \
|
||||
if (*(ftl--)) break; \
|
||||
(a)->top = tmp_top; \
|
||||
} \
|
||||
bn_pollute(a); \
|
||||
}
|
||||
|
||||
BN_ULONG bn_mul_add_words(BN_ULONG *rp, const BN_ULONG *ap, int num, BN_ULONG w);
|
||||
BN_ULONG bn_mul_words(BN_ULONG *rp, const BN_ULONG *ap, int num, BN_ULONG w);
|
||||
void bn_sqr_words(BN_ULONG *rp, const BN_ULONG *ap, int num);
|
||||
BN_ULONG bn_div_words(BN_ULONG h, BN_ULONG l, BN_ULONG d);
|
||||
BN_ULONG bn_add_words(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,int num);
|
||||
BN_ULONG bn_sub_words(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,int num);
|
||||
|
||||
/* Primes from RFC 2409 */
|
||||
BIGNUM *get_rfc2409_prime_768(BIGNUM *bn);
|
||||
BIGNUM *get_rfc2409_prime_1024(BIGNUM *bn);
|
||||
|
||||
/* Primes from RFC 3526 */
|
||||
BIGNUM *get_rfc3526_prime_1536(BIGNUM *bn);
|
||||
BIGNUM *get_rfc3526_prime_2048(BIGNUM *bn);
|
||||
BIGNUM *get_rfc3526_prime_3072(BIGNUM *bn);
|
||||
BIGNUM *get_rfc3526_prime_4096(BIGNUM *bn);
|
||||
BIGNUM *get_rfc3526_prime_6144(BIGNUM *bn);
|
||||
BIGNUM *get_rfc3526_prime_8192(BIGNUM *bn);
|
||||
|
||||
int BN_bntest_rand(BIGNUM *rnd, int bits, int top,int bottom);
|
||||
|
||||
/* BEGIN ERROR CODES */
|
||||
/* The following lines are auto generated by the script mkerr.pl. Any changes
|
||||
* made after this point may be overwritten when the script is next run.
|
||||
*/
|
||||
void ERR_load_BN_strings(void);
|
||||
|
||||
/* Error codes for the BN functions. */
|
||||
|
||||
/* Function codes. */
|
||||
#define BN_F_BNRAND 127
|
||||
#define BN_F_BN_BLINDING_CONVERT_EX 100
|
||||
#define BN_F_BN_BLINDING_CREATE_PARAM 128
|
||||
#define BN_F_BN_BLINDING_INVERT_EX 101
|
||||
#define BN_F_BN_BLINDING_NEW 102
|
||||
#define BN_F_BN_BLINDING_UPDATE 103
|
||||
#define BN_F_BN_BN2DEC 104
|
||||
#define BN_F_BN_BN2HEX 105
|
||||
#define BN_F_BN_CTX_GET 116
|
||||
#define BN_F_BN_CTX_NEW 106
|
||||
#define BN_F_BN_CTX_START 129
|
||||
#define BN_F_BN_DIV 107
|
||||
#define BN_F_BN_DIV_NO_BRANCH 138
|
||||
#define BN_F_BN_DIV_RECP 130
|
||||
#define BN_F_BN_EXP 123
|
||||
#define BN_F_BN_EXPAND2 108
|
||||
#define BN_F_BN_EXPAND_INTERNAL 120
|
||||
#define BN_F_BN_GF2M_MOD 131
|
||||
#define BN_F_BN_GF2M_MOD_EXP 132
|
||||
#define BN_F_BN_GF2M_MOD_MUL 133
|
||||
#define BN_F_BN_GF2M_MOD_SOLVE_QUAD 134
|
||||
#define BN_F_BN_GF2M_MOD_SOLVE_QUAD_ARR 135
|
||||
#define BN_F_BN_GF2M_MOD_SQR 136
|
||||
#define BN_F_BN_GF2M_MOD_SQRT 137
|
||||
#define BN_F_BN_MOD_EXP2_MONT 118
|
||||
#define BN_F_BN_MOD_EXP_MONT 109
|
||||
#define BN_F_BN_MOD_EXP_MONT_CONSTTIME 124
|
||||
#define BN_F_BN_MOD_EXP_MONT_WORD 117
|
||||
#define BN_F_BN_MOD_EXP_RECP 125
|
||||
#define BN_F_BN_MOD_EXP_SIMPLE 126
|
||||
#define BN_F_BN_MOD_INVERSE 110
|
||||
#define BN_F_BN_MOD_INVERSE_NO_BRANCH 139
|
||||
#define BN_F_BN_MOD_LSHIFT_QUICK 119
|
||||
#define BN_F_BN_MOD_MUL_RECIPROCAL 111
|
||||
#define BN_F_BN_MOD_SQRT 121
|
||||
#define BN_F_BN_MPI2BN 112
|
||||
#define BN_F_BN_NEW 113
|
||||
#define BN_F_BN_RAND 114
|
||||
#define BN_F_BN_RAND_RANGE 122
|
||||
#define BN_F_BN_USUB 115
|
||||
|
||||
/* Reason codes. */
|
||||
#define BN_R_ARG2_LT_ARG3 100
|
||||
#define BN_R_BAD_RECIPROCAL 101
|
||||
#define BN_R_BIGNUM_TOO_LONG 114
|
||||
#define BN_R_CALLED_WITH_EVEN_MODULUS 102
|
||||
#define BN_R_DIV_BY_ZERO 103
|
||||
#define BN_R_ENCODING_ERROR 104
|
||||
#define BN_R_EXPAND_ON_STATIC_BIGNUM_DATA 105
|
||||
#define BN_R_INPUT_NOT_REDUCED 110
|
||||
#define BN_R_INVALID_LENGTH 106
|
||||
#define BN_R_INVALID_RANGE 115
|
||||
#define BN_R_NOT_A_SQUARE 111
|
||||
#define BN_R_NOT_INITIALIZED 107
|
||||
#define BN_R_NO_INVERSE 108
|
||||
#define BN_R_NO_SOLUTION 116
|
||||
#define BN_R_P_IS_NOT_PRIME 112
|
||||
#define BN_R_TOO_MANY_ITERATIONS 113
|
||||
#define BN_R_TOO_MANY_TEMPORARY_VARIABLES 109
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
@@ -1,611 +0,0 @@
|
||||
/* crypto/crypto.h */
|
||||
/* ====================================================================
|
||||
* Copyright (c) 1998-2006 The OpenSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the OpenSSL Project
|
||||
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
|
||||
*
|
||||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
|
||||
* endorse or promote products derived from this software without
|
||||
* prior written permission. For written permission, please contact
|
||||
* openssl-core@openssl.org.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "OpenSSL"
|
||||
* nor may "OpenSSL" appear in their names without prior written
|
||||
* permission of the OpenSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the OpenSSL Project
|
||||
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*
|
||||
* This product includes cryptographic software written by Eric Young
|
||||
* (eay@cryptsoft.com). This product includes software written by Tim
|
||||
* Hudson (tjh@cryptsoft.com).
|
||||
*
|
||||
*/
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
* This package is an SSL implementation written
|
||||
* by Eric Young (eay@cryptsoft.com).
|
||||
* The implementation was written so as to conform with Netscapes SSL.
|
||||
*
|
||||
* This library is free for commercial and non-commercial use as long as
|
||||
* the following conditions are aheared to. The following conditions
|
||||
* apply to all code found in this distribution, be it the RC4, RSA,
|
||||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
|
||||
* included with this distribution is covered by the same copyright terms
|
||||
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
|
||||
*
|
||||
* Copyright remains Eric Young's, and as such any Copyright notices in
|
||||
* the code are not to be removed.
|
||||
* If this package is used in a product, Eric Young should be given attribution
|
||||
* as the author of the parts of the library used.
|
||||
* This can be in the form of a textual message at program startup or
|
||||
* in documentation (online or textual) provided with the package.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* "This product includes cryptographic software written by
|
||||
* Eric Young (eay@cryptsoft.com)"
|
||||
* The word 'cryptographic' can be left out if the rouines from the library
|
||||
* being used are not cryptographic related :-).
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* the apps directory (application code) you must include an acknowledgement:
|
||||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* The licence and distribution terms for any publically available version or
|
||||
* derivative of this code cannot be changed. i.e. this code cannot simply be
|
||||
* copied and put under another distribution licence
|
||||
* [including the GNU Public Licence.]
|
||||
*/
|
||||
/* ====================================================================
|
||||
* Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
|
||||
* ECDH support in OpenSSL originally developed by
|
||||
* SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
|
||||
*/
|
||||
|
||||
#ifndef HEADER_CRYPTO_H
|
||||
#define HEADER_CRYPTO_H
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <openssl/e_os2.h>
|
||||
|
||||
#ifndef OPENSSL_NO_FP_API
|
||||
#include <stdio.h>
|
||||
#endif
|
||||
|
||||
#include <openssl/stack.h>
|
||||
#include <openssl/safestack.h>
|
||||
#include <openssl/opensslv.h>
|
||||
#include <openssl/ossl_typ.h>
|
||||
|
||||
#ifdef CHARSET_EBCDIC
|
||||
#include <openssl/ebcdic.h>
|
||||
#endif
|
||||
|
||||
/* Resolve problems on some operating systems with symbol names that clash
|
||||
one way or another */
|
||||
#include <openssl/symhacks.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Backward compatibility to SSLeay */
|
||||
/* This is more to be used to check the correct DLL is being used
|
||||
* in the MS world. */
|
||||
#define SSLEAY_VERSION_NUMBER OPENSSL_VERSION_NUMBER
|
||||
#define SSLEAY_VERSION 0
|
||||
/* #define SSLEAY_OPTIONS 1 no longer supported */
|
||||
#define SSLEAY_CFLAGS 2
|
||||
#define SSLEAY_BUILT_ON 3
|
||||
#define SSLEAY_PLATFORM 4
|
||||
#define SSLEAY_DIR 5
|
||||
|
||||
/* Already declared in ossl_typ.h */
|
||||
#if 0
|
||||
typedef struct crypto_ex_data_st CRYPTO_EX_DATA;
|
||||
/* Called when a new object is created */
|
||||
typedef int CRYPTO_EX_new(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
|
||||
int idx, long argl, void *argp);
|
||||
/* Called when an object is free()ed */
|
||||
typedef void CRYPTO_EX_free(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
|
||||
int idx, long argl, void *argp);
|
||||
/* Called when we need to dup an object */
|
||||
typedef int CRYPTO_EX_dup(CRYPTO_EX_DATA *to, CRYPTO_EX_DATA *from, void *from_d,
|
||||
int idx, long argl, void *argp);
|
||||
#endif
|
||||
|
||||
/* A generic structure to pass assorted data in a expandable way */
|
||||
typedef struct openssl_item_st
|
||||
{
|
||||
int code;
|
||||
void *value; /* Not used for flag attributes */
|
||||
size_t value_size; /* Max size of value for output, length for input */
|
||||
size_t *value_length; /* Returned length of value for output */
|
||||
} OPENSSL_ITEM;
|
||||
|
||||
|
||||
/* When changing the CRYPTO_LOCK_* list, be sure to maintin the text lock
|
||||
* names in cryptlib.c
|
||||
*/
|
||||
|
||||
#define CRYPTO_LOCK_ERR 1
|
||||
#define CRYPTO_LOCK_EX_DATA 2
|
||||
#define CRYPTO_LOCK_X509 3
|
||||
#define CRYPTO_LOCK_X509_INFO 4
|
||||
#define CRYPTO_LOCK_X509_PKEY 5
|
||||
#define CRYPTO_LOCK_X509_CRL 6
|
||||
#define CRYPTO_LOCK_X509_REQ 7
|
||||
#define CRYPTO_LOCK_DSA 8
|
||||
#define CRYPTO_LOCK_RSA 9
|
||||
#define CRYPTO_LOCK_EVP_PKEY 10
|
||||
#define CRYPTO_LOCK_X509_STORE 11
|
||||
#define CRYPTO_LOCK_SSL_CTX 12
|
||||
#define CRYPTO_LOCK_SSL_CERT 13
|
||||
#define CRYPTO_LOCK_SSL_SESSION 14
|
||||
#define CRYPTO_LOCK_SSL_SESS_CERT 15
|
||||
#define CRYPTO_LOCK_SSL 16
|
||||
#define CRYPTO_LOCK_SSL_METHOD 17
|
||||
#define CRYPTO_LOCK_RAND 18
|
||||
#define CRYPTO_LOCK_RAND2 19
|
||||
#define CRYPTO_LOCK_MALLOC 20
|
||||
#define CRYPTO_LOCK_BIO 21
|
||||
#define CRYPTO_LOCK_GETHOSTBYNAME 22
|
||||
#define CRYPTO_LOCK_GETSERVBYNAME 23
|
||||
#define CRYPTO_LOCK_READDIR 24
|
||||
#define CRYPTO_LOCK_RSA_BLINDING 25
|
||||
#define CRYPTO_LOCK_DH 26
|
||||
#define CRYPTO_LOCK_MALLOC2 27
|
||||
#define CRYPTO_LOCK_DSO 28
|
||||
#define CRYPTO_LOCK_DYNLOCK 29
|
||||
#define CRYPTO_LOCK_ENGINE 30
|
||||
#define CRYPTO_LOCK_UI 31
|
||||
#define CRYPTO_LOCK_ECDSA 32
|
||||
#define CRYPTO_LOCK_EC 33
|
||||
#define CRYPTO_LOCK_ECDH 34
|
||||
#define CRYPTO_LOCK_BN 35
|
||||
#define CRYPTO_LOCK_EC_PRE_COMP 36
|
||||
#define CRYPTO_LOCK_STORE 37
|
||||
#define CRYPTO_LOCK_COMP 38
|
||||
#define CRYPTO_LOCK_FIPS 39
|
||||
#define CRYPTO_LOCK_FIPS2 40
|
||||
#define CRYPTO_NUM_LOCKS 41
|
||||
|
||||
#define CRYPTO_LOCK 1
|
||||
#define CRYPTO_UNLOCK 2
|
||||
#define CRYPTO_READ 4
|
||||
#define CRYPTO_WRITE 8
|
||||
|
||||
#ifndef OPENSSL_NO_LOCKING
|
||||
#ifndef CRYPTO_w_lock
|
||||
#define CRYPTO_w_lock(type) \
|
||||
CRYPTO_lock(CRYPTO_LOCK|CRYPTO_WRITE,type,__FILE__,__LINE__)
|
||||
#define CRYPTO_w_unlock(type) \
|
||||
CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_WRITE,type,__FILE__,__LINE__)
|
||||
#define CRYPTO_r_lock(type) \
|
||||
CRYPTO_lock(CRYPTO_LOCK|CRYPTO_READ,type,__FILE__,__LINE__)
|
||||
#define CRYPTO_r_unlock(type) \
|
||||
CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_READ,type,__FILE__,__LINE__)
|
||||
#define CRYPTO_add(addr,amount,type) \
|
||||
CRYPTO_add_lock(addr,amount,type,__FILE__,__LINE__)
|
||||
#endif
|
||||
#else
|
||||
#define CRYPTO_w_lock(a)
|
||||
#define CRYPTO_w_unlock(a)
|
||||
#define CRYPTO_r_lock(a)
|
||||
#define CRYPTO_r_unlock(a)
|
||||
#define CRYPTO_add(a,b,c) ((*(a))+=(b))
|
||||
#endif
|
||||
|
||||
/* Some applications as well as some parts of OpenSSL need to allocate
|
||||
and deallocate locks in a dynamic fashion. The following typedef
|
||||
makes this possible in a type-safe manner. */
|
||||
/* struct CRYPTO_dynlock_value has to be defined by the application. */
|
||||
typedef struct
|
||||
{
|
||||
int references;
|
||||
struct CRYPTO_dynlock_value *data;
|
||||
} CRYPTO_dynlock;
|
||||
|
||||
|
||||
/* The following can be used to detect memory leaks in the SSLeay library.
|
||||
* It used, it turns on malloc checking */
|
||||
|
||||
#define CRYPTO_MEM_CHECK_OFF 0x0 /* an enume */
|
||||
#define CRYPTO_MEM_CHECK_ON 0x1 /* a bit */
|
||||
#define CRYPTO_MEM_CHECK_ENABLE 0x2 /* a bit */
|
||||
#define CRYPTO_MEM_CHECK_DISABLE 0x3 /* an enume */
|
||||
|
||||
/* The following are bit values to turn on or off options connected to the
|
||||
* malloc checking functionality */
|
||||
|
||||
/* Adds time to the memory checking information */
|
||||
#define V_CRYPTO_MDEBUG_TIME 0x1 /* a bit */
|
||||
/* Adds thread number to the memory checking information */
|
||||
#define V_CRYPTO_MDEBUG_THREAD 0x2 /* a bit */
|
||||
|
||||
#define V_CRYPTO_MDEBUG_ALL (V_CRYPTO_MDEBUG_TIME | V_CRYPTO_MDEBUG_THREAD)
|
||||
|
||||
|
||||
/* predec of the BIO type */
|
||||
typedef struct bio_st BIO_dummy;
|
||||
|
||||
struct crypto_ex_data_st
|
||||
{
|
||||
STACK_OF(void) *sk;
|
||||
int dummy; /* gcc is screwing up this data structure :-( */
|
||||
};
|
||||
DECLARE_STACK_OF(void)
|
||||
|
||||
/* This stuff is basically class callback functions
|
||||
* The current classes are SSL_CTX, SSL, SSL_SESSION, and a few more */
|
||||
|
||||
typedef struct crypto_ex_data_func_st
|
||||
{
|
||||
long argl; /* Arbitary long */
|
||||
void *argp; /* Arbitary void * */
|
||||
CRYPTO_EX_new *new_func;
|
||||
CRYPTO_EX_free *free_func;
|
||||
CRYPTO_EX_dup *dup_func;
|
||||
} CRYPTO_EX_DATA_FUNCS;
|
||||
|
||||
DECLARE_STACK_OF(CRYPTO_EX_DATA_FUNCS)
|
||||
|
||||
/* Per class, we have a STACK of CRYPTO_EX_DATA_FUNCS for each CRYPTO_EX_DATA
|
||||
* entry.
|
||||
*/
|
||||
|
||||
#define CRYPTO_EX_INDEX_BIO 0
|
||||
#define CRYPTO_EX_INDEX_SSL 1
|
||||
#define CRYPTO_EX_INDEX_SSL_CTX 2
|
||||
#define CRYPTO_EX_INDEX_SSL_SESSION 3
|
||||
#define CRYPTO_EX_INDEX_X509_STORE 4
|
||||
#define CRYPTO_EX_INDEX_X509_STORE_CTX 5
|
||||
#define CRYPTO_EX_INDEX_RSA 6
|
||||
#define CRYPTO_EX_INDEX_DSA 7
|
||||
#define CRYPTO_EX_INDEX_DH 8
|
||||
#define CRYPTO_EX_INDEX_ENGINE 9
|
||||
#define CRYPTO_EX_INDEX_X509 10
|
||||
#define CRYPTO_EX_INDEX_UI 11
|
||||
#define CRYPTO_EX_INDEX_ECDSA 12
|
||||
#define CRYPTO_EX_INDEX_ECDH 13
|
||||
#define CRYPTO_EX_INDEX_COMP 14
|
||||
#define CRYPTO_EX_INDEX_STORE 15
|
||||
|
||||
/* Dynamically assigned indexes start from this value (don't use directly, use
|
||||
* via CRYPTO_ex_data_new_class). */
|
||||
#define CRYPTO_EX_INDEX_USER 100
|
||||
|
||||
|
||||
/* This is the default callbacks, but we can have others as well:
|
||||
* this is needed in Win32 where the application malloc and the
|
||||
* library malloc may not be the same.
|
||||
*/
|
||||
#define CRYPTO_malloc_init() CRYPTO_set_mem_functions(\
|
||||
malloc, realloc, free)
|
||||
|
||||
#if defined CRYPTO_MDEBUG_ALL || defined CRYPTO_MDEBUG_TIME || defined CRYPTO_MDEBUG_THREAD
|
||||
# ifndef CRYPTO_MDEBUG /* avoid duplicate #define */
|
||||
# define CRYPTO_MDEBUG
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Set standard debugging functions (not done by default
|
||||
* unless CRYPTO_MDEBUG is defined) */
|
||||
#define CRYPTO_malloc_debug_init() do {\
|
||||
CRYPTO_set_mem_debug_functions(\
|
||||
CRYPTO_dbg_malloc,\
|
||||
CRYPTO_dbg_realloc,\
|
||||
CRYPTO_dbg_free,\
|
||||
CRYPTO_dbg_set_options,\
|
||||
CRYPTO_dbg_get_options);\
|
||||
} while(0)
|
||||
|
||||
int CRYPTO_mem_ctrl(int mode);
|
||||
int CRYPTO_is_mem_check_on(void);
|
||||
|
||||
/* for applications */
|
||||
#define MemCheck_start() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON)
|
||||
#define MemCheck_stop() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_OFF)
|
||||
|
||||
/* for library-internal use */
|
||||
#define MemCheck_on() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE)
|
||||
#define MemCheck_off() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE)
|
||||
#define is_MemCheck_on() CRYPTO_is_mem_check_on()
|
||||
|
||||
#define OPENSSL_malloc(num) CRYPTO_malloc((int)num,__FILE__,__LINE__)
|
||||
#define OPENSSL_strdup(str) CRYPTO_strdup((str),__FILE__,__LINE__)
|
||||
#define OPENSSL_realloc(addr,num) \
|
||||
CRYPTO_realloc((char *)addr,(int)num,__FILE__,__LINE__)
|
||||
#define OPENSSL_realloc_clean(addr,old_num,num) \
|
||||
CRYPTO_realloc_clean(addr,old_num,num,__FILE__,__LINE__)
|
||||
#define OPENSSL_remalloc(addr,num) \
|
||||
CRYPTO_remalloc((char **)addr,(int)num,__FILE__,__LINE__)
|
||||
#define OPENSSL_freeFunc CRYPTO_free
|
||||
#define OPENSSL_free(addr) CRYPTO_free(addr)
|
||||
|
||||
#define OPENSSL_malloc_locked(num) \
|
||||
CRYPTO_malloc_locked((int)num,__FILE__,__LINE__)
|
||||
#define OPENSSL_free_locked(addr) CRYPTO_free_locked(addr)
|
||||
|
||||
|
||||
const char *SSLeay_version(int type);
|
||||
unsigned long SSLeay(void);
|
||||
|
||||
int OPENSSL_issetugid(void);
|
||||
|
||||
/* An opaque type representing an implementation of "ex_data" support */
|
||||
typedef struct st_CRYPTO_EX_DATA_IMPL CRYPTO_EX_DATA_IMPL;
|
||||
/* Return an opaque pointer to the current "ex_data" implementation */
|
||||
const CRYPTO_EX_DATA_IMPL *CRYPTO_get_ex_data_implementation(void);
|
||||
/* Sets the "ex_data" implementation to be used (if it's not too late) */
|
||||
int CRYPTO_set_ex_data_implementation(const CRYPTO_EX_DATA_IMPL *i);
|
||||
/* Get a new "ex_data" class, and return the corresponding "class_index" */
|
||||
int CRYPTO_ex_data_new_class(void);
|
||||
/* Within a given class, get/register a new index */
|
||||
int CRYPTO_get_ex_new_index(int class_index, long argl, void *argp,
|
||||
CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func,
|
||||
CRYPTO_EX_free *free_func);
|
||||
/* Initialise/duplicate/free CRYPTO_EX_DATA variables corresponding to a given
|
||||
* class (invokes whatever per-class callbacks are applicable) */
|
||||
int CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
|
||||
int CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to,
|
||||
CRYPTO_EX_DATA *from);
|
||||
void CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
|
||||
/* Get/set data in a CRYPTO_EX_DATA variable corresponding to a particular index
|
||||
* (relative to the class type involved) */
|
||||
int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val);
|
||||
void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad,int idx);
|
||||
/* This function cleans up all "ex_data" state. It mustn't be called under
|
||||
* potential race-conditions. */
|
||||
void CRYPTO_cleanup_all_ex_data(void);
|
||||
|
||||
int CRYPTO_get_new_lockid(char *name);
|
||||
|
||||
int CRYPTO_num_locks(void); /* return CRYPTO_NUM_LOCKS (shared libs!) */
|
||||
void CRYPTO_lock(int mode, int type,const char *file,int line);
|
||||
void CRYPTO_set_locking_callback(void (*func)(int mode,int type,
|
||||
const char *file,int line));
|
||||
void (*CRYPTO_get_locking_callback(void))(int mode,int type,const char *file,
|
||||
int line);
|
||||
void CRYPTO_set_add_lock_callback(int (*func)(int *num,int mount,int type,
|
||||
const char *file, int line));
|
||||
int (*CRYPTO_get_add_lock_callback(void))(int *num,int mount,int type,
|
||||
const char *file,int line);
|
||||
|
||||
/* Don't use this structure directly. */
|
||||
typedef struct crypto_threadid_st
|
||||
{
|
||||
void *ptr;
|
||||
unsigned long val;
|
||||
} CRYPTO_THREADID;
|
||||
/* Only use CRYPTO_THREADID_set_[numeric|pointer]() within callbacks */
|
||||
void CRYPTO_THREADID_set_numeric(CRYPTO_THREADID *id, unsigned long val);
|
||||
void CRYPTO_THREADID_set_pointer(CRYPTO_THREADID *id, void *ptr);
|
||||
int CRYPTO_THREADID_set_callback(void (*threadid_func)(CRYPTO_THREADID *));
|
||||
void (*CRYPTO_THREADID_get_callback(void))(CRYPTO_THREADID *);
|
||||
void CRYPTO_THREADID_current(CRYPTO_THREADID *id);
|
||||
int CRYPTO_THREADID_cmp(const CRYPTO_THREADID *a, const CRYPTO_THREADID *b);
|
||||
void CRYPTO_THREADID_cpy(CRYPTO_THREADID *dest, const CRYPTO_THREADID *src);
|
||||
unsigned long CRYPTO_THREADID_hash(const CRYPTO_THREADID *id);
|
||||
#ifndef OPENSSL_NO_DEPRECATED
|
||||
void CRYPTO_set_id_callback(unsigned long (*func)(void));
|
||||
unsigned long (*CRYPTO_get_id_callback(void))(void);
|
||||
unsigned long CRYPTO_thread_id(void);
|
||||
#endif
|
||||
|
||||
const char *CRYPTO_get_lock_name(int type);
|
||||
int CRYPTO_add_lock(int *pointer,int amount,int type, const char *file,
|
||||
int line);
|
||||
|
||||
int CRYPTO_get_new_dynlockid(void);
|
||||
void CRYPTO_destroy_dynlockid(int i);
|
||||
struct CRYPTO_dynlock_value *CRYPTO_get_dynlock_value(int i);
|
||||
void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value *(*dyn_create_function)(const char *file, int line));
|
||||
void CRYPTO_set_dynlock_lock_callback(void (*dyn_lock_function)(int mode, struct CRYPTO_dynlock_value *l, const char *file, int line));
|
||||
void CRYPTO_set_dynlock_destroy_callback(void (*dyn_destroy_function)(struct CRYPTO_dynlock_value *l, const char *file, int line));
|
||||
struct CRYPTO_dynlock_value *(*CRYPTO_get_dynlock_create_callback(void))(const char *file,int line);
|
||||
void (*CRYPTO_get_dynlock_lock_callback(void))(int mode, struct CRYPTO_dynlock_value *l, const char *file,int line);
|
||||
void (*CRYPTO_get_dynlock_destroy_callback(void))(struct CRYPTO_dynlock_value *l, const char *file,int line);
|
||||
|
||||
/* CRYPTO_set_mem_functions includes CRYPTO_set_locked_mem_functions --
|
||||
* call the latter last if you need different functions */
|
||||
int CRYPTO_set_mem_functions(void *(*m)(size_t),void *(*r)(void *,size_t), void (*f)(void *));
|
||||
int CRYPTO_set_locked_mem_functions(void *(*m)(size_t), void (*free_func)(void *));
|
||||
int CRYPTO_set_mem_ex_functions(void *(*m)(size_t,const char *,int),
|
||||
void *(*r)(void *,size_t,const char *,int),
|
||||
void (*f)(void *));
|
||||
int CRYPTO_set_locked_mem_ex_functions(void *(*m)(size_t,const char *,int),
|
||||
void (*free_func)(void *));
|
||||
int CRYPTO_set_mem_debug_functions(void (*m)(void *,int,const char *,int,int),
|
||||
void (*r)(void *,void *,int,const char *,int,int),
|
||||
void (*f)(void *,int),
|
||||
void (*so)(long),
|
||||
long (*go)(void));
|
||||
void CRYPTO_get_mem_functions(void *(**m)(size_t),void *(**r)(void *, size_t), void (**f)(void *));
|
||||
void CRYPTO_get_locked_mem_functions(void *(**m)(size_t), void (**f)(void *));
|
||||
void CRYPTO_get_mem_ex_functions(void *(**m)(size_t,const char *,int),
|
||||
void *(**r)(void *, size_t,const char *,int),
|
||||
void (**f)(void *));
|
||||
void CRYPTO_get_locked_mem_ex_functions(void *(**m)(size_t,const char *,int),
|
||||
void (**f)(void *));
|
||||
void CRYPTO_get_mem_debug_functions(void (**m)(void *,int,const char *,int,int),
|
||||
void (**r)(void *,void *,int,const char *,int,int),
|
||||
void (**f)(void *,int),
|
||||
void (**so)(long),
|
||||
long (**go)(void));
|
||||
|
||||
void *CRYPTO_malloc_locked(int num, const char *file, int line);
|
||||
void CRYPTO_free_locked(void *ptr);
|
||||
void *CRYPTO_malloc(int num, const char *file, int line);
|
||||
char *CRYPTO_strdup(const char *str, const char *file, int line);
|
||||
void CRYPTO_free(void *ptr);
|
||||
void *CRYPTO_realloc(void *addr,int num, const char *file, int line);
|
||||
void *CRYPTO_realloc_clean(void *addr,int old_num,int num,const char *file,
|
||||
int line);
|
||||
void *CRYPTO_remalloc(void *addr,int num, const char *file, int line);
|
||||
|
||||
void OPENSSL_cleanse(void *ptr, size_t len);
|
||||
|
||||
void CRYPTO_set_mem_debug_options(long bits);
|
||||
long CRYPTO_get_mem_debug_options(void);
|
||||
|
||||
#define CRYPTO_push_info(info) \
|
||||
CRYPTO_push_info_(info, __FILE__, __LINE__);
|
||||
int CRYPTO_push_info_(const char *info, const char *file, int line);
|
||||
int CRYPTO_pop_info(void);
|
||||
int CRYPTO_remove_all_info(void);
|
||||
|
||||
|
||||
/* Default debugging functions (enabled by CRYPTO_malloc_debug_init() macro;
|
||||
* used as default in CRYPTO_MDEBUG compilations): */
|
||||
/* The last argument has the following significance:
|
||||
*
|
||||
* 0: called before the actual memory allocation has taken place
|
||||
* 1: called after the actual memory allocation has taken place
|
||||
*/
|
||||
void CRYPTO_dbg_malloc(void *addr,int num,const char *file,int line,int before_p);
|
||||
void CRYPTO_dbg_realloc(void *addr1,void *addr2,int num,const char *file,int line,int before_p);
|
||||
void CRYPTO_dbg_free(void *addr,int before_p);
|
||||
/* Tell the debugging code about options. By default, the following values
|
||||
* apply:
|
||||
*
|
||||
* 0: Clear all options.
|
||||
* V_CRYPTO_MDEBUG_TIME (1): Set the "Show Time" option.
|
||||
* V_CRYPTO_MDEBUG_THREAD (2): Set the "Show Thread Number" option.
|
||||
* V_CRYPTO_MDEBUG_ALL (3): 1 + 2
|
||||
*/
|
||||
void CRYPTO_dbg_set_options(long bits);
|
||||
long CRYPTO_dbg_get_options(void);
|
||||
|
||||
|
||||
#ifndef OPENSSL_NO_FP_API
|
||||
void CRYPTO_mem_leaks_fp(FILE *);
|
||||
#endif
|
||||
void CRYPTO_mem_leaks(struct bio_st *bio);
|
||||
/* unsigned long order, char *file, int line, int num_bytes, char *addr */
|
||||
typedef void *CRYPTO_MEM_LEAK_CB(unsigned long, const char *, int, int, void *);
|
||||
void CRYPTO_mem_leaks_cb(CRYPTO_MEM_LEAK_CB *cb);
|
||||
|
||||
/* die if we have to */
|
||||
void OpenSSLDie(const char *file,int line,const char *assertion);
|
||||
#define OPENSSL_assert(e) (void)((e) ? 0 : (OpenSSLDie(__FILE__, __LINE__, #e),1))
|
||||
|
||||
unsigned long *OPENSSL_ia32cap_loc(void);
|
||||
#define OPENSSL_ia32cap (*(OPENSSL_ia32cap_loc()))
|
||||
int OPENSSL_isservice(void);
|
||||
|
||||
int FIPS_mode(void);
|
||||
int FIPS_mode_set(int r);
|
||||
|
||||
void OPENSSL_init(void);
|
||||
|
||||
#define fips_md_init(alg) fips_md_init_ctx(alg, alg)
|
||||
|
||||
#ifdef OPENSSL_FIPS
|
||||
#define fips_md_init_ctx(alg, cx) \
|
||||
int alg##_Init(cx##_CTX *c) \
|
||||
{ \
|
||||
if (FIPS_mode()) OpenSSLDie(__FILE__, __LINE__, \
|
||||
"Low level API call to digest " #alg " forbidden in FIPS mode!"); \
|
||||
return private_##alg##_Init(c); \
|
||||
} \
|
||||
int private_##alg##_Init(cx##_CTX *c)
|
||||
|
||||
#define fips_cipher_abort(alg) \
|
||||
if (FIPS_mode()) OpenSSLDie(__FILE__, __LINE__, \
|
||||
"Low level API call to cipher " #alg " forbidden in FIPS mode!")
|
||||
|
||||
#else
|
||||
#define fips_md_init_ctx(alg, cx) \
|
||||
int alg##_Init(cx##_CTX *c)
|
||||
#define fips_cipher_abort(alg) while(0)
|
||||
#endif
|
||||
|
||||
/* CRYPTO_memcmp returns zero iff the |len| bytes at |a| and |b| are equal. It
|
||||
* takes an amount of time dependent on |len|, but independent of the contents
|
||||
* of |a| and |b|. Unlike memcmp, it cannot be used to put elements into a
|
||||
* defined order as the return value when a != b is undefined, other than to be
|
||||
* non-zero. */
|
||||
int CRYPTO_memcmp(const void *a, const void *b, size_t len);
|
||||
|
||||
/* BEGIN ERROR CODES */
|
||||
/* The following lines are auto generated by the script mkerr.pl. Any changes
|
||||
* made after this point may be overwritten when the script is next run.
|
||||
*/
|
||||
void ERR_load_CRYPTO_strings(void);
|
||||
|
||||
/* Error codes for the CRYPTO functions. */
|
||||
|
||||
/* Function codes. */
|
||||
#define CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX 100
|
||||
#define CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID 103
|
||||
#define CRYPTO_F_CRYPTO_GET_NEW_LOCKID 101
|
||||
#define CRYPTO_F_CRYPTO_SET_EX_DATA 102
|
||||
#define CRYPTO_F_DEF_ADD_INDEX 104
|
||||
#define CRYPTO_F_DEF_GET_CLASS 105
|
||||
#define CRYPTO_F_FIPS_MODE_SET 109
|
||||
#define CRYPTO_F_INT_DUP_EX_DATA 106
|
||||
#define CRYPTO_F_INT_FREE_EX_DATA 107
|
||||
#define CRYPTO_F_INT_NEW_EX_DATA 108
|
||||
|
||||
/* Reason codes. */
|
||||
#define CRYPTO_R_FIPS_MODE_NOT_SUPPORTED 101
|
||||
#define CRYPTO_R_NO_DYNLOCK_CREATE_CALLBACK 100
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
@@ -1,89 +0,0 @@
|
||||
#ifndef HEADER_OPENSSLV_H
|
||||
#define HEADER_OPENSSLV_H
|
||||
|
||||
/* Numeric release version identifier:
|
||||
* MNNFFPPS: major minor fix patch status
|
||||
* The status nibble has one of the values 0 for development, 1 to e for betas
|
||||
* 1 to 14, and f for release. The patch level is exactly that.
|
||||
* For example:
|
||||
* 0.9.3-dev 0x00903000
|
||||
* 0.9.3-beta1 0x00903001
|
||||
* 0.9.3-beta2-dev 0x00903002
|
||||
* 0.9.3-beta2 0x00903002 (same as ...beta2-dev)
|
||||
* 0.9.3 0x0090300f
|
||||
* 0.9.3a 0x0090301f
|
||||
* 0.9.4 0x0090400f
|
||||
* 1.2.3z 0x102031af
|
||||
*
|
||||
* For continuity reasons (because 0.9.5 is already out, and is coded
|
||||
* 0x00905100), between 0.9.5 and 0.9.6 the coding of the patch level
|
||||
* part is slightly different, by setting the highest bit. This means
|
||||
* that 0.9.5a looks like this: 0x0090581f. At 0.9.6, we can start
|
||||
* with 0x0090600S...
|
||||
*
|
||||
* (Prior to 0.9.3-dev a different scheme was used: 0.9.2b is 0x0922.)
|
||||
* (Prior to 0.9.5a beta1, a different scheme was used: MMNNFFRBB for
|
||||
* major minor fix final patch/beta)
|
||||
*/
|
||||
#define OPENSSL_VERSION_NUMBER 0x1000109fL
|
||||
#ifdef OPENSSL_FIPS
|
||||
#define OPENSSL_VERSION_TEXT "OpenSSL 1.0.1i-fips 6 Aug 2014"
|
||||
#else
|
||||
#define OPENSSL_VERSION_TEXT "OpenSSL 1.0.1i 6 Aug 2014"
|
||||
#endif
|
||||
#define OPENSSL_VERSION_PTEXT " part of " OPENSSL_VERSION_TEXT
|
||||
|
||||
|
||||
/* The macros below are to be used for shared library (.so, .dll, ...)
|
||||
* versioning. That kind of versioning works a bit differently between
|
||||
* operating systems. The most usual scheme is to set a major and a minor
|
||||
* number, and have the runtime loader check that the major number is equal
|
||||
* to what it was at application link time, while the minor number has to
|
||||
* be greater or equal to what it was at application link time. With this
|
||||
* scheme, the version number is usually part of the file name, like this:
|
||||
*
|
||||
* libcrypto.so.0.9
|
||||
*
|
||||
* Some unixen also make a softlink with the major verson number only:
|
||||
*
|
||||
* libcrypto.so.0
|
||||
*
|
||||
* On Tru64 and IRIX 6.x it works a little bit differently. There, the
|
||||
* shared library version is stored in the file, and is actually a series
|
||||
* of versions, separated by colons. The rightmost version present in the
|
||||
* library when linking an application is stored in the application to be
|
||||
* matched at run time. When the application is run, a check is done to
|
||||
* see if the library version stored in the application matches any of the
|
||||
* versions in the version string of the library itself.
|
||||
* This version string can be constructed in any way, depending on what
|
||||
* kind of matching is desired. However, to implement the same scheme as
|
||||
* the one used in the other unixen, all compatible versions, from lowest
|
||||
* to highest, should be part of the string. Consecutive builds would
|
||||
* give the following versions strings:
|
||||
*
|
||||
* 3.0
|
||||
* 3.0:3.1
|
||||
* 3.0:3.1:3.2
|
||||
* 4.0
|
||||
* 4.0:4.1
|
||||
*
|
||||
* Notice how version 4 is completely incompatible with version, and
|
||||
* therefore give the breach you can see.
|
||||
*
|
||||
* There may be other schemes as well that I haven't yet discovered.
|
||||
*
|
||||
* So, here's the way it works here: first of all, the library version
|
||||
* number doesn't need at all to match the overall OpenSSL version.
|
||||
* However, it's nice and more understandable if it actually does.
|
||||
* The current library version is stored in the macro SHLIB_VERSION_NUMBER,
|
||||
* which is just a piece of text in the format "M.m.e" (Major, minor, edit).
|
||||
* For the sake of Tru64, IRIX, and any other OS that behaves in similar ways,
|
||||
* we need to keep a history of version numbers, which is done in the
|
||||
* macro SHLIB_VERSION_HISTORY. The numbers are separated by colons and
|
||||
* should only keep the versions that are binary compatible with the current.
|
||||
*/
|
||||
#define SHLIB_VERSION_HISTORY ""
|
||||
#define SHLIB_VERSION_NUMBER "1.0.0"
|
||||
|
||||
|
||||
#endif /* HEADER_OPENSSLV_H */
|
||||
@@ -1,202 +0,0 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 1998-2001 The OpenSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the OpenSSL Project
|
||||
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
|
||||
*
|
||||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
|
||||
* endorse or promote products derived from this software without
|
||||
* prior written permission. For written permission, please contact
|
||||
* openssl-core@openssl.org.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "OpenSSL"
|
||||
* nor may "OpenSSL" appear in their names without prior written
|
||||
* permission of the OpenSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the OpenSSL Project
|
||||
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*
|
||||
* This product includes cryptographic software written by Eric Young
|
||||
* (eay@cryptsoft.com). This product includes software written by Tim
|
||||
* Hudson (tjh@cryptsoft.com).
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef HEADER_OPENSSL_TYPES_H
|
||||
#define HEADER_OPENSSL_TYPES_H
|
||||
|
||||
#include <openssl/e_os2.h>
|
||||
|
||||
#ifdef NO_ASN1_TYPEDEFS
|
||||
#define ASN1_INTEGER ASN1_STRING
|
||||
#define ASN1_ENUMERATED ASN1_STRING
|
||||
#define ASN1_BIT_STRING ASN1_STRING
|
||||
#define ASN1_OCTET_STRING ASN1_STRING
|
||||
#define ASN1_PRINTABLESTRING ASN1_STRING
|
||||
#define ASN1_T61STRING ASN1_STRING
|
||||
#define ASN1_IA5STRING ASN1_STRING
|
||||
#define ASN1_UTCTIME ASN1_STRING
|
||||
#define ASN1_GENERALIZEDTIME ASN1_STRING
|
||||
#define ASN1_TIME ASN1_STRING
|
||||
#define ASN1_GENERALSTRING ASN1_STRING
|
||||
#define ASN1_UNIVERSALSTRING ASN1_STRING
|
||||
#define ASN1_BMPSTRING ASN1_STRING
|
||||
#define ASN1_VISIBLESTRING ASN1_STRING
|
||||
#define ASN1_UTF8STRING ASN1_STRING
|
||||
#define ASN1_BOOLEAN int
|
||||
#define ASN1_NULL int
|
||||
#else
|
||||
typedef struct asn1_string_st ASN1_INTEGER;
|
||||
typedef struct asn1_string_st ASN1_ENUMERATED;
|
||||
typedef struct asn1_string_st ASN1_BIT_STRING;
|
||||
typedef struct asn1_string_st ASN1_OCTET_STRING;
|
||||
typedef struct asn1_string_st ASN1_PRINTABLESTRING;
|
||||
typedef struct asn1_string_st ASN1_T61STRING;
|
||||
typedef struct asn1_string_st ASN1_IA5STRING;
|
||||
typedef struct asn1_string_st ASN1_GENERALSTRING;
|
||||
typedef struct asn1_string_st ASN1_UNIVERSALSTRING;
|
||||
typedef struct asn1_string_st ASN1_BMPSTRING;
|
||||
typedef struct asn1_string_st ASN1_UTCTIME;
|
||||
typedef struct asn1_string_st ASN1_TIME;
|
||||
typedef struct asn1_string_st ASN1_GENERALIZEDTIME;
|
||||
typedef struct asn1_string_st ASN1_VISIBLESTRING;
|
||||
typedef struct asn1_string_st ASN1_UTF8STRING;
|
||||
typedef struct asn1_string_st ASN1_STRING;
|
||||
typedef int ASN1_BOOLEAN;
|
||||
typedef int ASN1_NULL;
|
||||
#endif
|
||||
|
||||
typedef struct ASN1_ITEM_st ASN1_ITEM;
|
||||
typedef struct asn1_pctx_st ASN1_PCTX;
|
||||
|
||||
#ifdef OPENSSL_SYS_WIN32
|
||||
#undef X509_NAME
|
||||
#undef X509_EXTENSIONS
|
||||
#undef X509_CERT_PAIR
|
||||
#undef PKCS7_ISSUER_AND_SERIAL
|
||||
#undef OCSP_REQUEST
|
||||
#undef OCSP_RESPONSE
|
||||
#endif
|
||||
|
||||
#ifdef BIGNUM
|
||||
#undef BIGNUM
|
||||
#endif
|
||||
typedef struct bignum_st BIGNUM;
|
||||
typedef struct bignum_ctx BN_CTX;
|
||||
typedef struct bn_blinding_st BN_BLINDING;
|
||||
typedef struct bn_mont_ctx_st BN_MONT_CTX;
|
||||
typedef struct bn_recp_ctx_st BN_RECP_CTX;
|
||||
typedef struct bn_gencb_st BN_GENCB;
|
||||
|
||||
typedef struct buf_mem_st BUF_MEM;
|
||||
|
||||
typedef struct evp_cipher_st EVP_CIPHER;
|
||||
typedef struct evp_cipher_ctx_st EVP_CIPHER_CTX;
|
||||
typedef struct env_md_st EVP_MD;
|
||||
typedef struct env_md_ctx_st EVP_MD_CTX;
|
||||
typedef struct evp_pkey_st EVP_PKEY;
|
||||
|
||||
typedef struct evp_pkey_asn1_method_st EVP_PKEY_ASN1_METHOD;
|
||||
|
||||
typedef struct evp_pkey_method_st EVP_PKEY_METHOD;
|
||||
typedef struct evp_pkey_ctx_st EVP_PKEY_CTX;
|
||||
|
||||
typedef struct dh_st DH;
|
||||
typedef struct dh_method DH_METHOD;
|
||||
|
||||
typedef struct dsa_st DSA;
|
||||
typedef struct dsa_method DSA_METHOD;
|
||||
|
||||
typedef struct rsa_st RSA;
|
||||
typedef struct rsa_meth_st RSA_METHOD;
|
||||
|
||||
typedef struct rand_meth_st RAND_METHOD;
|
||||
|
||||
typedef struct ecdh_method ECDH_METHOD;
|
||||
typedef struct ecdsa_method ECDSA_METHOD;
|
||||
|
||||
typedef struct x509_st X509;
|
||||
typedef struct X509_algor_st X509_ALGOR;
|
||||
typedef struct X509_crl_st X509_CRL;
|
||||
typedef struct x509_crl_method_st X509_CRL_METHOD;
|
||||
typedef struct x509_revoked_st X509_REVOKED;
|
||||
typedef struct X509_name_st X509_NAME;
|
||||
typedef struct X509_pubkey_st X509_PUBKEY;
|
||||
typedef struct x509_store_st X509_STORE;
|
||||
typedef struct x509_store_ctx_st X509_STORE_CTX;
|
||||
|
||||
typedef struct pkcs8_priv_key_info_st PKCS8_PRIV_KEY_INFO;
|
||||
|
||||
typedef struct v3_ext_ctx X509V3_CTX;
|
||||
typedef struct conf_st CONF;
|
||||
|
||||
typedef struct store_st STORE;
|
||||
typedef struct store_method_st STORE_METHOD;
|
||||
|
||||
typedef struct ui_st UI;
|
||||
typedef struct ui_method_st UI_METHOD;
|
||||
|
||||
typedef struct st_ERR_FNS ERR_FNS;
|
||||
|
||||
typedef struct engine_st ENGINE;
|
||||
typedef struct ssl_st SSL;
|
||||
typedef struct ssl_ctx_st SSL_CTX;
|
||||
|
||||
typedef struct X509_POLICY_NODE_st X509_POLICY_NODE;
|
||||
typedef struct X509_POLICY_LEVEL_st X509_POLICY_LEVEL;
|
||||
typedef struct X509_POLICY_TREE_st X509_POLICY_TREE;
|
||||
typedef struct X509_POLICY_CACHE_st X509_POLICY_CACHE;
|
||||
|
||||
typedef struct AUTHORITY_KEYID_st AUTHORITY_KEYID;
|
||||
typedef struct DIST_POINT_st DIST_POINT;
|
||||
typedef struct ISSUING_DIST_POINT_st ISSUING_DIST_POINT;
|
||||
typedef struct NAME_CONSTRAINTS_st NAME_CONSTRAINTS;
|
||||
|
||||
/* If placed in pkcs12.h, we end up with a circular depency with pkcs7.h */
|
||||
#define DECLARE_PKCS12_STACK_OF(type) /* Nothing */
|
||||
#define IMPLEMENT_PKCS12_STACK_OF(type) /* Nothing */
|
||||
|
||||
typedef struct crypto_ex_data_st CRYPTO_EX_DATA;
|
||||
/* Callback types for crypto.h */
|
||||
typedef int CRYPTO_EX_new(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
|
||||
int idx, long argl, void *argp);
|
||||
typedef void CRYPTO_EX_free(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
|
||||
int idx, long argl, void *argp);
|
||||
typedef int CRYPTO_EX_dup(CRYPTO_EX_DATA *to, CRYPTO_EX_DATA *from, void *from_d,
|
||||
int idx, long argl, void *argp);
|
||||
|
||||
typedef struct ocsp_req_ctx_st OCSP_REQ_CTX;
|
||||
typedef struct ocsp_response_st OCSP_RESPONSE;
|
||||
typedef struct ocsp_responder_id_st OCSP_RESPID;
|
||||
|
||||
#endif /* def HEADER_OPENSSL_TYPES_H */
|
||||
File diff suppressed because it is too large.
Load diff
@@ -1,108 +0,0 @@
|
||||
/* crypto/stack/stack.h */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
* This package is an SSL implementation written
|
||||
* by Eric Young (eay@cryptsoft.com).
|
||||
* The implementation was written so as to conform with Netscapes SSL.
|
||||
*
|
||||
* This library is free for commercial and non-commercial use as long as
|
||||
* the following conditions are aheared to. The following conditions
|
||||
* apply to all code found in this distribution, be it the RC4, RSA,
|
||||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
|
||||
* included with this distribution is covered by the same copyright terms
|
||||
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
|
||||
*
|
||||
* Copyright remains Eric Young's, and as such any Copyright notices in
|
||||
* the code are not to be removed.
|
||||
* If this package is used in a product, Eric Young should be given attribution
|
||||
* as the author of the parts of the library used.
|
||||
* This can be in the form of a textual message at program startup or
|
||||
* in documentation (online or textual) provided with the package.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* "This product includes cryptographic software written by
|
||||
* Eric Young (eay@cryptsoft.com)"
|
||||
* The word 'cryptographic' can be left out if the rouines from the library
|
||||
* being used are not cryptographic related :-).
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* the apps directory (application code) you must include an acknowledgement:
|
||||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* The licence and distribution terms for any publically available version or
|
||||
* derivative of this code cannot be changed. i.e. this code cannot simply be
|
||||
* copied and put under another distribution licence
|
||||
* [including the GNU Public Licence.]
|
||||
*/
|
||||
|
||||
#ifndef HEADER_STACK_H
|
||||
#define HEADER_STACK_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct stack_st
|
||||
{
|
||||
int num;
|
||||
char **data;
|
||||
int sorted;
|
||||
|
||||
int num_alloc;
|
||||
int (*comp)(const void *, const void *);
|
||||
} _STACK; /* Use STACK_OF(...) instead */
|
||||
|
||||
#define M_sk_num(sk) ((sk) ? (sk)->num:-1)
|
||||
#define M_sk_value(sk,n) ((sk) ? (sk)->data[n] : NULL)
|
||||
|
||||
int sk_num(const _STACK *);
|
||||
void *sk_value(const _STACK *, int);
|
||||
|
||||
void *sk_set(_STACK *, int, void *);
|
||||
|
||||
_STACK *sk_new(int (*cmp)(const void *, const void *));
|
||||
_STACK *sk_new_null(void);
|
||||
void sk_free(_STACK *);
|
||||
void sk_pop_free(_STACK *st, void (*func)(void *));
|
||||
int sk_insert(_STACK *sk, void *data, int where);
|
||||
void *sk_delete(_STACK *st, int loc);
|
||||
void *sk_delete_ptr(_STACK *st, void *p);
|
||||
int sk_find(_STACK *st, void *data);
|
||||
int sk_find_ex(_STACK *st, void *data);
|
||||
int sk_push(_STACK *st, void *data);
|
||||
int sk_unshift(_STACK *st, void *data);
|
||||
void *sk_shift(_STACK *st);
|
||||
void *sk_pop(_STACK *st);
|
||||
void sk_zero(_STACK *st);
|
||||
int (*sk_set_cmp_func(_STACK *sk, int (*c)(const void *, const void *)))
|
||||
(const void *, const void *);
|
||||
_STACK *sk_dup(_STACK *st);
|
||||
void sk_sort(_STACK *st);
|
||||
int sk_is_sorted(const _STACK *st);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -1,481 +0,0 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 1999 The OpenSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the OpenSSL Project
|
||||
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
|
||||
*
|
||||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
|
||||
* endorse or promote products derived from this software without
|
||||
* prior written permission. For written permission, please contact
|
||||
* openssl-core@openssl.org.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "OpenSSL"
|
||||
* nor may "OpenSSL" appear in their names without prior written
|
||||
* permission of the OpenSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the OpenSSL Project
|
||||
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*
|
||||
* This product includes cryptographic software written by Eric Young
|
||||
* (eay@cryptsoft.com). This product includes software written by Tim
|
||||
* Hudson (tjh@cryptsoft.com).
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef HEADER_SYMHACKS_H
|
||||
#define HEADER_SYMHACKS_H
|
||||
|
||||
#include <openssl/e_os2.h>
|
||||
|
||||
/* Hacks to solve the problem with linkers incapable of handling very long
|
||||
symbol names. In the case of VMS, the limit is 31 characters on VMS for
|
||||
VAX. */
|
||||
/* Note that this affects util/libeay.num and util/ssleay.num... you may
|
||||
change those manually, but that's not recommended, as those files are
|
||||
controlled centrally and updated on Unix, and the central definition
|
||||
may disagree with yours, which in turn may come with shareable library
|
||||
incompatibilities. */
|
||||
#ifdef OPENSSL_SYS_VMS
|
||||
|
||||
/* Hack a long name in crypto/ex_data.c */
|
||||
#undef CRYPTO_get_ex_data_implementation
|
||||
#define CRYPTO_get_ex_data_implementation CRYPTO_get_ex_data_impl
|
||||
#undef CRYPTO_set_ex_data_implementation
|
||||
#define CRYPTO_set_ex_data_implementation CRYPTO_set_ex_data_impl
|
||||
|
||||
/* Hack a long name in crypto/asn1/a_mbstr.c */
|
||||
#undef ASN1_STRING_set_default_mask_asc
|
||||
#define ASN1_STRING_set_default_mask_asc ASN1_STRING_set_def_mask_asc
|
||||
|
||||
#if 0 /* No longer needed, since safestack macro magic does the job */
|
||||
/* Hack the names created with DECLARE_ASN1_SET_OF(PKCS7_SIGNER_INFO) */
|
||||
#undef i2d_ASN1_SET_OF_PKCS7_SIGNER_INFO
|
||||
#define i2d_ASN1_SET_OF_PKCS7_SIGNER_INFO i2d_ASN1_SET_OF_PKCS7_SIGINF
|
||||
#undef d2i_ASN1_SET_OF_PKCS7_SIGNER_INFO
|
||||
#define d2i_ASN1_SET_OF_PKCS7_SIGNER_INFO d2i_ASN1_SET_OF_PKCS7_SIGINF
|
||||
#endif
|
||||
|
||||
#if 0 /* No longer needed, since safestack macro magic does the job */
|
||||
/* Hack the names created with DECLARE_ASN1_SET_OF(PKCS7_RECIP_INFO) */
|
||||
#undef i2d_ASN1_SET_OF_PKCS7_RECIP_INFO
|
||||
#define i2d_ASN1_SET_OF_PKCS7_RECIP_INFO i2d_ASN1_SET_OF_PKCS7_RECINF
|
||||
#undef d2i_ASN1_SET_OF_PKCS7_RECIP_INFO
|
||||
#define d2i_ASN1_SET_OF_PKCS7_RECIP_INFO d2i_ASN1_SET_OF_PKCS7_RECINF
|
||||
#endif
|
||||
|
||||
#if 0 /* No longer needed, since safestack macro magic does the job */
|
||||
/* Hack the names created with DECLARE_ASN1_SET_OF(ACCESS_DESCRIPTION) */
|
||||
#undef i2d_ASN1_SET_OF_ACCESS_DESCRIPTION
|
||||
#define i2d_ASN1_SET_OF_ACCESS_DESCRIPTION i2d_ASN1_SET_OF_ACC_DESC
|
||||
#undef d2i_ASN1_SET_OF_ACCESS_DESCRIPTION
|
||||
#define d2i_ASN1_SET_OF_ACCESS_DESCRIPTION d2i_ASN1_SET_OF_ACC_DESC
|
||||
#endif
|
||||
|
||||
/* Hack the names created with DECLARE_PEM_rw(NETSCAPE_CERT_SEQUENCE) */
|
||||
#undef PEM_read_NETSCAPE_CERT_SEQUENCE
|
||||
#define PEM_read_NETSCAPE_CERT_SEQUENCE PEM_read_NS_CERT_SEQ
|
||||
#undef PEM_write_NETSCAPE_CERT_SEQUENCE
|
||||
#define PEM_write_NETSCAPE_CERT_SEQUENCE PEM_write_NS_CERT_SEQ
|
||||
#undef PEM_read_bio_NETSCAPE_CERT_SEQUENCE
|
||||
#define PEM_read_bio_NETSCAPE_CERT_SEQUENCE PEM_read_bio_NS_CERT_SEQ
|
||||
#undef PEM_write_bio_NETSCAPE_CERT_SEQUENCE
|
||||
#define PEM_write_bio_NETSCAPE_CERT_SEQUENCE PEM_write_bio_NS_CERT_SEQ
|
||||
#undef PEM_write_cb_bio_NETSCAPE_CERT_SEQUENCE
|
||||
#define PEM_write_cb_bio_NETSCAPE_CERT_SEQUENCE PEM_write_cb_bio_NS_CERT_SEQ
|
||||
|
||||
/* Hack the names created with DECLARE_PEM_rw(PKCS8_PRIV_KEY_INFO) */
|
||||
#undef PEM_read_PKCS8_PRIV_KEY_INFO
|
||||
#define PEM_read_PKCS8_PRIV_KEY_INFO PEM_read_P8_PRIV_KEY_INFO
|
||||
#undef PEM_write_PKCS8_PRIV_KEY_INFO
|
||||
#define PEM_write_PKCS8_PRIV_KEY_INFO PEM_write_P8_PRIV_KEY_INFO
|
||||
#undef PEM_read_bio_PKCS8_PRIV_KEY_INFO
|
||||
#define PEM_read_bio_PKCS8_PRIV_KEY_INFO PEM_read_bio_P8_PRIV_KEY_INFO
|
||||
#undef PEM_write_bio_PKCS8_PRIV_KEY_INFO
|
||||
#define PEM_write_bio_PKCS8_PRIV_KEY_INFO PEM_write_bio_P8_PRIV_KEY_INFO
|
||||
#undef PEM_write_cb_bio_PKCS8_PRIV_KEY_INFO
|
||||
#define PEM_write_cb_bio_PKCS8_PRIV_KEY_INFO PEM_wrt_cb_bio_P8_PRIV_KEY_INFO
|
||||
|
||||
/* Hack other PEM names */
|
||||
#undef PEM_write_bio_PKCS8PrivateKey_nid
|
||||
#define PEM_write_bio_PKCS8PrivateKey_nid PEM_write_bio_PKCS8PrivKey_nid
|
||||
|
||||
/* Hack some long X509 names */
|
||||
#undef X509_REVOKED_get_ext_by_critical
|
||||
#define X509_REVOKED_get_ext_by_critical X509_REVOKED_get_ext_by_critic
|
||||
#undef X509_policy_tree_get0_user_policies
|
||||
#define X509_policy_tree_get0_user_policies X509_pcy_tree_get0_usr_policies
|
||||
#undef X509_policy_node_get0_qualifiers
|
||||
#define X509_policy_node_get0_qualifiers X509_pcy_node_get0_qualifiers
|
||||
#undef X509_STORE_CTX_get_explicit_policy
|
||||
#define X509_STORE_CTX_get_explicit_policy X509_STORE_CTX_get_expl_policy
|
||||
#undef X509_STORE_CTX_get0_current_issuer
|
||||
#define X509_STORE_CTX_get0_current_issuer X509_STORE_CTX_get0_cur_issuer
|
||||
|
||||
/* Hack some long CRYPTO names */
|
||||
#undef CRYPTO_set_dynlock_destroy_callback
|
||||
#define CRYPTO_set_dynlock_destroy_callback CRYPTO_set_dynlock_destroy_cb
|
||||
#undef CRYPTO_set_dynlock_create_callback
|
||||
#define CRYPTO_set_dynlock_create_callback CRYPTO_set_dynlock_create_cb
|
||||
#undef CRYPTO_set_dynlock_lock_callback
|
||||
#define CRYPTO_set_dynlock_lock_callback CRYPTO_set_dynlock_lock_cb
|
||||
#undef CRYPTO_get_dynlock_lock_callback
|
||||
#define CRYPTO_get_dynlock_lock_callback CRYPTO_get_dynlock_lock_cb
|
||||
#undef CRYPTO_get_dynlock_destroy_callback
|
||||
#define CRYPTO_get_dynlock_destroy_callback CRYPTO_get_dynlock_destroy_cb
|
||||
#undef CRYPTO_get_dynlock_create_callback
|
||||
#define CRYPTO_get_dynlock_create_callback CRYPTO_get_dynlock_create_cb
|
||||
#undef CRYPTO_set_locked_mem_ex_functions
|
||||
#define CRYPTO_set_locked_mem_ex_functions CRYPTO_set_locked_mem_ex_funcs
|
||||
#undef CRYPTO_get_locked_mem_ex_functions
|
||||
#define CRYPTO_get_locked_mem_ex_functions CRYPTO_get_locked_mem_ex_funcs
|
||||
|
||||
/* Hack some long SSL names */
|
||||
#undef SSL_CTX_set_default_verify_paths
|
||||
#define SSL_CTX_set_default_verify_paths SSL_CTX_set_def_verify_paths
|
||||
#undef SSL_get_ex_data_X509_STORE_CTX_idx
|
||||
#define SSL_get_ex_data_X509_STORE_CTX_idx SSL_get_ex_d_X509_STORE_CTX_idx
|
||||
#undef SSL_add_file_cert_subjects_to_stack
|
||||
#define SSL_add_file_cert_subjects_to_stack SSL_add_file_cert_subjs_to_stk
|
||||
#undef SSL_add_dir_cert_subjects_to_stack
|
||||
#define SSL_add_dir_cert_subjects_to_stack SSL_add_dir_cert_subjs_to_stk
|
||||
#undef SSL_CTX_use_certificate_chain_file
|
||||
#define SSL_CTX_use_certificate_chain_file SSL_CTX_use_cert_chain_file
|
||||
#undef SSL_CTX_set_cert_verify_callback
|
||||
#define SSL_CTX_set_cert_verify_callback SSL_CTX_set_cert_verify_cb
|
||||
#undef SSL_CTX_set_default_passwd_cb_userdata
|
||||
#define SSL_CTX_set_default_passwd_cb_userdata SSL_CTX_set_def_passwd_cb_ud
|
||||
#undef SSL_COMP_get_compression_methods
|
||||
#define SSL_COMP_get_compression_methods SSL_COMP_get_compress_methods
|
||||
#undef ssl_add_clienthello_renegotiate_ext
|
||||
#define ssl_add_clienthello_renegotiate_ext ssl_add_clienthello_reneg_ext
|
||||
#undef ssl_add_serverhello_renegotiate_ext
|
||||
#define ssl_add_serverhello_renegotiate_ext ssl_add_serverhello_reneg_ext
|
||||
#undef ssl_parse_clienthello_renegotiate_ext
|
||||
#define ssl_parse_clienthello_renegotiate_ext ssl_parse_clienthello_reneg_ext
|
||||
#undef ssl_parse_serverhello_renegotiate_ext
|
||||
#define ssl_parse_serverhello_renegotiate_ext ssl_parse_serverhello_reneg_ext
|
||||
#undef SSL_srp_server_param_with_username
|
||||
#define SSL_srp_server_param_with_username SSL_srp_server_param_with_un
|
||||
#undef SSL_CTX_set_srp_client_pwd_callback
|
||||
#define SSL_CTX_set_srp_client_pwd_callback SSL_CTX_set_srp_client_pwd_cb
|
||||
#undef SSL_CTX_set_srp_verify_param_callback
|
||||
#define SSL_CTX_set_srp_verify_param_callback SSL_CTX_set_srp_vfy_param_cb
|
||||
#undef SSL_CTX_set_srp_username_callback
|
||||
#define SSL_CTX_set_srp_username_callback SSL_CTX_set_srp_un_cb
|
||||
#undef ssl_add_clienthello_use_srtp_ext
|
||||
#define ssl_add_clienthello_use_srtp_ext ssl_add_clihello_use_srtp_ext
|
||||
#undef ssl_add_serverhello_use_srtp_ext
|
||||
#define ssl_add_serverhello_use_srtp_ext ssl_add_serhello_use_srtp_ext
|
||||
#undef ssl_parse_clienthello_use_srtp_ext
|
||||
#define ssl_parse_clienthello_use_srtp_ext ssl_parse_clihello_use_srtp_ext
|
||||
#undef ssl_parse_serverhello_use_srtp_ext
|
||||
#define ssl_parse_serverhello_use_srtp_ext ssl_parse_serhello_use_srtp_ext
|
||||
#undef SSL_CTX_set_next_protos_advertised_cb
|
||||
#define SSL_CTX_set_next_protos_advertised_cb SSL_CTX_set_next_protos_adv_cb
|
||||
#undef SSL_CTX_set_next_proto_select_cb
|
||||
#define SSL_CTX_set_next_proto_select_cb SSL_CTX_set_next_proto_sel_cb
|
||||
#undef ssl3_cbc_record_digest_supported
|
||||
#define ssl3_cbc_record_digest_supported ssl3_cbc_record_digest_support
|
||||
#undef ssl_check_clienthello_tlsext_late
|
||||
#define ssl_check_clienthello_tlsext_late ssl_check_clihello_tlsext_late
|
||||
#undef ssl_check_clienthello_tlsext_early
|
||||
#define ssl_check_clienthello_tlsext_early ssl_check_clihello_tlsext_early
|
||||
|
||||
/* Hack some long ENGINE names */
|
||||
#undef ENGINE_get_default_BN_mod_exp_crt
|
||||
#define ENGINE_get_default_BN_mod_exp_crt ENGINE_get_def_BN_mod_exp_crt
|
||||
#undef ENGINE_set_default_BN_mod_exp_crt
|
||||
#define ENGINE_set_default_BN_mod_exp_crt ENGINE_set_def_BN_mod_exp_crt
|
||||
#undef ENGINE_set_load_privkey_function
|
||||
#define ENGINE_set_load_privkey_function ENGINE_set_load_privkey_fn
|
||||
#undef ENGINE_get_load_privkey_function
|
||||
#define ENGINE_get_load_privkey_function ENGINE_get_load_privkey_fn
|
||||
#undef ENGINE_unregister_pkey_asn1_meths
|
||||
#define ENGINE_unregister_pkey_asn1_meths ENGINE_unreg_pkey_asn1_meths
|
||||
#undef ENGINE_register_all_pkey_asn1_meths
|
||||
#define ENGINE_register_all_pkey_asn1_meths ENGINE_reg_all_pkey_asn1_meths
|
||||
#undef ENGINE_set_default_pkey_asn1_meths
|
||||
#define ENGINE_set_default_pkey_asn1_meths ENGINE_set_def_pkey_asn1_meths
|
||||
#undef ENGINE_get_pkey_asn1_meth_engine
|
||||
#define ENGINE_get_pkey_asn1_meth_engine ENGINE_get_pkey_asn1_meth_eng
|
||||
#undef ENGINE_set_load_ssl_client_cert_function
|
||||
#define ENGINE_set_load_ssl_client_cert_function \
|
||||
ENGINE_set_ld_ssl_clnt_cert_fn
|
||||
#undef ENGINE_get_ssl_client_cert_function
|
||||
#define ENGINE_get_ssl_client_cert_function ENGINE_get_ssl_client_cert_fn
|
||||
|
||||
/* Hack some long OCSP names */
|
||||
#undef OCSP_REQUEST_get_ext_by_critical
|
||||
#define OCSP_REQUEST_get_ext_by_critical OCSP_REQUEST_get_ext_by_crit
|
||||
#undef OCSP_BASICRESP_get_ext_by_critical
|
||||
#define OCSP_BASICRESP_get_ext_by_critical OCSP_BASICRESP_get_ext_by_crit
|
||||
#undef OCSP_SINGLERESP_get_ext_by_critical
|
||||
#define OCSP_SINGLERESP_get_ext_by_critical OCSP_SINGLERESP_get_ext_by_crit
|
||||
|
||||
/* Hack some long DES names */
|
||||
#undef _ossl_old_des_ede3_cfb64_encrypt
|
||||
#define _ossl_old_des_ede3_cfb64_encrypt _ossl_odes_ede3_cfb64_encrypt
|
||||
#undef _ossl_old_des_ede3_ofb64_encrypt
|
||||
#define _ossl_old_des_ede3_ofb64_encrypt _ossl_odes_ede3_ofb64_encrypt
|
||||
|
||||
/* Hack some long EVP names */
|
||||
#undef OPENSSL_add_all_algorithms_noconf
|
||||
#define OPENSSL_add_all_algorithms_noconf OPENSSL_add_all_algo_noconf
|
||||
#undef OPENSSL_add_all_algorithms_conf
|
||||
#define OPENSSL_add_all_algorithms_conf OPENSSL_add_all_algo_conf
|
||||
#undef EVP_PKEY_meth_set_verify_recover
|
||||
#define EVP_PKEY_meth_set_verify_recover EVP_PKEY_meth_set_vrfy_recover
|
||||
|
||||
/* Hack some long EC names */
|
||||
#undef EC_GROUP_set_point_conversion_form
|
||||
#define EC_GROUP_set_point_conversion_form EC_GROUP_set_point_conv_form
|
||||
#undef EC_GROUP_get_point_conversion_form
|
||||
#define EC_GROUP_get_point_conversion_form EC_GROUP_get_point_conv_form
|
||||
#undef EC_GROUP_clear_free_all_extra_data
|
||||
#define EC_GROUP_clear_free_all_extra_data EC_GROUP_clr_free_all_xtra_data
|
||||
#undef EC_KEY_set_public_key_affine_coordinates
|
||||
#define EC_KEY_set_public_key_affine_coordinates \
|
||||
EC_KEY_set_pub_key_aff_coords
|
||||
#undef EC_POINT_set_Jprojective_coordinates_GFp
|
||||
#define EC_POINT_set_Jprojective_coordinates_GFp \
|
||||
EC_POINT_set_Jproj_coords_GFp
|
||||
#undef EC_POINT_get_Jprojective_coordinates_GFp
|
||||
#define EC_POINT_get_Jprojective_coordinates_GFp \
|
||||
EC_POINT_get_Jproj_coords_GFp
|
||||
#undef EC_POINT_set_affine_coordinates_GFp
|
||||
#define EC_POINT_set_affine_coordinates_GFp EC_POINT_set_affine_coords_GFp
|
||||
#undef EC_POINT_get_affine_coordinates_GFp
|
||||
#define EC_POINT_get_affine_coordinates_GFp EC_POINT_get_affine_coords_GFp
|
||||
#undef EC_POINT_set_compressed_coordinates_GFp
|
||||
#define EC_POINT_set_compressed_coordinates_GFp EC_POINT_set_compr_coords_GFp
|
||||
#undef EC_POINT_set_affine_coordinates_GF2m
|
||||
#define EC_POINT_set_affine_coordinates_GF2m EC_POINT_set_affine_coords_GF2m
|
||||
#undef EC_POINT_get_affine_coordinates_GF2m
|
||||
#define EC_POINT_get_affine_coordinates_GF2m EC_POINT_get_affine_coords_GF2m
|
||||
#undef EC_POINT_set_compressed_coordinates_GF2m
|
||||
#define EC_POINT_set_compressed_coordinates_GF2m \
|
||||
EC_POINT_set_compr_coords_GF2m
|
||||
#undef ec_GF2m_simple_group_clear_finish
|
||||
#define ec_GF2m_simple_group_clear_finish ec_GF2m_simple_grp_clr_finish
|
||||
#undef ec_GF2m_simple_group_check_discriminant
|
||||
#define ec_GF2m_simple_group_check_discriminant ec_GF2m_simple_grp_chk_discrim
|
||||
#undef ec_GF2m_simple_point_clear_finish
|
||||
#define ec_GF2m_simple_point_clear_finish ec_GF2m_simple_pt_clr_finish
|
||||
#undef ec_GF2m_simple_point_set_to_infinity
|
||||
#define ec_GF2m_simple_point_set_to_infinity ec_GF2m_simple_pt_set_to_inf
|
||||
#undef ec_GF2m_simple_points_make_affine
|
||||
#define ec_GF2m_simple_points_make_affine ec_GF2m_simple_pts_make_affine
|
||||
#undef ec_GF2m_simple_point_set_affine_coordinates
|
||||
#define ec_GF2m_simple_point_set_affine_coordinates \
|
||||
ec_GF2m_smp_pt_set_af_coords
|
||||
#undef ec_GF2m_simple_point_get_affine_coordinates
|
||||
#define ec_GF2m_simple_point_get_affine_coordinates \
|
||||
ec_GF2m_smp_pt_get_af_coords
|
||||
#undef ec_GF2m_simple_set_compressed_coordinates
|
||||
#define ec_GF2m_simple_set_compressed_coordinates \
|
||||
ec_GF2m_smp_set_compr_coords
|
||||
#undef ec_GFp_simple_group_set_curve_GFp
|
||||
#define ec_GFp_simple_group_set_curve_GFp ec_GFp_simple_grp_set_curve_GFp
|
||||
#undef ec_GFp_simple_group_get_curve_GFp
|
||||
#define ec_GFp_simple_group_get_curve_GFp ec_GFp_simple_grp_get_curve_GFp
|
||||
#undef ec_GFp_simple_group_clear_finish
|
||||
#define ec_GFp_simple_group_clear_finish ec_GFp_simple_grp_clear_finish
|
||||
#undef ec_GFp_simple_group_set_generator
|
||||
#define ec_GFp_simple_group_set_generator ec_GFp_simple_grp_set_generator
|
||||
#undef ec_GFp_simple_group_get0_generator
|
||||
#define ec_GFp_simple_group_get0_generator ec_GFp_simple_grp_gt0_generator
|
||||
#undef ec_GFp_simple_group_get_cofactor
|
||||
#define ec_GFp_simple_group_get_cofactor ec_GFp_simple_grp_get_cofactor
|
||||
#undef ec_GFp_simple_point_clear_finish
|
||||
#define ec_GFp_simple_point_clear_finish ec_GFp_simple_pt_clear_finish
|
||||
#undef ec_GFp_simple_point_set_to_infinity
|
||||
#define ec_GFp_simple_point_set_to_infinity ec_GFp_simple_pt_set_to_inf
|
||||
#undef ec_GFp_simple_points_make_affine
|
||||
#define ec_GFp_simple_points_make_affine ec_GFp_simple_pts_make_affine
|
||||
#undef ec_GFp_simple_set_Jprojective_coordinates_GFp
|
||||
#define ec_GFp_simple_set_Jprojective_coordinates_GFp \
|
||||
ec_GFp_smp_set_Jproj_coords_GFp
|
||||
#undef ec_GFp_simple_get_Jprojective_coordinates_GFp
|
||||
#define ec_GFp_simple_get_Jprojective_coordinates_GFp \
|
||||
ec_GFp_smp_get_Jproj_coords_GFp
|
||||
#undef ec_GFp_simple_point_set_affine_coordinates_GFp
|
||||
#define ec_GFp_simple_point_set_affine_coordinates_GFp \
|
||||
ec_GFp_smp_pt_set_af_coords_GFp
|
||||
#undef ec_GFp_simple_point_get_affine_coordinates_GFp
|
||||
#define ec_GFp_simple_point_get_affine_coordinates_GFp \
|
||||
ec_GFp_smp_pt_get_af_coords_GFp
|
||||
#undef ec_GFp_simple_set_compressed_coordinates_GFp
|
||||
#define ec_GFp_simple_set_compressed_coordinates_GFp \
|
||||
ec_GFp_smp_set_compr_coords_GFp
|
||||
#undef ec_GFp_simple_point_set_affine_coordinates
|
||||
#define ec_GFp_simple_point_set_affine_coordinates \
|
||||
ec_GFp_smp_pt_set_af_coords
|
||||
#undef ec_GFp_simple_point_get_affine_coordinates
|
||||
#define ec_GFp_simple_point_get_affine_coordinates \
|
||||
ec_GFp_smp_pt_get_af_coords
|
||||
#undef ec_GFp_simple_set_compressed_coordinates
|
||||
#define ec_GFp_simple_set_compressed_coordinates \
|
||||
ec_GFp_smp_set_compr_coords
|
||||
#undef ec_GFp_simple_group_check_discriminant
|
||||
#define ec_GFp_simple_group_check_discriminant ec_GFp_simple_grp_chk_discrim
|
||||
|
||||
/* Hack som long STORE names */
|
||||
#undef STORE_method_set_initialise_function
|
||||
#define STORE_method_set_initialise_function STORE_meth_set_initialise_fn
|
||||
#undef STORE_method_set_cleanup_function
|
||||
#define STORE_method_set_cleanup_function STORE_meth_set_cleanup_fn
|
||||
#undef STORE_method_set_generate_function
|
||||
#define STORE_method_set_generate_function STORE_meth_set_generate_fn
|
||||
#undef STORE_method_set_modify_function
|
||||
#define STORE_method_set_modify_function STORE_meth_set_modify_fn
|
||||
#undef STORE_method_set_revoke_function
|
||||
#define STORE_method_set_revoke_function STORE_meth_set_revoke_fn
|
||||
#undef STORE_method_set_delete_function
|
||||
#define STORE_method_set_delete_function STORE_meth_set_delete_fn
|
||||
#undef STORE_method_set_list_start_function
|
||||
#define STORE_method_set_list_start_function STORE_meth_set_list_start_fn
|
||||
#undef STORE_method_set_list_next_function
|
||||
#define STORE_method_set_list_next_function STORE_meth_set_list_next_fn
|
||||
#undef STORE_method_set_list_end_function
|
||||
#define STORE_method_set_list_end_function STORE_meth_set_list_end_fn
|
||||
#undef STORE_method_set_update_store_function
|
||||
#define STORE_method_set_update_store_function STORE_meth_set_update_store_fn
|
||||
#undef STORE_method_set_lock_store_function
|
||||
#define STORE_method_set_lock_store_function STORE_meth_set_lock_store_fn
|
||||
#undef STORE_method_set_unlock_store_function
|
||||
#define STORE_method_set_unlock_store_function STORE_meth_set_unlock_store_fn
|
||||
#undef STORE_method_get_initialise_function
|
||||
#define STORE_method_get_initialise_function STORE_meth_get_initialise_fn
|
||||
#undef STORE_method_get_cleanup_function
|
||||
#define STORE_method_get_cleanup_function STORE_meth_get_cleanup_fn
|
||||
#undef STORE_method_get_generate_function
|
||||
#define STORE_method_get_generate_function STORE_meth_get_generate_fn
|
||||
#undef STORE_method_get_modify_function
|
||||
#define STORE_method_get_modify_function STORE_meth_get_modify_fn
|
||||
#undef STORE_method_get_revoke_function
|
||||
#define STORE_method_get_revoke_function STORE_meth_get_revoke_fn
|
||||
#undef STORE_method_get_delete_function
|
||||
#define STORE_method_get_delete_function STORE_meth_get_delete_fn
|
||||
#undef STORE_method_get_list_start_function
|
||||
#define STORE_method_get_list_start_function STORE_meth_get_list_start_fn
|
||||
#undef STORE_method_get_list_next_function
|
||||
#define STORE_method_get_list_next_function STORE_meth_get_list_next_fn
|
||||
#undef STORE_method_get_list_end_function
|
||||
#define STORE_method_get_list_end_function STORE_meth_get_list_end_fn
|
||||
#undef STORE_method_get_update_store_function
|
||||
#define STORE_method_get_update_store_function STORE_meth_get_update_store_fn
|
||||
#undef STORE_method_get_lock_store_function
|
||||
#define STORE_method_get_lock_store_function STORE_meth_get_lock_store_fn
|
||||
#undef STORE_method_get_unlock_store_function
|
||||
#define STORE_method_get_unlock_store_function STORE_meth_get_unlock_store_fn
|
||||
|
||||
/* Hack some long TS names */
|
||||
#undef TS_RESP_CTX_set_status_info_cond
|
||||
#define TS_RESP_CTX_set_status_info_cond TS_RESP_CTX_set_stat_info_cond
|
||||
#undef TS_RESP_CTX_set_clock_precision_digits
|
||||
#define TS_RESP_CTX_set_clock_precision_digits TS_RESP_CTX_set_clk_prec_digits
|
||||
#undef TS_CONF_set_clock_precision_digits
|
||||
#define TS_CONF_set_clock_precision_digits TS_CONF_set_clk_prec_digits
|
||||
|
||||
/* Hack some long CMS names */
|
||||
#undef CMS_RecipientInfo_ktri_get0_algs
|
||||
#define CMS_RecipientInfo_ktri_get0_algs CMS_RecipInfo_ktri_get0_algs
|
||||
#undef CMS_RecipientInfo_ktri_get0_signer_id
|
||||
#define CMS_RecipientInfo_ktri_get0_signer_id CMS_RecipInfo_ktri_get0_sigr_id
|
||||
#undef CMS_OtherRevocationInfoFormat_it
|
||||
#define CMS_OtherRevocationInfoFormat_it CMS_OtherRevocInfoFormat_it
|
||||
#undef CMS_KeyAgreeRecipientIdentifier_it
|
||||
#define CMS_KeyAgreeRecipientIdentifier_it CMS_KeyAgreeRecipIdentifier_it
|
||||
#undef CMS_OriginatorIdentifierOrKey_it
|
||||
#define CMS_OriginatorIdentifierOrKey_it CMS_OriginatorIdOrKey_it
|
||||
#undef cms_SignerIdentifier_get0_signer_id
|
||||
#define cms_SignerIdentifier_get0_signer_id cms_SignerId_get0_signer_id
|
||||
|
||||
/* Hack some long DTLS1 names */
|
||||
#undef dtls1_retransmit_buffered_messages
|
||||
#define dtls1_retransmit_buffered_messages dtls1_retransmit_buffered_msgs
|
||||
|
||||
/* Hack some long SRP names */
|
||||
#undef SRP_generate_server_master_secret
|
||||
#define SRP_generate_server_master_secret SRP_gen_server_master_secret
|
||||
#undef SRP_generate_client_master_secret
|
||||
#define SRP_generate_client_master_secret SRP_gen_client_master_secret
|
||||
|
||||
/* Hack some long UI names */
|
||||
#undef UI_method_get_prompt_constructor
|
||||
#define UI_method_get_prompt_constructor UI_method_get_prompt_constructr
|
||||
#undef UI_method_set_prompt_constructor
|
||||
#define UI_method_set_prompt_constructor UI_method_set_prompt_constructr
|
||||
|
||||
#endif /* defined OPENSSL_SYS_VMS */
|
||||
|
||||
|
||||
/* Case insensitive linking causes problems.... */
|
||||
#if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_OS2)
|
||||
#undef ERR_load_CRYPTO_strings
|
||||
#define ERR_load_CRYPTO_strings ERR_load_CRYPTOlib_strings
|
||||
#undef OCSP_crlID_new
|
||||
#define OCSP_crlID_new OCSP_crlID2_new
|
||||
|
||||
#undef d2i_ECPARAMETERS
|
||||
#define d2i_ECPARAMETERS d2i_UC_ECPARAMETERS
|
||||
#undef i2d_ECPARAMETERS
|
||||
#define i2d_ECPARAMETERS i2d_UC_ECPARAMETERS
|
||||
#undef d2i_ECPKPARAMETERS
|
||||
#define d2i_ECPKPARAMETERS d2i_UC_ECPKPARAMETERS
|
||||
#undef i2d_ECPKPARAMETERS
|
||||
#define i2d_ECPKPARAMETERS i2d_UC_ECPKPARAMETERS
|
||||
|
||||
/* These functions do not seem to exist! However, I'm paranoid...
|
||||
Original command in x509v3.h:
|
||||
These functions are being redefined in another directory,
|
||||
and clash when the linker is case-insensitive, so let's
|
||||
hide them a little, by giving them an extra 'o' at the
|
||||
beginning of the name... */
|
||||
#undef X509v3_cleanup_extensions
|
||||
#define X509v3_cleanup_extensions oX509v3_cleanup_extensions
|
||||
#undef X509v3_add_extension
|
||||
#define X509v3_add_extension oX509v3_add_extension
|
||||
#undef X509v3_add_netscape_extensions
|
||||
#define X509v3_add_netscape_extensions oX509v3_add_netscape_extensions
|
||||
#undef X509v3_add_standard_extensions
|
||||
#define X509v3_add_standard_extensions oX509v3_add_standard_extensions
|
||||
|
||||
/* This one clashes with CMS_data_create */
|
||||
#undef cms_Data_create
|
||||
#define cms_Data_create priv_cms_Data_create
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#endif /* ! defined HEADER_VMS_IDHACKS_H */
|
||||
+31
-28
@@ -54,39 +54,42 @@ static const char rcsid[]="$Id: getopt_long.c,v 1.1 2009/10/16 19:50:28 rodney E
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#if 0
|
||||
#include <err.h>
|
||||
#endif
|
||||
#include <errno.h>
|
||||
#include <getopt.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#ifdef _WIN32
|
||||
|
||||
/* Windows needs warnx(). We change the definition though:
|
||||
* 1. (another) global is defined, opterrmsg, which holds the error message
|
||||
* 2. errors are always printed out on stderr w/o the program name
|
||||
* Note that opterrmsg always gets set no matter what opterr is set to. The
|
||||
* error message will not be printed if opterr is 0 as usual.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
char opterrmsg[128]; /* last error message is stored here */
|
||||
|
||||
static void warnx(const char *fmt, ...)
|
||||
{
|
||||
va_list ap;
|
||||
va_start(ap, fmt);
|
||||
if (fmt != NULL)
|
||||
_vsnprintf(opterrmsg, 128, fmt, ap);
|
||||
else
|
||||
opterrmsg[0]='\0';
|
||||
va_end(ap);
|
||||
fprintf(stderr, opterrmsg);
|
||||
fprintf(stderr, "\n");
|
||||
}
|
||||
|
||||
#ifdef _WIN32
|
||||
|
||||
/* Windows needs warnx(). We change the definition though:
|
||||
* 1. (another) global is defined, opterrmsg, which holds the error message
|
||||
* 2. errors are always printed out on stderr w/o the program name
|
||||
* Note that opterrmsg always gets set no matter what opterr is set to. The
|
||||
* error message will not be printed if opterr is 0 as usual.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
char opterrmsg[128]; /* last error message is stored here */
|
||||
|
||||
static void warnx(const char *fmt, ...)
|
||||
{
|
||||
va_list ap;
|
||||
va_start(ap, fmt);
|
||||
if (fmt != NULL)
|
||||
_vsnprintf(opterrmsg, 128, fmt, ap);
|
||||
else
|
||||
opterrmsg[0]='\0';
|
||||
va_end(ap);
|
||||
fprintf(stderr, opterrmsg);
|
||||
fprintf(stderr, "\n");
|
||||
}
|
||||
|
||||
#endif /*_WIN32*/
|
||||
|
||||
#define REPLACE_GETOPT /* use this getopt as the system getopt(3) */
|
||||
|
||||
+1
-8
@@ -1,4 +1,4 @@
|
||||
AC_INIT([ccminer], [1.6.6-dev])
|
||||
AC_INIT([ccminer], [1.6.4])
|
||||
|
||||
AC_PREREQ([2.59c])
|
||||
AC_CANONICAL_SYSTEM
|
||||
@@ -72,16 +72,9 @@ AC_CHECK_LIB([pthread], [pthread_create], PTHREAD_LIBS="-lpthread",
|
||||
AC_CHECK_LIB([pthreadGC], [pthread_create], PTHREAD_LIBS="-lpthreadGC"
|
||||
))))
|
||||
|
||||
AC_CHECK_LIB([z],[gzopen], [], [])
|
||||
AC_CHECK_LIB([ssl],[SSL_library_init], [], [AC_MSG_ERROR([OpenSSL library required])])
|
||||
AC_CHECK_LIB([crypto],[EVP_DigestFinal_ex], [], [AC_MSG_ERROR([OpenSSL library required])])
|
||||
|
||||
# libpci-dev (to get vendor name)
|
||||
PCILIB=""; PCIFLAGS=""
|
||||
AC_CHECK_LIB([pci],[pci_alloc], PCILIB="-lpci"; PCIFLAGS="-DHAVE_PCIDEV", [])
|
||||
AC_SUBST(PCILIB)
|
||||
AC_SUBST(PCIFLAGS)
|
||||
|
||||
AM_CONDITIONAL([WANT_JANSSON], [test x$request_jansson = xtrue])
|
||||
AM_CONDITIONAL([HAVE_WINDOWS], [test x$have_win32 = xtrue])
|
||||
AM_CONDITIONAL([ARCH_x86], [test x$have_x86 = xtrue])
|
||||
|
||||
+3
-6
@@ -47,9 +47,6 @@
|
||||
/* Define to 1 if you have the `ssl' library (-lssl). */
|
||||
#define HAVE_LIBSSL 1
|
||||
|
||||
/* Define to 1 if you have the `z' library (-lz). */
|
||||
#define HAVE_LIBZ 1
|
||||
|
||||
/* Define to 1 if you have the <memory.h> header file. */
|
||||
#define HAVE_MEMORY_H 1
|
||||
|
||||
@@ -162,7 +159,7 @@
|
||||
#define PACKAGE_NAME "ccminer"
|
||||
|
||||
/* Define to the full name and version of this package. */
|
||||
#define PACKAGE_STRING "ccminer 1.6.6-dev"
|
||||
#define PACKAGE_STRING "ccminer 1.6.4"
|
||||
|
||||
/* Define to the one symbol short name of this package. */
|
||||
#define PACKAGE_TARNAME "ccminer"
|
||||
@@ -171,7 +168,7 @@
|
||||
#define PACKAGE_URL "http://github.com/tpruvot/ccminer"
|
||||
|
||||
/* Define to the version of this package. */
|
||||
#define PACKAGE_VERSION "1.6.6-dev"
|
||||
#define PACKAGE_VERSION "1.6.4"
|
||||
|
||||
/* If using the C implementation of alloca, define if you know the
|
||||
direction of stack growth for your system; otherwise it will be
|
||||
@@ -185,7 +182,7 @@
|
||||
#define STDC_HEADERS 1
|
||||
|
||||
/* Version number of package */
|
||||
#define VERSION "1.6.6-dev"
|
||||
#define VERSION "1.6.4"
|
||||
|
||||
/* Define curl_free() as free() if our version of curl lacks curl_free. */
|
||||
/* #undef curl_free */
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
#include <stdio.h>
|
||||
#include <memory.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <map>
|
||||
|
||||
#ifndef _WIN32
|
||||
@@ -19,7 +18,6 @@
|
||||
#endif
|
||||
|
||||
#include "miner.h"
|
||||
#include "nvml.h"
|
||||
|
||||
#include "cuda_runtime.h"
|
||||
|
||||
@@ -62,43 +60,25 @@ void cuda_devicenames()
|
||||
exit(1);
|
||||
}
|
||||
|
||||
GPU_N = min(MAX_GPUS, GPU_N);
|
||||
for (int i=0; i < GPU_N; i++)
|
||||
{
|
||||
char vendorname[32] = { 0 };
|
||||
cudaDeviceProp props;
|
||||
cudaGetDeviceProperties(&props, device_map[i]);
|
||||
|
||||
device_name[i] = strdup(props.name);
|
||||
device_sm[i] = (props.major * 100 + props.minor * 10);
|
||||
|
||||
if (device_name[i]) {
|
||||
free(device_name[i]);
|
||||
device_name[i] = NULL;
|
||||
}
|
||||
#ifdef USE_WRAPNVML
|
||||
if (gpu_vendor((uint8_t)props.pciBusID, vendorname) > 0 && strlen(vendorname)) {
|
||||
device_name[i] = (char*) calloc(1, strlen(vendorname) + strlen(props.name) + 2);
|
||||
if (!strncmp(props.name, "GeForce ", 8))
|
||||
sprintf(device_name[i], "%s %s", vendorname, &props.name[8]);
|
||||
else
|
||||
sprintf(device_name[i], "%s %s", vendorname, props.name);
|
||||
} else
|
||||
#endif
|
||||
device_name[i] = strdup(props.name);
|
||||
}
|
||||
}
|
||||
|
||||
void cuda_print_devices()
|
||||
{
|
||||
int ngpus = cuda_num_devices();
|
||||
cuda_devicenames();
|
||||
for (int n=0; n < ngpus; n++) {
|
||||
int m = device_map[n];
|
||||
cudaDeviceProp props;
|
||||
cudaGetDeviceProperties(&props, m);
|
||||
if (!opt_n_threads || n < opt_n_threads) {
|
||||
fprintf(stderr, "GPU #%d: SM %d.%d %s\n", m, props.major, props.minor, device_name[n]);
|
||||
}
|
||||
if (!opt_n_threads || n < opt_n_threads)
|
||||
fprintf(stderr, "GPU #%d: SM %d.%d %s\n", m, props.major, props.minor, props.name);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -197,20 +177,13 @@ int cuda_gpu_clocks(struct cgpu_info *gpu)
|
||||
void cuda_reset_device(int thr_id, bool *init)
|
||||
{
|
||||
int dev_id = device_map[thr_id];
|
||||
cudaSetDevice(dev_id);
|
||||
if (init != NULL) {
|
||||
// with init array, its meant to be used in algo's scan code...
|
||||
for (int i=0; i < MAX_GPUS; i++) {
|
||||
if (device_map[i] == dev_id) {
|
||||
init[i] = false;
|
||||
}
|
||||
for (int i=0; i < MAX_GPUS; i++) {
|
||||
if (device_map[i] == dev_id) {
|
||||
init[i] = false;
|
||||
}
|
||||
// force exit from algo's scan loops/function
|
||||
restart_threads();
|
||||
cudaDeviceSynchronize();
|
||||
while (cudaStreamQuery(NULL) == cudaErrorNotReady)
|
||||
usleep(1000);
|
||||
}
|
||||
restart_threads();
|
||||
cudaDeviceSynchronize();
|
||||
cudaDeviceReset();
|
||||
}
|
||||
|
||||
|
||||
@@ -13,14 +13,12 @@ __constant__ uint32_t pTarget[8]; // 32 bytes
|
||||
// store MAX_GPUS device arrays of 8 nonces
|
||||
static uint32_t* h_resNonces[MAX_GPUS];
|
||||
static uint32_t* d_resNonces[MAX_GPUS];
|
||||
static bool init_done = false;
|
||||
|
||||
__host__
|
||||
void cuda_check_cpu_init(int thr_id, uint32_t threads)
|
||||
{
|
||||
CUDA_CALL_OR_RET(cudaMallocHost(&h_resNonces[thr_id], 32));
|
||||
CUDA_CALL_OR_RET(cudaMalloc(&d_resNonces[thr_id], 32));
|
||||
init_done = true;
|
||||
}
|
||||
|
||||
// Target Difficulty
|
||||
@@ -99,11 +97,6 @@ uint32_t cuda_check_hash(int thr_id, uint32_t threads, uint32_t startNounce, uin
|
||||
dim3 grid((threads + threadsperblock - 1) / threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
|
||||
if (!init_done) {
|
||||
applog(LOG_ERR, "missing call to cuda_check_cpu_init");
|
||||
return UINT32_MAX;
|
||||
}
|
||||
|
||||
cuda_checkhash_64 <<<grid, block>>> (threads, startNounce, d_inputHash, d_resNonces[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
@@ -137,11 +130,6 @@ uint32_t cuda_check_hash_suppl(int thr_id, uint32_t threads, uint32_t startNounc
|
||||
dim3 grid((threads + threadsperblock - 1) / threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
|
||||
if (!init_done) {
|
||||
applog(LOG_ERR, "missing call to cuda_check_cpu_init");
|
||||
return 0;
|
||||
}
|
||||
|
||||
// first element stores the count of found nonces
|
||||
cudaMemset(d_resNonces[thr_id], 0, sizeof(uint32_t));
|
||||
|
||||
@@ -192,12 +180,6 @@ uint32_t cuda_check_hash_branch(int thr_id, uint32_t threads, uint32_t startNoun
|
||||
const uint32_t threadsperblock = 256;
|
||||
|
||||
uint32_t result = UINT32_MAX;
|
||||
|
||||
if (!init_done) {
|
||||
applog(LOG_ERR, "missing call to cuda_check_cpu_init");
|
||||
return UINT32_MAX;
|
||||
}
|
||||
|
||||
cudaMemset(d_resNonces[thr_id], 0xff, sizeof(uint32_t));
|
||||
|
||||
dim3 grid((threads + threadsperblock-1)/threadsperblock);
|
||||
|
||||
+50
-35
@@ -148,13 +148,6 @@ __device__ __forceinline__ uint64_t cuda_swab64(uint64_t x)
|
||||
(((uint64_t)(x) & 0x00000000000000ffULL) << 56)))
|
||||
#endif
|
||||
|
||||
// swap two uint32_t without extra registers
|
||||
__device__ __host__ __forceinline__ void xchg(uint32_t &x, uint32_t &y) {
|
||||
x ^= y; y = x ^ y; x ^= y;
|
||||
}
|
||||
// for other types...
|
||||
#define XCHG(x, y) { x ^= y; y = x ^ y; x ^= y; }
|
||||
|
||||
/*********************************************************************/
|
||||
// Macros to catch CUDA errors in CUDA runtime calls
|
||||
|
||||
@@ -309,6 +302,7 @@ uint64_t shr_t64(uint64_t x, uint32_t n)
|
||||
#endif
|
||||
}
|
||||
|
||||
// device asm for ?
|
||||
__device__ __forceinline__
|
||||
uint64_t shl_t64(uint64_t x, uint32_t n)
|
||||
{
|
||||
@@ -323,6 +317,40 @@ uint64_t shl_t64(uint64_t x, uint32_t n)
|
||||
#endif
|
||||
}
|
||||
|
||||
// device asm 32 for pluck
|
||||
__device__ __forceinline__
|
||||
uint32_t andor32(uint32_t a, uint32_t b, uint32_t c) {
|
||||
#ifdef __CUDA_ARCH__
|
||||
uint32_t result;
|
||||
asm("{ .reg .u32 m,n,o;\n\t"
|
||||
"and.b32 m, %1, %2;\n\t"
|
||||
" or.b32 n, %1, %2;\n\t"
|
||||
"and.b32 o, n, %3;\n\t"
|
||||
" or.b32 %0, m, o ;\n\t"
|
||||
"}\n\t"
|
||||
: "=r"(result) : "r"(a), "r"(b), "r"(c));
|
||||
return result;
|
||||
#else
|
||||
// unused on host...
|
||||
return 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
uint32_t xor3b(uint32_t a, uint32_t b, uint32_t c) {
|
||||
#ifdef __CUDA_ARCH__
|
||||
uint32_t result;
|
||||
asm("{ .reg .u32 t1;\n\t"
|
||||
"xor.b32 t1, %2, %3;\n\t"
|
||||
"xor.b32 %0, %1, t1;\n\t"
|
||||
"}"
|
||||
: "=r"(result) : "r"(a) ,"r"(b),"r"(c));
|
||||
return result;
|
||||
#else
|
||||
return a^b^c;
|
||||
#endif
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
uint32_t shr_t32(uint32_t x,uint32_t n) {
|
||||
#ifdef __CUDA_ARCH__
|
||||
@@ -452,7 +480,7 @@ uint64_t SWAPDWORDS(uint64_t value)
|
||||
#endif
|
||||
}
|
||||
|
||||
/* lyra2/bmw - uint2 vector's operators */
|
||||
/* lyra2 - int2 operators */
|
||||
|
||||
__device__ __forceinline__
|
||||
void LOHI(uint32_t &lo, uint32_t &hi, uint64_t x) {
|
||||
@@ -460,41 +488,27 @@ void LOHI(uint32_t &lo, uint32_t &hi, uint64_t x) {
|
||||
asm("mov.b64 {%0,%1},%2; \n\t"
|
||||
: "=r"(lo), "=r"(hi) : "l"(x));
|
||||
#else
|
||||
lo = (uint32_t)(x);
|
||||
hi = (uint32_t)(x >> 32);
|
||||
lo = _LODWORD(x);
|
||||
hi = _HIDWORD(x);
|
||||
#endif
|
||||
}
|
||||
|
||||
static __host__ __device__ __forceinline__ uint2 vectorize(uint64_t v) {
|
||||
static __device__ __forceinline__ uint2 vectorize(uint64_t v) {
|
||||
uint2 result;
|
||||
#ifdef __CUDA_ARCH__
|
||||
asm("mov.b64 {%0,%1},%2; \n\t"
|
||||
: "=r"(result.x), "=r"(result.y) : "l"(v));
|
||||
#else
|
||||
result.x = (uint32_t)(v);
|
||||
result.y = (uint32_t)(v >> 32);
|
||||
#endif
|
||||
LOHI(result.x, result.y, v);
|
||||
return result;
|
||||
}
|
||||
|
||||
static __host__ __device__ __forceinline__ uint64_t devectorize(uint2 v) {
|
||||
#ifdef __CUDA_ARCH__
|
||||
return MAKE_ULONGLONG(v.x, v.y);
|
||||
#else
|
||||
return (((uint64_t)v.y) << 32) + v.x;
|
||||
#endif
|
||||
}
|
||||
static __device__ __forceinline__ uint64_t devectorize(uint2 v) { return MAKE_ULONGLONG(v.x, v.y); }
|
||||
|
||||
/**
|
||||
* uint2 direct ops by c++ operator definitions
|
||||
*/
|
||||
static __device__ __forceinline__ uint2 operator^ (uint2 a, uint2 b) { return make_uint2(a.x ^ b.x, a.y ^ b.y); }
|
||||
static __device__ __forceinline__ uint2 operator& (uint2 a, uint2 b) { return make_uint2(a.x & b.x, a.y & b.y); }
|
||||
static __device__ __forceinline__ uint2 operator| (uint2 a, uint2 b) { return make_uint2(a.x | b.x, a.y | b.y); }
|
||||
static __device__ __forceinline__ uint2 operator~ (uint2 a) { return make_uint2(~a.x, ~a.y); }
|
||||
static __device__ __forceinline__ void operator^= (uint2 &a, uint2 b) { a = a ^ b; }
|
||||
|
||||
static __device__ __forceinline__ uint2 operator+ (uint2 a, uint2 b) {
|
||||
static __device__ __forceinline__ uint2 operator+ (uint2 a, uint2 b)
|
||||
{
|
||||
#ifdef __CUDA_ARCH__
|
||||
uint2 result;
|
||||
asm("{\n\t"
|
||||
@@ -504,14 +518,15 @@ static __device__ __forceinline__ uint2 operator+ (uint2 a, uint2 b) {
|
||||
: "=r"(result.x), "=r"(result.y) : "r"(a.x), "r"(a.y), "r"(b.x), "r"(b.y));
|
||||
return result;
|
||||
#else
|
||||
return vectorize(devectorize(a) + devectorize(b));
|
||||
// incorrect but unused host equiv
|
||||
return make_uint2(a.x + b.x, a.y + b.y);
|
||||
#endif
|
||||
}
|
||||
static __device__ __forceinline__ void operator+= (uint2 &a, uint2 b) { a = a + b; }
|
||||
|
||||
|
||||
static __device__ __forceinline__ uint2 operator- (uint2 a, uint2 b) {
|
||||
#if defined(__CUDA_ARCH__) && CUDA_VERSION < 7000
|
||||
static __device__ __forceinline__ uint2 operator- (uint2 a, uint2 b)
|
||||
{
|
||||
#ifdef __CUDA_ARCH__
|
||||
uint2 result;
|
||||
asm("{\n\t"
|
||||
"sub.cc.u32 %0,%2,%4; \n\t"
|
||||
@@ -520,10 +535,10 @@ static __device__ __forceinline__ uint2 operator- (uint2 a, uint2 b) {
|
||||
: "=r"(result.x), "=r"(result.y) : "r"(a.x), "r"(a.y), "r"(b.x), "r"(b.y));
|
||||
return result;
|
||||
#else
|
||||
return vectorize(devectorize(a) - devectorize(b));
|
||||
// incorrect but unused host equiv
|
||||
return make_uint2(a.x - b.x, a.y - b.y);
|
||||
#endif
|
||||
}
|
||||
static __device__ __forceinline__ void operator-= (uint2 &a, uint2 b) { a = a - b; }
|
||||
|
||||
/**
|
||||
* basic multiplication between 64bit no carry outside that range (ie mul.lo.b64(a*b))
|
||||
|
||||
@@ -1,531 +0,0 @@
|
||||
/*
|
||||
* Genoil's CUDA mining kernel for Ethereum
|
||||
* based on Tim Hughes' opencl kernel.
|
||||
* thanks to tpruvot,djm34,sp,cbuchner for things i took from ccminer.
|
||||
*/
|
||||
|
||||
#define SHUFFLE_MIN_VER 9350
|
||||
|
||||
|
||||
#include "miner.h"
|
||||
#include "cuda_helper.h"
|
||||
#include "ethash_cu_miner_kernel.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
#include <memory.h>
|
||||
#include <fcntl.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/mman.h>
|
||||
|
||||
#include "vector_types.h"
|
||||
|
||||
#include "rotl64.cuh"
|
||||
#include "keccak.cuh"
|
||||
|
||||
//#include "ethash_cu_miner_kernel_globals.h"
|
||||
__constant__ uint32_t d_dag_size;
|
||||
__constant__ uint32_t d_max_outputs;
|
||||
|
||||
#define ACCESSES 64
|
||||
#define THREADS_PER_HASH (128 / 16) /* 8 */
|
||||
|
||||
#define FNV_PRIME 0x01000193
|
||||
|
||||
#define SWAP64(v) \
|
||||
((ROTL64L(v, 8) & 0x000000FF000000FF) | \
|
||||
(ROTL64L(v, 24) & 0x0000FF000000FF00) | \
|
||||
(ROTL64H(v, 40) & 0x00FF000000FF0000) | \
|
||||
(ROTL64H(v, 56) & 0xFF000000FF000000))
|
||||
|
||||
#undef SWAP64
|
||||
#define SWAP64(v) cuda_swab64(v)
|
||||
|
||||
#define PACK64(result, lo, hi) asm("mov.b64 %0, {%1,%2};//pack64" : "=l"(result) : "r"(lo), "r"(hi));
|
||||
#define UNPACK64(lo, hi, input) asm("mov.b64 {%0, %1}, %2;//unpack64" : "=r"(lo),"=r"(hi) : "l"(input));
|
||||
|
||||
#define copy(dst, src, count) for (uint32_t i = 0; i < count; i++) { (dst)[i] = (src)[i]; }
|
||||
|
||||
#define countof(x) (sizeof(x) / sizeof(x[0]))
|
||||
|
||||
#define fnv(x,y) ((x) * FNV_PRIME ^(y))
|
||||
|
||||
__device__ uint4 fnv4(uint4 a, uint4 b)
|
||||
{
|
||||
uint4 c;
|
||||
c.x = a.x * FNV_PRIME ^ b.x;
|
||||
c.y = a.y * FNV_PRIME ^ b.y;
|
||||
c.z = a.z * FNV_PRIME ^ b.z;
|
||||
c.w = a.w * FNV_PRIME ^ b.w;
|
||||
return c;
|
||||
}
|
||||
|
||||
__device__ uint32_t fnv_reduce(uint4 v)
|
||||
{
|
||||
return fnv(fnv(fnv(v.x, v.y), v.z), v.w);
|
||||
}
|
||||
|
||||
|
||||
__device__ void init_hash(hash32_t const* header, uint64_t nonce, hash64_t &init)
|
||||
{
|
||||
// sha3_512(header .. nonce)
|
||||
uint64_t state[25] = { 0 };
|
||||
|
||||
//copy(state, header->uint64s, 4);
|
||||
#pragma unroll
|
||||
for (int i = 0; i < 4; i++) state[i] = header->uint64s[i];
|
||||
|
||||
state[4] = nonce;
|
||||
state[5] = 0x0000000000000001;
|
||||
//state[6] = 0;
|
||||
//state[7] = 0;
|
||||
state[8] = 0x8000000000000000;
|
||||
//for (uint32_t i = 9; i < 25; i++) {
|
||||
// state[i] = 0;
|
||||
//}
|
||||
|
||||
keccak_f1600_block(state, 8);
|
||||
|
||||
//copy(init.uint64s, state, 8);
|
||||
#pragma unroll
|
||||
for (int i = 0; i < 8; i++) init.uint64s[i] = state[i];
|
||||
}
|
||||
|
||||
__device__ uint32_t inner_loop(uint4 mix, uint32_t thread_id, uint32_t* share, hash128_t const* g_dag)
|
||||
{
|
||||
// share init0
|
||||
if (thread_id == 0)
|
||||
*share = mix.x;
|
||||
|
||||
uint32_t init0 = *share;
|
||||
|
||||
uint32_t a = 0;
|
||||
|
||||
do
|
||||
{
|
||||
|
||||
bool update_share = thread_id == ((a >> 2) & (THREADS_PER_HASH-1));
|
||||
|
||||
//#pragma unroll 4
|
||||
for (uint32_t i = 0; i < 4; i++)
|
||||
{
|
||||
|
||||
if (update_share)
|
||||
{
|
||||
uint32_t m[4] = { mix.x, mix.y, mix.z, mix.w };
|
||||
*share = fnv(init0 ^ (a + i), m[i]) % d_dag_size;
|
||||
}
|
||||
__threadfence_block();
|
||||
|
||||
#if __CUDA_ARCH__ >= 350
|
||||
mix = fnv4(mix, __ldg(&g_dag[*share].uint4s[thread_id]));
|
||||
#else
|
||||
mix = fnv4(mix, g_dag[*share].uint4s[thread_id]);
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
} while ((a += 4) != ACCESSES);
|
||||
|
||||
return fnv_reduce(mix);
|
||||
}
|
||||
|
||||
__device__ void final_hash(hash64_t const* init, hash32_t const* mix, hash32_t &hash)
|
||||
{
|
||||
uint64_t state[25] = { 0 };
|
||||
|
||||
// keccak_256(keccak_512(header..nonce) .. mix);
|
||||
copy(state, init->uint64s, 8);
|
||||
copy(state + 8, mix->uint64s, 4);
|
||||
state[12] = 0x0000000000000001;
|
||||
//#pragma unroll
|
||||
//for (uint32_t i = 13; i < 16; i++)
|
||||
//{
|
||||
//state[i] = 0;
|
||||
//}
|
||||
state[16] = 0x8000000000000000;
|
||||
//#pragma unroll
|
||||
//for (uint32_t i = 17; i < 25; i++)
|
||||
//{
|
||||
//state[i] = 0;
|
||||
//}
|
||||
|
||||
keccak_f1600_block(state,1);
|
||||
|
||||
// copy out
|
||||
copy(hash.uint64s, state, 4);
|
||||
}
|
||||
|
||||
typedef union
|
||||
{
|
||||
hash64_t init;
|
||||
hash32_t mix;
|
||||
} compute_hash_share;
|
||||
|
||||
#if __CUDA_ARCH__ >= SHUFFLE_MIN_VER
|
||||
__device__ uint64_t compute_hash_shuffle(
|
||||
hash32_t const* g_header,
|
||||
hash128_t const* g_dag,
|
||||
uint64_t nonce
|
||||
)
|
||||
{
|
||||
// sha3_512(header .. nonce)
|
||||
uint64_t state[25];
|
||||
|
||||
copy(state, g_header->uint64s, 4);
|
||||
state[4] = nonce;
|
||||
state[5] = 0x0000000000000001ULL;
|
||||
for (uint32_t i = 6; i < 25; i++)
|
||||
{
|
||||
state[i] = 0;
|
||||
}
|
||||
state[8] = 0x8000000000000000ULL;
|
||||
keccak_f1600_block(state, 8);
|
||||
|
||||
// Threads work together in this phase in groups of 8.
|
||||
const int thread_id = threadIdx.x & (THREADS_PER_HASH - 1);
|
||||
const int start_lane = threadIdx.x & ~(THREADS_PER_HASH - 1);
|
||||
const int mix_idx = (thread_id & 3);
|
||||
|
||||
uint4 mix;
|
||||
|
||||
uint32_t shuffle[16];
|
||||
//uint32_t * init = (uint32_t *)state;
|
||||
|
||||
uint32_t init[16];
|
||||
UNPACK64(init[0], init[1], state[0]);
|
||||
UNPACK64(init[2], init[3], state[1]);
|
||||
UNPACK64(init[4], init[5], state[2]);
|
||||
UNPACK64(init[6], init[7], state[3]);
|
||||
UNPACK64(init[8], init[9], state[4]);
|
||||
UNPACK64(init[10], init[11], state[5]);
|
||||
UNPACK64(init[12], init[13], state[6]);
|
||||
UNPACK64(init[14], init[15], state[7]);
|
||||
|
||||
for (int i = 0; i < THREADS_PER_HASH; i++)
|
||||
{
|
||||
|
||||
// share init among threads
|
||||
for (int j = 0; j < 16; j++)
|
||||
shuffle[j] = __shfl(init[j], start_lane + i);
|
||||
|
||||
// ugly but avoids local reads/writes
|
||||
if (mix_idx == 0) {
|
||||
mix = make_uint4(shuffle[0], shuffle[1], shuffle[2], shuffle[3]);
|
||||
}
|
||||
else if (mix_idx == 1) {
|
||||
mix = make_uint4(shuffle[4], shuffle[5], shuffle[6], shuffle[7]);
|
||||
}
|
||||
else if (mix_idx == 2) {
|
||||
mix = make_uint4(shuffle[8], shuffle[9], shuffle[10], shuffle[11]);
|
||||
}
|
||||
else {
|
||||
mix = make_uint4(shuffle[12], shuffle[13], shuffle[14], shuffle[15]);
|
||||
}
|
||||
|
||||
uint32_t init0 = __shfl(shuffle[0], start_lane);
|
||||
|
||||
|
||||
for (uint32_t a = 0; a < ACCESSES; a+=4)
|
||||
{
|
||||
int t = ((a >> 2) & (THREADS_PER_HASH - 1));
|
||||
|
||||
for (uint32_t b = 0; b < 4; b++)
|
||||
{
|
||||
if (thread_id == t)
|
||||
{
|
||||
shuffle[0] = fnv(init0 ^ (a + b), ((uint32_t *)&mix)[b]) % d_dag_size;;
|
||||
}
|
||||
shuffle[0] = __shfl(shuffle[0], start_lane + t);
|
||||
|
||||
mix = fnv4(mix, g_dag[shuffle[0]].uint4s[thread_id]);
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t thread_mix = fnv_reduce(mix);
|
||||
|
||||
// update mix accross threads
|
||||
|
||||
for (int j = 0; j < 8; j++)
|
||||
shuffle[j] = __shfl(thread_mix, start_lane + j);
|
||||
|
||||
if (i == thread_id) {
|
||||
|
||||
//move mix into state:
|
||||
PACK64(state[8], shuffle[0], shuffle[1]);
|
||||
PACK64(state[9], shuffle[2], shuffle[3]);
|
||||
PACK64(state[10], shuffle[4], shuffle[5]);
|
||||
PACK64(state[11], shuffle[6], shuffle[7]);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// keccak_256(keccak_512(header..nonce) .. mix);
|
||||
state[12] = 0x0000000000000001ULL;
|
||||
for (uint32_t i = 13; i < 25; i++)
|
||||
{
|
||||
state[i] = 0ULL;
|
||||
}
|
||||
state[16] = 0x8000000000000000;
|
||||
keccak_f1600_block(state, 1);
|
||||
|
||||
return state[0];
|
||||
}
|
||||
#endif
|
||||
|
||||
__device__ void compute_hash(
|
||||
hash32_t const* g_header,
|
||||
hash128_t const* g_dag,
|
||||
uint64_t nonce,
|
||||
hash32_t &out
|
||||
)
|
||||
{
|
||||
extern __shared__ compute_hash_share share[];
|
||||
|
||||
// Compute one init hash per work item.
|
||||
hash64_t init;
|
||||
init_hash(g_header, nonce, init);
|
||||
|
||||
// Threads work together in this phase in groups of 8.
|
||||
uint32_t const thread_id = threadIdx.x & (THREADS_PER_HASH-1);
|
||||
uint32_t const hash_id = threadIdx.x >> 3;
|
||||
|
||||
hash32_t mix;
|
||||
|
||||
for (int i = 0; i < THREADS_PER_HASH; i++)
|
||||
{
|
||||
// share init with other threads
|
||||
if (i == thread_id)
|
||||
share[hash_id].init = init;
|
||||
|
||||
uint4 thread_init = share[hash_id].init.uint4s[thread_id & 3];
|
||||
|
||||
uint32_t thread_mix = inner_loop(thread_init, thread_id, share[hash_id].mix.uint32s, g_dag);
|
||||
|
||||
share[hash_id].mix.uint32s[thread_id] = thread_mix;
|
||||
|
||||
|
||||
if (i == thread_id)
|
||||
mix = share[hash_id].mix;
|
||||
}
|
||||
|
||||
final_hash(&init, &mix, out);
|
||||
}
|
||||
|
||||
__global__ void
|
||||
__launch_bounds__(128, 7)
|
||||
ethash_search(
|
||||
uint32_t* g_output,
|
||||
hash32_t const* g_header,
|
||||
hash128_t const* g_dag,
|
||||
uint64_t start_nonce,
|
||||
uint64_t target
|
||||
)
|
||||
{
|
||||
|
||||
uint32_t const gid = blockIdx.x * blockDim.x + threadIdx.x;
|
||||
|
||||
#if 0 // _CUDA_ARCH__ >= SHUFFLE_MIN_VER
|
||||
uint64_t hash = compute_hash_shuffle(g_header, g_dag, start_nonce + gid);
|
||||
if (SWAP64(hash) < target)
|
||||
{
|
||||
atomicInc(g_output, d_max_outputs);
|
||||
g_output[g_output[0]] = gid;
|
||||
}
|
||||
#else
|
||||
hash32_t hash;
|
||||
compute_hash(g_header, g_dag, start_nonce + gid, hash);
|
||||
if (SWAP64(hash.uint64s[0]) <= target)
|
||||
{
|
||||
atomicInc(g_output,d_max_outputs);
|
||||
g_output[g_output[0]] = gid;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
}
|
||||
|
||||
void run_ethash_hash(
|
||||
hash32_t* g_hashes,
|
||||
hash32_t const* g_header,
|
||||
hash128_t const* g_dag,
|
||||
uint64_t start_nonce
|
||||
)
|
||||
{
|
||||
}
|
||||
|
||||
void run_ethash_search(
|
||||
uint32_t blocks,
|
||||
uint32_t threads,
|
||||
cudaStream_t stream,
|
||||
uint32_t* g_output,
|
||||
hash32_t const* g_header,
|
||||
hash128_t const* g_dag,
|
||||
uint64_t start_nonce,
|
||||
uint64_t target
|
||||
)
|
||||
{
|
||||
#if __CUDA_ARCH__ >= SHUFFLE_MIN_VER
|
||||
ethash_search <<<blocks, threads, 0, stream>>>(g_output, g_header, g_dag, start_nonce, target);
|
||||
#else
|
||||
ethash_search <<<blocks, threads, (sizeof(compute_hash_share) * threads) / THREADS_PER_HASH, stream>>>(g_output, g_header, g_dag, start_nonce, target);
|
||||
#endif
|
||||
}
|
||||
|
||||
cudaError set_constants(
|
||||
uint32_t * dag_size,
|
||||
uint32_t * max_outputs
|
||||
)
|
||||
{
|
||||
cudaError result;
|
||||
result = cudaMemcpyToSymbol(d_dag_size, dag_size, sizeof(uint32_t));
|
||||
result = cudaMemcpyToSymbol(d_max_outputs, max_outputs, sizeof(uint32_t));
|
||||
return result;
|
||||
}
|
||||
|
||||
static unsigned m_search_batch_size = 262144;
|
||||
static unsigned m_workgroup_size = 64;
|
||||
|
||||
static __thread hash128_t * m_dag_ptr;
|
||||
static __thread hash32_t * m_header;
|
||||
|
||||
//static void* m_hash_buf[MAX_GPUS] = { 0 };
|
||||
static uint32_t* m_search_buf[MAX_GPUS] = { 0 };
|
||||
static cudaStream_t m_streams[MAX_GPUS] = { 0 };
|
||||
|
||||
static uint64_t dagSize = 0;
|
||||
static int fdDAG = -1;
|
||||
static uint8_t const *dag = NULL;
|
||||
|
||||
uint32_t const c_zero = 0;
|
||||
|
||||
#define ETHASH_MIX_BYTES 128
|
||||
#define MIX_WORDS (ETHASH_MIX_BYTES/4)
|
||||
|
||||
|
||||
uint8_t* alloc_dag_file(uint32_t rev, uint32_t* seedhash)
|
||||
{
|
||||
uint8_t* buffer = NULL;
|
||||
char fn[256];
|
||||
struct stat stat_buf;
|
||||
int rc;
|
||||
|
||||
sprintf(fn, "%s/.ethash/full-R%u-%08x%08x", getenv("HOME"), rev, seedhash[7], seedhash[6]);
|
||||
|
||||
rc = stat(fn, &stat_buf);
|
||||
fdDAG = open(fn, O_RDONLY);
|
||||
if (rc != 0) {
|
||||
applog(LOG_ERR, "Unable to open DAG file %s (%d)!", fn, rc);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
dagSize = stat_buf.st_size - 8;
|
||||
|
||||
#ifdef __linux__
|
||||
buffer = (uint8_t*) (mmap(NULL, dagSize, PROT_READ, MAP_FILE | MAP_SHARED | MAP_POPULATE , fdDAG, 0));
|
||||
#else
|
||||
buffer = (uint8_t*) (mmap(NULL, dagSize, PROT_READ, MAP_FILE | MAP_SHARED), fdDAG, 0));
|
||||
#endif
|
||||
if (buffer == MAP_FAILED) {
|
||||
applog(LOG_ERR, "Unable to map DAG file %s!", fn);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (buffer[0] != 0xfe) {
|
||||
applog(LOG_ERR, "DAG file header is bad %s!", fn);
|
||||
close(fdDAG);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return (buffer+8);
|
||||
}
|
||||
|
||||
void close_dag_file(uint8_t const *dag)
|
||||
{
|
||||
uint8_t* buffer = dag ? (uint8_t*) dag - 8 : NULL;
|
||||
munmap(buffer, dagSize);
|
||||
dag = NULL;
|
||||
close(fdDAG);
|
||||
fdDAG = -1;
|
||||
}
|
||||
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
|
||||
int scanhash_ether(int thr_id, struct work *work, uint64_t max_nonce, unsigned long *hashes_done)
|
||||
{
|
||||
uint32_t *pdata = work->data;
|
||||
uint32_t *ptarget = work->target;
|
||||
uint32_t *pseed = &work->data[8];
|
||||
|
||||
const uint64_t first_nonce = (((uint64_t)pdata[20]) << 32) + pdata[19];
|
||||
uint64_t nonce = first_nonce;
|
||||
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1U << 18);
|
||||
throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
if (!dagSize) {
|
||||
dag = alloc_dag_file(23, pseed);
|
||||
applog(LOG_NOTICE, "DAG size=%ld", (long int) dagSize);
|
||||
}
|
||||
|
||||
//0000.0000 0050.4c39c 047378ad262a995be73cc504643443728e1ca415bae9208
|
||||
uint64_t target64 = ptarget[7];
|
||||
target64 = (target64 << 32) + ptarget[6];
|
||||
|
||||
if (!init[thr_id])
|
||||
{
|
||||
uint32_t dag_size = (unsigned)(dagSize / ETHASH_MIX_BYTES);
|
||||
uint32_t max_outputs=63;
|
||||
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
|
||||
// create buffer for header256
|
||||
cudaMalloc(&m_header, 32);
|
||||
|
||||
// create mining buffer
|
||||
cudaMalloc(&m_search_buf[thr_id], 8 * sizeof(uint32_t));
|
||||
//cudaMalloc(&m_hash_buf[thr_id], c_hash_batch_size * 32);
|
||||
|
||||
//cudaStreamCreate(&m_streams[thr_id]);
|
||||
m_streams[thr_id] = 0;
|
||||
|
||||
// create buffer for dag
|
||||
CUDA_SAFE_CALL(cudaMalloc(&m_dag_ptr, dagSize));
|
||||
CUDA_SAFE_CALL(cudaMemcpy(m_dag_ptr, dag, dagSize, cudaMemcpyHostToDevice));
|
||||
|
||||
CUDA_SAFE_CALL(set_constants(&dag_size, &max_outputs));
|
||||
|
||||
init[thr_id] = true;
|
||||
}
|
||||
else if (dag) {
|
||||
close_dag_file(dag);
|
||||
}
|
||||
|
||||
CUDA_SAFE_CALL(cudaMemcpy(m_header, work->data, 32, cudaMemcpyHostToDevice));
|
||||
CUDA_SAFE_CALL(cudaMemcpy(m_search_buf[thr_id], &c_zero, 4, cudaMemcpyHostToDevice));
|
||||
|
||||
uint32_t results[8] = { 0 };
|
||||
do {
|
||||
results[0] = 0;
|
||||
CUDA_SAFE_CALL(cudaMemset(m_search_buf[thr_id], 0, sizeof(uint32_t)));
|
||||
|
||||
run_ethash_search(m_search_batch_size / m_workgroup_size, m_workgroup_size, m_streams[thr_id], m_search_buf[thr_id], m_header, m_dag_ptr, nonce, target64);
|
||||
|
||||
CUDA_SAFE_CALL(cudaThreadSynchronize());
|
||||
CUDA_SAFE_CALL(cudaMemcpyAsync(results, m_search_buf[thr_id], 2*sizeof(uint32_t), cudaMemcpyDeviceToHost, m_streams[thr_id]));
|
||||
|
||||
unsigned num_found = results[0];
|
||||
if (num_found) {
|
||||
nonce = nonce + results[1];
|
||||
pdata[19] = (uint32_t) nonce;
|
||||
pdata[20] = (uint32_t) (nonce >> 32);
|
||||
return 1;
|
||||
}
|
||||
|
||||
nonce += throughput;
|
||||
|
||||
} while (nonce < max_nonce && !work_restart[thr_id].restart);
|
||||
|
||||
*hashes_done = nonce - first_nonce + 1;
|
||||
return 0;
|
||||
}
|
||||
@@ -1,59 +0,0 @@
|
||||
#ifndef _ETHASH_CU_MINER_KERNEL_H_
|
||||
#define _ETHASH_CU_MINER_KERNEL_H_
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
|
||||
typedef union
|
||||
{
|
||||
uint64_t uint64s[16 / sizeof(uint64_t)];
|
||||
uint32_t uint32s[16 / sizeof(uint32_t)];
|
||||
} hash16_t;
|
||||
|
||||
typedef union
|
||||
{
|
||||
uint32_t uint32s[32 / sizeof(uint32_t)];
|
||||
uint64_t uint64s[32 / sizeof(uint64_t)];
|
||||
} hash32_t;
|
||||
|
||||
|
||||
typedef union
|
||||
{
|
||||
uint32_t uint32s[64 / sizeof(uint32_t)];
|
||||
uint64_t uint64s[64 / sizeof(uint64_t)];
|
||||
uint4 uint4s[64 / sizeof(uint4)];
|
||||
} hash64_t;
|
||||
|
||||
|
||||
typedef union
|
||||
{
|
||||
uint32_t uint32s[128 / sizeof(uint32_t)];
|
||||
uint4 uint4s[128 / sizeof(uint4)];
|
||||
} hash128_t;
|
||||
|
||||
//typedef uint32_t hash128_t;
|
||||
|
||||
cudaError set_constants(
|
||||
uint32_t * dag_size,
|
||||
uint32_t * max_outputs
|
||||
);
|
||||
|
||||
void run_ethash_hash(
|
||||
hash32_t* g_hashes,
|
||||
hash32_t const* g_header,
|
||||
hash128_t const* g_dag,
|
||||
uint64_t start_nonce
|
||||
);
|
||||
|
||||
void run_ethash_search(
|
||||
uint32_t search_batch_size,
|
||||
uint32_t workgroup_size,
|
||||
cudaStream_t stream,
|
||||
uint32_t* g_output,
|
||||
hash32_t const* g_header,
|
||||
hash128_t const* g_dag,
|
||||
uint64_t start_nonce,
|
||||
uint64_t target
|
||||
);
|
||||
|
||||
#endif
|
||||
@@ -1,510 +0,0 @@
|
||||
#include "cpuminer-config.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <stdarg.h>
|
||||
#include <unistd.h>
|
||||
//#include <jansson.h>
|
||||
|
||||
#include <curl/curl.h>
|
||||
|
||||
#ifdef WIN32
|
||||
#include <winsock2.h>
|
||||
#include <mstcpip.h>
|
||||
#else
|
||||
#include <errno.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/in.h>
|
||||
#include <netinet/tcp.h>
|
||||
#endif
|
||||
|
||||
#include "miner.h"
|
||||
|
||||
struct data_buffer {
|
||||
void *buf;
|
||||
size_t len;
|
||||
};
|
||||
|
||||
struct upload_buffer {
|
||||
const void *buf;
|
||||
size_t len;
|
||||
size_t pos;
|
||||
};
|
||||
|
||||
struct header_info {
|
||||
char *lp_path;
|
||||
char *reason;
|
||||
char *stratum_url;
|
||||
};
|
||||
|
||||
static void databuf_free(struct data_buffer *db)
|
||||
{
|
||||
if (!db)
|
||||
return;
|
||||
|
||||
free(db->buf);
|
||||
|
||||
memset(db, 0, sizeof(*db));
|
||||
}
|
||||
|
||||
static size_t all_data_cb(const void *ptr, size_t size, size_t nmemb,
|
||||
void *user_data)
|
||||
{
|
||||
struct data_buffer *db = (struct data_buffer *)user_data;
|
||||
size_t len = size * nmemb;
|
||||
size_t oldlen, newlen;
|
||||
void *newmem;
|
||||
static const uchar zero = 0;
|
||||
|
||||
oldlen = db->len;
|
||||
newlen = oldlen + len;
|
||||
|
||||
newmem = realloc(db->buf, newlen + 1);
|
||||
if (!newmem)
|
||||
return 0;
|
||||
|
||||
db->buf = newmem;
|
||||
db->len = newlen;
|
||||
memcpy((char*)db->buf + oldlen, ptr, len);
|
||||
memcpy((char*)db->buf + newlen, &zero, 1); /* null terminate */
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
static size_t upload_data_cb(void *ptr, size_t size, size_t nmemb,
|
||||
void *user_data)
|
||||
{
|
||||
struct upload_buffer *ub = (struct upload_buffer *)user_data;
|
||||
unsigned int len = (unsigned int)(size * nmemb);
|
||||
|
||||
if (len > ub->len - ub->pos)
|
||||
len = (unsigned int)(ub->len - ub->pos);
|
||||
|
||||
if (len) {
|
||||
memcpy(ptr, (char*)ub->buf + ub->pos, len);
|
||||
ub->pos += len;
|
||||
}
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
#if LIBCURL_VERSION_NUM >= 0x071200
|
||||
static int seek_data_cb(void *user_data, curl_off_t offset, int origin)
|
||||
{
|
||||
struct upload_buffer *ub = (struct upload_buffer *)user_data;
|
||||
|
||||
switch (origin) {
|
||||
case SEEK_SET:
|
||||
ub->pos = (size_t)offset;
|
||||
break;
|
||||
case SEEK_CUR:
|
||||
ub->pos += (size_t)offset;
|
||||
break;
|
||||
case SEEK_END:
|
||||
ub->pos = ub->len + (size_t)offset;
|
||||
break;
|
||||
default:
|
||||
return 1; /* CURL_SEEKFUNC_FAIL */
|
||||
}
|
||||
|
||||
return 0; /* CURL_SEEKFUNC_OK */
|
||||
}
|
||||
#endif
|
||||
|
||||
static size_t resp_hdr_cb(void *ptr, size_t size, size_t nmemb, void *user_data)
|
||||
{
|
||||
struct header_info *hi = (struct header_info *)user_data;
|
||||
size_t remlen, slen, ptrlen = size * nmemb;
|
||||
char *rem, *val = NULL, *key = NULL;
|
||||
void *tmp;
|
||||
|
||||
val = (char*)calloc(1, ptrlen);
|
||||
key = (char*)calloc(1, ptrlen);
|
||||
if (!key || !val)
|
||||
goto out;
|
||||
|
||||
tmp = memchr(ptr, ':', ptrlen);
|
||||
if (!tmp || (tmp == ptr)) /* skip empty keys / blanks */
|
||||
goto out;
|
||||
slen = (size_t)((char*)tmp - (char*)ptr);
|
||||
if ((slen + 1) == ptrlen) /* skip key w/ no value */
|
||||
goto out;
|
||||
memcpy(key, ptr, slen); /* store & nul term key */
|
||||
key[slen] = 0;
|
||||
|
||||
rem = (char*)ptr + slen + 1; /* trim value's leading whitespace */
|
||||
remlen = ptrlen - slen - 1;
|
||||
while ((remlen > 0) && (isspace(*rem))) {
|
||||
remlen--;
|
||||
rem++;
|
||||
}
|
||||
|
||||
memcpy(val, rem, remlen); /* store value, trim trailing ws */
|
||||
val[remlen] = 0;
|
||||
while ((*val) && (isspace(val[strlen(val) - 1]))) {
|
||||
val[strlen(val) - 1] = 0;
|
||||
}
|
||||
if (!*val) /* skip blank value */
|
||||
goto out;
|
||||
|
||||
if (!strcasecmp("X-Long-Polling", key)) {
|
||||
hi->lp_path = val; /* X-Mining-Extensions: longpoll */
|
||||
val = NULL;
|
||||
}
|
||||
|
||||
if (!strcasecmp("X-Reject-Reason", key)) {
|
||||
hi->reason = val; /* X-Mining-Extensions: reject-reason */
|
||||
//applog(LOG_WARNING, "%s:%s", key, val);
|
||||
val = NULL;
|
||||
}
|
||||
|
||||
if (!strcasecmp("X-Stratum", key)) {
|
||||
hi->stratum_url = val; /* steal memory reference */
|
||||
val = NULL;
|
||||
}
|
||||
|
||||
if (!strcasecmp("X-Nonce-Range", key)) {
|
||||
/* todo when available: X-Mining-Extensions: noncerange */
|
||||
}
|
||||
out:
|
||||
free(key);
|
||||
free(val);
|
||||
return ptrlen;
|
||||
}
|
||||
|
||||
#if LIBCURL_VERSION_NUM >= 0x070f06
|
||||
static int sockopt_keepalive_cb(void *userdata, curl_socket_t fd,
|
||||
curlsocktype purpose)
|
||||
{
|
||||
int keepalive = 1;
|
||||
int tcp_keepcnt = 3;
|
||||
int tcp_keepidle = 50;
|
||||
int tcp_keepintvl = 50;
|
||||
#ifdef WIN32
|
||||
DWORD outputBytes;
|
||||
#endif
|
||||
|
||||
#ifndef WIN32
|
||||
if (unlikely(setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &keepalive,
|
||||
sizeof(keepalive))))
|
||||
return 1;
|
||||
#ifdef __linux
|
||||
if (unlikely(setsockopt(fd, SOL_TCP, TCP_KEEPCNT,
|
||||
&tcp_keepcnt, sizeof(tcp_keepcnt))))
|
||||
return 1;
|
||||
if (unlikely(setsockopt(fd, SOL_TCP, TCP_KEEPIDLE,
|
||||
&tcp_keepidle, sizeof(tcp_keepidle))))
|
||||
return 1;
|
||||
if (unlikely(setsockopt(fd, SOL_TCP, TCP_KEEPINTVL,
|
||||
&tcp_keepintvl, sizeof(tcp_keepintvl))))
|
||||
return 1;
|
||||
#endif /* __linux */
|
||||
#ifdef __APPLE_CC__
|
||||
if (unlikely(setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE,
|
||||
&tcp_keepintvl, sizeof(tcp_keepintvl))))
|
||||
return 1;
|
||||
#endif /* __APPLE_CC__ */
|
||||
#else /* WIN32 */
|
||||
struct tcp_keepalive vals;
|
||||
vals.onoff = 1;
|
||||
vals.keepalivetime = tcp_keepidle * 1000;
|
||||
vals.keepaliveinterval = tcp_keepintvl * 1000;
|
||||
if (unlikely(WSAIoctl(fd, SIO_KEEPALIVE_VALS, &vals, sizeof(vals),
|
||||
NULL, 0, &outputBytes, NULL, NULL)))
|
||||
return 1;
|
||||
#endif /* WIN32 */
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
static json_t *ether_json_rpc(CURL *curl, const char *url, const char *rpc_req, int *curl_err)
|
||||
{
|
||||
char len_hdr[64], hashrate_hdr[64];
|
||||
char curl_err_str[CURL_ERROR_SIZE] = { 0 };
|
||||
struct data_buffer all_data = { 0 };
|
||||
struct upload_buffer upload_data;
|
||||
struct curl_slist *headers = NULL;
|
||||
struct header_info hi = { 0 };
|
||||
char *httpdata;
|
||||
json_t *val, *err_val, *res_val;
|
||||
json_error_t err;
|
||||
int rc;
|
||||
|
||||
long timeout = opt_timeout;
|
||||
bool keepalive = false;
|
||||
|
||||
/* it is assumed that 'curl' is freshly [re]initialized at this pt */
|
||||
|
||||
if (opt_protocol)
|
||||
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
|
||||
curl_easy_setopt(curl, CURLOPT_URL, url);
|
||||
if (opt_cert)
|
||||
curl_easy_setopt(curl, CURLOPT_CAINFO, opt_cert);
|
||||
curl_easy_setopt(curl, CURLOPT_ENCODING, "");
|
||||
curl_easy_setopt(curl, CURLOPT_FAILONERROR, 0);
|
||||
curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
|
||||
curl_easy_setopt(curl, CURLOPT_TCP_NODELAY, 1);
|
||||
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, all_data_cb);
|
||||
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &all_data);
|
||||
curl_easy_setopt(curl, CURLOPT_READFUNCTION, upload_data_cb);
|
||||
curl_easy_setopt(curl, CURLOPT_READDATA, &upload_data);
|
||||
#if LIBCURL_VERSION_NUM >= 0x071200
|
||||
curl_easy_setopt(curl, CURLOPT_SEEKFUNCTION, &seek_data_cb);
|
||||
curl_easy_setopt(curl, CURLOPT_SEEKDATA, &upload_data);
|
||||
#endif
|
||||
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, curl_err_str);
|
||||
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
|
||||
curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);
|
||||
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, resp_hdr_cb);
|
||||
curl_easy_setopt(curl, CURLOPT_HEADERDATA, &hi);
|
||||
if (opt_proxy) {
|
||||
curl_easy_setopt(curl, CURLOPT_PROXY, opt_proxy);
|
||||
curl_easy_setopt(curl, CURLOPT_PROXYTYPE, opt_proxy_type);
|
||||
}
|
||||
#if 0
|
||||
if (userpass) {
|
||||
curl_easy_setopt(curl, CURLOPT_USERPWD, userpass);
|
||||
curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
|
||||
}
|
||||
#endif
|
||||
#if LIBCURL_VERSION_NUM >= 0x070f06
|
||||
if (keepalive)
|
||||
curl_easy_setopt(curl, CURLOPT_SOCKOPTFUNCTION, sockopt_keepalive_cb);
|
||||
#endif
|
||||
curl_easy_setopt(curl, CURLOPT_POST, 1);
|
||||
|
||||
if (opt_protocol)
|
||||
applog(LOG_DEBUG, "JSON protocol request:\n%s", rpc_req);
|
||||
|
||||
upload_data.buf = rpc_req;
|
||||
upload_data.len = strlen(rpc_req);
|
||||
upload_data.pos = 0;
|
||||
sprintf(len_hdr, "Content-Length: %lu", (unsigned long) upload_data.len);
|
||||
sprintf(hashrate_hdr, "X-Mining-Hashrate: %llu", (unsigned long long) global_hashrate);
|
||||
|
||||
headers = curl_slist_append(headers, "Content-Type: application/json");
|
||||
headers = curl_slist_append(headers, len_hdr);
|
||||
headers = curl_slist_append(headers, "User-Agent: " USER_AGENT);
|
||||
headers = curl_slist_append(headers, "X-Mining-Extensions: longpoll noncerange reject-reason");
|
||||
headers = curl_slist_append(headers, hashrate_hdr);
|
||||
headers = curl_slist_append(headers, "Accept:"); /* disable Accept hdr*/
|
||||
headers = curl_slist_append(headers, "Expect:"); /* disable Expect hdr*/
|
||||
|
||||
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
|
||||
|
||||
rc = curl_easy_perform(curl);
|
||||
if (curl_err != NULL)
|
||||
*curl_err = rc;
|
||||
if (rc) {
|
||||
if (rc != CURLE_OPERATION_TIMEDOUT) {
|
||||
applog(LOG_ERR, "HTTP request failed: %s", curl_err_str);
|
||||
goto err_out;
|
||||
}
|
||||
}
|
||||
|
||||
if (!all_data.buf || !all_data.len) {
|
||||
applog(LOG_ERR, "Empty data received in json_rpc_call.");
|
||||
goto err_out;
|
||||
}
|
||||
|
||||
httpdata = (char*) all_data.buf;
|
||||
|
||||
if (*httpdata != '{' && *httpdata != '[') {
|
||||
long errcode = 0;
|
||||
CURLcode c = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &errcode);
|
||||
if (c == CURLE_OK && errcode == 401) {
|
||||
applog(LOG_ERR, "You are not authorized, check your login and password.");
|
||||
goto err_out;
|
||||
}
|
||||
}
|
||||
|
||||
val = JSON_LOADS(httpdata, &err);
|
||||
if (!val) {
|
||||
applog(LOG_ERR, "JSON decode failed(%d): %s", err.line, err.text);
|
||||
if (opt_protocol)
|
||||
applog(LOG_DEBUG, "%s", httpdata);
|
||||
goto err_out;
|
||||
}
|
||||
|
||||
if (opt_protocol) {
|
||||
char *s = json_dumps(val, JSON_INDENT(3));
|
||||
applog(LOG_DEBUG, "JSON protocol response:\n%s\n", s);
|
||||
free(s);
|
||||
}
|
||||
|
||||
/* JSON-RPC valid response returns a non-null 'result',
|
||||
* and a null 'error'. */
|
||||
res_val = json_object_get(val, "result");
|
||||
err_val = json_object_get(val, "error");
|
||||
|
||||
if (!res_val || json_is_null(res_val) ||
|
||||
(err_val && !json_is_null(err_val))) {
|
||||
char *s = NULL;
|
||||
|
||||
if (err_val) {
|
||||
s = json_dumps(err_val, 0);
|
||||
json_t *msg = json_object_get(err_val, "message");
|
||||
json_t *err_code = json_object_get(err_val, "code");
|
||||
if (curl_err && json_integer_value(err_code))
|
||||
*curl_err = (int) json_integer_value(err_code);
|
||||
|
||||
if (json_is_string(msg)) {
|
||||
free(s);
|
||||
s = strdup(json_string_value(msg));
|
||||
if (have_longpoll && s && !strcmp(s, "method not getwork")) {
|
||||
json_decref(err_val);
|
||||
free(s);
|
||||
goto err_out;
|
||||
}
|
||||
}
|
||||
json_decref(err_val);
|
||||
}
|
||||
else
|
||||
s = strdup("(unknown reason)");
|
||||
|
||||
if (!curl_err || opt_debug)
|
||||
applog(LOG_ERR, "JSON-RPC call failed: %s", s);
|
||||
|
||||
free(s);
|
||||
|
||||
goto err_out;
|
||||
}
|
||||
|
||||
if (hi.reason)
|
||||
json_object_set_new(val, "reject-reason", json_string(hi.reason));
|
||||
|
||||
databuf_free(&all_data);
|
||||
curl_slist_free_all(headers);
|
||||
curl_easy_reset(curl);
|
||||
return val;
|
||||
|
||||
err_out:
|
||||
free(hi.lp_path);
|
||||
free(hi.reason);
|
||||
free(hi.stratum_url);
|
||||
databuf_free(&all_data);
|
||||
curl_slist_free_all(headers);
|
||||
curl_easy_reset(curl);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Made for len 32
|
||||
bool hex2uint(uint32_t *target, const char *hexstr, int len)
|
||||
{
|
||||
char buf[32];
|
||||
char pad[80];
|
||||
char hex_byte[3];
|
||||
char *ep;
|
||||
char *p = buf;
|
||||
char *hex = pad;
|
||||
|
||||
hex_byte[2] = '\0';
|
||||
|
||||
// pad, we can receive non padded numbers (0x44 => 0x0044)
|
||||
size_t hexlen = strlen(hexstr);
|
||||
if (hexlen < len*2)
|
||||
memset(hex, '0', len*2 - hexlen);
|
||||
sprintf(&hex[len*2 - hexlen],"%s", hexstr);
|
||||
|
||||
while (*hex && len) {
|
||||
if (!hex[1]) {
|
||||
applog(LOG_ERR, "hex2uint str truncated");
|
||||
return false;
|
||||
}
|
||||
hex_byte[0] = hex[0];
|
||||
hex_byte[1] = hex[1];
|
||||
*p = (uchar) strtol(hex_byte, &ep, 16);
|
||||
if (*ep) {
|
||||
applog(LOG_ERR, "hex2uint failed on '%s'", hex_byte);
|
||||
return false;
|
||||
}
|
||||
p++;
|
||||
hex += 2;
|
||||
len--;
|
||||
if (len % 8 == 0) {
|
||||
//..
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < 8; i++) {
|
||||
be32enc(&target[7 - i], ((uint32_t*)buf)[i]);
|
||||
}
|
||||
|
||||
return (len == 0 && *hexstr == 0) ? true : false;
|
||||
}
|
||||
|
||||
void uint2hex(char *out, uint32_t *in, int len)
|
||||
{
|
||||
if (out) {
|
||||
for (int i = 0; i < len/sizeof(uint32_t); i++)
|
||||
sprintf(out + (i * 8), "%08x", in[7-i]);
|
||||
}
|
||||
}
|
||||
|
||||
bool ether_getwork(CURL *curl, struct pool_infos *pool, struct work *work)
|
||||
{
|
||||
char req[512];
|
||||
bool ret = false;
|
||||
|
||||
sprintf(req, "{ \"jsonrpc\": \"2.0\", \"method\": \"eth_getWork\", \"params\": [], \"id\": 4 }\r\n");
|
||||
json_t *result = ether_json_rpc(curl, pool->url, req, NULL);
|
||||
if (result)
|
||||
ret = true;
|
||||
|
||||
json_t *arr = json_object_get(result, "result");
|
||||
if (!json_is_array(arr)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const char *header = json_string_value(json_array_get(arr, 0));
|
||||
const char *seed = json_string_value(json_array_get(arr, 1));
|
||||
const char *target = json_string_value(json_array_get(arr, 2));
|
||||
|
||||
//0x2b800e3ffcafdf7ffdd5b2ea1c0ed79c534e92b3459331eae61597943d0743bc
|
||||
//0x356e5a2cc1eba076e650ac7473fccc37952b46bc2e419a200cec0c451dce2336
|
||||
//0x000000000050ec7dea051867e987e3eed0066a128f161b5776a8f5da326b06ec
|
||||
|
||||
applog(LOG_NOTICE, "%s %s %s", header, seed, target);
|
||||
|
||||
hex2uint(work->data, &header[2], 32);
|
||||
hex2uint(&work->data[8], &seed[2], 32);
|
||||
hex2uint(work->target, &target[2], 32);
|
||||
|
||||
//applog(LOG_BLUE, "%08x %08x", work->target[7], work->target[6]);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool ether_submitwork(CURL *curl, struct pool_infos *pool, struct work *work)
|
||||
{
|
||||
char req[512];
|
||||
bool ret = false;
|
||||
char noncehex[32]={0}, header[80]={0}, mixhash[80]={0};
|
||||
|
||||
sprintf(noncehex, "0x%08x%08x", work->data[20], work->data[19]);
|
||||
uint2hex(header, work->data, 32);
|
||||
uint2hex(mixhash, &work->data[24], 32);
|
||||
|
||||
applog(LOG_NOTICE, "%s mixhash:", __func__);
|
||||
applog_hash((uchar*)&work->data[24]);
|
||||
|
||||
sprintf(req, "{ \"jsonrpc\": \"2.0\", \"method\": \"eth_submitWork\","
|
||||
"\"params\": [\"%s\", \"0x%s\", \"0x%s\"], \"id\": 4 }\r\n",
|
||||
noncehex, header, mixhash
|
||||
);
|
||||
json_t *result = ether_json_rpc(curl, pool->url, req, NULL);
|
||||
if (result)
|
||||
ret = true;
|
||||
|
||||
json_t *res = json_object_get(result, "result");
|
||||
if (!json_is_true(res)) {
|
||||
applog(LOG_ERR, "not true! %s", json_dumps(result, JSON_INDENT(3)));
|
||||
exit(0);
|
||||
return false;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -1,83 +0,0 @@
|
||||
__device__ __constant__ uint64_t const keccak_round_constants[24] = {
|
||||
0x0000000000000001ULL, 0x0000000000008082ULL, 0x800000000000808AULL,
|
||||
0x8000000080008000ULL, 0x000000000000808BULL, 0x0000000080000001ULL,
|
||||
0x8000000080008081ULL, 0x8000000000008009ULL, 0x000000000000008AULL,
|
||||
0x0000000000000088ULL, 0x0000000080008009ULL, 0x000000008000000AULL,
|
||||
0x000000008000808BULL, 0x800000000000008BULL, 0x8000000000008089ULL,
|
||||
0x8000000000008003ULL, 0x8000000000008002ULL, 0x8000000000000080ULL,
|
||||
0x000000000000800AULL, 0x800000008000000AULL, 0x8000000080008081ULL,
|
||||
0x8000000000008080ULL, 0x0000000080000001ULL, 0x8000000080008008ULL
|
||||
};
|
||||
|
||||
__device__ static void keccak_f1600_block(uint64_t* s, uint32_t out_size)//, uint32_t in_size, uint32_t out_size)
|
||||
{
|
||||
uint64_t t[5], u, v;
|
||||
|
||||
for (size_t i = 0; i < 24; i++) {
|
||||
/* theta: c = a[0,i] ^ a[1,i] ^ .. a[4,i] */
|
||||
t[0] = s[0] ^ s[5] ^ s[10] ^ s[15] ^ s[20];
|
||||
t[1] = s[1] ^ s[6] ^ s[11] ^ s[16] ^ s[21];
|
||||
t[2] = s[2] ^ s[7] ^ s[12] ^ s[17] ^ s[22];
|
||||
t[3] = s[3] ^ s[8] ^ s[13] ^ s[18] ^ s[23];
|
||||
t[4] = s[4] ^ s[9] ^ s[14] ^ s[19] ^ s[24];
|
||||
|
||||
/* theta: d[i] = c[i+4] ^ rotl(c[i+1],1) */
|
||||
/* theta: a[0,i], a[1,i], .. a[4,i] ^= d[i] */
|
||||
u = t[4] ^ ROTL64L(t[1], 1);
|
||||
s[0] ^= u; s[5] ^= u; s[10] ^= u; s[15] ^= u; s[20] ^= u;
|
||||
u = t[0] ^ ROTL64L(t[2], 1);
|
||||
s[1] ^= u; s[6] ^= u; s[11] ^= u; s[16] ^= u; s[21] ^= u;
|
||||
u = t[1] ^ ROTL64L(t[3], 1);
|
||||
s[2] ^= u; s[7] ^= u; s[12] ^= u; s[17] ^= u; s[22] ^= u;
|
||||
u = t[2] ^ ROTL64L(t[4], 1);
|
||||
s[3] ^= u; s[8] ^= u; s[13] ^= u; s[18] ^= u; s[23] ^= u;
|
||||
u = t[3] ^ ROTL64L(t[0], 1);
|
||||
s[4] ^= u; s[9] ^= u; s[14] ^= u; s[19] ^= u; s[24] ^= u;
|
||||
|
||||
/* rho pi: b[..] = rotl(a[..], ..) */
|
||||
u = s[1];
|
||||
|
||||
s[1] = ROTL64H(s[6], 44);
|
||||
s[6] = ROTL64L(s[9], 20);
|
||||
s[9] = ROTL64H(s[22], 61);
|
||||
s[22] = ROTL64H(s[14], 39);
|
||||
s[14] = ROTL64L(s[20], 18);
|
||||
s[20] = ROTL64H(s[2], 62);
|
||||
s[2] = ROTL64H(s[12], 43);
|
||||
s[12] = ROTL64L(s[13], 25);
|
||||
s[13] = ROTL64L(s[19], 8);
|
||||
s[19] = ROTL64H(s[23], 56);
|
||||
s[23] = ROTL64H(s[15], 41);
|
||||
s[15] = ROTL64L(s[4], 27);
|
||||
s[4] = ROTL64L(s[24], 14);
|
||||
s[24] = ROTL64L(s[21], 2);
|
||||
s[21] = ROTL64H(s[8], 55);
|
||||
s[8] = ROTL64H(s[16], 45);
|
||||
s[16] = ROTL64H(s[5], 36);
|
||||
s[5] = ROTL64L(s[3], 28);
|
||||
s[3] = ROTL64L(s[18], 21);
|
||||
s[18] = ROTL64L(s[17], 15);
|
||||
s[17] = ROTL64L(s[11], 10);
|
||||
s[11] = ROTL64L(s[7], 6);
|
||||
s[7] = ROTL64L(s[10], 3);
|
||||
s[10] = ROTL64L(u, 1);
|
||||
|
||||
// squeeze this in here
|
||||
/* chi: a[i,j] ^= ~b[i,j+1] & b[i,j+2] */
|
||||
u = s[0]; v = s[1]; s[0] ^= (~v) & s[2];
|
||||
|
||||
/* iota: a[0,0] ^= round constant */
|
||||
s[0] ^= keccak_round_constants[i];
|
||||
if (i == 23 && out_size == 1) return;
|
||||
|
||||
// continue chi
|
||||
s[1] ^= (~s[2]) & s[3]; s[2] ^= (~s[3]) & s[4]; s[3] ^= (~s[4]) & u; s[4] ^= (~u) & v;
|
||||
u = s[5]; v = s[6]; s[5] ^= (~v) & s[7]; s[6] ^= (~s[7]) & s[8]; s[7] ^= (~s[8]) & s[9];
|
||||
|
||||
if (i == 23) return;
|
||||
s[8] ^= (~s[9]) & u; s[9] ^= (~u) & v;
|
||||
u = s[10]; v = s[11]; s[10] ^= (~v) & s[12]; s[11] ^= (~s[12]) & s[13]; s[12] ^= (~s[13]) & s[14]; s[13] ^= (~s[14]) & u; s[14] ^= (~u) & v;
|
||||
u = s[15]; v = s[16]; s[15] ^= (~v) & s[17]; s[16] ^= (~s[17]) & s[18]; s[17] ^= (~s[18]) & s[19]; s[18] ^= (~s[19]) & u; s[19] ^= (~u) & v;
|
||||
u = s[20]; v = s[21]; s[20] ^= (~v) & s[22]; s[21] ^= (~s[22]) & s[23]; s[22] ^= (~s[23]) & s[24]; s[23] ^= (~s[24]) & u; s[24] ^= (~u) & v;
|
||||
}
|
||||
}
|
||||
@@ -1,64 +0,0 @@
|
||||
#include <cuda.h>
|
||||
#include <cuda_runtime.h>
|
||||
#include <stdint.h>
|
||||
|
||||
|
||||
// 64-bit ROTATE LEFT
|
||||
|
||||
#if __CUDA_ARCH__ >= 320
|
||||
|
||||
__device__ uint64_t ROTL64H(const uint64_t x, const int offset)
|
||||
{
|
||||
uint64_t res;
|
||||
asm("{\n\t"
|
||||
".reg .u32 tl,th,vl,vh;\n\t"
|
||||
"mov.b64 {tl,th}, %1;\n\t"
|
||||
"shf.l.wrap.b32 vl, tl, th, %2;\n\t"
|
||||
"shf.l.wrap.b32 vh, th, tl, %2;\n\t"
|
||||
"mov.b64 %0, {vl,vh};\n\t"
|
||||
"}"
|
||||
: "=l"(res) : "l"(x), "r"(offset)
|
||||
);
|
||||
return res;
|
||||
}
|
||||
|
||||
__device__ uint64_t ROTL64L(const uint64_t x, const int offset)
|
||||
{
|
||||
uint64_t res;
|
||||
asm("{\n\t"
|
||||
".reg .u32 tl,th,vl,vh;\n\t"
|
||||
"mov.b64 {tl,th}, %1;\n\t"
|
||||
"shf.l.wrap.b32 vl, tl, th, %2;\n\t"
|
||||
"shf.l.wrap.b32 vh, th, tl, %2;\n\t"
|
||||
"mov.b64 %0, {vh,vl};\n\t"
|
||||
"}"
|
||||
: "=l"(res) : "l"(x), "r"(offset)
|
||||
);
|
||||
return res;
|
||||
}
|
||||
#elif __CUDA_ARCH__ >= 120
|
||||
|
||||
#define ROTL64H(x, n) ROTL64(x,n)
|
||||
#define ROTL64L(x, n) ROTL64(x,n)
|
||||
|
||||
__device__ __forceinline__
|
||||
uint64_t ROTL64(const uint64_t x, const int offset)
|
||||
{
|
||||
uint64_t result;
|
||||
asm("{\n\t"
|
||||
".reg .b64 lhs;\n\t"
|
||||
".reg .u32 roff;\n\t"
|
||||
"shl.b64 lhs, %1, %2;\n\t"
|
||||
"sub.u32 roff, 64, %2;\n\t"
|
||||
"shr.b64 %0, %1, roff;\n\t"
|
||||
"add.u64 %0, lhs, %0;\n\t"
|
||||
"}\n"
|
||||
: "=l"(result) : "l"(x), "r"(offset));
|
||||
return result;
|
||||
}
|
||||
#else
|
||||
#define ROTL64H(x, n) ROTL64(x,n)
|
||||
#define ROTL64L(x, n) ROTL64(x,n)
|
||||
/* host */
|
||||
#define ROTL64(x, n) (((x) << (n)) | ((x) >> (64 - (n))))
|
||||
#endif
|
||||
@@ -2,6 +2,7 @@
|
||||
#include <stdint.h>
|
||||
#include <cuda_runtime.h>
|
||||
|
||||
#include "uint256.h"
|
||||
#include "sph/sph_fugue.h"
|
||||
|
||||
#include "miner.h"
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
#include <cuda_runtime.h>
|
||||
#include <openssl/sha.h>
|
||||
|
||||
#include "uint256.h"
|
||||
#include "sph/sph_groestl.h"
|
||||
#include "cuda_groestlcoin.h"
|
||||
|
||||
|
||||
@@ -89,9 +89,6 @@ static void round_lyra(uint2 *s)
|
||||
__device__ __forceinline__
|
||||
void reduceDuplexRowSetup(const int rowIn, const int rowInOut, const int rowOut, uint2 state[16], uint2 Matrix[96][8])
|
||||
{
|
||||
#if __CUDA_ARCH__ > 500
|
||||
#pragma unroll
|
||||
#endif
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
#pragma unroll
|
||||
|
||||
@@ -258,8 +258,6 @@ void sha256d(unsigned char *hash, const unsigned char *data, int len);
|
||||
#define HAVE_SHA256_4WAY 0
|
||||
#define HAVE_SHA256_8WAY 0
|
||||
|
||||
struct work;
|
||||
|
||||
extern int scanhash_sha256d(int thr_id, uint32_t *pdata,
|
||||
const uint32_t *ptarget, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
|
||||
@@ -267,7 +265,7 @@ extern int scanhash_deep(int thr_id, uint32_t *pdata,
|
||||
const uint32_t *ptarget, uint32_t max_nonce,
|
||||
unsigned long *hashes_done);
|
||||
|
||||
extern int scanhash_luffa(int thr_id, uint32_t *pdata,
|
||||
extern int scanhash_doom(int thr_id, uint32_t *pdata,
|
||||
const uint32_t *ptarget, uint32_t max_nonce,
|
||||
unsigned long *hashes_done);
|
||||
|
||||
@@ -307,10 +305,6 @@ extern int scanhash_blake256(int thr_id, uint32_t *pdata,
|
||||
const uint32_t *ptarget, uint32_t max_nonce,
|
||||
unsigned long *hashes_done, int8_t blakerounds);
|
||||
|
||||
extern int scanhash_c11(int thr_id, uint32_t *pdata,
|
||||
const uint32_t *ptarget, uint32_t max_nonce,
|
||||
unsigned long *hashes_done);
|
||||
|
||||
extern int scanhash_fresh(int thr_id, uint32_t *pdata,
|
||||
const uint32_t *ptarget, uint32_t max_nonce,
|
||||
unsigned long *hashes_done);
|
||||
@@ -330,6 +324,10 @@ extern int scanhash_pentablake(int thr_id, uint32_t *pdata,
|
||||
const uint32_t *ptarget, uint32_t max_nonce,
|
||||
unsigned long *hashes_done);
|
||||
|
||||
extern int scanhash_pluck(int thr_id, uint32_t *pdata,
|
||||
const uint32_t *ptarget, uint32_t max_nonce,
|
||||
unsigned long *hashes_done);
|
||||
|
||||
extern int scanhash_qubit(int thr_id, uint32_t *pdata,
|
||||
const uint32_t *ptarget, uint32_t max_nonce,
|
||||
unsigned long *hashes_done);
|
||||
@@ -374,16 +372,10 @@ extern int scanhash_x17(int thr_id, uint32_t *pdata,
|
||||
const uint32_t *ptarget, uint32_t max_nonce,
|
||||
unsigned long *hashes_done);
|
||||
|
||||
extern int scanhash_whirlpoolx(int thr_id, uint32_t *pdata,
|
||||
extern int scanhash_zr5(int thr_id, uint32_t *pdata,
|
||||
const uint32_t *ptarget, uint32_t max_nonce,
|
||||
unsigned long *hashes_done);
|
||||
|
||||
extern int scanhash_zr5(int thr_id, struct work *work, uint32_t max_nonce,
|
||||
unsigned long *hashes_done);
|
||||
|
||||
extern int scanhash_ether(int thr_id, struct work *work, uint64_t max_nonce,
|
||||
unsigned long *hashes_done);
|
||||
|
||||
/* api related */
|
||||
void *api_thread(void *userdata);
|
||||
void api_set_throughput(int thr_id, uint32_t throughput);
|
||||
@@ -404,7 +396,7 @@ struct cgpu_info {
|
||||
int gpu_clock;
|
||||
int gpu_memclock;
|
||||
size_t gpu_mem;
|
||||
uint32_t gpu_power;
|
||||
uint32_t gpu_usage;
|
||||
double gpu_vddc;
|
||||
int16_t gpu_pstate;
|
||||
int16_t gpu_bus;
|
||||
@@ -476,18 +468,6 @@ struct work_restart {
|
||||
char padding[128 - sizeof(uint32_t)];
|
||||
};
|
||||
|
||||
#ifdef HAVE_GETOPT_LONG
|
||||
#include <getopt.h>
|
||||
#else
|
||||
struct option {
|
||||
const char *name;
|
||||
int has_arg;
|
||||
int *flag;
|
||||
int val;
|
||||
};
|
||||
#endif
|
||||
extern int options_count();
|
||||
|
||||
extern bool opt_benchmark;
|
||||
extern bool opt_debug;
|
||||
extern bool opt_quiet;
|
||||
@@ -505,13 +485,11 @@ extern char *opt_proxy;
|
||||
extern long opt_proxy_type;
|
||||
extern bool use_syslog;
|
||||
extern bool use_colors;
|
||||
extern int use_pok;
|
||||
extern pthread_mutex_t applog_lock;
|
||||
extern struct thr_info *thr_info;
|
||||
extern int longpoll_thr_id;
|
||||
extern int stratum_thr_id;
|
||||
extern int api_thr_id;
|
||||
extern volatile bool abort_flag;
|
||||
extern struct work_restart *work_restart;
|
||||
extern bool opt_trust_pool;
|
||||
extern uint16_t opt_vote;
|
||||
@@ -571,10 +549,6 @@ extern void diff_to_target(uint32_t *target, double diff);
|
||||
extern void get_currentalgo(char* buf, int sz);
|
||||
extern uint32_t device_intensity(int thr_id, const char *func, uint32_t defcount);
|
||||
|
||||
// bignum
|
||||
double bn_convert_nbits(const uint32_t nbits);
|
||||
void bn_nbits_to_uchar(const uint32_t nBits, uchar *target);
|
||||
|
||||
struct stratum_job {
|
||||
char *job_id;
|
||||
unsigned char prevhash[32];
|
||||
@@ -618,13 +592,6 @@ struct stratum_ctx {
|
||||
int srvtime_diff;
|
||||
};
|
||||
|
||||
#define POK_MAX_TXS 4
|
||||
#define POK_MAX_TX_SZ 16384U
|
||||
struct tx {
|
||||
uint8_t data[POK_MAX_TX_SZ];
|
||||
uint32_t len;
|
||||
};
|
||||
|
||||
struct work {
|
||||
uint32_t data[32];
|
||||
uint32_t target[8];
|
||||
@@ -645,16 +612,8 @@ struct work {
|
||||
|
||||
uint32_t scanned_from;
|
||||
uint32_t scanned_to;
|
||||
|
||||
/* pok getwork txs */
|
||||
uint32_t tx_count;
|
||||
struct tx txs[POK_MAX_TXS];
|
||||
};
|
||||
|
||||
#define POK_BOOL_MASK 0x00008000
|
||||
#define POK_DATA_MASK 0xFFFF0000
|
||||
|
||||
|
||||
#define MAX_POOLS 8
|
||||
struct pool_infos {
|
||||
uint8_t id;
|
||||
@@ -662,7 +621,6 @@ struct pool_infos {
|
||||
#define POOL_GETWORK 1
|
||||
#define POOL_STRATUM 2
|
||||
#define POOL_LONGPOLL 4
|
||||
#define POOL_ETHER 128
|
||||
uint8_t type;
|
||||
#define POOL_ST_DEFINED 1
|
||||
#define POOL_ST_VALID 2
|
||||
@@ -700,24 +658,18 @@ extern struct pool_infos pools[MAX_POOLS];
|
||||
extern int num_pools;
|
||||
extern volatile int cur_pooln;
|
||||
|
||||
void pool_init_defaults(void);
|
||||
int pool_get_first_valid(int startfrom);
|
||||
void pool_set_creds(int pooln);
|
||||
void pool_set_attr(int pooln, const char* key, char* arg);
|
||||
bool pool_switch_url(char *params);
|
||||
bool pool_switch(int pooln);
|
||||
bool pool_switch_next(void);
|
||||
int pool_get_first_valid(int startfrom);
|
||||
bool parse_pool_array(json_t *obj);
|
||||
void pool_dump_infos(void);
|
||||
|
||||
json_t * json_rpc_call_pool(CURL *curl, struct pool_infos*,
|
||||
const char *req, bool lp_scan, bool lp, int *err);
|
||||
json_t * json_rpc_longpoll(CURL *curl, char *lp_url, struct pool_infos*,
|
||||
const char *req, int *err);
|
||||
|
||||
bool ether_getwork(CURL *curl, struct pool_infos *pool, struct work *work);
|
||||
bool ether_submitwork(CURL *curl, struct pool_infos *pool, struct work *work);
|
||||
|
||||
bool stratum_socket_full(struct stratum_ctx *sctx, int timeout);
|
||||
bool stratum_send_line(struct stratum_ctx *sctx, char *s);
|
||||
char *stratum_recv_line(struct stratum_ctx *sctx);
|
||||
@@ -779,9 +731,8 @@ void applog_compare_hash(unsigned char *hash, unsigned char *hash2);
|
||||
void print_hash_tests(void);
|
||||
void animehash(void *state, const void *input);
|
||||
void blake256hash(void *output, const void *input, int8_t rounds);
|
||||
void c11hash(void *output, const void *input);
|
||||
void deephash(void *state, const void *input);
|
||||
void luffa_hash(void *state, const void *input);
|
||||
void doomhash(void *state, const void *input);
|
||||
void fresh_hash(void *state, const void *input);
|
||||
void fugue256_hash(unsigned char* output, const unsigned char* input, int len);
|
||||
void heavycoin_hash(unsigned char* output, const unsigned char* input, int len);
|
||||
@@ -793,6 +744,7 @@ void myriadhash(void *state, const void *input);
|
||||
void neoscrypt(uchar *output, const uchar *input, uint32_t profile);
|
||||
void nist5hash(void *state, const void *input);
|
||||
void pentablakehash(void *output, const void *input);
|
||||
void pluckhash(uint32_t *hash, const uint32_t *data, uchar *hashbuffer, const int N);
|
||||
void quarkhash(void *state, const void *input);
|
||||
void qubithash(void *state, const void *input);
|
||||
void scrypthash(void* output, const void* input);
|
||||
@@ -800,7 +752,6 @@ void scryptjane_hash(void* output, const void* input);
|
||||
void skeincoinhash(void *output, const void *input);
|
||||
void skein2hash(void *output, const void *input);
|
||||
void s3hash(void *output, const void *input);
|
||||
void whirlxHash(void *state, const void *input);
|
||||
void x11hash(void *output, const void *input);
|
||||
void x13hash(void *output, const void *input);
|
||||
void x14hash(void *output, const void *input);
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
#include <cuda_runtime.h>
|
||||
#include <openssl/sha.h>
|
||||
|
||||
#include "uint256.h"
|
||||
#include "sph/sph_groestl.h"
|
||||
|
||||
#include "miner.h"
|
||||
|
||||
@@ -15,11 +15,9 @@
|
||||
*
|
||||
*/
|
||||
|
||||
#include <errno.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "miner.h"
|
||||
#include "nvml.h"
|
||||
@@ -35,15 +33,6 @@ extern char driver_version[32];
|
||||
|
||||
static uint32_t device_bus_ids[MAX_GPUS] = { 0 };
|
||||
|
||||
extern uint32_t device_gpu_clocks[MAX_GPUS];
|
||||
extern uint32_t device_mem_clocks[MAX_GPUS];
|
||||
extern uint32_t device_plimit[MAX_GPUS];
|
||||
extern int8_t device_pstate[MAX_GPUS];
|
||||
|
||||
uint32_t clock_prev[MAX_GPUS] = { 0 };
|
||||
uint32_t clock_prev_mem[MAX_GPUS] = { 0 };
|
||||
uint32_t limit_prev[MAX_GPUS] = { 0 };
|
||||
|
||||
/*
|
||||
* Wrappers to emulate dlopen() on other systems like Windows
|
||||
*/
|
||||
@@ -118,12 +107,14 @@ nvml_handle * nvml_create()
|
||||
|
||||
nvmlh->nvml_dll = nvml_dll;
|
||||
|
||||
nvmlh->nvmlInit = (nvmlReturn_t (*)(void)) wrap_dlsym(nvmlh->nvml_dll, "nvmlInit_v2");
|
||||
if (!nvmlh->nvmlInit)
|
||||
nvmlh->nvmlInit = (nvmlReturn_t (*)(void)) wrap_dlsym(nvmlh->nvml_dll, "nvmlInit");
|
||||
nvmlh->nvmlDeviceGetCount = (nvmlReturn_t (*)(int *)) wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetCount_v2");
|
||||
if (!nvmlh->nvmlDeviceGetCount)
|
||||
nvmlh->nvmlDeviceGetCount = (nvmlReturn_t (*)(int *)) wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetCount");
|
||||
nvmlh->nvmlInit = (nvmlReturn_t (*)(void))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlInit_v2");
|
||||
if (!nvmlh->nvmlInit) {
|
||||
nvmlh->nvmlInit = (nvmlReturn_t (*)(void))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlInit");
|
||||
}
|
||||
nvmlh->nvmlDeviceGetCount = (nvmlReturn_t (*)(int *))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetCount_v2");
|
||||
nvmlh->nvmlDeviceGetHandleByIndex = (nvmlReturn_t (*)(int, nvmlDevice_t *))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetHandleByIndex_v2");
|
||||
nvmlh->nvmlDeviceGetAPIRestriction = (nvmlReturn_t (*)(nvmlDevice_t, nvmlRestrictedAPI_t, nvmlEnableState_t *))
|
||||
@@ -136,37 +127,10 @@ nvml_handle * nvml_create()
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetApplicationsClock");
|
||||
nvmlh->nvmlDeviceSetApplicationsClocks = (nvmlReturn_t (*)(nvmlDevice_t, unsigned int mem, unsigned int gpu))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceSetApplicationsClocks");
|
||||
nvmlh->nvmlDeviceResetApplicationsClocks = (nvmlReturn_t (*)(nvmlDevice_t))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceResetApplicationsClocks");
|
||||
nvmlh->nvmlDeviceGetSupportedGraphicsClocks = (nvmlReturn_t (*)(nvmlDevice_t, uint32_t mem, uint32_t *num, uint32_t *))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetSupportedGraphicsClocks");
|
||||
nvmlh->nvmlDeviceGetSupportedMemoryClocks = (nvmlReturn_t (*)(nvmlDevice_t, unsigned int *count, unsigned int *clocksMHz))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetSupportedMemoryClocks");
|
||||
nvmlh->nvmlDeviceGetClockInfo = (nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, unsigned int *clock))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetClockInfo");
|
||||
nvmlh->nvmlDeviceGetMaxClockInfo = (nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, unsigned int *clock))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetMaxClockInfo");
|
||||
nvmlh->nvmlDeviceGetPciInfo = (nvmlReturn_t (*)(nvmlDevice_t, nvmlPciInfo_t *)) wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetPciInfo_v2");
|
||||
if (!nvmlh->nvmlDeviceGetPciInfo)
|
||||
nvmlh->nvmlDeviceGetPciInfo = (nvmlReturn_t (*)(nvmlDevice_t, nvmlPciInfo_t *)) wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetPciInfo");
|
||||
nvmlh->nvmlDeviceGetCurrPcieLinkGeneration = (nvmlReturn_t (*)(nvmlDevice_t, unsigned int *gen))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetCurrPcieLinkGeneration");
|
||||
nvmlh->nvmlDeviceGetCurrPcieLinkWidth = (nvmlReturn_t (*)(nvmlDevice_t, unsigned int *width))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetCurrPcieLinkWidth");
|
||||
nvmlh->nvmlDeviceGetMaxPcieLinkGeneration = (nvmlReturn_t (*)(nvmlDevice_t, unsigned int *gen))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetMaxPcieLinkGeneration");
|
||||
nvmlh->nvmlDeviceGetMaxPcieLinkWidth = (nvmlReturn_t (*)(nvmlDevice_t, unsigned int *width))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetMaxPcieLinkWidth");
|
||||
nvmlh->nvmlDeviceGetPowerUsage = (nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetPowerUsage");
|
||||
nvmlh->nvmlDeviceGetPowerManagementDefaultLimit = (nvmlReturn_t (*)(nvmlDevice_t, unsigned int *limit))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetPowerManagementDefaultLimit");
|
||||
nvmlh->nvmlDeviceGetPowerManagementLimit = (nvmlReturn_t (*)(nvmlDevice_t, unsigned int *limit))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetPowerManagementLimit");
|
||||
nvmlh->nvmlDeviceGetPowerManagementLimitConstraints = (nvmlReturn_t (*)(nvmlDevice_t, unsigned int *min, unsigned int *max))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetPowerManagementLimitConstraints");
|
||||
nvmlh->nvmlDeviceSetPowerManagementLimit = (nvmlReturn_t (*)(nvmlDevice_t, unsigned int limit))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceSetPowerManagementLimit");
|
||||
nvmlh->nvmlDeviceGetPciInfo = (nvmlReturn_t (*)(nvmlDevice_t, nvmlPciInfo_t *))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetPciInfo");
|
||||
nvmlh->nvmlDeviceGetName = (nvmlReturn_t (*)(nvmlDevice_t, char *, int))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetName");
|
||||
nvmlh->nvmlDeviceGetTemperature = (nvmlReturn_t (*)(nvmlDevice_t, int, unsigned int *))
|
||||
@@ -174,7 +138,7 @@ nvml_handle * nvml_create()
|
||||
nvmlh->nvmlDeviceGetFanSpeed = (nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetFanSpeed");
|
||||
nvmlh->nvmlDeviceGetPerformanceState = (nvmlReturn_t (*)(nvmlDevice_t, int *))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetPerformanceState"); /* or nvmlDeviceGetPowerState */
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetPowerUsage");
|
||||
nvmlh->nvmlDeviceGetSerial = (nvmlReturn_t (*)(nvmlDevice_t, char *, unsigned int))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetSerial");
|
||||
nvmlh->nvmlDeviceGetUUID = (nvmlReturn_t (*)(nvmlDevice_t, char *, unsigned int))
|
||||
@@ -187,26 +151,17 @@ nvml_handle * nvml_create()
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlErrorString");
|
||||
nvmlh->nvmlShutdown = (nvmlReturn_t (*)())
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlShutdown");
|
||||
// v331
|
||||
nvmlh->nvmlDeviceGetEnforcedPowerLimit = (nvmlReturn_t (*)(nvmlDevice_t, unsigned int *limit))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetEnforcedPowerLimit");
|
||||
// v340
|
||||
/* NVML_ERROR_NOT_SUPPORTED
|
||||
nvmlh->nvmlDeviceGetAutoBoostedClocksEnabled = (nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t *isEnabled, nvmlEnableState_t *defaultIsEnabled))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetAutoBoostedClocksEnabled");
|
||||
nvmlh->nvmlDeviceSetAutoBoostedClocksEnabled = (nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t enabled))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceSetAutoBoostedClocksEnabled"); */
|
||||
// v346
|
||||
nvmlh->nvmlDeviceGetPcieThroughput = (nvmlReturn_t (*)(nvmlDevice_t, nvmlPcieUtilCounter_t, unsigned int *value))
|
||||
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetPcieThroughput");
|
||||
|
||||
if (nvmlh->nvmlInit == NULL ||
|
||||
nvmlh->nvmlShutdown == NULL ||
|
||||
nvmlh->nvmlErrorString == NULL ||
|
||||
nvmlh->nvmlSystemGetDriverVersion == NULL ||
|
||||
nvmlh->nvmlDeviceGetCount == NULL ||
|
||||
nvmlh->nvmlDeviceGetHandleByIndex == NULL ||
|
||||
nvmlh->nvmlDeviceGetPciInfo == NULL ||
|
||||
nvmlh->nvmlDeviceGetName == NULL)
|
||||
nvmlh->nvmlDeviceGetName == NULL ||
|
||||
nvmlh->nvmlDeviceGetTemperature == NULL ||
|
||||
nvmlh->nvmlDeviceGetFanSpeed == NULL)
|
||||
{
|
||||
if (opt_debug)
|
||||
applog(LOG_DEBUG, "Failed to obtain required NVML function pointers");
|
||||
@@ -216,8 +171,7 @@ nvml_handle * nvml_create()
|
||||
}
|
||||
|
||||
nvmlh->nvmlInit();
|
||||
if (nvmlh->nvmlSystemGetDriverVersion)
|
||||
nvmlh->nvmlSystemGetDriverVersion(driver_version, sizeof(driver_version));
|
||||
nvmlh->nvmlSystemGetDriverVersion(driver_version, sizeof(driver_version));
|
||||
nvmlh->nvmlDeviceGetCount(&nvmlh->nvml_gpucount);
|
||||
|
||||
/* Query CUDA device count, in case it doesn't agree with NVML, since */
|
||||
@@ -253,7 +207,7 @@ nvml_handle * nvml_create()
|
||||
nvmlh->nvml_pci_domain_id[i] = pciinfo.domain;
|
||||
nvmlh->nvml_pci_bus_id[i] = pciinfo.bus;
|
||||
nvmlh->nvml_pci_device_id[i] = pciinfo.device;
|
||||
nvmlh->nvml_pci_subsys_id[i] = pciinfo.pci_subsystem_id;
|
||||
nvmlh->nvml_pci_subsys_id[i] = pciinfo.pci_device_id;
|
||||
|
||||
nvmlh->app_clocks[i] = NVML_FEATURE_UNKNOWN;
|
||||
if (nvmlh->nvmlDeviceSetAPIRestriction) {
|
||||
@@ -264,6 +218,21 @@ nvml_handle * nvml_create()
|
||||
if (nvmlh->nvmlDeviceGetAPIRestriction) {
|
||||
nvmlh->nvmlDeviceGetAPIRestriction(nvmlh->devs[i], NVML_RESTRICTED_API_SET_APPLICATION_CLOCKS,
|
||||
&nvmlh->app_clocks[i]);
|
||||
if (nvmlh->app_clocks[i] == NVML_FEATURE_ENABLED && opt_debug) {
|
||||
applog(LOG_DEBUG, "NVML application clock feature is allowed");
|
||||
#if 0
|
||||
uint32_t mem;
|
||||
nvmlReturn_t rc;
|
||||
rc = nvmlh->nvmlDeviceGetDefaultApplicationsClock(nvmlh->devs[i], NVML_CLOCK_MEM, &mem);
|
||||
if (rc == NVML_SUCCESS)
|
||||
applog(LOG_DEBUG, "nvmlDeviceGetDefaultApplicationsClock: mem %u", mem);
|
||||
else
|
||||
applog(LOG_DEBUG, "nvmlDeviceGetDefaultApplicationsClock: %s", nvmlh->nvmlErrorString(rc));
|
||||
rc = nvmlh->nvmlDeviceSetApplicationsClocks(nvmlh->devs[i], mem, 1228000);
|
||||
if (rc != NVML_SUCCESS)
|
||||
applog(LOG_DEBUG, "nvmlDeviceSetApplicationsClocks: %s", nvmlh->nvmlErrorString(rc));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -282,7 +251,7 @@ nvml_handle * nvml_create()
|
||||
(nvmlh->nvml_pci_bus_id[j] == (uint32_t) props.pciBusID) &&
|
||||
(nvmlh->nvml_pci_device_id[j] == (uint32_t) props.pciDeviceID)) {
|
||||
if (opt_debug)
|
||||
applog(LOG_DEBUG, "CUDA GPU %d matches NVML GPU %d by busId %u",
|
||||
applog(LOG_DEBUG, "CUDA GPU#%d matches NVML GPU %d by busId %u",
|
||||
i, j, (uint32_t) props.pciBusID);
|
||||
nvmlh->nvml_cuda_device_id[j] = i;
|
||||
nvmlh->cuda_nvml_device_id[i] = j;
|
||||
@@ -294,234 +263,6 @@ nvml_handle * nvml_create()
|
||||
return nvmlh;
|
||||
}
|
||||
|
||||
/* apply config clocks to an used device */
|
||||
int nvml_set_clocks(nvml_handle *nvmlh, int dev_id)
|
||||
{
|
||||
nvmlReturn_t rc;
|
||||
uint32_t gpu_clk = 0, mem_clk = 0;
|
||||
int n = nvmlh->cuda_nvml_device_id[dev_id];
|
||||
if (n < 0 || n >= nvmlh->nvml_gpucount)
|
||||
return -ENODEV;
|
||||
|
||||
if (!device_gpu_clocks[dev_id] && !device_mem_clocks[dev_id])
|
||||
return 0; // nothing to do
|
||||
|
||||
if (nvmlh->app_clocks[n] != NVML_FEATURE_ENABLED) {
|
||||
applog(LOG_WARNING, "GPU #%d: NVML application clock feature is not allowed!", dev_id);
|
||||
return -EPERM;
|
||||
}
|
||||
|
||||
uint32_t mem_prev = clock_prev_mem[dev_id];
|
||||
if (!mem_prev)
|
||||
nvmlh->nvmlDeviceGetApplicationsClock(nvmlh->devs[n], NVML_CLOCK_MEM, &mem_prev);
|
||||
uint32_t gpu_prev = clock_prev[dev_id];
|
||||
if (!gpu_prev)
|
||||
nvmlh->nvmlDeviceGetApplicationsClock(nvmlh->devs[n], NVML_CLOCK_GRAPHICS, &gpu_prev);
|
||||
|
||||
nvmlh->nvmlDeviceGetDefaultApplicationsClock(nvmlh->devs[n], NVML_CLOCK_MEM, &mem_clk);
|
||||
rc = nvmlh->nvmlDeviceGetDefaultApplicationsClock(nvmlh->devs[n], NVML_CLOCK_GRAPHICS, &gpu_clk);
|
||||
if (rc != NVML_SUCCESS) {
|
||||
applog(LOG_WARNING, "GPU #%d: unable to query application clocks", dev_id);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (opt_debug)
|
||||
applog(LOG_DEBUG, "GPU #%d: default application clocks are %u/%u", dev_id, mem_clk, gpu_clk);
|
||||
|
||||
// get application config values
|
||||
if (device_mem_clocks[dev_id]) mem_clk = device_mem_clocks[dev_id];
|
||||
if (device_gpu_clocks[dev_id]) gpu_clk = device_gpu_clocks[dev_id];
|
||||
|
||||
// these functions works for the 960 and the 970 (346.72+), not for the 750 Ti
|
||||
uint32_t nclocks = 0, clocks[127] = { 0 };
|
||||
nvmlh->nvmlDeviceGetSupportedMemoryClocks(nvmlh->devs[n], &nclocks, NULL);
|
||||
nclocks = min(nclocks, 127);
|
||||
if (nclocks)
|
||||
nvmlh->nvmlDeviceGetSupportedMemoryClocks(nvmlh->devs[n], &nclocks, clocks);
|
||||
for (int8_t u=0; u < nclocks; u++) {
|
||||
// ordered by pstate (so highest is first memory clock - P0)
|
||||
if (clocks[u] <= mem_clk) {
|
||||
mem_clk = clocks[u];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
nclocks = 0;
|
||||
nvmlh->nvmlDeviceGetSupportedGraphicsClocks(nvmlh->devs[n], mem_clk, &nclocks, NULL);
|
||||
nclocks = min(nclocks, 127);
|
||||
if (nclocks)
|
||||
nvmlh->nvmlDeviceGetSupportedGraphicsClocks(nvmlh->devs[n], mem_clk, &nclocks, clocks);
|
||||
for (uint8_t u=0; u < nclocks; u++) {
|
||||
// ordered desc, so get first
|
||||
if (clocks[u] <= gpu_clk) {
|
||||
gpu_clk = clocks[u];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
rc = nvmlh->nvmlDeviceSetApplicationsClocks(nvmlh->devs[n], mem_clk, gpu_clk);
|
||||
if (rc == NVML_SUCCESS)
|
||||
applog(LOG_INFO, "GPU #%d: application clocks set to %u/%u", dev_id, mem_clk, gpu_clk);
|
||||
else {
|
||||
applog(LOG_WARNING, "GPU #%d: %u/%u - %s", dev_id, mem_clk, gpu_clk, nvmlh->nvmlErrorString(rc));
|
||||
return -1;
|
||||
}
|
||||
|
||||
// store previous clocks for reset on exit (or during wait...)
|
||||
clock_prev[dev_id] = gpu_prev;
|
||||
clock_prev_mem[dev_id] = mem_prev;
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* reset default app clocks and limits on exit */
|
||||
int nvml_reset_clocks(nvml_handle *nvmlh, int dev_id)
|
||||
{
|
||||
int ret = 0;
|
||||
nvmlReturn_t rc;
|
||||
uint32_t gpu_clk = 0, mem_clk = 0;
|
||||
int n = nvmlh->cuda_nvml_device_id[dev_id];
|
||||
if (n < 0 || n >= nvmlh->nvml_gpucount)
|
||||
return -ENODEV;
|
||||
|
||||
if (clock_prev[dev_id]) {
|
||||
rc = nvmlh->nvmlDeviceResetApplicationsClocks(nvmlh->devs[n]);
|
||||
if (rc != NVML_SUCCESS) {
|
||||
applog(LOG_WARNING, "GPU #%d: unable to reset application clocks", dev_id);
|
||||
}
|
||||
clock_prev[dev_id] = 0;
|
||||
ret = 1;
|
||||
}
|
||||
|
||||
if (limit_prev[dev_id]) {
|
||||
uint32_t plimit = limit_prev[dev_id];
|
||||
if (nvmlh->nvmlDeviceGetPowerManagementDefaultLimit && !plimit) {
|
||||
rc = nvmlh->nvmlDeviceGetPowerManagementDefaultLimit(nvmlh->devs[n], &plimit);
|
||||
} else if (plimit) {
|
||||
rc = NVML_SUCCESS;
|
||||
}
|
||||
if (rc == NVML_SUCCESS)
|
||||
nvmlh->nvmlDeviceSetPowerManagementLimit(nvmlh->devs[n], plimit);
|
||||
ret = 1;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Set power state of a device (9xx)
|
||||
* Code is similar as clocks one, which allow the change of the pstate
|
||||
*/
|
||||
int nvml_set_pstate(nvml_handle *nvmlh, int dev_id)
|
||||
{
|
||||
nvmlReturn_t rc;
|
||||
uint32_t gpu_clk = 0, mem_clk = 0;
|
||||
int n = nvmlh->cuda_nvml_device_id[dev_id];
|
||||
if (n < 0 || n >= nvmlh->nvml_gpucount)
|
||||
return -ENODEV;
|
||||
|
||||
if (device_pstate[dev_id] < 0)
|
||||
return 0;
|
||||
|
||||
if (nvmlh->app_clocks[n] != NVML_FEATURE_ENABLED) {
|
||||
applog(LOG_WARNING, "GPU #%d: NVML app. clock feature is not allowed!", dev_id);
|
||||
return -EPERM;
|
||||
}
|
||||
|
||||
nvmlh->nvmlDeviceGetDefaultApplicationsClock(nvmlh->devs[n], NVML_CLOCK_MEM, &mem_clk);
|
||||
rc = nvmlh->nvmlDeviceGetDefaultApplicationsClock(nvmlh->devs[n], NVML_CLOCK_GRAPHICS, &gpu_clk);
|
||||
if (rc != NVML_SUCCESS) {
|
||||
applog(LOG_WARNING, "GPU #%d: unable to query application clocks", dev_id);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
// get application config values
|
||||
if (device_mem_clocks[dev_id]) mem_clk = device_mem_clocks[dev_id];
|
||||
if (device_gpu_clocks[dev_id]) gpu_clk = device_gpu_clocks[dev_id];
|
||||
|
||||
// these functions works for the 960 and the 970 (346.72+), not for the 750 Ti
|
||||
uint32_t nclocks = 0, clocks[127] = { 0 };
|
||||
int8_t wanted_pstate = device_pstate[dev_id];
|
||||
nvmlh->nvmlDeviceGetSupportedMemoryClocks(nvmlh->devs[n], &nclocks, NULL);
|
||||
nclocks = min(nclocks, 127);
|
||||
if (nclocks)
|
||||
nvmlh->nvmlDeviceGetSupportedMemoryClocks(nvmlh->devs[n], &nclocks, clocks);
|
||||
for (uint8_t u=0; u < nclocks; u++) {
|
||||
// ordered by pstate (so highest P0 first)
|
||||
if (u == wanted_pstate) {
|
||||
mem_clk = clocks[u];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
nclocks = 0;
|
||||
nvmlh->nvmlDeviceGetSupportedGraphicsClocks(nvmlh->devs[n], mem_clk, &nclocks, NULL);
|
||||
nclocks = min(nclocks, 127);
|
||||
if (nclocks)
|
||||
nvmlh->nvmlDeviceGetSupportedGraphicsClocks(nvmlh->devs[n], mem_clk, &nclocks, clocks);
|
||||
for (uint8_t u=0; u < nclocks; u++) {
|
||||
// ordered desc, so get first
|
||||
if (clocks[u] <= gpu_clk) {
|
||||
gpu_clk = clocks[u];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
rc = nvmlh->nvmlDeviceSetApplicationsClocks(nvmlh->devs[n], mem_clk, gpu_clk);
|
||||
if (rc != NVML_SUCCESS) {
|
||||
applog(LOG_WARNING, "GPU #%d: pstate %s", dev_id, nvmlh->nvmlErrorString(rc));
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (!opt_quiet)
|
||||
applog(LOG_INFO, "GPU #%d: app clocks set to P%d (%u/%u)", dev_id, (int) wanted_pstate, mem_clk, gpu_clk);
|
||||
|
||||
clock_prev[dev_id] = 1;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int nvml_set_plimit(nvml_handle *nvmlh, int dev_id)
|
||||
{
|
||||
nvmlReturn_t rc = NVML_ERROR_UNKNOWN;
|
||||
uint32_t gpu_clk = 0, mem_clk = 0;
|
||||
int n = nvmlh->cuda_nvml_device_id[dev_id];
|
||||
if (n < 0 || n >= nvmlh->nvml_gpucount)
|
||||
return -ENODEV;
|
||||
|
||||
if (!device_plimit[dev_id])
|
||||
return 0; // nothing to do
|
||||
|
||||
if (!nvmlh->nvmlDeviceSetPowerManagementLimit)
|
||||
return -ENOSYS;
|
||||
|
||||
uint32_t plimit = device_plimit[dev_id] * 1000;
|
||||
uint32_t pmin = 1000, pmax = 0, prev_limit = 0;
|
||||
if (nvmlh->nvmlDeviceGetPowerManagementLimitConstraints)
|
||||
rc = nvmlh->nvmlDeviceGetPowerManagementLimitConstraints(nvmlh->devs[n], &pmin, &pmax);
|
||||
|
||||
if (rc != NVML_SUCCESS) {
|
||||
if (!nvmlh->nvmlDeviceGetPowerManagementLimit)
|
||||
return -ENOSYS;
|
||||
}
|
||||
nvmlh->nvmlDeviceGetPowerManagementLimit(nvmlh->devs[n], &prev_limit);
|
||||
if (!pmax) pmax = prev_limit;
|
||||
|
||||
plimit = min(plimit, pmax);
|
||||
plimit = max(plimit, pmin);
|
||||
rc = nvmlh->nvmlDeviceSetPowerManagementLimit(nvmlh->devs[n], plimit);
|
||||
if (rc != NVML_SUCCESS) {
|
||||
applog(LOG_WARNING, "GPU #%d: plimit %s", dev_id, nvmlh->nvmlErrorString(rc));
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (!opt_quiet) {
|
||||
applog(LOG_INFO, "GPU #%d: power limit set to %uW (allowed range is %u-%u)",
|
||||
dev_id, plimit/1000U, pmin/1000U, pmax/1000U);
|
||||
}
|
||||
|
||||
limit_prev[dev_id] = prev_limit;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int nvml_get_gpucount(nvml_handle *nvmlh, int *gpucount)
|
||||
{
|
||||
*gpucount = nvmlh->nvml_gpucount;
|
||||
@@ -539,10 +280,7 @@ int nvml_get_gpu_name(nvml_handle *nvmlh, int cudaindex, char *namebuf, int bufs
|
||||
{
|
||||
int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex];
|
||||
if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount)
|
||||
return -ENODEV;
|
||||
|
||||
if (!nvmlh->nvmlDeviceGetName)
|
||||
return -ENOSYS;
|
||||
return -1;
|
||||
|
||||
if (nvmlh->nvmlDeviceGetName(nvmlh->devs[gpuindex], namebuf, bufsize) != NVML_SUCCESS)
|
||||
return -1;
|
||||
@@ -556,10 +294,7 @@ int nvml_get_tempC(nvml_handle *nvmlh, int cudaindex, unsigned int *tempC)
|
||||
nvmlReturn_t rc;
|
||||
int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex];
|
||||
if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount)
|
||||
return -ENODEV;
|
||||
|
||||
if (!nvmlh->nvmlDeviceGetTemperature)
|
||||
return -ENOSYS;
|
||||
return -1;
|
||||
|
||||
rc = nvmlh->nvmlDeviceGetTemperature(nvmlh->devs[gpuindex], 0u /* NVML_TEMPERATURE_GPU */, tempC);
|
||||
if (rc != NVML_SUCCESS) {
|
||||
@@ -575,10 +310,7 @@ int nvml_get_fanpcnt(nvml_handle *nvmlh, int cudaindex, unsigned int *fanpcnt)
|
||||
nvmlReturn_t rc;
|
||||
int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex];
|
||||
if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount)
|
||||
return -ENODEV;
|
||||
|
||||
if (!nvmlh->nvmlDeviceGetFanSpeed)
|
||||
return -ENOSYS;
|
||||
return -1;
|
||||
|
||||
rc = nvmlh->nvmlDeviceGetFanSpeed(nvmlh->devs[gpuindex], fanpcnt);
|
||||
if (rc != NVML_SUCCESS) {
|
||||
@@ -593,15 +325,12 @@ int nvml_get_power_usage(nvml_handle *nvmlh, int cudaindex, unsigned int *milliw
|
||||
{
|
||||
int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex];
|
||||
if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount)
|
||||
return -ENODEV;
|
||||
|
||||
if (!nvmlh->nvmlDeviceGetPowerUsage)
|
||||
return -ENOSYS;
|
||||
return -1;
|
||||
|
||||
nvmlReturn_t res = nvmlh->nvmlDeviceGetPowerUsage(nvmlh->devs[gpuindex], milliwatts);
|
||||
if (res != NVML_SUCCESS) {
|
||||
//if (opt_debug)
|
||||
// applog(LOG_DEBUG, "nvmlDeviceGetPowerUsage: %s", nvmlh->nvmlErrorString(res));
|
||||
if (opt_debug)
|
||||
applog(LOG_DEBUG, "nvmlDeviceGetPowerUsage: %s", nvmlh->nvmlErrorString(res));
|
||||
return -1;
|
||||
}
|
||||
|
||||
@@ -613,10 +342,7 @@ int nvml_get_pstate(nvml_handle *nvmlh, int cudaindex, int *pstate)
|
||||
{
|
||||
int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex];
|
||||
if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount)
|
||||
return -ENODEV;
|
||||
|
||||
if (!nvmlh->nvmlDeviceGetPerformanceState)
|
||||
return -ENOSYS;
|
||||
return -1;
|
||||
|
||||
nvmlReturn_t res = nvmlh->nvmlDeviceGetPerformanceState(nvmlh->devs[gpuindex], pstate);
|
||||
if (res != NVML_SUCCESS) {
|
||||
@@ -632,7 +358,7 @@ int nvml_get_busid(nvml_handle *nvmlh, int cudaindex, int *busid)
|
||||
{
|
||||
int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex];
|
||||
if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount)
|
||||
return -ENODEV;
|
||||
return -1;
|
||||
|
||||
(*busid) = nvmlh->nvml_pci_bus_id[gpuindex];
|
||||
return 0;
|
||||
@@ -645,17 +371,13 @@ int nvml_get_serial(nvml_handle *nvmlh, int cudaindex, char *sn, int maxlen)
|
||||
int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex];
|
||||
nvmlReturn_t res;
|
||||
if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount)
|
||||
return -ENODEV;
|
||||
return -1;
|
||||
|
||||
if (nvmlh->nvmlDeviceGetSerial) {
|
||||
res = nvmlh->nvmlDeviceGetSerial(nvmlh->devs[gpuindex], sn, maxlen);
|
||||
if (res == NVML_SUCCESS)
|
||||
return 0;
|
||||
res = nvmlh->nvmlDeviceGetSerial(nvmlh->devs[gpuindex], sn, maxlen);
|
||||
if (res == NVML_SUCCESS) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!nvmlh->nvmlDeviceGetUUID)
|
||||
return -ENOSYS;
|
||||
|
||||
// nvmlDeviceGetUUID: GPU-f2bd642c-369f-5a14-e0b4-0d22dfe9a1fc
|
||||
// use a part of uuid to generate an unique serial
|
||||
// todo: check if there is vendor id is inside
|
||||
@@ -676,10 +398,7 @@ int nvml_get_bios(nvml_handle *nvmlh, int cudaindex, char *desc, int maxlen)
|
||||
uint32_t subids = 0;
|
||||
int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex];
|
||||
if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount)
|
||||
return -ENODEV;
|
||||
|
||||
if (!nvmlh->nvmlDeviceGetVbiosVersion)
|
||||
return -ENOSYS;
|
||||
return -1;
|
||||
|
||||
nvmlReturn_t res = nvmlh->nvmlDeviceGetVbiosVersion(nvmlh->devs[gpuindex], desc, maxlen);
|
||||
if (res != NVML_SUCCESS) {
|
||||
@@ -690,16 +409,16 @@ int nvml_get_bios(nvml_handle *nvmlh, int cudaindex, char *desc, int maxlen)
|
||||
return 0;
|
||||
}
|
||||
|
||||
int nvml_get_info(nvml_handle *nvmlh, int cudaindex, uint16_t &vid, uint16_t &pid)
|
||||
int nvml_get_info(nvml_handle *nvmlh, int cudaindex, uint16_t *vid, uint16_t *pid)
|
||||
{
|
||||
uint32_t subids = 0;
|
||||
int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex];
|
||||
if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount)
|
||||
return -ENODEV;
|
||||
return -1;
|
||||
|
||||
subids = nvmlh->nvml_pci_subsys_id[gpuindex];
|
||||
pid = subids >> 16;
|
||||
vid = subids & 0xFFFF;
|
||||
(*pid) = subids >> 16;
|
||||
(*vid) = subids & 0xFFFF;
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -739,7 +458,7 @@ int nvapi_temperature(unsigned int devNum, unsigned int *temperature)
|
||||
NvAPI_Status ret;
|
||||
|
||||
if (devNum >= nvapi_dev_cnt)
|
||||
return -ENODEV;
|
||||
return -1;
|
||||
|
||||
NV_GPU_THERMAL_SETTINGS thermal;
|
||||
thermal.version = NV_GPU_THERMAL_SETTINGS_VER;
|
||||
@@ -762,7 +481,7 @@ int nvapi_fanspeed(unsigned int devNum, unsigned int *speed)
|
||||
NvAPI_Status ret;
|
||||
|
||||
if (devNum >= nvapi_dev_cnt)
|
||||
return -ENODEV;
|
||||
return -1;
|
||||
|
||||
NvU32 fanspeed = 0;
|
||||
ret = NvAPI_GPU_GetTachReading(phys[devNum], &fanspeed);
|
||||
@@ -784,7 +503,7 @@ int nvapi_getpstate(unsigned int devNum, unsigned int *power)
|
||||
NvAPI_Status ret;
|
||||
|
||||
if (devNum >= nvapi_dev_cnt)
|
||||
return -ENODEV;
|
||||
return -1;
|
||||
|
||||
NV_GPU_PERF_PSTATE_ID CurrentPstate = NVAPI_GPU_PERF_PSTATE_UNDEFINED; /* 16 */
|
||||
ret = NvAPI_GPU_GetCurrentPstate(phys[devNum], &CurrentPstate);
|
||||
@@ -809,7 +528,7 @@ int nvapi_getusage(unsigned int devNum, unsigned int *pct)
|
||||
NvAPI_Status ret;
|
||||
|
||||
if (devNum >= nvapi_dev_cnt)
|
||||
return -ENODEV;
|
||||
return -1;
|
||||
|
||||
NV_GPU_DYNAMIC_PSTATES_INFO_EX info;
|
||||
info.version = NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER;
|
||||
@@ -829,13 +548,13 @@ int nvapi_getusage(unsigned int devNum, unsigned int *pct)
|
||||
return 0;
|
||||
}
|
||||
|
||||
int nvapi_getinfo(unsigned int devNum, uint16_t &vid, uint16_t &pid)
|
||||
int nvapi_getinfo(unsigned int devNum, uint16_t *vid, uint16_t *pid)
|
||||
{
|
||||
NvAPI_Status ret;
|
||||
NvU32 pDeviceId, pSubSystemId, pRevisionId, pExtDeviceId;
|
||||
|
||||
if (devNum >= nvapi_dev_cnt)
|
||||
return -ENODEV;
|
||||
return -1;
|
||||
|
||||
ret = NvAPI_GPU_GetPCIIdentifiers(phys[devNum], &pDeviceId, &pSubSystemId, &pRevisionId, &pExtDeviceId);
|
||||
if (ret != NVAPI_OK) {
|
||||
@@ -846,8 +565,8 @@ int nvapi_getinfo(unsigned int devNum, uint16_t &vid, uint16_t &pid)
|
||||
return -1;
|
||||
}
|
||||
|
||||
pid = pDeviceId >> 16;
|
||||
vid = pDeviceId & 0xFFFF;
|
||||
(*pid) = pDeviceId >> 16;
|
||||
(*vid) = pDeviceId & 0xFFFF;
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -856,7 +575,7 @@ int nvapi_getserial(unsigned int devNum, char *serial, unsigned int maxlen)
|
||||
{
|
||||
// NvAPI_Status ret;
|
||||
if (devNum >= nvapi_dev_cnt)
|
||||
return -ENODEV;
|
||||
return -1;
|
||||
|
||||
sprintf(serial, "");
|
||||
|
||||
@@ -880,7 +599,7 @@ int nvapi_getbios(unsigned int devNum, char *desc, unsigned int maxlen)
|
||||
{
|
||||
NvAPI_Status ret;
|
||||
if (devNum >= nvapi_dev_cnt)
|
||||
return -ENODEV;
|
||||
return -1;
|
||||
|
||||
if (maxlen < 64) // Short String
|
||||
return -1;
|
||||
@@ -957,7 +676,7 @@ int nvapi_init()
|
||||
NvAPI_ShortString str;
|
||||
ret = NvAPI_SYS_GetDriverAndBranchVersion(&udv, str);
|
||||
if (ret == NVAPI_OK) {
|
||||
sprintf(driver_version,"%d.%02d", udv / 100, udv % 100);
|
||||
sprintf(driver_version,"%d.%d", udv/100, udv % 100);
|
||||
}
|
||||
|
||||
return 0;
|
||||
@@ -1066,107 +785,9 @@ unsigned int gpu_power(struct cgpu_info *gpu)
|
||||
return mw;
|
||||
}
|
||||
|
||||
static int translate_vendor_id(uint16_t vid, char *vendorname)
|
||||
{
|
||||
struct VENDORS {
|
||||
const uint16_t vid;
|
||||
const char *name;
|
||||
} vendors[] = {
|
||||
{ 0x1043, "ASUS" },
|
||||
{ 0x107D, "Leadtek" },
|
||||
{ 0x10B0, "Gainward" },
|
||||
// { 0x10DE, "NVIDIA" },
|
||||
{ 0x1458, "Gigabyte" },
|
||||
{ 0x1462, "MSI" },
|
||||
{ 0x154B, "PNY" },
|
||||
{ 0x1682, "XFX" },
|
||||
{ 0x196D, "Club3D" },
|
||||
{ 0x19DA, "Zotac" },
|
||||
{ 0x19F1, "BFG" },
|
||||
{ 0x1ACC, "PoV" },
|
||||
{ 0x1B4C, "KFA2" },
|
||||
{ 0x3842, "EVGA" },
|
||||
{ 0x7377, "Colorful" },
|
||||
{ 0, "" }
|
||||
};
|
||||
|
||||
if (!vendorname)
|
||||
return -EINVAL;
|
||||
|
||||
for(int v=0; v < ARRAY_SIZE(vendors); v++) {
|
||||
if (vid == vendors[v].vid) {
|
||||
strcpy(vendorname, vendors[v].name);
|
||||
return vid;
|
||||
}
|
||||
}
|
||||
if (opt_debug)
|
||||
applog(LOG_DEBUG, "nvml: Unknown vendor %04x\n", vid);
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef HAVE_PCIDEV
|
||||
extern "C" {
|
||||
#include <pci/pci.h>
|
||||
}
|
||||
static int linux_gpu_vendor(uint8_t pci_bus_id, char* vendorname, uint16_t &pid)
|
||||
{
|
||||
uint16_t subvendor = 0;
|
||||
struct pci_access *pci;
|
||||
struct pci_dev *dev;
|
||||
uint16_t subdevice;
|
||||
|
||||
if (!vendorname)
|
||||
return -EINVAL;
|
||||
|
||||
pci = pci_alloc();
|
||||
if (!pci)
|
||||
return -ENODEV;
|
||||
|
||||
pci_init(pci);
|
||||
pci_scan_bus(pci);
|
||||
|
||||
for(dev = pci->devices; dev; dev = dev->next)
|
||||
{
|
||||
if (dev->bus == pci_bus_id && dev->vendor_id == 0x10DE)
|
||||
{
|
||||
if (!(dev->known_fields & PCI_FILL_CLASS))
|
||||
pci_fill_info(dev, PCI_FILL_CLASS);
|
||||
if (dev->device_class != PCI_CLASS_DISPLAY_VGA)
|
||||
continue;
|
||||
subvendor = pci_read_word(dev, PCI_SUBSYSTEM_VENDOR_ID);
|
||||
subdevice = pci_read_word(dev, PCI_SUBSYSTEM_ID); // model
|
||||
|
||||
translate_vendor_id(subvendor, vendorname);
|
||||
}
|
||||
}
|
||||
pci_cleanup(pci);
|
||||
return (int) subvendor;
|
||||
}
|
||||
#endif
|
||||
|
||||
int gpu_vendor(uint8_t pci_bus_id, char *vendorname)
|
||||
{
|
||||
#ifdef HAVE_PCIDEV
|
||||
uint16_t pid = 0;
|
||||
return linux_gpu_vendor(pci_bus_id, vendorname, pid);
|
||||
#else
|
||||
uint16_t vid = 0, pid = 0;
|
||||
if (hnvml) { // may not be initialized on start...
|
||||
for (int id=0; id < hnvml->nvml_gpucount; id++) {
|
||||
if (hnvml->nvml_pci_bus_id[id] == pci_bus_id) {
|
||||
nvml_get_info(hnvml, id, vid, pid);
|
||||
}
|
||||
}
|
||||
}
|
||||
return translate_vendor_id(vid, vendorname);
|
||||
#endif
|
||||
}
|
||||
|
||||
int gpu_info(struct cgpu_info *gpu)
|
||||
{
|
||||
char vendorname[32] = { 0 };
|
||||
int id = gpu->gpu_id;
|
||||
uint8_t bus_id = 0;
|
||||
|
||||
gpu->nvml_id = -1;
|
||||
gpu->nvapi_id = -1;
|
||||
@@ -1176,19 +797,13 @@ int gpu_info(struct cgpu_info *gpu)
|
||||
|
||||
if (hnvml) {
|
||||
gpu->nvml_id = (int8_t) hnvml->cuda_nvml_device_id[id];
|
||||
#ifdef HAVE_PCIDEV
|
||||
gpu->gpu_vid = linux_gpu_vendor(hnvml->nvml_pci_bus_id[id], vendorname, gpu->gpu_pid);
|
||||
if (!gpu->gpu_vid || !gpu->gpu_pid)
|
||||
nvml_get_info(hnvml, id, gpu->gpu_vid, gpu->gpu_pid);
|
||||
#else
|
||||
nvml_get_info(hnvml, id, gpu->gpu_vid, gpu->gpu_pid);
|
||||
#endif
|
||||
nvml_get_info(hnvml, id, &gpu->gpu_vid, &gpu->gpu_pid);
|
||||
nvml_get_serial(hnvml, id, gpu->gpu_sn, sizeof(gpu->gpu_sn));
|
||||
nvml_get_bios(hnvml, id, gpu->gpu_desc, sizeof(gpu->gpu_desc));
|
||||
}
|
||||
#ifdef WIN32
|
||||
gpu->nvapi_id = (int8_t) nvapi_dev_map[id];
|
||||
nvapi_getinfo(nvapi_dev_map[id], gpu->gpu_vid, gpu->gpu_pid);
|
||||
nvapi_getinfo(nvapi_dev_map[id], &gpu->gpu_vid, &gpu->gpu_pid);
|
||||
nvapi_getserial(nvapi_dev_map[id], gpu->gpu_sn, sizeof(gpu->gpu_sn));
|
||||
nvapi_getbios(nvapi_dev_map[id], gpu->gpu_desc, sizeof(gpu->gpu_desc));
|
||||
#endif
|
||||
|
||||
@@ -66,20 +66,6 @@ enum nvmlClockType_t {
|
||||
NVML_CLOCK_MEM = 2
|
||||
};
|
||||
|
||||
enum nvmlPcieUtilCounter_t {
|
||||
NVML_PCIE_UTIL_TX_BYTES = 0,
|
||||
NVML_PCIE_UTIL_RX_BYTES = 1,
|
||||
NVML_PCIE_UTIL_COUNT
|
||||
};
|
||||
|
||||
enum nvmlValueType_t {
|
||||
NVML_VALUE_TYPE_DOUBLE = 0,
|
||||
NVML_VALUE_TYPE_UNSIGNED_INT = 1,
|
||||
NVML_VALUE_TYPE_UNSIGNED_LONG = 2,
|
||||
NVML_VALUE_TYPE_UNSIGNED_LONG_LONG = 3,
|
||||
NVML_VALUE_TYPE_COUNT
|
||||
};
|
||||
|
||||
#define NVML_DEVICE_SERIAL_BUFFER_SIZE 30
|
||||
#define NVML_DEVICE_UUID_BUFFER_SIZE 80
|
||||
#define NVML_DEVICE_VBIOS_VERSION_BUFFER_SIZE 32
|
||||
@@ -108,20 +94,8 @@ typedef struct {
|
||||
nvmlReturn_t (*nvmlDeviceGetDefaultApplicationsClock)(nvmlDevice_t, nvmlClockType_t, unsigned int *);
|
||||
nvmlReturn_t (*nvmlDeviceGetApplicationsClock)(nvmlDevice_t, nvmlClockType_t, unsigned int *);
|
||||
nvmlReturn_t (*nvmlDeviceSetApplicationsClocks)(nvmlDevice_t, unsigned int, unsigned int);
|
||||
nvmlReturn_t (*nvmlDeviceResetApplicationsClocks)(nvmlDevice_t);
|
||||
nvmlReturn_t (*nvmlDeviceGetSupportedGraphicsClocks)(nvmlDevice_t, uint32_t mem, uint32_t *num, uint32_t *arr);
|
||||
nvmlReturn_t (*nvmlDeviceGetSupportedMemoryClocks)(nvmlDevice_t, unsigned int *count, unsigned int *clocksMHz);
|
||||
nvmlReturn_t (*nvmlDeviceGetClockInfo)(nvmlDevice_t, nvmlClockType_t, unsigned int *);
|
||||
nvmlReturn_t (*nvmlDeviceGetMaxClockInfo)(nvmlDevice_t, nvmlClockType_t, unsigned int *);
|
||||
nvmlReturn_t (*nvmlDeviceGetPowerManagementDefaultLimit)(nvmlDevice_t, unsigned int *limit);
|
||||
nvmlReturn_t (*nvmlDeviceGetPowerManagementLimit)(nvmlDevice_t, unsigned int *limit);
|
||||
nvmlReturn_t (*nvmlDeviceGetPowerManagementLimitConstraints)(nvmlDevice_t, unsigned int *min, unsigned int *max);
|
||||
nvmlReturn_t (*nvmlDeviceSetPowerManagementLimit)(nvmlDevice_t device, unsigned int limit);
|
||||
nvmlReturn_t (*nvmlDeviceGetPciInfo)(nvmlDevice_t, nvmlPciInfo_t *);
|
||||
nvmlReturn_t (*nvmlDeviceGetCurrPcieLinkGeneration)(nvmlDevice_t device, unsigned int *gen);
|
||||
nvmlReturn_t (*nvmlDeviceGetCurrPcieLinkWidth)(nvmlDevice_t device, unsigned int *width);
|
||||
nvmlReturn_t (*nvmlDeviceGetMaxPcieLinkGeneration)(nvmlDevice_t device, unsigned int *gen);
|
||||
nvmlReturn_t (*nvmlDeviceGetMaxPcieLinkWidth)(nvmlDevice_t device, unsigned int *width);
|
||||
nvmlReturn_t (*nvmlDeviceGetName)(nvmlDevice_t, char *, int);
|
||||
nvmlReturn_t (*nvmlDeviceGetTemperature)(nvmlDevice_t, int, unsigned int *);
|
||||
nvmlReturn_t (*nvmlDeviceGetFanSpeed)(nvmlDevice_t, unsigned int *);
|
||||
@@ -133,15 +107,6 @@ typedef struct {
|
||||
nvmlReturn_t (*nvmlSystemGetDriverVersion)(char *version, unsigned int len);
|
||||
char* (*nvmlErrorString)(nvmlReturn_t);
|
||||
nvmlReturn_t (*nvmlShutdown)(void);
|
||||
// v331
|
||||
nvmlReturn_t (*nvmlDeviceGetEnforcedPowerLimit)(nvmlDevice_t, unsigned int *limit);
|
||||
// v340
|
||||
//nvmlReturn_t (*nvmlDeviceGetCpuAffinity)(nvmlDevice_t, unsigned int cpuSetSize, unsigned long* cpuSet);
|
||||
//nvmlReturn_t (*nvmlDeviceSetCpuAffinity)(nvmlDevice_t);
|
||||
//nvmlReturn_t (*nvmlDeviceGetAutoBoostedClocksEnabled)(nvmlDevice_t, nvmlEnableState_t *isEnabled, nvmlEnableState_t *defaultIsEnabled);
|
||||
//nvmlReturn_t (*nvmlDeviceSetAutoBoostedClocksEnabled)(nvmlDevice_t, nvmlEnableState_t enabled);
|
||||
// v346
|
||||
nvmlReturn_t (*nvmlDeviceGetPcieThroughput)(nvmlDevice_t, nvmlPcieUtilCounter_t, unsigned int *value);
|
||||
} nvml_handle;
|
||||
|
||||
|
||||
@@ -153,11 +118,43 @@ int nvml_destroy(nvml_handle *nvmlh);
|
||||
*/
|
||||
int nvml_get_gpucount(nvml_handle *nvmlh, int *gpucount);
|
||||
|
||||
int nvml_set_plimit(nvml_handle *nvmlh, int dev_id);
|
||||
int nvml_set_pstate(nvml_handle *nvmlh, int dev_id);
|
||||
/*
|
||||
* Query the number of GPUs seen by CUDA
|
||||
*/
|
||||
int cuda_get_gpucount(nvml_handle *nvmlh, int *gpucount);
|
||||
|
||||
int nvml_set_clocks(nvml_handle *nvmlh, int dev_id);
|
||||
int nvml_reset_clocks(nvml_handle *nvmlh, int dev_id);
|
||||
|
||||
/*
|
||||
* query the name of the GPU model from the CUDA device ID
|
||||
*
|
||||
*/
|
||||
int nvml_get_gpu_name(nvml_handle *nvmlh,
|
||||
int gpuindex,
|
||||
char *namebuf,
|
||||
int bufsize);
|
||||
|
||||
/*
|
||||
* Query the current GPU temperature (Celsius), from the CUDA device ID
|
||||
*/
|
||||
int nvml_get_tempC(nvml_handle *nvmlh,
|
||||
int gpuindex, unsigned int *tempC);
|
||||
|
||||
/*
|
||||
* Query the current GPU fan speed (percent) from the CUDA device ID
|
||||
*/
|
||||
int nvml_get_fanpcnt(nvml_handle *nvmlh,
|
||||
int gpuindex, unsigned int *fanpcnt);
|
||||
|
||||
/*
|
||||
* Query the current GPU power usage in millwatts from the CUDA device ID
|
||||
*
|
||||
* This feature is only available on recent GPU generations and may be
|
||||
* limited in some cases only to Tesla series GPUs.
|
||||
* If the query is run on an unsupported GPU, this routine will return -1.
|
||||
*/
|
||||
int nvml_get_power_usage(nvml_handle *nvmlh,
|
||||
int gpuindex,
|
||||
unsigned int *milliwatts);
|
||||
|
||||
/* api functions */
|
||||
|
||||
@@ -165,13 +162,12 @@ unsigned int gpu_fanpercent(struct cgpu_info *gpu);
|
||||
unsigned int gpu_fanrpm(struct cgpu_info *gpu);
|
||||
float gpu_temp(struct cgpu_info *gpu);
|
||||
unsigned int gpu_power(struct cgpu_info *gpu);
|
||||
unsigned int gpu_usage(struct cgpu_info *gpu);
|
||||
int gpu_pstate(struct cgpu_info *gpu);
|
||||
int gpu_busid(struct cgpu_info *gpu);
|
||||
|
||||
/* pid/vid, sn and bios rev */
|
||||
int gpu_info(struct cgpu_info *gpu);
|
||||
int gpu_vendor(uint8_t pci_bus_id, char *vendorname);
|
||||
|
||||
|
||||
/* nvapi functions */
|
||||
#ifdef WIN32
|
||||
|
||||
@@ -0,0 +1,573 @@
|
||||
/*
|
||||
* "pluck" kernel implementation.
|
||||
*
|
||||
* ==========================(LICENSE BEGIN)============================
|
||||
*
|
||||
* Copyright (c) 2015 djm34
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining
|
||||
* a copy of this software and associated documentation files (the
|
||||
* "Software"), to deal in the Software without restriction, including
|
||||
* without limitation the rights to use, copy, modify, merge, publish,
|
||||
* distribute, sublicense, and/or sell copies of the Software, and to
|
||||
* permit persons to whom the Software is furnished to do so, subject to
|
||||
* the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be
|
||||
* included in all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* ===========================(LICENSE END)=============================
|
||||
*
|
||||
* @author djm34
|
||||
* @author tpruvot
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <memory.h>
|
||||
|
||||
#include "cuda_vector.h"
|
||||
|
||||
#include "miner.h"
|
||||
|
||||
uint32_t *d_PlNonce[MAX_GPUS];
|
||||
|
||||
__device__ uint8_t * hashbuffer;
|
||||
__constant__ uint32_t pTarget[8];
|
||||
__constant__ uint32_t c_data[20];
|
||||
|
||||
#define HASH_MEMORY_8bit 131072
|
||||
#define HASH_MEMORY_32bit 32768
|
||||
#define HASH_MEMORY 4096
|
||||
|
||||
static __constant__ uint32_t H256[8] = {
|
||||
0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
|
||||
0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
|
||||
};
|
||||
|
||||
static __constant__ uint32_t Ksha[64] = {
|
||||
0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
|
||||
0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
|
||||
0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
|
||||
0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
|
||||
0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,
|
||||
0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
|
||||
0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,
|
||||
0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
|
||||
0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
|
||||
0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
|
||||
0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,
|
||||
0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
|
||||
0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,
|
||||
0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
|
||||
0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
|
||||
0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2
|
||||
};
|
||||
|
||||
|
||||
#define SALSA(a,b,c,d) { \
|
||||
t = a+d; b^=rotateL(t, 7); \
|
||||
t = b+a; c^=rotateL(t, 9); \
|
||||
t = c+b; d^=rotateL(t, 13); \
|
||||
t = d+c; a^=rotateL(t, 18); \
|
||||
}
|
||||
|
||||
#define SALSA_CORE(state) { \
|
||||
SALSA(state.s0,state.s4,state.s8,state.sc); \
|
||||
SALSA(state.s5,state.s9,state.sd,state.s1); \
|
||||
SALSA(state.sa,state.se,state.s2,state.s6); \
|
||||
SALSA(state.sf,state.s3,state.s7,state.sb); \
|
||||
SALSA(state.s0,state.s1,state.s2,state.s3); \
|
||||
SALSA(state.s5,state.s6,state.s7,state.s4); \
|
||||
SALSA(state.sa,state.sb,state.s8,state.s9); \
|
||||
SALSA(state.sf,state.sc,state.sd,state.se); \
|
||||
}
|
||||
|
||||
#if __CUDA_ARCH__ >= 320
|
||||
static __device__ __forceinline__ uint16 xor_salsa8(const uint16 &Bx)
|
||||
{
|
||||
uint32_t t;
|
||||
uint16 state = Bx;
|
||||
SALSA_CORE(state);
|
||||
SALSA_CORE(state);
|
||||
SALSA_CORE(state);
|
||||
SALSA_CORE(state);
|
||||
return(state+Bx);
|
||||
}
|
||||
#endif
|
||||
|
||||
// sha256
|
||||
|
||||
static __device__ __forceinline__ uint32_t bsg2_0(const uint32_t x)
|
||||
{
|
||||
uint32_t r1 = ROTR32(x, 2);
|
||||
uint32_t r2 = ROTR32(x, 13);
|
||||
uint32_t r3 = ROTR32(x, 22);
|
||||
return xor3b(r1, r2, r3);
|
||||
}
|
||||
|
||||
static __device__ __forceinline__ uint32_t bsg2_1(const uint32_t x)
|
||||
{
|
||||
uint32_t r1 = ROTR32(x, 6);
|
||||
uint32_t r2 = ROTR32(x, 11);
|
||||
uint32_t r3 = ROTR32(x, 25);
|
||||
return xor3b(r1, r2, r3);
|
||||
}
|
||||
|
||||
static __device__ __forceinline__ uint32_t ssg2_0(const uint32_t x)
|
||||
{
|
||||
uint64_t r1 = ROTR32(x, 7);
|
||||
uint64_t r2 = ROTR32(x, 18);
|
||||
uint64_t r3 = shr_t32(x, 3);
|
||||
return xor3b(r1, r2, r3);
|
||||
}
|
||||
|
||||
static __device__ __forceinline__ uint32_t ssg2_1(const uint32_t x)
|
||||
{
|
||||
uint64_t r1 = ROTR32(x, 17);
|
||||
uint64_t r2 = ROTR32(x, 19);
|
||||
uint64_t r3 = shr_t32(x, 10);
|
||||
return xor3b(r1, r2, r3);
|
||||
}
|
||||
|
||||
static __device__ __forceinline__ void sha2_step1(const uint32_t a, const uint32_t b, const uint32_t c, uint32_t &d, const uint32_t e,
|
||||
const uint32_t f, const uint32_t g, uint32_t &h, const uint32_t in, const uint32_t Kshared)
|
||||
{
|
||||
uint32_t t1, t2;
|
||||
uint32_t vxandx = xandx(e, f, g);
|
||||
uint32_t bsg21 = bsg2_1(e);
|
||||
uint32_t bsg20 = bsg2_0(a);
|
||||
uint32_t andorv = andor32(a, b, c);
|
||||
|
||||
t1 = h + bsg21 + vxandx + Kshared + in;
|
||||
t2 = bsg20 + andorv;
|
||||
d = d + t1;
|
||||
h = t1 + t2;
|
||||
}
|
||||
|
||||
static __device__ __forceinline__ void sha2_step2(const uint32_t a, const uint32_t b, const uint32_t c, uint32_t &d, const uint32_t e,
|
||||
const uint32_t f, const uint32_t g, uint32_t &h, uint32_t* in, const uint32_t pc, const uint32_t Kshared)
|
||||
{
|
||||
uint32_t t1, t2;
|
||||
|
||||
int pcidx1 = (pc - 2) & 0xF;
|
||||
int pcidx2 = (pc - 7) & 0xF;
|
||||
int pcidx3 = (pc - 15) & 0xF;
|
||||
uint32_t inx0 = in[pc];
|
||||
uint32_t inx1 = in[pcidx1];
|
||||
uint32_t inx2 = in[pcidx2];
|
||||
uint32_t inx3 = in[pcidx3];
|
||||
|
||||
uint32_t ssg21 = ssg2_1(inx1);
|
||||
uint32_t ssg20 = ssg2_0(inx3);
|
||||
uint32_t vxandx = xandx(e, f, g);
|
||||
uint32_t bsg21 = bsg2_1(e);
|
||||
uint32_t bsg20 = bsg2_0(a);
|
||||
uint32_t andorv = andor32(a, b, c);
|
||||
|
||||
in[pc] = ssg21 + inx2 + ssg20 + inx0;
|
||||
|
||||
t1 = h + bsg21 + vxandx + Kshared + in[pc];
|
||||
t2 = bsg20 + andorv;
|
||||
d = d + t1;
|
||||
h = t1 + t2;
|
||||
}
|
||||
|
||||
static __device__ __forceinline__
|
||||
void sha2_round_body(uint32_t* in, uint32_t* r)
|
||||
{
|
||||
uint32_t a = r[0];
|
||||
uint32_t b = r[1];
|
||||
uint32_t c = r[2];
|
||||
uint32_t d = r[3];
|
||||
uint32_t e = r[4];
|
||||
uint32_t f = r[5];
|
||||
uint32_t g = r[6];
|
||||
uint32_t h = r[7];
|
||||
|
||||
sha2_step1(a, b, c, d, e, f, g, h, in[0], Ksha[0]);
|
||||
sha2_step1(h, a, b, c, d, e, f, g, in[1], Ksha[1]);
|
||||
sha2_step1(g, h, a, b, c, d, e, f, in[2], Ksha[2]);
|
||||
sha2_step1(f, g, h, a, b, c, d, e, in[3], Ksha[3]);
|
||||
sha2_step1(e, f, g, h, a, b, c, d, in[4], Ksha[4]);
|
||||
sha2_step1(d, e, f, g, h, a, b, c, in[5], Ksha[5]);
|
||||
sha2_step1(c, d, e, f, g, h, a, b, in[6], Ksha[6]);
|
||||
sha2_step1(b, c, d, e, f, g, h, a, in[7], Ksha[7]);
|
||||
sha2_step1(a, b, c, d, e, f, g, h, in[8], Ksha[8]);
|
||||
sha2_step1(h, a, b, c, d, e, f, g, in[9], Ksha[9]);
|
||||
sha2_step1(g, h, a, b, c, d, e, f, in[10], Ksha[10]);
|
||||
sha2_step1(f, g, h, a, b, c, d, e, in[11], Ksha[11]);
|
||||
sha2_step1(e, f, g, h, a, b, c, d, in[12], Ksha[12]);
|
||||
sha2_step1(d, e, f, g, h, a, b, c, in[13], Ksha[13]);
|
||||
sha2_step1(c, d, e, f, g, h, a, b, in[14], Ksha[14]);
|
||||
sha2_step1(b, c, d, e, f, g, h, a, in[15], Ksha[15]);
|
||||
|
||||
#pragma unroll 3
|
||||
for (int i = 0; i<3; i++) {
|
||||
|
||||
sha2_step2(a, b, c, d, e, f, g, h, in, 0, Ksha[16 + 16 * i]);
|
||||
sha2_step2(h, a, b, c, d, e, f, g, in, 1, Ksha[17 + 16 * i]);
|
||||
sha2_step2(g, h, a, b, c, d, e, f, in, 2, Ksha[18 + 16 * i]);
|
||||
sha2_step2(f, g, h, a, b, c, d, e, in, 3, Ksha[19 + 16 * i]);
|
||||
sha2_step2(e, f, g, h, a, b, c, d, in, 4, Ksha[20 + 16 * i]);
|
||||
sha2_step2(d, e, f, g, h, a, b, c, in, 5, Ksha[21 + 16 * i]);
|
||||
sha2_step2(c, d, e, f, g, h, a, b, in, 6, Ksha[22 + 16 * i]);
|
||||
sha2_step2(b, c, d, e, f, g, h, a, in, 7, Ksha[23 + 16 * i]);
|
||||
sha2_step2(a, b, c, d, e, f, g, h, in, 8, Ksha[24 + 16 * i]);
|
||||
sha2_step2(h, a, b, c, d, e, f, g, in, 9, Ksha[25 + 16 * i]);
|
||||
sha2_step2(g, h, a, b, c, d, e, f, in, 10, Ksha[26 + 16 * i]);
|
||||
sha2_step2(f, g, h, a, b, c, d, e, in, 11, Ksha[27 + 16 * i]);
|
||||
sha2_step2(e, f, g, h, a, b, c, d, in, 12, Ksha[28 + 16 * i]);
|
||||
sha2_step2(d, e, f, g, h, a, b, c, in, 13, Ksha[29 + 16 * i]);
|
||||
sha2_step2(c, d, e, f, g, h, a, b, in, 14, Ksha[30 + 16 * i]);
|
||||
sha2_step2(b, c, d, e, f, g, h, a, in, 15, Ksha[31 + 16 * i]);
|
||||
|
||||
}
|
||||
|
||||
r[0] += a;
|
||||
r[1] += b;
|
||||
r[2] += c;
|
||||
r[3] += d;
|
||||
r[4] += e;
|
||||
r[5] += f;
|
||||
r[6] += g;
|
||||
r[7] += h;
|
||||
}
|
||||
|
||||
static __device__ __forceinline__ uint8 sha256_64(uint32_t *data)
|
||||
{
|
||||
uint32_t __align__(64) in[16];
|
||||
uint32_t __align__(32) buf[8];
|
||||
|
||||
((uint16 *)in)[0] = swapvec((uint16*)data);
|
||||
|
||||
((uint8*)buf)[0] = ((uint8*)H256)[0];
|
||||
|
||||
sha2_round_body(in, buf);
|
||||
|
||||
#pragma unroll 14
|
||||
for (int i = 0; i<14; i++) { in[i + 1] = 0; }
|
||||
|
||||
in[0] = 0x80000000;
|
||||
in[15] = 0x200;
|
||||
|
||||
sha2_round_body(in, buf);
|
||||
return swapvec((uint8*)buf);
|
||||
}
|
||||
|
||||
static __device__ __forceinline__ uint8 sha256_80(uint32_t nonce)
|
||||
{
|
||||
uint32_t __align__(64) in[16];
|
||||
uint32_t __align__(32) buf[8];
|
||||
|
||||
((uint16 *)in)[0] = swapvec((uint16*)c_data);
|
||||
((uint8*)buf)[0] = ((uint8*)H256)[0];
|
||||
|
||||
sha2_round_body(in, buf);
|
||||
|
||||
#pragma unroll 3
|
||||
for (int i = 0; i<3; i++) { in[i] = cuda_swab32(c_data[i + 16]); }
|
||||
|
||||
// in[3] = cuda_swab32(nonce);
|
||||
in[3] = nonce;
|
||||
in[4] = 0x80000000;
|
||||
in[15] = 0x280;
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 5; i<15; i++) { in[i] = 0; }
|
||||
|
||||
sha2_round_body(in, buf);
|
||||
return swapvec((uint8*)buf);
|
||||
}
|
||||
|
||||
// Pluck Factor 128
|
||||
#define SHIFT (1024 * 128)
|
||||
|
||||
__global__ __launch_bounds__(256, 1)
|
||||
void pluck_gpu_hash0_v50(uint32_t threads, uint32_t startNonce)
|
||||
{
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
#if __CUDA_ARCH__ >= 320
|
||||
const uint32_t nonce = startNonce + thread;
|
||||
uint32_t shift = SHIFT * thread;
|
||||
((uint8*)(hashbuffer + shift))[0] = sha256_80(nonce);
|
||||
((uint8*)(hashbuffer + shift))[1] = make_uint8(0, 0, 0, 0, 0, 0, 0, 0);
|
||||
for (int i = 2; i < 5; i++)
|
||||
{
|
||||
uint32_t randmax = i * 32 - 4;
|
||||
uint32_t randseed[16];
|
||||
uint32_t randbuffer[16];
|
||||
uint32_t joint[16];
|
||||
|
||||
((uint8*)randseed)[0] = __ldg8(&(hashbuffer + shift)[32 * i - 64]);
|
||||
((uint8*)randseed)[1] = __ldg8(&(hashbuffer + shift)[32 * i - 32]);
|
||||
|
||||
((uint16*)randbuffer)[0] = xor_salsa8(((uint16*)randseed)[0]);
|
||||
|
||||
((uint8*)joint)[0] = ((uint8*)randseed)[1];
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 8; j++) {
|
||||
uint32_t rand = randbuffer[j] % (randmax - 32);
|
||||
joint[j + 8] = __ldgtoint_unaligned(&(hashbuffer + shift)[rand]);
|
||||
}
|
||||
|
||||
uint8 truc = sha256_64(joint);
|
||||
((uint8*)(hashbuffer + shift))[i] = truc;
|
||||
((uint8*)randseed)[0] = ((uint8*)joint)[0];
|
||||
((uint8*)randseed)[1] = truc;
|
||||
|
||||
((uint16*)randbuffer)[0] = xor_salsa8(((uint16*)randseed)[0]);
|
||||
|
||||
for (int j = 0; j < 32; j += 2)
|
||||
{
|
||||
uint32_t rand = randbuffer[j / 2] % randmax;
|
||||
(hashbuffer + shift)[rand] = __ldg(&(hashbuffer + shift)[randmax + j]);
|
||||
(hashbuffer + shift)[rand + 1] = __ldg(&(hashbuffer + shift)[randmax + j + 1]);
|
||||
(hashbuffer + shift)[rand + 2] = __ldg(&(hashbuffer + shift)[randmax + j + 2]);
|
||||
(hashbuffer + shift)[rand + 3] = __ldg(&(hashbuffer + shift)[randmax + j + 3]);
|
||||
}
|
||||
} // main loop
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
__global__ __launch_bounds__(256, 1)
|
||||
void pluck_gpu_hash_v50(uint32_t threads, uint32_t startNonce, uint32_t *nonceVector)
|
||||
{
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
#if __CUDA_ARCH__ >= 320
|
||||
const uint32_t nonce = startNonce + thread;
|
||||
uint32_t shift = SHIFT * thread;
|
||||
|
||||
for (int i = 5; i < HASH_MEMORY - 1; i++)
|
||||
{
|
||||
uint32_t randmax = i*32-4;
|
||||
uint32_t randseed[16];
|
||||
uint32_t randbuffer[16];
|
||||
uint32_t joint[16];
|
||||
uint8 Buffbuffer[2];
|
||||
|
||||
((uint8*)randseed)[0] = __ldg8(&(hashbuffer + shift)[32*i-64]);
|
||||
((uint8*)randseed)[1] = __ldg8(&(hashbuffer + shift)[32*i-32]);
|
||||
|
||||
|
||||
Buffbuffer[0] = __ldg8(&(hashbuffer + shift)[32*i - 128]);
|
||||
Buffbuffer[1] = __ldg8(&(hashbuffer + shift)[32*i - 96]);
|
||||
|
||||
((uint16*)randseed)[0] ^= ((uint16*)Buffbuffer)[0];
|
||||
((uint16*)randbuffer)[0]= xor_salsa8(((uint16*)randseed)[0]);
|
||||
((uint8*)joint)[0] = __ldg8(&(hashbuffer + shift)[(i-1)<<5]);
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 8; j++) {
|
||||
uint32_t rand = randbuffer[j] % (randmax - 32);
|
||||
joint[j+8] = __ldgtoint_unaligned(&(hashbuffer + shift)[rand]);
|
||||
}
|
||||
|
||||
uint8 truc = sha256_64(joint);
|
||||
((uint8*)(hashbuffer + shift))[i] = truc;
|
||||
((uint8*)randseed)[0] = ((uint8*)joint)[0];
|
||||
((uint8*)randseed)[1] = truc;
|
||||
|
||||
((uint16*)randseed)[0] ^= ((uint16*)Buffbuffer)[0];
|
||||
((uint16*)randbuffer)[0] = xor_salsa8(((uint16*)randseed)[0]);
|
||||
|
||||
for (int j = 0; j < 32; j += 2)
|
||||
{
|
||||
uint32_t rand = randbuffer[j / 2] % randmax;
|
||||
|
||||
(hashbuffer+shift)[rand] = __ldg(&(hashbuffer+shift)[randmax+j]);
|
||||
(hashbuffer + shift)[rand + 1] = __ldg(&(hashbuffer + shift)[randmax + j + 1]);
|
||||
(hashbuffer + shift)[rand + 2] = __ldg(&(hashbuffer + shift)[randmax + j + 2]);
|
||||
(hashbuffer + shift)[rand + 3] = __ldg(&(hashbuffer + shift)[randmax + j + 3]);
|
||||
}
|
||||
|
||||
} // main loop
|
||||
|
||||
uint32_t outbuf = __ldgtoint(&(hashbuffer + shift)[28]);
|
||||
|
||||
if (outbuf <= pTarget[7]) {
|
||||
nonceVector[0] = nonce;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
__global__ __launch_bounds__(128, 3)
|
||||
void pluck_gpu_hash0(uint32_t threads, uint32_t startNonce)
|
||||
{
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
#if __CUDA_ARCH__ >= 320
|
||||
const uint32_t nonce = startNonce + thread;
|
||||
|
||||
uint32_t shift = SHIFT * thread;
|
||||
((uint8*)(hashbuffer + shift))[0] = sha256_80(nonce);
|
||||
((uint8*)(hashbuffer + shift))[1] = make_uint8(0, 0, 0, 0, 0, 0, 0, 0);
|
||||
for (int i = 2; i < 5; i++)
|
||||
{
|
||||
uint32_t randmax = i * 32 - 4;
|
||||
uint32_t randseed[16];
|
||||
uint32_t randbuffer[16];
|
||||
uint32_t joint[16];
|
||||
|
||||
((uint8*)randseed)[0] = __ldg8(&(hashbuffer + shift)[32 * i - 64]);
|
||||
((uint8*)randseed)[1] = __ldg8(&(hashbuffer + shift)[32 * i - 32]);
|
||||
|
||||
((uint16*)randbuffer)[0] = xor_salsa8(((uint16*)randseed)[0]);
|
||||
|
||||
((uint8*)joint)[0] = ((uint8*)randseed)[1];
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 8; j++) {
|
||||
uint32_t rand = randbuffer[j] % (randmax - 32);
|
||||
joint[j + 8] = __ldgtoint_unaligned(&(hashbuffer + shift)[rand]);
|
||||
}
|
||||
|
||||
uint8 truc = sha256_64(joint);
|
||||
((uint8*)(hashbuffer + shift))[i] = truc;
|
||||
((uint8*)randseed)[0] = ((uint8*)joint)[0];
|
||||
((uint8*)randseed)[1] = truc;
|
||||
|
||||
((uint16*)randbuffer)[0] = xor_salsa8(((uint16*)randseed)[0]);
|
||||
|
||||
for (int j = 0; j < 32; j += 2)
|
||||
{
|
||||
uint32_t rand = randbuffer[j / 2] % randmax;
|
||||
(hashbuffer + shift)[rand] = __ldg(&(hashbuffer + shift)[randmax + j]);
|
||||
(hashbuffer + shift)[rand + 1] = __ldg(&(hashbuffer + shift)[randmax + j + 1]);
|
||||
(hashbuffer + shift)[rand + 2] = __ldg(&(hashbuffer + shift)[randmax + j + 2]);
|
||||
(hashbuffer + shift)[rand + 3] = __ldg(&(hashbuffer + shift)[randmax + j + 3]);
|
||||
}
|
||||
} // main loop
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
__global__ __launch_bounds__(128, 3)
|
||||
void pluck_gpu_hash(uint32_t threads, uint32_t startNonce, uint32_t *nonceVector)
|
||||
{
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
#if __CUDA_ARCH__ >= 320
|
||||
const uint32_t nonce = startNonce + thread;
|
||||
|
||||
uint32_t shift = SHIFT * thread;
|
||||
|
||||
for (int i = 5; i < HASH_MEMORY - 1; i++)
|
||||
{
|
||||
uint32_t randmax = i * 32 - 4;
|
||||
uint32_t randseed[16];
|
||||
uint32_t randbuffer[16];
|
||||
uint32_t joint[16];
|
||||
uint8 Buffbuffer[2];
|
||||
|
||||
((uint8*)randseed)[0] = __ldg8(&(hashbuffer + shift)[32 * i - 64]);
|
||||
((uint8*)randseed)[1] = __ldg8(&(hashbuffer + shift)[32 * i - 32]);
|
||||
|
||||
|
||||
Buffbuffer[0] = __ldg8(&(hashbuffer + shift)[32 * i - 128]);
|
||||
Buffbuffer[1] = __ldg8(&(hashbuffer + shift)[32 * i - 96]);
|
||||
((uint16*)randseed)[0] ^= ((uint16*)Buffbuffer)[0];
|
||||
|
||||
((uint16*)randbuffer)[0] = xor_salsa8(((uint16*)randseed)[0]);
|
||||
|
||||
((uint8*)joint)[0] = __ldg8(&(hashbuffer + shift)[(i - 1) << 5]);
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 8; j++)
|
||||
{
|
||||
uint32_t rand = randbuffer[j] % (randmax - 32);
|
||||
joint[j + 8] = __ldgtoint_unaligned(&(hashbuffer + shift)[rand]);
|
||||
}
|
||||
|
||||
uint8 truc = sha256_64(joint);
|
||||
((uint8*)(hashbuffer + shift))[i] = truc;
|
||||
((uint8*)randseed)[0] = ((uint8*)joint)[0];
|
||||
((uint8*)randseed)[1] = truc;
|
||||
|
||||
|
||||
((uint16*)randseed)[0] ^= ((uint16*)Buffbuffer)[0];
|
||||
((uint16*)randbuffer)[0] = xor_salsa8(((uint16*)randseed)[0]);
|
||||
for (int j = 0; j < 32; j += 2)
|
||||
{
|
||||
uint32_t rand = randbuffer[j / 2] % randmax;
|
||||
|
||||
(hashbuffer + shift)[rand] = __ldg(&(hashbuffer + shift)[randmax + j]);
|
||||
(hashbuffer + shift)[rand + 1] = __ldg(&(hashbuffer + shift)[randmax + j + 1]);
|
||||
(hashbuffer + shift)[rand + 2] = __ldg(&(hashbuffer + shift)[randmax + j + 2]);
|
||||
(hashbuffer + shift)[rand + 3] = __ldg(&(hashbuffer + shift)[randmax + j + 3]);
|
||||
}
|
||||
} // main loop
|
||||
|
||||
uint32_t outbuf = __ldgtoint(&(hashbuffer + shift)[28]);
|
||||
|
||||
if (outbuf <= pTarget[7]) {
|
||||
nonceVector[0] = nonce;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
void pluck_cpu_init(int thr_id, uint32_t threads, uint32_t* hash)
|
||||
{
|
||||
cuda_get_arch(thr_id);
|
||||
cudaMemcpyToSymbol(hashbuffer, &hash, sizeof(hash), 0, cudaMemcpyHostToDevice);
|
||||
cudaMalloc(&d_PlNonce[thr_id], sizeof(uint32_t));
|
||||
}
|
||||
|
||||
__host__
|
||||
uint32_t pluck_cpu_hash(int thr_id, uint32_t threads, uint32_t startNounce, int order)
|
||||
{
|
||||
uint32_t result[8] = { 0xffffffff };
|
||||
cudaMemset(d_PlNonce[thr_id], 0xff, sizeof(uint32_t));
|
||||
|
||||
const uint32_t threadsperblock = 128;
|
||||
|
||||
dim3 grid((threads + threadsperblock - 1) / threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
dim3 grid50((threads + 256 - 1) / 256);
|
||||
dim3 block50(256);
|
||||
|
||||
if (device_sm[device_map[thr_id]] <= 300) {
|
||||
applog(LOG_ERR,"Sorry pluck not supported on SM 3.0 devices");
|
||||
return 0;
|
||||
} else if (device_sm[device_map[thr_id]] >= 500) {
|
||||
pluck_gpu_hash0_v50 <<< grid50, block50 >>>(threads, startNounce);
|
||||
pluck_gpu_hash_v50 <<< grid50, block50 >>>(threads, startNounce, d_PlNonce[thr_id]);
|
||||
} else {
|
||||
pluck_gpu_hash0 <<< grid, block >>>(threads, startNounce);
|
||||
pluck_gpu_hash <<< grid, block >>>(threads, startNounce, d_PlNonce[thr_id]);
|
||||
}
|
||||
|
||||
//MyStreamSynchronize(NULL, order, thr_id);
|
||||
CUDA_SAFE_CALL(cudaThreadSynchronize());
|
||||
cudaMemcpy(&result[thr_id], d_PlNonce[thr_id], sizeof(uint32_t), cudaMemcpyDeviceToHost);
|
||||
|
||||
return result[thr_id];
|
||||
}
|
||||
|
||||
__host__
|
||||
void pluck_setBlockTarget(const void *pdata, const void *ptarget)
|
||||
{
|
||||
unsigned char PaddedMessage[80];
|
||||
memcpy(PaddedMessage, pdata, 80);
|
||||
|
||||
cudaMemcpyToSymbol(c_data, PaddedMessage, 80, 0, cudaMemcpyHostToDevice);
|
||||
cudaMemcpyToSymbol(pTarget, ptarget, 32, 0, cudaMemcpyHostToDevice);
|
||||
}
|
||||
+240
@@ -0,0 +1,240 @@
|
||||
/* Based on djm code */
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#include "miner.h"
|
||||
#include "cuda_helper.h"
|
||||
|
||||
#include <openssl/sha.h>
|
||||
|
||||
static uint32_t *d_hash[MAX_GPUS] ;
|
||||
|
||||
extern void pluck_setBlockTarget(const void* data, const void *ptarget);
|
||||
extern void pluck_cpu_init(int thr_id, uint32_t threads, uint32_t *d_outputHash);
|
||||
extern uint32_t pluck_cpu_hash(int thr_id, uint32_t threads, uint32_t startNounce, int order);
|
||||
|
||||
extern float tp_coef[MAX_GPUS];
|
||||
|
||||
#define ROTL(a, b) (((a) << (b)) | ((a) >> (32 - (b))))
|
||||
//note, this is 64 bytes
|
||||
static inline void xor_salsa8(uint32_t B[16], const uint32_t Bx[16])
|
||||
{
|
||||
#define ROTL(a, b) (((a) << (b)) | ((a) >> (32 - (b))))
|
||||
uint32_t x00, x01, x02, x03, x04, x05, x06, x07, x08, x09, x10, x11, x12, x13, x14, x15;
|
||||
int i;
|
||||
|
||||
x00 = (B[0] ^= Bx[0]);
|
||||
x01 = (B[1] ^= Bx[1]);
|
||||
x02 = (B[2] ^= Bx[2]);
|
||||
x03 = (B[3] ^= Bx[3]);
|
||||
x04 = (B[4] ^= Bx[4]);
|
||||
x05 = (B[5] ^= Bx[5]);
|
||||
x06 = (B[6] ^= Bx[6]);
|
||||
x07 = (B[7] ^= Bx[7]);
|
||||
x08 = (B[8] ^= Bx[8]);
|
||||
x09 = (B[9] ^= Bx[9]);
|
||||
x10 = (B[10] ^= Bx[10]);
|
||||
x11 = (B[11] ^= Bx[11]);
|
||||
x12 = (B[12] ^= Bx[12]);
|
||||
x13 = (B[13] ^= Bx[13]);
|
||||
x14 = (B[14] ^= Bx[14]);
|
||||
x15 = (B[15] ^= Bx[15]);
|
||||
for (i = 0; i < 8; i += 2) {
|
||||
/* Operate on columns. */
|
||||
x04 ^= ROTL(x00 + x12, 7); x09 ^= ROTL(x05 + x01, 7);
|
||||
x14 ^= ROTL(x10 + x06, 7); x03 ^= ROTL(x15 + x11, 7);
|
||||
|
||||
x08 ^= ROTL(x04 + x00, 9); x13 ^= ROTL(x09 + x05, 9);
|
||||
x02 ^= ROTL(x14 + x10, 9); x07 ^= ROTL(x03 + x15, 9);
|
||||
|
||||
x12 ^= ROTL(x08 + x04, 13); x01 ^= ROTL(x13 + x09, 13);
|
||||
x06 ^= ROTL(x02 + x14, 13); x11 ^= ROTL(x07 + x03, 13);
|
||||
|
||||
x00 ^= ROTL(x12 + x08, 18); x05 ^= ROTL(x01 + x13, 18);
|
||||
x10 ^= ROTL(x06 + x02, 18); x15 ^= ROTL(x11 + x07, 18);
|
||||
|
||||
/* Operate on rows. */
|
||||
x01 ^= ROTL(x00 + x03, 7); x06 ^= ROTL(x05 + x04, 7);
|
||||
x11 ^= ROTL(x10 + x09, 7); x12 ^= ROTL(x15 + x14, 7);
|
||||
|
||||
x02 ^= ROTL(x01 + x00, 9); x07 ^= ROTL(x06 + x05, 9);
|
||||
x08 ^= ROTL(x11 + x10, 9); x13 ^= ROTL(x12 + x15, 9);
|
||||
|
||||
x03 ^= ROTL(x02 + x01, 13); x04 ^= ROTL(x07 + x06, 13);
|
||||
x09 ^= ROTL(x08 + x11, 13); x14 ^= ROTL(x13 + x12, 13);
|
||||
|
||||
x00 ^= ROTL(x03 + x02, 18); x05 ^= ROTL(x04 + x07, 18);
|
||||
x10 ^= ROTL(x09 + x08, 18); x15 ^= ROTL(x14 + x13, 18);
|
||||
}
|
||||
B[0] += x00;
|
||||
B[1] += x01;
|
||||
B[2] += x02;
|
||||
B[3] += x03;
|
||||
B[4] += x04;
|
||||
B[5] += x05;
|
||||
B[6] += x06;
|
||||
B[7] += x07;
|
||||
B[8] += x08;
|
||||
B[9] += x09;
|
||||
B[10] += x10;
|
||||
B[11] += x11;
|
||||
B[12] += x12;
|
||||
B[13] += x13;
|
||||
B[14] += x14;
|
||||
B[15] += x15;
|
||||
#undef ROTL
|
||||
}
|
||||
|
||||
static void sha256_hash(uchar *hash, const uchar *data, int len)
|
||||
{
|
||||
SHA256_CTX ctx;
|
||||
SHA256_Init(&ctx);
|
||||
SHA256_Update(&ctx, data, len);
|
||||
SHA256_Final(hash, &ctx);
|
||||
}
|
||||
|
||||
// hash exactly 64 bytes (ie, sha256 block size)
|
||||
static void sha256_hash512(uint32_t *hash, const uint32_t *data)
|
||||
{
|
||||
uint32_t _ALIGN(64) S[16];
|
||||
uint32_t _ALIGN(64) T[16];
|
||||
uchar _ALIGN(64) E[64] = { 0 };
|
||||
int i;
|
||||
|
||||
sha256_init(S);
|
||||
|
||||
for (i = 0; i < 16; i++)
|
||||
T[i] = be32dec(&data[i]);
|
||||
sha256_transform(S, T, 0);
|
||||
|
||||
E[3] = 0x80;
|
||||
E[61] = 0x02; // T[15] = 8 * 64 => 0x200;
|
||||
sha256_transform(S, (uint32_t*)E, 0);
|
||||
|
||||
for (i = 0; i < 8; i++)
|
||||
be32enc(&hash[i], S[i]);
|
||||
}
|
||||
|
||||
#define BLOCK_HEADER_SIZE 80
|
||||
void pluckhash(uint32_t *hash, const uint32_t *data, uchar *hashbuffer, const int N)
|
||||
{
|
||||
int size = N * 1024;
|
||||
sha256_hash(hashbuffer, (uchar*)data, BLOCK_HEADER_SIZE);
|
||||
memset(&hashbuffer[32], 0, 32);
|
||||
|
||||
for (int i = 64; i < size - 32; i += 32)
|
||||
{
|
||||
uint32_t _ALIGN(64) randseed[16];
|
||||
uint32_t _ALIGN(64) randbuffer[16];
|
||||
uint32_t _ALIGN(64) joint[16];
|
||||
//i-4 because we use integers for all references against this, and we don't want to go 3 bytes over the defined area
|
||||
//we could use size here, but then it's probable to use 0 as the value in most cases
|
||||
int randmax = i - 4;
|
||||
|
||||
//setup randbuffer to be an array of random indexes
|
||||
memcpy(randseed, &hashbuffer[i - 64], 64);
|
||||
|
||||
if (i > 128) memcpy(randbuffer, &hashbuffer[i - 128], 64);
|
||||
else memset(randbuffer, 0, 64);
|
||||
|
||||
xor_salsa8((uint32_t*)randbuffer, (uint32_t*)randseed);
|
||||
memcpy(joint, &hashbuffer[i - 32], 32);
|
||||
|
||||
//use the last hash value as the seed
|
||||
for (int j = 32; j < 64; j += 4)
|
||||
{
|
||||
//every other time, change to next random index
|
||||
//randmax - 32 as otherwise we go beyond memory that's already been written to
|
||||
uint32_t rand = randbuffer[(j - 32) >> 2] % (randmax - 32);
|
||||
joint[j >> 2] = *((uint32_t *)&hashbuffer[rand]);
|
||||
}
|
||||
|
||||
sha256_hash512((uint32_t*)&hashbuffer[i], joint);
|
||||
|
||||
//setup randbuffer to be an array of random indexes
|
||||
//use last hash value and previous hash value(post-mixing)
|
||||
memcpy(randseed, &hashbuffer[i - 32], 64);
|
||||
|
||||
if (i > 128) memcpy(randbuffer, &hashbuffer[i - 128], 64);
|
||||
else memset(randbuffer, 0, 64);
|
||||
|
||||
xor_salsa8((uint32_t*)randbuffer, (uint32_t*)randseed);
|
||||
|
||||
//use the last hash value as the seed
|
||||
for (int j = 0; j < 32; j += 2)
|
||||
{
|
||||
uint32_t rand = randbuffer[j >> 1] % randmax;
|
||||
*((uint32_t *)(hashbuffer + rand)) = *((uint32_t *)(hashbuffer + j + randmax));
|
||||
}
|
||||
}
|
||||
|
||||
memcpy(hash, hashbuffer, 32);
|
||||
}
|
||||
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
|
||||
static __thread uchar* scratchbuf = NULL;
|
||||
|
||||
extern "C" int scanhash_pluck(int thr_id, uint32_t *pdata, const uint32_t *ptarget,
|
||||
uint32_t max_nonce, unsigned long *hashes_done)
|
||||
{
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
uint32_t endiandata[20];
|
||||
int opt_pluck_n = 128;
|
||||
|
||||
int intensity = is_windows() ? 17 : 19; /* beware > 20 could work and create diff problems later */
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1U << intensity);
|
||||
// divide by 128 for this algo which require a lot of memory
|
||||
throughput = throughput / 128 - 256;
|
||||
throughput = min(throughput, max_nonce - first_nonce + 1);
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0x0000ff;
|
||||
|
||||
if (!init[thr_id])
|
||||
{
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
//cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);
|
||||
//cudaDeviceSetCacheConfig(cudaFuncCachePreferL1);
|
||||
cudaMalloc(&d_hash[thr_id], opt_pluck_n * 1024 * throughput);
|
||||
|
||||
if (!scratchbuf)
|
||||
scratchbuf = (uchar*) calloc(opt_pluck_n, 1024);
|
||||
|
||||
pluck_cpu_init(thr_id, throughput, d_hash[thr_id]);
|
||||
|
||||
CUDA_SAFE_CALL(cudaGetLastError());
|
||||
applog(LOG_INFO, "Using %d cuda threads", throughput);
|
||||
|
||||
init[thr_id] = true;
|
||||
}
|
||||
|
||||
for (int k = 0; k < 20; k++)
|
||||
be32enc(&endiandata[k], ((uint32_t*)pdata)[k]);
|
||||
|
||||
pluck_setBlockTarget(endiandata,ptarget);
|
||||
|
||||
do {
|
||||
uint32_t foundNonce = pluck_cpu_hash(thr_id, throughput, pdata[19], 0);
|
||||
if (foundNonce != UINT32_MAX)
|
||||
{
|
||||
const uint32_t Htarg = ptarget[7];
|
||||
uint32_t vhash64[8];
|
||||
be32enc(&endiandata[19], foundNonce);
|
||||
pluckhash(vhash64, endiandata, scratchbuf, opt_pluck_n);
|
||||
if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) {
|
||||
*hashes_done = pdata[19] - first_nonce + throughput;
|
||||
pdata[19] = foundNonce;
|
||||
return 1;
|
||||
} else {
|
||||
applog(LOG_WARNING, "GPU #%d: result for %08x does not validate on CPU!", device_map[thr_id], foundNonce);
|
||||
}
|
||||
}
|
||||
|
||||
pdata[19] += throughput;
|
||||
|
||||
} while (pdata[19] < max_nonce && !work_restart[thr_id].restart);
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
return 0;
|
||||
}
|
||||
@@ -1,361 +0,0 @@
|
||||
/**
|
||||
* Functions which handle multiple pools data
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "miner.h"
|
||||
#include "compat.h"
|
||||
|
||||
// to move in miner.h
|
||||
extern bool allow_gbt;
|
||||
extern bool allow_mininginfo;
|
||||
extern bool check_dups;
|
||||
|
||||
extern double opt_max_diff;
|
||||
extern double opt_max_rate;
|
||||
extern int opt_scantime;
|
||||
extern int opt_time_limit;
|
||||
|
||||
extern char* rpc_url;
|
||||
extern char* rpc_user;
|
||||
extern char* rpc_pass;
|
||||
extern char* short_url;
|
||||
|
||||
extern struct work _ALIGN(64) g_work;
|
||||
extern struct stratum_ctx stratum;
|
||||
extern pthread_mutex_t stratum_work_lock;
|
||||
extern bool get_work(struct thr_info *thr, struct work *work);
|
||||
extern bool stratum_need_reset;
|
||||
extern time_t firstwork_time;
|
||||
|
||||
extern volatile time_t g_work_time;
|
||||
extern volatile int pool_switch_count;
|
||||
extern volatile bool pool_is_switching;
|
||||
extern uint8_t conditional_state[MAX_GPUS];
|
||||
|
||||
extern struct option options[];
|
||||
|
||||
#define CFG_NULL 0
|
||||
#define CFG_POOL 1
|
||||
struct opt_config_array {
|
||||
int cat;
|
||||
const char *name; // json key
|
||||
const char *longname; // global opt name if different
|
||||
} cfg_array_keys[] = {
|
||||
{ CFG_POOL, "url", NULL }, /* let this key first, increment pools */
|
||||
{ CFG_POOL, "user", NULL },
|
||||
{ CFG_POOL, "pass", NULL },
|
||||
{ CFG_POOL, "userpass", NULL },
|
||||
{ CFG_POOL, "name", "pool-name" },
|
||||
{ CFG_POOL, "scantime", "pool-scantime" },
|
||||
{ CFG_POOL, "max-diff", "pool-max-diff" },
|
||||
{ CFG_POOL, "max-rate", "pool-max-rate" },
|
||||
{ CFG_POOL, "removed", "pool-removed" },
|
||||
{ CFG_POOL, "disabled", "pool-removed" }, // sample alias
|
||||
{ CFG_POOL, "time-limit", "pool-time-limit" },
|
||||
{ CFG_NULL, NULL, NULL }
|
||||
};
|
||||
|
||||
// store current credentials in pools container
|
||||
void pool_set_creds(int pooln)
|
||||
{
|
||||
struct pool_infos *p = &pools[pooln];
|
||||
|
||||
snprintf(p->url, sizeof(p->url), "%s", rpc_url);
|
||||
snprintf(p->short_url, sizeof(p->short_url), "%s", short_url);
|
||||
snprintf(p->user, sizeof(p->user), "%s", rpc_user);
|
||||
snprintf(p->pass, sizeof(p->pass), "%s", rpc_pass);
|
||||
|
||||
if (!(p->status & POOL_ST_DEFINED)) {
|
||||
p->id = pooln;
|
||||
p->status |= POOL_ST_DEFINED;
|
||||
// init pool options as "unset"
|
||||
// until cmdline is not fully parsed...
|
||||
p->max_diff = -1.;
|
||||
p->max_rate = -1.;
|
||||
p->scantime = -1;
|
||||
p->time_limit = -1;
|
||||
|
||||
p->allow_mininginfo = allow_mininginfo;
|
||||
p->allow_gbt = allow_gbt;
|
||||
p->check_dups = check_dups;
|
||||
|
||||
p->status |= POOL_ST_DEFINED;
|
||||
}
|
||||
|
||||
if (strlen(rpc_url)) {
|
||||
if (!strncasecmp(rpc_url, "stratum", 7))
|
||||
p->type = POOL_STRATUM;
|
||||
else /* if (!strncasecmp(rpc_url, "http", 4)) */
|
||||
p->type = POOL_GETWORK; // todo: or longpoll
|
||||
p->status |= POOL_ST_VALID;
|
||||
}
|
||||
}
|
||||
|
||||
// fill the unset pools options with cmdline ones
|
||||
void pool_init_defaults()
|
||||
{
|
||||
struct pool_infos *p;
|
||||
for (int i=0; i<num_pools; i++) {
|
||||
p = &pools[i];
|
||||
if (p->max_diff == -1.) p->max_diff = opt_max_diff;
|
||||
if (p->max_rate == -1.) p->max_rate = opt_max_rate;
|
||||
if (p->scantime == -1) p->scantime = opt_scantime;
|
||||
if (p->time_limit == -1) p->time_limit = opt_time_limit;
|
||||
}
|
||||
}
|
||||
|
||||
// attributes only set by a json pools config
|
||||
void pool_set_attr(int pooln, const char* key, char* arg)
|
||||
{
|
||||
struct pool_infos *p = &pools[pooln];
|
||||
|
||||
if (!strcasecmp(key, "name")) {
|
||||
snprintf(p->name, sizeof(p->name), "%s", arg);
|
||||
return;
|
||||
}
|
||||
if (!strcasecmp(key, "scantime")) {
|
||||
p->scantime = atoi(arg);
|
||||
return;
|
||||
}
|
||||
if (!strcasecmp(key, "max-diff")) {
|
||||
p->max_diff = atof(arg);
|
||||
return;
|
||||
}
|
||||
if (!strcasecmp(key, "max-rate")) {
|
||||
p->max_rate = atof(arg);
|
||||
return;
|
||||
}
|
||||
if (!strcasecmp(key, "time-limit")) {
|
||||
p->time_limit = atoi(arg);
|
||||
return;
|
||||
}
|
||||
if (!strcasecmp(key, "removed")) {
|
||||
int removed = atoi(arg);
|
||||
if (removed) {
|
||||
p->status |= POOL_ST_REMOVED;
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// pool switching code
|
||||
bool pool_switch(int pooln)
|
||||
{
|
||||
int prevn = cur_pooln;
|
||||
struct pool_infos *prev = &pools[cur_pooln];
|
||||
struct pool_infos* p = NULL;
|
||||
|
||||
// save prev stratum connection infos (struct)
|
||||
if (prev->type & POOL_STRATUM) {
|
||||
// may not be the right moment to free,
|
||||
// to check if required on submit...
|
||||
stratum_free_job(&stratum);
|
||||
prev->stratum = stratum;
|
||||
}
|
||||
|
||||
if (pooln < num_pools) {
|
||||
cur_pooln = pooln;
|
||||
p = &pools[cur_pooln];
|
||||
} else {
|
||||
applog(LOG_ERR, "Switch to inexistant pool %d!", pooln);
|
||||
return false;
|
||||
}
|
||||
|
||||
// save global attributes
|
||||
prev->allow_mininginfo = allow_mininginfo;
|
||||
prev->allow_gbt = allow_gbt;
|
||||
prev->check_dups = check_dups;
|
||||
|
||||
pthread_mutex_lock(&stratum_work_lock);
|
||||
|
||||
free(rpc_user); rpc_user = strdup(p->user);
|
||||
free(rpc_pass); rpc_pass = strdup(p->pass);
|
||||
free(rpc_url); rpc_url = strdup(p->url);
|
||||
|
||||
short_url = p->short_url; // just a pointer, no alloc
|
||||
|
||||
opt_scantime = p->scantime;
|
||||
opt_max_diff = p->max_diff;
|
||||
opt_max_rate = p->max_rate;
|
||||
opt_time_limit = p->time_limit;
|
||||
|
||||
want_stratum = have_stratum = (p->type & POOL_STRATUM) != 0;
|
||||
|
||||
pthread_mutex_unlock(&stratum_work_lock);
|
||||
|
||||
if (prevn != cur_pooln) {
|
||||
|
||||
pool_switch_count++;
|
||||
g_work_time = 0;
|
||||
g_work.data[0] = 0;
|
||||
pool_is_switching = true;
|
||||
stratum_need_reset = true;
|
||||
// used to get the pool uptime
|
||||
firstwork_time = time(NULL);
|
||||
restart_threads();
|
||||
// reset wait states
|
||||
for (int n=0; n<opt_n_threads; n++)
|
||||
conditional_state[n] = false;
|
||||
|
||||
// restore flags
|
||||
allow_gbt = p->allow_gbt;
|
||||
allow_mininginfo = p->allow_mininginfo;
|
||||
check_dups = p->check_dups;
|
||||
|
||||
if (want_stratum) {
|
||||
|
||||
// temporary... until stratum code cleanup
|
||||
stratum = p->stratum;
|
||||
stratum.pooln = cur_pooln;
|
||||
|
||||
// unlock the stratum thread
|
||||
tq_push(thr_info[stratum_thr_id].q, strdup(rpc_url));
|
||||
applog(LOG_BLUE, "Switch to stratum pool %d: %s", cur_pooln,
|
||||
strlen(p->name) ? p->name : p->short_url);
|
||||
} else {
|
||||
applog(LOG_BLUE, "Switch to pool %d: %s", cur_pooln,
|
||||
strlen(p->name) ? p->name : p->short_url);
|
||||
}
|
||||
|
||||
// will unlock the longpoll thread on /LP url receive
|
||||
want_longpoll = (p->type & POOL_LONGPOLL) || !(p->type & POOL_STRATUM);
|
||||
if (want_longpoll) {
|
||||
pthread_mutex_lock(&stratum_work_lock);
|
||||
// will issue a lp_url request to unlock the longpoll thread
|
||||
have_longpoll = false;
|
||||
get_work(&thr_info[0], &g_work);
|
||||
pthread_mutex_unlock(&stratum_work_lock);
|
||||
}
|
||||
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// search available pool
|
||||
int pool_get_first_valid(int startfrom)
|
||||
{
|
||||
int next = 0;
|
||||
struct pool_infos *p;
|
||||
for (int i=0; i<num_pools; i++) {
|
||||
int pooln = (startfrom + i) % num_pools;
|
||||
p = &pools[pooln];
|
||||
if (!(p->status & POOL_ST_VALID))
|
||||
continue;
|
||||
if (p->status & (POOL_ST_DISABLED | POOL_ST_REMOVED))
|
||||
continue;
|
||||
next = pooln;
|
||||
break;
|
||||
}
|
||||
return next;
|
||||
}
|
||||
|
||||
// switch to next available pool
|
||||
bool pool_switch_next()
|
||||
{
|
||||
if (num_pools > 1) {
|
||||
int pooln = pool_get_first_valid(cur_pooln+1);
|
||||
return pool_switch(pooln);
|
||||
} else {
|
||||
// no switch possible
|
||||
if (!opt_quiet)
|
||||
applog(LOG_DEBUG, "No other pools to try...");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// seturl from api remote (deprecated)
|
||||
bool pool_switch_url(char *params)
|
||||
{
|
||||
int prevn = cur_pooln, nextn;
|
||||
parse_arg('o', params);
|
||||
// cur_pooln modified by parse_arg('o'), get new pool num
|
||||
nextn = cur_pooln;
|
||||
// and to handle the "hot swap" from current one...
|
||||
cur_pooln = prevn;
|
||||
if (nextn == prevn)
|
||||
return false;
|
||||
return pool_switch(nextn);
|
||||
}
|
||||
|
||||
// Parse pools array in json config
|
||||
bool parse_pool_array(json_t *obj)
|
||||
{
|
||||
size_t idx;
|
||||
json_t *p, *val;
|
||||
|
||||
if (!json_is_array(obj))
|
||||
return false;
|
||||
|
||||
// array of objects [ {}, {} ]
|
||||
json_array_foreach(obj, idx, p)
|
||||
{
|
||||
if (!json_is_object(p))
|
||||
continue;
|
||||
|
||||
for (int i = 0; i < ARRAY_SIZE(cfg_array_keys); i++)
|
||||
{
|
||||
int opt = -1;
|
||||
char *s = NULL;
|
||||
if (cfg_array_keys[i].cat != CFG_POOL)
|
||||
continue;
|
||||
|
||||
val = json_object_get(p, cfg_array_keys[i].name);
|
||||
if (!val)
|
||||
continue;
|
||||
|
||||
for (int k = 0; k < options_count(); k++)
|
||||
{
|
||||
const char *alias = cfg_array_keys[i].longname;
|
||||
if (alias && !strcasecmp(options[k].name, alias)) {
|
||||
opt = k;
|
||||
break;
|
||||
}
|
||||
if (!alias && !strcasecmp(options[k].name, cfg_array_keys[i].name)) {
|
||||
opt = k;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (opt == -1)
|
||||
continue;
|
||||
|
||||
if (json_is_string(val)) {
|
||||
s = strdup(json_string_value(val));
|
||||
if (!s)
|
||||
continue;
|
||||
|
||||
// applog(LOG_DEBUG, "pool key %s '%s'", options[opt].name, s);
|
||||
parse_arg(options[opt].val, s);
|
||||
free(s);
|
||||
} else {
|
||||
// numeric or bool
|
||||
char buf[32] = { 0 };
|
||||
double d = 0.;
|
||||
if (json_is_true(val)) d = 1.;
|
||||
else if (json_is_integer(val))
|
||||
d = 1.0 * json_integer_value(val);
|
||||
else if (json_is_real(val))
|
||||
d = json_real_value(val);
|
||||
snprintf(buf, sizeof(buf)-1, "%f", d);
|
||||
// applog(LOG_DEBUG, "pool key %s '%f'", options[opt].name, d);
|
||||
parse_arg(options[opt].val, buf);
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// debug stuff
|
||||
void pool_dump_infos()
|
||||
{
|
||||
struct pool_infos *p;
|
||||
for (int i=0; i<num_pools; i++) {
|
||||
p = &pools[i];
|
||||
applog(LOG_DEBUG, "POOL %01d: %s USER %s -s %d", i,
|
||||
p->short_url, p->user, p->scantime);
|
||||
}
|
||||
}
|
||||
+193
-191
@@ -11,15 +11,20 @@ __constant__ uint64_t c_PaddedMessage80[16]; // padded message (80 bytes + paddi
|
||||
#undef SHR
|
||||
#undef CONST_EXP2
|
||||
|
||||
//#define SHL(x, n) ((x) << (n))
|
||||
//#define SHR(x, n) ((x) >> (n))
|
||||
#define SHR(x, n) SHR2(x, n)
|
||||
#define SHL(x, n) SHL2(x, n)
|
||||
#define ROL(x, n) ROL2(x, n)
|
||||
|
||||
#undef ROTL64
|
||||
#define ROTL64 ROL2
|
||||
|
||||
|
||||
#define CONST_EXP2(i) \
|
||||
q[i+0] + ROL(q[i+1], 5) + q[i+2] + ROL(q[i+3], 11) + \
|
||||
q[i+4] + ROL(q[i+5], 27) + q[i+6] + SWAPUINT2(q[i+7]) + \
|
||||
q[i+8] + ROL(q[i+9], 37) + q[i+10] + ROL(q[i+11], 43) + \
|
||||
q[i+12] + ROL(q[i+13], 53) + (SHR(q[i+14],1) ^ q[i+14]) + (SHR(q[i+15],2) ^ q[i+15])
|
||||
q[i+0] + ROTL64(q[i+1], 5) + q[i+2] + ROTL64(q[i+3], 11) + \
|
||||
q[i+4] + ROTL64(q[i+5], 27) + q[i+6] + SWAPUINT2(q[i+7]) + \
|
||||
q[i+8] + ROTL64(q[i+9], 37) + q[i+10] + ROTL64(q[i+11], 43) + \
|
||||
q[i+12] + ROTL64(q[i+13], 53) + (SHR(q[i+14],1) ^ q[i+14]) + (SHR(q[i+15],2) ^ q[i+15])
|
||||
|
||||
__device__ void Compression512_64_first(uint2 *msg, uint2 *hash)
|
||||
{
|
||||
@@ -28,138 +33,136 @@ __device__ void Compression512_64_first(uint2 *msg, uint2 *hash)
|
||||
uint2 tmp;
|
||||
|
||||
tmp = (msg[5] ^ hash[5]) - (msg[7] ^ hash[7]) + (hash[10]) + (hash[13]) + (hash[14]);
|
||||
q[0] = (SHR(tmp, 1) ^ SHL(tmp, 3) ^ ROL(tmp, 4) ^ ROL(tmp, 37)) + hash[1];
|
||||
|
||||
q[0] = (SHR(tmp, 1) ^ SHL(tmp, 3) ^ ROTL64(tmp, 4) ^ ROTL64(tmp, 37)) + hash[1];
|
||||
tmp = (msg[6] ^ hash[6]) - (msg[8] ^ hash[8]) + (hash[11]) + (hash[14]) - (msg[15] ^ hash[15]);
|
||||
q[1] = (SHR(tmp, 1) ^ SHL(tmp, 2) ^ ROL(tmp, 13) ^ ROL(tmp, 43)) + hash[2];
|
||||
q[1] = (SHR(tmp, 1) ^ SHL(tmp, 2) ^ ROTL64(tmp, 13) ^ ROTL64(tmp, 43)) + hash[2];
|
||||
tmp = (msg[0] ^ hash[0]) + (msg[7] ^ hash[7]) + (hash[9]) - (hash[12]) + (msg[15] ^ hash[15]);
|
||||
q[2] = (SHR(tmp, 2) ^ SHL(tmp, 1) ^ ROL(tmp, 19) ^ ROL(tmp, 53)) + hash[3];
|
||||
q[2] = (SHR(tmp, 2) ^ SHL(tmp, 1) ^ ROTL64(tmp, 19) ^ ROTL64(tmp, 53)) + hash[3];
|
||||
tmp = (msg[0] ^ hash[0]) - (msg[1] ^ hash[1]) + (msg[8] ^ hash[8]) - (hash[10]) + (hash[13]);
|
||||
q[3] = (SHR(tmp, 2) ^ SHL(tmp, 2) ^ ROL(tmp, 28) ^ ROL(tmp, 59)) + hash[4];
|
||||
q[3] = (SHR(tmp, 2) ^ SHL(tmp, 2) ^ ROTL64(tmp, 28) ^ ROTL64(tmp, 59)) + hash[4];
|
||||
tmp = (msg[1] ^ hash[1]) + (msg[2] ^ hash[2]) + (hash[9]) - (hash[11]) - (hash[14]);
|
||||
q[4] = (SHR(tmp, 1) ^ tmp) + hash[5];
|
||||
tmp = (msg[3] ^ hash[3]) - (msg[2] ^ hash[2]) + (hash[10]) - (hash[12]) + (msg[15] ^ hash[15]);
|
||||
q[5] = (SHR(tmp, 1) ^ SHL(tmp, 3) ^ ROL(tmp, 4) ^ ROL(tmp, 37)) + hash[6];
|
||||
q[5] = (SHR(tmp, 1) ^ SHL(tmp, 3) ^ ROTL64(tmp, 4) ^ ROTL64(tmp, 37)) + hash[6];
|
||||
tmp = (msg[4] ^ hash[4]) - (msg[0] ^ hash[0]) - (msg[3] ^ hash[3]) - (hash[11]) + (hash[13]);
|
||||
q[6] = (SHR(tmp, 1) ^ SHL(tmp, 2) ^ ROL(tmp, 13) ^ ROL(tmp, 43)) + hash[7];
|
||||
q[6] = (SHR(tmp, 1) ^ SHL(tmp, 2) ^ ROTL64(tmp, 13) ^ ROTL64(tmp, 43)) + hash[7];
|
||||
tmp = (msg[1] ^ hash[1]) - (msg[4] ^ hash[4]) - (msg[5] ^ hash[5]) - (hash[12]) - (hash[14]);
|
||||
q[7] = (SHR(tmp, 2) ^ SHL(tmp, 1) ^ ROL(tmp, 19) ^ ROL(tmp, 53)) + hash[8];
|
||||
|
||||
q[7] = (SHR(tmp, 2) ^ SHL(tmp, 1) ^ ROTL64(tmp, 19) ^ ROTL64(tmp, 53)) + hash[8];
|
||||
tmp = (msg[2] ^ hash[2]) - (msg[5] ^ hash[5]) - (msg[6] ^ hash[6]) + (hash[13]) - (msg[15] ^ hash[15]);
|
||||
q[8] = (SHR(tmp, 2) ^ SHL(tmp, 2) ^ ROL(tmp, 28) ^ ROL(tmp, 59)) + hash[9];
|
||||
q[8] = (SHR(tmp, 2) ^ SHL(tmp, 2) ^ ROTL64(tmp, 28) ^ ROTL64(tmp, 59)) + hash[9];
|
||||
tmp = (msg[0] ^ hash[0]) - (msg[3] ^ hash[3]) + (msg[6] ^ hash[6]) - (msg[7] ^ hash[7]) + (hash[14]);
|
||||
q[9] = (SHR(tmp, 1) ^ tmp) + hash[10];
|
||||
tmp = (msg[8] ^ hash[8]) - (msg[1] ^ hash[1]) - (msg[4] ^ hash[4]) - (msg[7] ^ hash[7]) + (msg[15] ^ hash[15]);
|
||||
q[10] = (SHR(tmp, 1) ^ SHL(tmp, 3) ^ ROL(tmp, 4) ^ ROL(tmp, 37)) + hash[11];
|
||||
q[10] = (SHR(tmp, 1) ^ SHL(tmp, 3) ^ ROTL64(tmp, 4) ^ ROTL64(tmp, 37)) + hash[11];
|
||||
tmp = (msg[8] ^ hash[8]) - (msg[0] ^ hash[0]) - (msg[2] ^ hash[2]) - (msg[5] ^ hash[5]) + (hash[9]);
|
||||
q[11] = (SHR(tmp, 1) ^ SHL(tmp, 2) ^ ROL(tmp, 13) ^ ROL(tmp, 43)) + hash[12];
|
||||
q[11] = (SHR(tmp, 1) ^ SHL(tmp, 2) ^ ROTL64(tmp, 13) ^ ROTL64(tmp, 43)) + hash[12];
|
||||
tmp = (msg[1] ^ hash[1]) + (msg[3] ^ hash[3]) - (msg[6] ^ hash[6]) - (hash[9]) + (hash[10]);
|
||||
q[12] = (SHR(tmp, 2) ^ SHL(tmp, 1) ^ ROL(tmp, 19) ^ ROL(tmp, 53)) + hash[13];
|
||||
q[12] = (SHR(tmp, 2) ^ SHL(tmp, 1) ^ ROTL64(tmp, 19) ^ ROTL64(tmp, 53)) + hash[13];
|
||||
tmp = (msg[2] ^ hash[2]) + (msg[4] ^ hash[4]) + (msg[7] ^ hash[7]) + (hash[10]) + (hash[11]);
|
||||
q[13] = (SHR(tmp, 2) ^ SHL(tmp, 2) ^ ROL(tmp, 28) ^ ROL(tmp, 59)) + hash[14];
|
||||
q[13] = (SHR(tmp, 2) ^ SHL(tmp, 2) ^ ROTL64(tmp, 28) ^ ROTL64(tmp, 59)) + hash[14];
|
||||
tmp = (msg[3] ^ hash[3]) - (msg[5] ^ hash[5]) + (msg[8] ^ hash[8]) - (hash[11]) - (hash[12]);
|
||||
q[14] = (SHR(tmp, 1) ^ tmp) + hash[15];
|
||||
tmp = (msg[12] ^ hash[12]) - (msg[4] ^ hash[4]) - (msg[6] ^ hash[6]) - (hash[9]) + (hash[13]);
|
||||
q[15] = (SHR(tmp, 1) ^ SHL(tmp, 3) ^ ROL(tmp, 4) ^ ROL(tmp, 37)) + hash[0];
|
||||
q[15] = (SHR(tmp, 1) ^ SHL(tmp, 3) ^ ROTL64(tmp, 4) ^ ROTL64(tmp, 37)) + hash[0];
|
||||
|
||||
q[0 + 16] =
|
||||
(SHR(q[0], 1) ^ SHL(q[0], 2) ^ ROL(q[0], 13) ^ ROL(q[0], 43)) +
|
||||
(SHR(q[0 + 1], 2) ^ SHL(q[0 + 1], 1) ^ ROL(q[0 + 1], 19) ^ ROL(q[0 + 1], 53)) +
|
||||
(SHR(q[0 + 2], 2) ^ SHL(q[0 + 2], 2) ^ ROL(q[0 + 2], 28) ^ ROL(q[0 + 2], 59)) +
|
||||
(SHR(q[0 + 3], 1) ^ SHL(q[0 + 3], 3) ^ ROL(q[0 + 3], 4) ^ ROL(q[0 + 3], 37)) +
|
||||
(SHR(q[0 + 4], 1) ^ SHL(q[0 + 4], 2) ^ ROL(q[0 + 4], 13) ^ ROL(q[0 + 4], 43)) +
|
||||
(SHR(q[0 + 5], 2) ^ SHL(q[0 + 5], 1) ^ ROL(q[0 + 5], 19) ^ ROL(q[0 + 5], 53)) +
|
||||
(SHR(q[0 + 6], 2) ^ SHL(q[0 + 6], 2) ^ ROL(q[0 + 6], 28) ^ ROL(q[0 + 6], 59)) +
|
||||
(SHR(q[0 + 7], 1) ^ SHL(q[0 + 7], 3) ^ ROL(q[0 + 7], 4) ^ ROL(q[0 + 7], 37)) +
|
||||
(SHR(q[0 + 8], 1) ^ SHL(q[0 + 8], 2) ^ ROL(q[0 + 8], 13) ^ ROL(q[0 + 8], 43)) +
|
||||
(SHR(q[0 + 9], 2) ^ SHL(q[0 + 9], 1) ^ ROL(q[0 + 9], 19) ^ ROL(q[0 + 9], 53)) +
|
||||
(SHR(q[0 + 10], 2) ^ SHL(q[0 + 10], 2) ^ ROL(q[0 + 10], 28) ^ ROL(q[0 + 10], 59)) +
|
||||
(SHR(q[0 + 11], 1) ^ SHL(q[0 + 11], 3) ^ ROL(q[0 + 11], 4) ^ ROL(q[0 + 11], 37)) +
|
||||
(SHR(q[0 + 12], 1) ^ SHL(q[0 + 12], 2) ^ ROL(q[0 + 12], 13) ^ ROL(q[0 + 12], 43)) +
|
||||
(SHR(q[0 + 13], 2) ^ SHL(q[0 + 13], 1) ^ ROL(q[0 + 13], 19) ^ ROL(q[0 + 13], 53)) +
|
||||
(SHR(q[0 + 14], 2) ^ SHL(q[0 + 14], 2) ^ ROL(q[0 + 14], 28) ^ ROL(q[0 + 14], 59)) +
|
||||
(SHR(q[0 + 15], 1) ^ SHL(q[0 + 15], 3) ^ ROL(q[0 + 15], 4) ^ ROL(q[0 + 15], 37)) +
|
||||
((make_uint2(0x55555550ul,0x55555555) + ROL(msg[0], 0 + 1) +
|
||||
ROL(msg[0 + 3], 0 + 4)) ^ hash[0 + 7]);
|
||||
(SHR(q[0], 1) ^ SHL(q[0], 2) ^ ROTL64(q[0], 13) ^ ROTL64(q[0], 43)) +
|
||||
(SHR(q[0 + 1], 2) ^ SHL(q[0 + 1], 1) ^ ROTL64(q[0 + 1], 19) ^ ROTL64(q[0 + 1], 53)) +
|
||||
(SHR(q[0 + 2], 2) ^ SHL(q[0 + 2], 2) ^ ROTL64(q[0 + 2], 28) ^ ROTL64(q[0 + 2], 59)) +
|
||||
(SHR(q[0 + 3], 1) ^ SHL(q[0 + 3], 3) ^ ROTL64(q[0 + 3], 4) ^ ROTL64(q[0 + 3], 37)) +
|
||||
(SHR(q[0 + 4], 1) ^ SHL(q[0 + 4], 2) ^ ROTL64(q[0 + 4], 13) ^ ROTL64(q[0 + 4], 43)) +
|
||||
(SHR(q[0 + 5], 2) ^ SHL(q[0 + 5], 1) ^ ROTL64(q[0 + 5], 19) ^ ROTL64(q[0 + 5], 53)) +
|
||||
(SHR(q[0 + 6], 2) ^ SHL(q[0 + 6], 2) ^ ROTL64(q[0 + 6], 28) ^ ROTL64(q[0 + 6], 59)) +
|
||||
(SHR(q[0 + 7], 1) ^ SHL(q[0 + 7], 3) ^ ROTL64(q[0 + 7], 4) ^ ROTL64(q[0 + 7], 37)) +
|
||||
(SHR(q[0 + 8], 1) ^ SHL(q[0 + 8], 2) ^ ROTL64(q[0 + 8], 13) ^ ROTL64(q[0 + 8], 43)) +
|
||||
(SHR(q[0 + 9], 2) ^ SHL(q[0 + 9], 1) ^ ROTL64(q[0 + 9], 19) ^ ROTL64(q[0 + 9], 53)) +
|
||||
(SHR(q[0 + 10], 2) ^ SHL(q[0 + 10], 2) ^ ROTL64(q[0 + 10], 28) ^ ROTL64(q[0 + 10], 59)) +
|
||||
(SHR(q[0 + 11], 1) ^ SHL(q[0 + 11], 3) ^ ROTL64(q[0 + 11], 4) ^ ROTL64(q[0 + 11], 37)) +
|
||||
(SHR(q[0 + 12], 1) ^ SHL(q[0 + 12], 2) ^ ROTL64(q[0 + 12], 13) ^ ROTL64(q[0 + 12], 43)) +
|
||||
(SHR(q[0 + 13], 2) ^ SHL(q[0 + 13], 1) ^ ROTL64(q[0 + 13], 19) ^ ROTL64(q[0 + 13], 53)) +
|
||||
(SHR(q[0 + 14], 2) ^ SHL(q[0 + 14], 2) ^ ROTL64(q[0 + 14], 28) ^ ROTL64(q[0 + 14], 59)) +
|
||||
(SHR(q[0 + 15], 1) ^ SHL(q[0 + 15], 3) ^ ROTL64(q[0 + 15], 4) ^ ROTL64(q[0 + 15], 37)) +
|
||||
((make_uint2(0x55555550ul,0x55555555) + ROTL64(msg[0], 0 + 1) +
|
||||
ROTL64(msg[0 + 3], 0 + 4)) ^ hash[0 + 7]);
|
||||
|
||||
q[1 + 16] =
|
||||
(SHR(q[1], 1) ^ SHL(q[1], 2) ^ ROL(q[1], 13) ^ ROL(q[1], 43)) +
|
||||
(SHR(q[1 + 1], 2) ^ SHL(q[1 + 1], 1) ^ ROL(q[1 + 1], 19) ^ ROL(q[1 + 1], 53)) +
|
||||
(SHR(q[1 + 2], 2) ^ SHL(q[1 + 2], 2) ^ ROL(q[1 + 2], 28) ^ ROL(q[1 + 2], 59)) +
|
||||
(SHR(q[1 + 3], 1) ^ SHL(q[1 + 3], 3) ^ ROL(q[1 + 3], 4) ^ ROL(q[1 + 3], 37)) +
|
||||
(SHR(q[1 + 4], 1) ^ SHL(q[1 + 4], 2) ^ ROL(q[1 + 4], 13) ^ ROL(q[1 + 4], 43)) +
|
||||
(SHR(q[1 + 5], 2) ^ SHL(q[1 + 5], 1) ^ ROL(q[1 + 5], 19) ^ ROL(q[1 + 5], 53)) +
|
||||
(SHR(q[1 + 6], 2) ^ SHL(q[1 + 6], 2) ^ ROL(q[1 + 6], 28) ^ ROL(q[1 + 6], 59)) +
|
||||
(SHR(q[1 + 7], 1) ^ SHL(q[1 + 7], 3) ^ ROL(q[1 + 7], 4) ^ ROL(q[1 + 7], 37)) +
|
||||
(SHR(q[1 + 8], 1) ^ SHL(q[1 + 8], 2) ^ ROL(q[1 + 8], 13) ^ ROL(q[1 + 8], 43)) +
|
||||
(SHR(q[1 + 9], 2) ^ SHL(q[1 + 9], 1) ^ ROL(q[1 + 9], 19) ^ ROL(q[1 + 9], 53)) +
|
||||
(SHR(q[1 + 10], 2) ^ SHL(q[1 + 10], 2) ^ ROL(q[1 + 10], 28) ^ ROL(q[1 + 10], 59)) +
|
||||
(SHR(q[1 + 11], 1) ^ SHL(q[1 + 11], 3) ^ ROL(q[1 + 11], 4) ^ ROL(q[1 + 11], 37)) +
|
||||
(SHR(q[1 + 12], 1) ^ SHL(q[1 + 12], 2) ^ ROL(q[1 + 12], 13) ^ ROL(q[1 + 12], 43)) +
|
||||
(SHR(q[1 + 13], 2) ^ SHL(q[1 + 13], 1) ^ ROL(q[1 + 13], 19) ^ ROL(q[1 + 13], 53)) +
|
||||
(SHR(q[1 + 14], 2) ^ SHL(q[1 + 14], 2) ^ ROL(q[1 + 14], 28) ^ ROL(q[1 + 14], 59)) +
|
||||
(SHR(q[1 + 15], 1) ^ SHL(q[1 + 15], 3) ^ ROL(q[1 + 15], 4) ^ ROL(q[1 + 15], 37)) +
|
||||
((make_uint2(0xAAAAAAA5, 0x5AAAAAAA) + ROL(msg[1], 1 + 1) +
|
||||
ROL(msg[1 + 3], 1 + 4)) ^ hash[1 + 7]);
|
||||
(SHR(q[1], 1) ^ SHL(q[1], 2) ^ ROTL64(q[1], 13) ^ ROTL64(q[1], 43)) +
|
||||
(SHR(q[1 + 1], 2) ^ SHL(q[1 + 1], 1) ^ ROTL64(q[1 + 1], 19) ^ ROTL64(q[1 + 1], 53)) +
|
||||
(SHR(q[1 + 2], 2) ^ SHL(q[1 + 2], 2) ^ ROTL64(q[1 + 2], 28) ^ ROTL64(q[1 + 2], 59)) +
|
||||
(SHR(q[1 + 3], 1) ^ SHL(q[1 + 3], 3) ^ ROTL64(q[1 + 3], 4) ^ ROTL64(q[1 + 3], 37)) +
|
||||
(SHR(q[1 + 4], 1) ^ SHL(q[1 + 4], 2) ^ ROTL64(q[1 + 4], 13) ^ ROTL64(q[1 + 4], 43)) +
|
||||
(SHR(q[1 + 5], 2) ^ SHL(q[1 + 5], 1) ^ ROTL64(q[1 + 5], 19) ^ ROTL64(q[1 + 5], 53)) +
|
||||
(SHR(q[1 + 6], 2) ^ SHL(q[1 + 6], 2) ^ ROTL64(q[1 + 6], 28) ^ ROTL64(q[1 + 6], 59)) +
|
||||
(SHR(q[1 + 7], 1) ^ SHL(q[1 + 7], 3) ^ ROTL64(q[1 + 7], 4) ^ ROTL64(q[1 + 7], 37)) +
|
||||
(SHR(q[1 + 8], 1) ^ SHL(q[1 + 8], 2) ^ ROTL64(q[1 + 8], 13) ^ ROTL64(q[1 + 8], 43)) +
|
||||
(SHR(q[1 + 9], 2) ^ SHL(q[1 + 9], 1) ^ ROTL64(q[1 + 9], 19) ^ ROTL64(q[1 + 9], 53)) +
|
||||
(SHR(q[1 + 10], 2) ^ SHL(q[1 + 10], 2) ^ ROTL64(q[1 + 10], 28) ^ ROTL64(q[1 + 10], 59)) +
|
||||
(SHR(q[1 + 11], 1) ^ SHL(q[1 + 11], 3) ^ ROTL64(q[1 + 11], 4) ^ ROTL64(q[1 + 11], 37)) +
|
||||
(SHR(q[1 + 12], 1) ^ SHL(q[1 + 12], 2) ^ ROTL64(q[1 + 12], 13) ^ ROTL64(q[1 + 12], 43)) +
|
||||
(SHR(q[1 + 13], 2) ^ SHL(q[1 + 13], 1) ^ ROTL64(q[1 + 13], 19) ^ ROTL64(q[1 + 13], 53)) +
|
||||
(SHR(q[1 + 14], 2) ^ SHL(q[1 + 14], 2) ^ ROTL64(q[1 + 14], 28) ^ ROTL64(q[1 + 14], 59)) +
|
||||
(SHR(q[1 + 15], 1) ^ SHL(q[1 + 15], 3) ^ ROTL64(q[1 + 15], 4) ^ ROTL64(q[1 + 15], 37)) +
|
||||
((make_uint2(0xAAAAAAA5, 0x5AAAAAAA) + ROTL64(msg[1], 1 + 1) +
|
||||
ROTL64(msg[1 + 3], 1 + 4)) ^ hash[1 + 7]);
|
||||
|
||||
q[2 + 16] = CONST_EXP2(2) +
|
||||
((make_uint2(0xFFFFFFFA, 0x5FFFFFFF) + ROL(msg[2], 2 + 1) +
|
||||
ROL(msg[2 + 3], 2 + 4) - ROL(msg[2 + 10], 2 + 11)) ^ hash[2 + 7]);
|
||||
((make_uint2(0xFFFFFFFA, 0x5FFFFFFF) + ROTL64(msg[2], 2 + 1) +
|
||||
ROTL64(msg[2 + 3], 2 + 4) - ROTL64(msg[2 + 10], 2 + 11)) ^ hash[2 + 7]);
|
||||
q[3 + 16] = CONST_EXP2(3) +
|
||||
((make_uint2(0x5555554F, 0x65555555) + ROL(msg[3], 3 + 1) +
|
||||
ROL(msg[3 + 3], 3 + 4) - ROL(msg[3 + 10], 3 + 11)) ^ hash[3 + 7]);
|
||||
((make_uint2(0x5555554F, 0x65555555) + ROTL64(msg[3], 3 + 1) +
|
||||
ROTL64(msg[3 + 3], 3 + 4) - ROTL64(msg[3 + 10], 3 + 11)) ^ hash[3 + 7]);
|
||||
q[4 + 16] = CONST_EXP2(4) +
|
||||
((make_uint2(0xAAAAAAA4, 0x6AAAAAAA) +ROL(msg[4], 4 + 1) +
|
||||
ROL(msg[4 + 3], 4 + 4) - ROL(msg[4 + 10], 4 + 11)) ^ hash[4 + 7]);
|
||||
((make_uint2(0xAAAAAAA4, 0x6AAAAAAA) +ROTL64(msg[4], 4 + 1) +
|
||||
ROTL64(msg[4 + 3], 4 + 4) - ROTL64(msg[4 + 10], 4 + 11)) ^ hash[4 + 7]);
|
||||
q[5 + 16] = CONST_EXP2(5) +
|
||||
((make_uint2(0xFFFFFFF9, 0x6FFFFFFF) + ROL(msg[5], 5 + 1) +
|
||||
ROL(msg[5 + 3], 5 + 4) - ROL(msg[5 + 10], 5 + 11)) ^ hash[5 + 7]);
|
||||
((make_uint2(0xFFFFFFF9, 0x6FFFFFFF) + ROTL64(msg[5], 5 + 1) +
|
||||
ROTL64(msg[5 + 3], 5 + 4) - ROTL64(msg[5 + 10], 5 + 11)) ^ hash[5 + 7]);
|
||||
|
||||
#pragma unroll 3
|
||||
for (int i = 6; i<9; i++) {
|
||||
q[i + 16] = CONST_EXP2(i) +
|
||||
((vectorize((i + 16)*(0x0555555555555555ull)) + ROL(msg[i], i + 1) -
|
||||
ROL(msg[i - 6], (i - 6) + 1)) ^ hash[i + 7]);
|
||||
((vectorize((i + 16)*(0x0555555555555555ull)) + ROTL64(msg[i], i + 1) -
|
||||
ROTL64(msg[i - 6], (i - 6) + 1)) ^ hash[i + 7]);
|
||||
}
|
||||
|
||||
#pragma unroll 4
|
||||
for (int i = 9; i<13; i++) {
|
||||
q[i + 16] = CONST_EXP2(i) +
|
||||
((vectorize((i + 16)*(0x0555555555555555ull)) +
|
||||
ROL(msg[i + 3], i + 4) - ROL(msg[i - 6], (i - 6) + 1)) ^ hash[i - 9]);
|
||||
ROTL64(msg[i + 3], i + 4) - ROTL64(msg[i - 6], (i - 6) + 1)) ^ hash[i - 9]);
|
||||
}
|
||||
|
||||
q[13 + 16] = CONST_EXP2(13) +
|
||||
((make_uint2(0xAAAAAAA1, 0x9AAAAAAA) + ROL(msg[13], 13 + 1) +
|
||||
ROL(msg[13 - 13], (13 - 13) + 1) - ROL(msg[13 - 6], (13 - 6) + 1)) ^ hash[13 - 9]);
|
||||
((make_uint2(0xAAAAAAA1, 0x9AAAAAAA) + ROTL64(msg[13], 13 + 1) +
|
||||
ROTL64(msg[13 - 13], (13 - 13) + 1) - ROTL64(msg[13 - 6], (13 - 6) + 1)) ^ hash[13 - 9]);
|
||||
q[14 + 16] = CONST_EXP2(14) +
|
||||
((make_uint2(0xFFFFFFF6, 0x9FFFFFFF) + ROL(msg[14], 14 + 1) +
|
||||
ROL(msg[14 - 13], (14 - 13) + 1) - ROL(msg[14 - 6], (14 - 6) + 1)) ^ hash[14 - 9]);
|
||||
((make_uint2(0xFFFFFFF6, 0x9FFFFFFF) + ROTL64(msg[14], 14 + 1) +
|
||||
ROTL64(msg[14 - 13], (14 - 13) + 1) - ROTL64(msg[14 - 6], (14 - 6) + 1)) ^ hash[14 - 9]);
|
||||
q[15 + 16] = CONST_EXP2(15) +
|
||||
((make_uint2(0x5555554B, 0xA5555555) + ROL(msg[15], 15 + 1) +
|
||||
ROL(msg[15 - 13], (15 - 13) + 1) - ROL(msg[15 - 6], (15 - 6) + 1)) ^ hash[15 - 9]);
|
||||
((make_uint2(0x5555554B, 0xA5555555) + ROTL64(msg[15], 15 + 1) +
|
||||
ROTL64(msg[15 - 13], (15 - 13) + 1) - ROTL64(msg[15 - 6], (15 - 6) + 1)) ^ hash[15 - 9]);
|
||||
|
||||
|
||||
uint2 XL64 = q[16] ^ q[17] ^ q[18] ^ q[19] ^ q[20] ^ q[21] ^ q[22] ^ q[23];
|
||||
uint2 XH64 = XL64^q[24] ^ q[25] ^ q[26] ^ q[27] ^ q[28] ^ q[29] ^ q[30] ^ q[31];
|
||||
|
||||
hash[0] = (SHL(XH64, 5) ^ SHR(q[16], 5) ^ msg[0]) + (XL64 ^ q[24] ^ q[0]);
|
||||
hash[1] = (SHR(XH64, 7) ^ SHL(q[17], 8) ^ msg[1]) + (XL64 ^ q[25] ^ q[1]);
|
||||
hash[2] = (SHR(XH64, 5) ^ SHL(q[18], 5) ^ msg[2]) + (XL64 ^ q[26] ^ q[2]);
|
||||
hash[3] = (SHR(XH64, 1) ^ SHL(q[19], 5) ^ msg[3]) + (XL64 ^ q[27] ^ q[3]);
|
||||
hash[4] = (SHR(XH64, 3) ^ q[20] ^ msg[4]) + (XL64 ^ q[28] ^ q[4]);
|
||||
hash[5] = (SHL(XH64, 6) ^ SHR(q[21], 6) ^ msg[5]) + (XL64 ^ q[29] ^ q[5]);
|
||||
hash[6] = (SHR(XH64, 4) ^ SHL(q[22], 6) ^ msg[6]) + (XL64 ^ q[30] ^ q[6]);
|
||||
hash[7] = (SHR(XH64, 11) ^ SHL(q[23], 2) ^ msg[7]) + (XL64 ^ q[31] ^ q[7]);
|
||||
hash[0] = (SHL(XH64, 5) ^ SHR(q[16], 5) ^ msg[0]) + (XL64 ^ q[24] ^ q[0]);
|
||||
hash[1] = (SHR(XH64, 7) ^ SHL(q[17], 8) ^ msg[1]) + (XL64 ^ q[25] ^ q[1]);
|
||||
hash[2] = (SHR(XH64, 5) ^ SHL(q[18], 5) ^ msg[2]) + (XL64 ^ q[26] ^ q[2]);
|
||||
hash[3] = (SHR(XH64, 1) ^ SHL(q[19], 5) ^ msg[3]) + (XL64 ^ q[27] ^ q[3]);
|
||||
hash[4] = (SHR(XH64, 3) ^ q[20] ^ msg[4]) + (XL64 ^ q[28] ^ q[4]);
|
||||
hash[5] = (SHL(XH64, 6) ^ SHR(q[21], 6) ^ msg[5]) + (XL64 ^ q[29] ^ q[5]);
|
||||
hash[6] = (SHR(XH64, 4) ^ SHL(q[22], 6) ^ msg[6]) + (XL64 ^ q[30] ^ q[6]);
|
||||
hash[7] = (SHR(XH64, 11) ^ SHL(q[23], 2) ^ msg[7]) + (XL64 ^ q[31] ^ q[7]);
|
||||
|
||||
hash[8] = ROL(hash[4], 9) + (XH64 ^ q[24] ^ msg[8]) + (SHL(XL64, 8) ^ q[23] ^ q[8]);
|
||||
hash[9] = ROL(hash[5], 10) + (XH64 ^ q[25]) + (SHR(XL64, 6) ^ q[16] ^ q[9]);
|
||||
hash[10] = ROL(hash[6], 11) + (XH64 ^ q[26]) + (SHL(XL64, 6) ^ q[17] ^ q[10]);
|
||||
hash[11] = ROL(hash[7], 12) + (XH64 ^ q[27]) + (SHL(XL64, 4) ^ q[18] ^ q[11]);
|
||||
hash[12] = ROL(hash[0], 13) + (XH64 ^ q[28]) + (SHR(XL64, 3) ^ q[19] ^ q[12]);
|
||||
hash[13] = ROL(hash[1], 14) + (XH64 ^ q[29]) + (SHR(XL64, 4) ^ q[20] ^ q[13]);
|
||||
hash[14] = ROL(hash[2], 15) + (XH64 ^ q[30]) + (SHR(XL64, 7) ^ q[21] ^ q[14]);
|
||||
hash[15] = ROL(hash[3], 16) + (XH64 ^ q[31] ^ msg[15]) + (SHR(XL64, 2) ^ q[22] ^ q[15]);
|
||||
hash[8] = ROTL64(hash[4], 9) + (XH64 ^ q[24] ^ msg[8]) + (SHL(XL64, 8) ^ q[23] ^ q[8]);
|
||||
hash[9] = ROTL64(hash[5], 10) + (XH64 ^ q[25]) + (SHR(XL64, 6) ^ q[16] ^ q[9]);
|
||||
hash[10] = ROTL64(hash[6], 11) + (XH64 ^ q[26]) + (SHL(XL64, 6) ^ q[17] ^ q[10]);
|
||||
hash[11] = ROTL64(hash[7], 12) + (XH64 ^ q[27]) + (SHL(XL64, 4) ^ q[18] ^ q[11]);
|
||||
hash[12] = ROTL64(hash[0], 13) + (XH64 ^ q[28]) + (SHR(XL64, 3) ^ q[19] ^ q[12]);
|
||||
hash[13] = ROTL64(hash[1], 14) + (XH64 ^ q[29]) + (SHR(XL64, 4) ^ q[20] ^ q[13]);
|
||||
hash[14] = ROTL64(hash[2], 15) + (XH64 ^ q[30]) + (SHR(XL64, 7) ^ q[21] ^ q[14]);
|
||||
hash[15] = ROTL64(hash[3], 16) + (XH64 ^ q[31] ^ msg[15]) + (SHR(XL64, 2) ^ q[22] ^ q[15]);
|
||||
}
|
||||
|
||||
__device__
|
||||
@@ -170,141 +173,141 @@ void Compression512(uint2 *msg, uint2 *hash)
|
||||
uint2 tmp;
|
||||
|
||||
tmp = (msg[ 5] ^ hash[ 5]) - (msg[ 7] ^ hash[ 7]) + (msg[10] ^ hash[10]) + (msg[13] ^ hash[13]) + (msg[14] ^ hash[14]);
|
||||
q[0] = (SHR(tmp, 1) ^ SHL(tmp, 3) ^ ROL(tmp, 4) ^ ROL(tmp, 37)) + hash[1];
|
||||
q[0] = (SHR(tmp, 1) ^ SHL(tmp, 3) ^ ROTL64(tmp, 4) ^ ROTL64(tmp, 37)) + hash[1];
|
||||
tmp = (msg[ 6] ^ hash[ 6]) - (msg[ 8] ^ hash[ 8]) + (msg[11] ^ hash[11]) + (msg[14] ^ hash[14]) - (msg[15] ^ hash[15]);
|
||||
q[1] = (SHR(tmp, 1) ^ SHL(tmp, 2) ^ ROL(tmp, 13) ^ ROL(tmp, 43)) + hash[2];
|
||||
q[1] = (SHR(tmp, 1) ^ SHL(tmp, 2) ^ ROTL64(tmp, 13) ^ ROTL64(tmp, 43)) + hash[2];
|
||||
tmp = (msg[ 0] ^ hash[ 0]) + (msg[ 7] ^ hash[ 7]) + (msg[ 9] ^ hash[ 9]) - (msg[12] ^ hash[12]) + (msg[15] ^ hash[15]);
|
||||
q[2] = (SHR(tmp, 2) ^ SHL(tmp, 1) ^ ROL(tmp, 19) ^ ROL(tmp, 53)) + hash[3];
|
||||
q[2] = (SHR(tmp, 2) ^ SHL(tmp, 1) ^ ROTL64(tmp, 19) ^ ROTL64(tmp, 53)) + hash[3];
|
||||
tmp = (msg[ 0] ^ hash[ 0]) - (msg[ 1] ^ hash[ 1]) + (msg[ 8] ^ hash[ 8]) - (msg[10] ^ hash[10]) + (msg[13] ^ hash[13]);
|
||||
q[3] = (SHR(tmp, 2) ^ SHL(tmp, 2) ^ ROL(tmp, 28) ^ ROL(tmp, 59)) + hash[4];
|
||||
q[3] = (SHR(tmp, 2) ^ SHL(tmp, 2) ^ ROTL64(tmp, 28) ^ ROTL64(tmp, 59)) + hash[4];
|
||||
tmp = (msg[ 1] ^ hash[ 1]) + (msg[ 2] ^ hash[ 2]) + (msg[ 9] ^ hash[ 9]) - (msg[11] ^ hash[11]) - (msg[14] ^ hash[14]);
|
||||
q[4] = (SHR(tmp, 1) ^ tmp) + hash[5];
|
||||
tmp = (msg[ 3] ^ hash[ 3]) - (msg[ 2] ^ hash[ 2]) + (msg[10] ^ hash[10]) - (msg[12] ^ hash[12]) + (msg[15] ^ hash[15]);
|
||||
q[5] = (SHR(tmp, 1) ^ SHL(tmp, 3) ^ ROL(tmp, 4) ^ ROL(tmp, 37)) + hash[6];
|
||||
q[5] = (SHR(tmp, 1) ^ SHL(tmp, 3) ^ ROTL64(tmp, 4) ^ ROTL64(tmp, 37)) + hash[6];
|
||||
tmp = (msg[ 4] ^ hash[ 4]) - (msg[ 0] ^ hash[ 0]) - (msg[ 3] ^ hash[ 3]) - (msg[11] ^ hash[11]) + (msg[13] ^ hash[13]);
|
||||
q[6] = (SHR(tmp, 1) ^ SHL(tmp, 2) ^ ROL(tmp, 13) ^ ROL(tmp, 43)) + hash[7];
|
||||
q[6] = (SHR(tmp, 1) ^ SHL(tmp, 2) ^ ROTL64(tmp, 13) ^ ROTL64(tmp, 43)) + hash[7];
|
||||
tmp = (msg[ 1] ^ hash[ 1]) - (msg[ 4] ^ hash[ 4]) - (msg[ 5] ^ hash[ 5]) - (msg[12] ^ hash[12]) - (msg[14] ^ hash[14]);
|
||||
q[7] = (SHR(tmp, 2) ^ SHL(tmp, 1) ^ ROL(tmp, 19) ^ ROL(tmp, 53)) + hash[8];
|
||||
q[7] = (SHR(tmp, 2) ^ SHL(tmp, 1) ^ ROTL64(tmp, 19) ^ ROTL64(tmp, 53)) + hash[8];
|
||||
tmp = (msg[ 2] ^ hash[ 2]) - (msg[ 5] ^ hash[ 5]) - (msg[ 6] ^ hash[ 6]) + (msg[13] ^ hash[13]) - (msg[15] ^ hash[15]);
|
||||
q[8] = (SHR(tmp, 2) ^ SHL(tmp, 2) ^ ROL(tmp, 28) ^ ROL(tmp, 59)) + hash[9];
|
||||
q[8] = (SHR(tmp, 2) ^ SHL(tmp, 2) ^ ROTL64(tmp, 28) ^ ROTL64(tmp, 59)) + hash[9];
|
||||
tmp = (msg[ 0] ^ hash[ 0]) - (msg[ 3] ^ hash[ 3]) + (msg[ 6] ^ hash[ 6]) - (msg[ 7] ^ hash[ 7]) + (msg[14] ^ hash[14]);
|
||||
q[9] = (SHR(tmp, 1) ^ tmp) + hash[10];
|
||||
tmp = (msg[ 8] ^ hash[ 8]) - (msg[ 1] ^ hash[ 1]) - (msg[ 4] ^ hash[ 4]) - (msg[ 7] ^ hash[ 7]) + (msg[15] ^ hash[15]);
|
||||
q[10] = (SHR(tmp, 1) ^ SHL(tmp, 3) ^ ROL(tmp, 4) ^ ROL(tmp, 37)) + hash[11];
|
||||
q[10] = (SHR(tmp, 1) ^ SHL(tmp, 3) ^ ROTL64(tmp, 4) ^ ROTL64(tmp, 37)) + hash[11];
|
||||
tmp = (msg[ 8] ^ hash[ 8]) - (msg[ 0] ^ hash[ 0]) - (msg[ 2] ^ hash[ 2]) - (msg[ 5] ^ hash[ 5]) + (msg[ 9] ^ hash[ 9]);
|
||||
q[11] = (SHR(tmp, 1) ^ SHL(tmp, 2) ^ ROL(tmp, 13) ^ ROL(tmp, 43)) + hash[12];
|
||||
q[11] = (SHR(tmp, 1) ^ SHL(tmp, 2) ^ ROTL64(tmp, 13) ^ ROTL64(tmp, 43)) + hash[12];
|
||||
tmp = (msg[ 1] ^ hash[ 1]) + (msg[ 3] ^ hash[ 3]) - (msg[ 6] ^ hash[ 6]) - (msg[ 9] ^ hash[ 9]) + (msg[10] ^ hash[10]);
|
||||
q[12] = (SHR(tmp, 2) ^ SHL(tmp, 1) ^ ROL(tmp, 19) ^ ROL(tmp, 53)) + hash[13];
|
||||
q[12] = (SHR(tmp, 2) ^ SHL(tmp, 1) ^ ROTL64(tmp, 19) ^ ROTL64(tmp, 53)) + hash[13];
|
||||
tmp = (msg[ 2] ^ hash[ 2]) + (msg[ 4] ^ hash[ 4]) + (msg[ 7] ^ hash[ 7]) + (msg[10] ^ hash[10]) + (msg[11] ^ hash[11]);
|
||||
q[13] = (SHR(tmp, 2) ^ SHL(tmp, 2) ^ ROL(tmp, 28) ^ ROL(tmp, 59)) + hash[14];
|
||||
q[13] = (SHR(tmp, 2) ^ SHL(tmp, 2) ^ ROTL64(tmp, 28) ^ ROTL64(tmp, 59)) + hash[14];
|
||||
tmp = (msg[ 3] ^ hash[ 3]) - (msg[ 5] ^ hash[ 5]) + (msg[ 8] ^ hash[ 8]) - (msg[11] ^ hash[11]) - (msg[12] ^ hash[12]);
|
||||
q[14] = (SHR(tmp, 1) ^ tmp) + hash[15];
|
||||
tmp = (msg[12] ^ hash[12]) - (msg[ 4] ^ hash[ 4]) - (msg[ 6] ^ hash[ 6]) - (msg[ 9] ^ hash[ 9]) + (msg[13] ^ hash[13]);
|
||||
q[15] = (SHR(tmp, 1) ^ SHL(tmp, 3) ^ ROL(tmp, 4) ^ ROL(tmp, 37)) + hash[0];
|
||||
q[15] = (SHR(tmp, 1) ^ SHL(tmp, 3) ^ ROTL64(tmp, 4) ^ ROTL64(tmp, 37)) + hash[0];
|
||||
|
||||
q[0+16] =
|
||||
(SHR(q[0], 1) ^ SHL(q[0], 2) ^ ROL(q[0], 13) ^ ROL(q[0], 43)) +
|
||||
(SHR(q[0+1], 2) ^ SHL(q[0+1], 1) ^ ROL(q[0+1], 19) ^ ROL(q[0+1], 53)) +
|
||||
(SHR(q[0+2], 2) ^ SHL(q[0+2], 2) ^ ROL(q[0+2], 28) ^ ROL(q[0+2], 59)) +
|
||||
(SHR(q[0+3], 1) ^ SHL(q[0+3], 3) ^ ROL(q[0+3], 4) ^ ROL(q[0+3], 37)) +
|
||||
(SHR(q[0+4], 1) ^ SHL(q[0+4], 2) ^ ROL(q[0+4], 13) ^ ROL(q[0+4], 43)) +
|
||||
(SHR(q[0+5], 2) ^ SHL(q[0+5], 1) ^ ROL(q[0+5], 19) ^ ROL(q[0+5], 53)) +
|
||||
(SHR(q[0+6], 2) ^ SHL(q[0+6], 2) ^ ROL(q[0+6], 28) ^ ROL(q[0+6], 59)) +
|
||||
(SHR(q[0+7], 1) ^ SHL(q[0+7], 3) ^ ROL(q[0+7], 4) ^ ROL(q[0+7], 37)) +
|
||||
(SHR(q[0+8], 1) ^ SHL(q[0+8], 2) ^ ROL(q[0+8], 13) ^ ROL(q[0+8], 43)) +
|
||||
(SHR(q[0+9], 2) ^ SHL(q[0+9], 1) ^ ROL(q[0+9], 19) ^ ROL(q[0+9], 53)) +
|
||||
(SHR(q[0+10], 2) ^ SHL(q[0+10], 2) ^ ROL(q[0+10], 28) ^ ROL(q[0+10], 59)) +
|
||||
(SHR(q[0+11], 1) ^ SHL(q[0+11], 3) ^ ROL(q[0+11], 4) ^ ROL(q[0+11], 37)) +
|
||||
(SHR(q[0+12], 1) ^ SHL(q[0+12], 2) ^ ROL(q[0+12], 13) ^ ROL(q[0+12], 43)) +
|
||||
(SHR(q[0+13], 2) ^ SHL(q[0+13], 1) ^ ROL(q[0+13], 19) ^ ROL(q[0+13], 53)) +
|
||||
(SHR(q[0+14], 2) ^ SHL(q[0+14], 2) ^ ROL(q[0+14], 28) ^ ROL(q[0+14], 59)) +
|
||||
(SHR(q[0+15], 1) ^ SHL(q[0+15], 3) ^ ROL(q[0+15], 4) ^ ROL(q[0+15], 37)) +
|
||||
((make_uint2(0x55555550ul, 0x55555555) + ROL(msg[0], 0 + 1) +
|
||||
ROL(msg[0+3], 0+4) - ROL(msg[0+10], 0+11) ) ^ hash[0+7]);
|
||||
(SHR(q[0], 1) ^ SHL(q[0], 2) ^ ROTL64(q[0], 13) ^ ROTL64(q[0], 43)) +
|
||||
(SHR(q[0+1], 2) ^ SHL(q[0+1], 1) ^ ROTL64(q[0+1], 19) ^ ROTL64(q[0+1], 53)) +
|
||||
(SHR(q[0+2], 2) ^ SHL(q[0+2], 2) ^ ROTL64(q[0+2], 28) ^ ROTL64(q[0+2], 59)) +
|
||||
(SHR(q[0+3], 1) ^ SHL(q[0+3], 3) ^ ROTL64(q[0+3], 4) ^ ROTL64(q[0+3], 37)) +
|
||||
(SHR(q[0+4], 1) ^ SHL(q[0+4], 2) ^ ROTL64(q[0+4], 13) ^ ROTL64(q[0+4], 43)) +
|
||||
(SHR(q[0+5], 2) ^ SHL(q[0+5], 1) ^ ROTL64(q[0+5], 19) ^ ROTL64(q[0+5], 53)) +
|
||||
(SHR(q[0+6], 2) ^ SHL(q[0+6], 2) ^ ROTL64(q[0+6], 28) ^ ROTL64(q[0+6], 59)) +
|
||||
(SHR(q[0+7], 1) ^ SHL(q[0+7], 3) ^ ROTL64(q[0+7], 4) ^ ROTL64(q[0+7], 37)) +
|
||||
(SHR(q[0+8], 1) ^ SHL(q[0+8], 2) ^ ROTL64(q[0+8], 13) ^ ROTL64(q[0+8], 43)) +
|
||||
(SHR(q[0+9], 2) ^ SHL(q[0+9], 1) ^ ROTL64(q[0+9], 19) ^ ROTL64(q[0+9], 53)) +
|
||||
(SHR(q[0+10], 2) ^ SHL(q[0+10], 2) ^ ROTL64(q[0+10], 28) ^ ROTL64(q[0+10], 59)) +
|
||||
(SHR(q[0+11], 1) ^ SHL(q[0+11], 3) ^ ROTL64(q[0+11], 4) ^ ROTL64(q[0+11], 37)) +
|
||||
(SHR(q[0+12], 1) ^ SHL(q[0+12], 2) ^ ROTL64(q[0+12], 13) ^ ROTL64(q[0+12], 43)) +
|
||||
(SHR(q[0+13], 2) ^ SHL(q[0+13], 1) ^ ROTL64(q[0+13], 19) ^ ROTL64(q[0+13], 53)) +
|
||||
(SHR(q[0+14], 2) ^ SHL(q[0+14], 2) ^ ROTL64(q[0+14], 28) ^ ROTL64(q[0+14], 59)) +
|
||||
(SHR(q[0+15], 1) ^ SHL(q[0+15], 3) ^ ROTL64(q[0+15], 4) ^ ROTL64(q[0+15], 37)) +
|
||||
((make_uint2(0x55555550ul, 0x55555555) + ROTL64(msg[0], 0 + 1) +
|
||||
ROTL64(msg[0+3], 0+4) - ROTL64(msg[0+10], 0+11) ) ^ hash[0+7]);
|
||||
|
||||
q[1 + 16] =
|
||||
(SHR(q[1], 1) ^ SHL(q[1], 2) ^ ROL(q[1], 13) ^ ROL(q[1], 43)) +
|
||||
(SHR(q[1 + 1], 2) ^ SHL(q[1 + 1], 1) ^ ROL(q[1 + 1], 19) ^ ROL(q[1 + 1], 53)) +
|
||||
(SHR(q[1 + 2], 2) ^ SHL(q[1 + 2], 2) ^ ROL(q[1 + 2], 28) ^ ROL(q[1 + 2], 59)) +
|
||||
(SHR(q[1 + 3], 1) ^ SHL(q[1 + 3], 3) ^ ROL(q[1 + 3], 4) ^ ROL(q[1 + 3], 37)) +
|
||||
(SHR(q[1 + 4], 1) ^ SHL(q[1 + 4], 2) ^ ROL(q[1 + 4], 13) ^ ROL(q[1 + 4], 43)) +
|
||||
(SHR(q[1 + 5], 2) ^ SHL(q[1 + 5], 1) ^ ROL(q[1 + 5], 19) ^ ROL(q[1 + 5], 53)) +
|
||||
(SHR(q[1 + 6], 2) ^ SHL(q[1 + 6], 2) ^ ROL(q[1 + 6], 28) ^ ROL(q[1 + 6], 59)) +
|
||||
(SHR(q[1 + 7], 1) ^ SHL(q[1 + 7], 3) ^ ROL(q[1 + 7], 4) ^ ROL(q[1 + 7], 37)) +
|
||||
(SHR(q[1 + 8], 1) ^ SHL(q[1 + 8], 2) ^ ROL(q[1 + 8], 13) ^ ROL(q[1 + 8], 43)) +
|
||||
(SHR(q[1 + 9], 2) ^ SHL(q[1 + 9], 1) ^ ROL(q[1 + 9], 19) ^ ROL(q[1 + 9], 53)) +
|
||||
(SHR(q[1 + 10], 2) ^ SHL(q[1 + 10], 2) ^ ROL(q[1 + 10], 28) ^ ROL(q[1 + 10], 59)) +
|
||||
(SHR(q[1 + 11], 1) ^ SHL(q[1 + 11], 3) ^ ROL(q[1 + 11], 4) ^ ROL(q[1 + 11], 37)) +
|
||||
(SHR(q[1 + 12], 1) ^ SHL(q[1 + 12], 2) ^ ROL(q[1 + 12], 13) ^ ROL(q[1 + 12], 43)) +
|
||||
(SHR(q[1 + 13], 2) ^ SHL(q[1 + 13], 1) ^ ROL(q[1 + 13], 19) ^ ROL(q[1 + 13], 53)) +
|
||||
(SHR(q[1 + 14], 2) ^ SHL(q[1 + 14], 2) ^ ROL(q[1 + 14], 28) ^ ROL(q[1 + 14], 59)) +
|
||||
(SHR(q[1 + 15], 1) ^ SHL(q[1 + 15], 3) ^ ROL(q[1 + 15], 4) ^ ROL(q[1 + 15], 37)) +
|
||||
((make_uint2(0xAAAAAAA5, 0x5AAAAAAA) + ROL(msg[1], 1 + 1) +
|
||||
ROL(msg[1 + 3], 1 + 4) - ROL(msg[1 + 10], 1 + 11)) ^ hash[1 + 7]);
|
||||
(SHR(q[1], 1) ^ SHL(q[1], 2) ^ ROTL64(q[1], 13) ^ ROTL64(q[1], 43)) +
|
||||
(SHR(q[1 + 1], 2) ^ SHL(q[1 + 1], 1) ^ ROTL64(q[1 + 1], 19) ^ ROTL64(q[1 + 1], 53)) +
|
||||
(SHR(q[1 + 2], 2) ^ SHL(q[1 + 2], 2) ^ ROTL64(q[1 + 2], 28) ^ ROTL64(q[1 + 2], 59)) +
|
||||
(SHR(q[1 + 3], 1) ^ SHL(q[1 + 3], 3) ^ ROTL64(q[1 + 3], 4) ^ ROTL64(q[1 + 3], 37)) +
|
||||
(SHR(q[1 + 4], 1) ^ SHL(q[1 + 4], 2) ^ ROTL64(q[1 + 4], 13) ^ ROTL64(q[1 + 4], 43)) +
|
||||
(SHR(q[1 + 5], 2) ^ SHL(q[1 + 5], 1) ^ ROTL64(q[1 + 5], 19) ^ ROTL64(q[1 + 5], 53)) +
|
||||
(SHR(q[1 + 6], 2) ^ SHL(q[1 + 6], 2) ^ ROTL64(q[1 + 6], 28) ^ ROTL64(q[1 + 6], 59)) +
|
||||
(SHR(q[1 + 7], 1) ^ SHL(q[1 + 7], 3) ^ ROTL64(q[1 + 7], 4) ^ ROTL64(q[1 + 7], 37)) +
|
||||
(SHR(q[1 + 8], 1) ^ SHL(q[1 + 8], 2) ^ ROTL64(q[1 + 8], 13) ^ ROTL64(q[1 + 8], 43)) +
|
||||
(SHR(q[1 + 9], 2) ^ SHL(q[1 + 9], 1) ^ ROTL64(q[1 + 9], 19) ^ ROTL64(q[1 + 9], 53)) +
|
||||
(SHR(q[1 + 10], 2) ^ SHL(q[1 + 10], 2) ^ ROTL64(q[1 + 10], 28) ^ ROTL64(q[1 + 10], 59)) +
|
||||
(SHR(q[1 + 11], 1) ^ SHL(q[1 + 11], 3) ^ ROTL64(q[1 + 11], 4) ^ ROTL64(q[1 + 11], 37)) +
|
||||
(SHR(q[1 + 12], 1) ^ SHL(q[1 + 12], 2) ^ ROTL64(q[1 + 12], 13) ^ ROTL64(q[1 + 12], 43)) +
|
||||
(SHR(q[1 + 13], 2) ^ SHL(q[1 + 13], 1) ^ ROTL64(q[1 + 13], 19) ^ ROTL64(q[1 + 13], 53)) +
|
||||
(SHR(q[1 + 14], 2) ^ SHL(q[1 + 14], 2) ^ ROTL64(q[1 + 14], 28) ^ ROTL64(q[1 + 14], 59)) +
|
||||
(SHR(q[1 + 15], 1) ^ SHL(q[1 + 15], 3) ^ ROTL64(q[1 + 15], 4) ^ ROTL64(q[1 + 15], 37)) +
|
||||
((make_uint2(0xAAAAAAA5, 0x5AAAAAAA) + ROTL64(msg[1], 1 + 1) +
|
||||
ROTL64(msg[1 + 3], 1 + 4) - ROTL64(msg[1 + 10], 1 + 11)) ^ hash[1 + 7]);
|
||||
|
||||
q[2 + 16] = CONST_EXP2(2) +
|
||||
((make_uint2(0xFFFFFFFA, 0x5FFFFFFF) + ROL(msg[2], 2 + 1) +
|
||||
ROL(msg[2+3], 2+4) - ROL(msg[2+10], 2+11) ) ^ hash[2+7]);
|
||||
((make_uint2(0xFFFFFFFA, 0x5FFFFFFF) + ROTL64(msg[2], 2 + 1) +
|
||||
ROTL64(msg[2+3], 2+4) - ROTL64(msg[2+10], 2+11) ) ^ hash[2+7]);
|
||||
q[3 + 16] = CONST_EXP2(3) +
|
||||
((make_uint2(0x5555554F, 0x65555555) + ROL(msg[3], 3 + 1) +
|
||||
ROL(msg[3 + 3], 3 + 4) - ROL(msg[3 + 10], 3 + 11)) ^ hash[3 + 7]);
|
||||
((make_uint2(0x5555554F, 0x65555555) + ROTL64(msg[3], 3 + 1) +
|
||||
ROTL64(msg[3 + 3], 3 + 4) - ROTL64(msg[3 + 10], 3 + 11)) ^ hash[3 + 7]);
|
||||
q[4 + 16] = CONST_EXP2(4) +
|
||||
((make_uint2(0xAAAAAAA4, 0x6AAAAAAA) + ROL(msg[4], 4 + 1) +
|
||||
ROL(msg[4 + 3], 4 + 4) - ROL(msg[4 + 10], 4 + 11)) ^ hash[4 + 7]);
|
||||
((make_uint2(0xAAAAAAA4, 0x6AAAAAAA) + ROTL64(msg[4], 4 + 1) +
|
||||
ROTL64(msg[4 + 3], 4 + 4) - ROTL64(msg[4 + 10], 4 + 11)) ^ hash[4 + 7]);
|
||||
q[5 + 16] = CONST_EXP2(5) +
|
||||
((make_uint2(0xFFFFFFF9, 0x6FFFFFFF) + ROL(msg[5], 5 + 1) +
|
||||
ROL(msg[5 + 3], 5 + 4) - ROL(msg[5 + 10], 5 + 11)) ^ hash[5 + 7]);
|
||||
((make_uint2(0xFFFFFFF9, 0x6FFFFFFF) + ROTL64(msg[5], 5 + 1) +
|
||||
ROTL64(msg[5 + 3], 5 + 4) - ROTL64(msg[5 + 10], 5 + 11)) ^ hash[5 + 7]);
|
||||
q[6 + 16] = CONST_EXP2(6) +
|
||||
((make_uint2(0x5555554E, 0x75555555)+ ROL(msg[6], 6 + 1) +
|
||||
ROL(msg[6 + 3], 6 + 4) - ROL(msg[6 - 6], (6 - 6) + 1)) ^ hash[6 + 7]);
|
||||
((make_uint2(0x5555554E, 0x75555555)+ ROTL64(msg[6], 6 + 1) +
|
||||
ROTL64(msg[6 + 3], 6 + 4) - ROTL64(msg[6 - 6], (6 - 6) + 1)) ^ hash[6 + 7]);
|
||||
q[7 + 16] = CONST_EXP2(7) +
|
||||
((make_uint2(0xAAAAAAA3, 0x7AAAAAAA) + ROL(msg[7], 7 + 1) +
|
||||
ROL(msg[7 + 3], 7 + 4) - ROL(msg[7 - 6], (7 - 6) + 1)) ^ hash[7 + 7]);
|
||||
((make_uint2(0xAAAAAAA3, 0x7AAAAAAA) + ROTL64(msg[7], 7 + 1) +
|
||||
ROTL64(msg[7 + 3], 7 + 4) - ROTL64(msg[7 - 6], (7 - 6) + 1)) ^ hash[7 + 7]);
|
||||
q[8 + 16] = CONST_EXP2(8) +
|
||||
((make_uint2(0xFFFFFFF8, 0x7FFFFFFF) + ROL(msg[8], 8 + 1) +
|
||||
ROL(msg[8 + 3], 8 + 4) - ROL(msg[8 - 6], (8 - 6) + 1)) ^ hash[8 + 7]);
|
||||
((make_uint2(0xFFFFFFF8, 0x7FFFFFFF) + ROTL64(msg[8], 8 + 1) +
|
||||
ROTL64(msg[8 + 3], 8 + 4) - ROTL64(msg[8 - 6], (8 - 6) + 1)) ^ hash[8 + 7]);
|
||||
q[9 + 16] = CONST_EXP2(9) +
|
||||
((make_uint2(0x5555554D, 0x85555555) + ROL(msg[9], 9 + 1) +
|
||||
ROL(msg[9 + 3], 9 + 4) - ROL(msg[9 - 6], (9 - 6) + 1)) ^ hash[9 - 9]);
|
||||
((make_uint2(0x5555554D, 0x85555555) + ROTL64(msg[9], 9 + 1) +
|
||||
ROTL64(msg[9 + 3], 9 + 4) - ROTL64(msg[9 - 6], (9 - 6) + 1)) ^ hash[9 - 9]);
|
||||
q[10 + 16] = CONST_EXP2(10) +
|
||||
((make_uint2(0xAAAAAAA2, 0x8AAAAAAA) + ROL(msg[10], 10 + 1) +
|
||||
ROL(msg[10 + 3], 10 + 4) - ROL(msg[10 - 6], (10 - 6) + 1)) ^ hash[10 - 9]);
|
||||
((make_uint2(0xAAAAAAA2, 0x8AAAAAAA) + ROTL64(msg[10], 10 + 1) +
|
||||
ROTL64(msg[10 + 3], 10 + 4) - ROTL64(msg[10 - 6], (10 - 6) + 1)) ^ hash[10 - 9]);
|
||||
q[11 + 16] = CONST_EXP2(11) +
|
||||
((make_uint2(0xFFFFFFF7, 0x8FFFFFFF) + ROL(msg[11], 11 + 1) +
|
||||
ROL(msg[11 + 3], 11 + 4) - ROL(msg[11 - 6], (11 - 6) + 1)) ^ hash[11 - 9]);
|
||||
((make_uint2(0xFFFFFFF7, 0x8FFFFFFF) + ROTL64(msg[11], 11 + 1) +
|
||||
ROTL64(msg[11 + 3], 11 + 4) - ROTL64(msg[11 - 6], (11 - 6) + 1)) ^ hash[11 - 9]);
|
||||
q[12 + 16] = CONST_EXP2(12) +
|
||||
((make_uint2(0x5555554C, 0x95555555) + ROL(msg[12], 12 + 1) +
|
||||
ROL(msg[12 + 3], 12 + 4) - ROL(msg[12 - 6], (12 - 6) + 1)) ^ hash[12 - 9]);
|
||||
((make_uint2(0x5555554C, 0x95555555) + ROTL64(msg[12], 12 + 1) +
|
||||
ROTL64(msg[12 + 3], 12 + 4) - ROTL64(msg[12 - 6], (12 - 6) + 1)) ^ hash[12 - 9]);
|
||||
q[13 + 16] = CONST_EXP2(13) +
|
||||
((make_uint2(0xAAAAAAA1, 0x9AAAAAAA) + ROL(msg[13], 13 + 1) +
|
||||
ROL(msg[13 - 13], (13 - 13) + 1) - ROL(msg[13 - 6], (13 - 6) + 1)) ^ hash[13 - 9]);
|
||||
((make_uint2(0xAAAAAAA1, 0x9AAAAAAA) + ROTL64(msg[13], 13 + 1) +
|
||||
ROTL64(msg[13 - 13], (13 - 13) + 1) - ROTL64(msg[13 - 6], (13 - 6) + 1)) ^ hash[13 - 9]);
|
||||
q[14 + 16] = CONST_EXP2(14) +
|
||||
((make_uint2(0xFFFFFFF6, 0x9FFFFFFF) + ROL(msg[14], 14 + 1) +
|
||||
ROL(msg[14 - 13], (14 - 13) + 1) - ROL(msg[14 - 6], (14 - 6) + 1)) ^ hash[14 - 9]);
|
||||
((make_uint2(0xFFFFFFF6, 0x9FFFFFFF) + ROTL64(msg[14], 14 + 1) +
|
||||
ROTL64(msg[14 - 13], (14 - 13) + 1) - ROTL64(msg[14 - 6], (14 - 6) + 1)) ^ hash[14 - 9]);
|
||||
q[15 + 16] = CONST_EXP2(15) +
|
||||
((make_uint2(0x5555554B, 0xA5555555) + ROL(msg[15], 15 + 1) +
|
||||
ROL(msg[15 - 13], (15 - 13) + 1) - ROL(msg[15 - 6], (15 - 6) + 1)) ^ hash[15 - 9]);
|
||||
((make_uint2(0x5555554B, 0xA5555555) + ROTL64(msg[15], 15 + 1) +
|
||||
ROTL64(msg[15 - 13], (15 - 13) + 1) - ROTL64(msg[15 - 6], (15 - 6) + 1)) ^ hash[15 - 9]);
|
||||
|
||||
uint2 XL64 = q[16]^q[17]^q[18]^q[19]^q[20]^q[21]^q[22]^q[23];
|
||||
uint2 XH64 = XL64^q[24] ^ q[25] ^ q[26] ^ q[27] ^ q[28] ^ q[29] ^ q[30] ^ q[31];
|
||||
|
||||
hash[0] = (SHL(XH64, 5) ^ SHR(q[16],5) ^ msg[ 0]) + (XL64 ^ q[24] ^ q[ 0]);
|
||||
hash[1] = (SHR(XH64, 7) ^ SHL(q[17],8) ^ msg[ 1]) + (XL64 ^ q[25] ^ q[ 1]);
|
||||
hash[2] = (SHR(XH64, 5) ^ SHL(q[18],5) ^ msg[ 2]) + (XL64 ^ q[26] ^ q[ 2]);
|
||||
hash[3] = (SHR(XH64, 1) ^ SHL(q[19],5) ^ msg[ 3]) + (XL64 ^ q[27] ^ q[ 3]);
|
||||
hash[4] = (SHR(XH64, 3) ^ q[20] ^ msg[ 4]) + (XL64 ^ q[28] ^ q[ 4]);
|
||||
hash[5] = (SHL(XH64, 6) ^ SHR(q[21],6) ^ msg[ 5]) + (XL64 ^ q[29] ^ q[ 5]);
|
||||
hash[6] = (SHR(XH64, 4) ^ SHL(q[22],6) ^ msg[ 6]) + (XL64 ^ q[30] ^ q[ 6]);
|
||||
hash[7] = (SHR(XH64,11) ^ SHL(q[23],2) ^ msg[ 7]) + (XL64 ^ q[31] ^ q[ 7]);
|
||||
hash[0] = (SHL(XH64, 5) ^ SHR(q[16],5) ^ msg[ 0]) + ( XL64 ^ q[24] ^ q[ 0]);
|
||||
hash[1] = (SHR(XH64, 7) ^ SHL(q[17],8) ^ msg[ 1]) + ( XL64 ^ q[25] ^ q[ 1]);
|
||||
hash[2] = (SHR(XH64, 5) ^ SHL(q[18],5) ^ msg[ 2]) + ( XL64 ^ q[26] ^ q[ 2]);
|
||||
hash[3] = (SHR(XH64, 1) ^ SHL(q[19],5) ^ msg[ 3]) + ( XL64 ^ q[27] ^ q[ 3]);
|
||||
hash[4] = (SHR(XH64, 3) ^ q[20] ^ msg[ 4]) + ( XL64 ^ q[28] ^ q[ 4]);
|
||||
hash[5] = (SHL(XH64, 6) ^ SHR(q[21],6) ^ msg[ 5]) + ( XL64 ^ q[29] ^ q[ 5]);
|
||||
hash[6] = (SHR(XH64, 4) ^ SHL(q[22],6) ^ msg[ 6]) + ( XL64 ^ q[30] ^ q[ 6]);
|
||||
hash[7] = (SHR(XH64,11) ^ SHL(q[23],2) ^ msg[ 7]) + ( XL64 ^ q[31] ^ q[ 7]);
|
||||
|
||||
hash[ 8] = ROL(hash[4], 9) + (XH64 ^ q[24] ^ msg[ 8]) + (SHL(XL64,8) ^ q[23] ^ q[ 8]);
|
||||
hash[ 9] = ROL(hash[5],10) + (XH64 ^ q[25] ^ msg[ 9]) + (SHR(XL64,6) ^ q[16] ^ q[ 9]);
|
||||
hash[10] = ROL(hash[6],11) + (XH64 ^ q[26] ^ msg[10]) + (SHL(XL64,6) ^ q[17] ^ q[10]);
|
||||
hash[11] = ROL(hash[7],12) + (XH64 ^ q[27] ^ msg[11]) + (SHL(XL64,4) ^ q[18] ^ q[11]);
|
||||
hash[12] = ROL(hash[0],13) + (XH64 ^ q[28] ^ msg[12]) + (SHR(XL64,3) ^ q[19] ^ q[12]);
|
||||
hash[13] = ROL(hash[1],14) + (XH64 ^ q[29] ^ msg[13]) + (SHR(XL64,4) ^ q[20] ^ q[13]);
|
||||
hash[14] = ROL(hash[2],15) + (XH64 ^ q[30] ^ msg[14]) + (SHR(XL64,7) ^ q[21] ^ q[14]);
|
||||
hash[15] = ROL(hash[3],16) + (XH64 ^ q[31] ^ msg[15]) + (SHR(XL64, 2) ^ q[22] ^ q[15]);
|
||||
hash[ 8] = ROTL64(hash[4], 9) + ( XH64 ^ q[24] ^ msg[ 8]) + (SHL(XL64,8) ^ q[23] ^ q[ 8]);
|
||||
hash[ 9] = ROTL64(hash[5],10) + ( XH64 ^ q[25] ^ msg[ 9]) + (SHR(XL64,6) ^ q[16] ^ q[ 9]);
|
||||
hash[10] = ROTL64(hash[6],11) + ( XH64 ^ q[26] ^ msg[10]) + (SHL(XL64,6) ^ q[17] ^ q[10]);
|
||||
hash[11] = ROTL64(hash[7],12) + ( XH64 ^ q[27] ^ msg[11]) + (SHL(XL64,4) ^ q[18] ^ q[11]);
|
||||
hash[12] = ROTL64(hash[0],13) + ( XH64 ^ q[28] ^ msg[12]) + (SHR(XL64,3) ^ q[19] ^ q[12]);
|
||||
hash[13] = ROTL64(hash[1],14) + ( XH64 ^ q[29] ^ msg[13]) + (SHR(XL64,4) ^ q[20] ^ q[13]);
|
||||
hash[14] = ROTL64(hash[2],15) + ( XH64 ^ q[30] ^ msg[14]) + (SHR(XL64,7) ^ q[21] ^ q[14]);
|
||||
hash[15] = ROTL64(hash[3],16) + (XH64 ^ q[31] ^ msg[15]) + (SHR(XL64, 2) ^ q[22] ^ q[15]);
|
||||
}
|
||||
|
||||
__global__
|
||||
@@ -320,8 +323,8 @@ void quark_bmw512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint64_t *
|
||||
{
|
||||
uint32_t nounce = (g_nonceVector != NULL) ? g_nonceVector[thread] : (startNounce + thread);
|
||||
|
||||
uint32_t hashPosition = nounce - startNounce;
|
||||
uint64_t *inpHash = &g_hash[hashPosition * 8];
|
||||
int hashPosition = nounce - startNounce;
|
||||
uint64_t *inpHash = &g_hash[8 * hashPosition];
|
||||
|
||||
// Init
|
||||
uint2 h[16] = {
|
||||
@@ -346,11 +349,10 @@ void quark_bmw512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint64_t *
|
||||
// Nachricht kopieren (Achtung, die Nachricht hat 64 Byte,
|
||||
// BMW arbeitet mit 128 Byte!!!
|
||||
uint2 message[16];
|
||||
#pragma unroll
|
||||
#pragma unroll 8
|
||||
for(int i=0;i<8;i++)
|
||||
message[i] = vectorize(inpHash[i]);
|
||||
|
||||
#pragma unroll 6
|
||||
#pragma unroll 6
|
||||
for(int i=9;i<15;i++)
|
||||
message[i] = make_uint2(0,0);
|
||||
|
||||
@@ -363,7 +365,7 @@ void quark_bmw512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint64_t *
|
||||
Compression512_64_first(message, h);
|
||||
|
||||
// Final
|
||||
#pragma unroll
|
||||
#pragma unroll 16
|
||||
for(int i=0;i<16;i++)
|
||||
{
|
||||
message[i].y = 0xaaaaaaaa;
|
||||
@@ -372,9 +374,9 @@ void quark_bmw512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint64_t *
|
||||
Compression512(h, message);
|
||||
|
||||
// fertig
|
||||
uint64_t *outpHash = &g_hash[hashPosition * 8];
|
||||
uint64_t *outpHash = &g_hash[8 * hashPosition];
|
||||
|
||||
#pragma unroll
|
||||
#pragma unroll 8
|
||||
for(int i=0;i<8;i++)
|
||||
outpHash[i] = devectorize(message[i+8]);
|
||||
}
|
||||
@@ -428,7 +430,7 @@ void quark_bmw512_gpu_hash_80(uint32_t threads, uint32_t startNounce, uint64_t *
|
||||
Compression512(h, message);
|
||||
|
||||
// fertig
|
||||
uint64_t *outpHash = &g_hash[thread * 8];
|
||||
uint64_t *outpHash = &g_hash[8 * thread];
|
||||
|
||||
#pragma unroll 8
|
||||
for(int i=0;i<8;i++)
|
||||
|
||||
@@ -151,8 +151,8 @@ void quark_bmw512_gpu_hash_64_30(uint32_t threads, uint32_t startNounce, uint64_
|
||||
{
|
||||
uint32_t nounce = (g_nonceVector != NULL) ? g_nonceVector[thread] : (startNounce + thread);
|
||||
|
||||
uint32_t hashPosition = nounce - startNounce;
|
||||
uint64_t *inpHash = &g_hash[hashPosition * 8];
|
||||
int hashPosition = nounce - startNounce;
|
||||
uint64_t *inpHash = &g_hash[8 * hashPosition];
|
||||
|
||||
// Init
|
||||
uint64_t h[16];
|
||||
@@ -205,7 +205,7 @@ void quark_bmw512_gpu_hash_64_30(uint32_t threads, uint32_t startNounce, uint64_
|
||||
|
||||
Compression512_30(h, message);
|
||||
|
||||
uint64_t *outpHash = &g_hash[hashPosition * 8];
|
||||
uint64_t *outpHash = &g_hash[8 * hashPosition];
|
||||
|
||||
#pragma unroll 8
|
||||
for(int i=0;i<8;i++)
|
||||
|
||||
+204
-247
@@ -1,287 +1,245 @@
|
||||
#include "cuda_helper.h"
|
||||
|
||||
// #include <stdio.h> // printf
|
||||
// #include <unistd.h> // sleep
|
||||
__constant__ unsigned char c_E8_bitslice_roundconstant[42][32] = {
|
||||
{ 0x72, 0xd5, 0xde, 0xa2, 0xdf, 0x15, 0xf8, 0x67, 0x7b, 0x84, 0x15, 0xa, 0xb7, 0x23, 0x15, 0x57, 0x81, 0xab, 0xd6, 0x90, 0x4d, 0x5a, 0x87, 0xf6, 0x4e, 0x9f, 0x4f, 0xc5, 0xc3, 0xd1, 0x2b, 0x40 },
|
||||
{ 0xea, 0x98, 0x3a, 0xe0, 0x5c, 0x45, 0xfa, 0x9c, 0x3, 0xc5, 0xd2, 0x99, 0x66, 0xb2, 0x99, 0x9a, 0x66, 0x2, 0x96, 0xb4, 0xf2, 0xbb, 0x53, 0x8a, 0xb5, 0x56, 0x14, 0x1a, 0x88, 0xdb, 0xa2, 0x31 },
|
||||
{ 0x3, 0xa3, 0x5a, 0x5c, 0x9a, 0x19, 0xe, 0xdb, 0x40, 0x3f, 0xb2, 0xa, 0x87, 0xc1, 0x44, 0x10, 0x1c, 0x5, 0x19, 0x80, 0x84, 0x9e, 0x95, 0x1d, 0x6f, 0x33, 0xeb, 0xad, 0x5e, 0xe7, 0xcd, 0xdc },
|
||||
{ 0x10, 0xba, 0x13, 0x92, 0x2, 0xbf, 0x6b, 0x41, 0xdc, 0x78, 0x65, 0x15, 0xf7, 0xbb, 0x27, 0xd0, 0xa, 0x2c, 0x81, 0x39, 0x37, 0xaa, 0x78, 0x50, 0x3f, 0x1a, 0xbf, 0xd2, 0x41, 0x0, 0x91, 0xd3 },
|
||||
{ 0x42, 0x2d, 0x5a, 0xd, 0xf6, 0xcc, 0x7e, 0x90, 0xdd, 0x62, 0x9f, 0x9c, 0x92, 0xc0, 0x97, 0xce, 0x18, 0x5c, 0xa7, 0xb, 0xc7, 0x2b, 0x44, 0xac, 0xd1, 0xdf, 0x65, 0xd6, 0x63, 0xc6, 0xfc, 0x23 },
|
||||
{ 0x97, 0x6e, 0x6c, 0x3, 0x9e, 0xe0, 0xb8, 0x1a, 0x21, 0x5, 0x45, 0x7e, 0x44, 0x6c, 0xec, 0xa8, 0xee, 0xf1, 0x3, 0xbb, 0x5d, 0x8e, 0x61, 0xfa, 0xfd, 0x96, 0x97, 0xb2, 0x94, 0x83, 0x81, 0x97 },
|
||||
{ 0x4a, 0x8e, 0x85, 0x37, 0xdb, 0x3, 0x30, 0x2f, 0x2a, 0x67, 0x8d, 0x2d, 0xfb, 0x9f, 0x6a, 0x95, 0x8a, 0xfe, 0x73, 0x81, 0xf8, 0xb8, 0x69, 0x6c, 0x8a, 0xc7, 0x72, 0x46, 0xc0, 0x7f, 0x42, 0x14 },
|
||||
{ 0xc5, 0xf4, 0x15, 0x8f, 0xbd, 0xc7, 0x5e, 0xc4, 0x75, 0x44, 0x6f, 0xa7, 0x8f, 0x11, 0xbb, 0x80, 0x52, 0xde, 0x75, 0xb7, 0xae, 0xe4, 0x88, 0xbc, 0x82, 0xb8, 0x0, 0x1e, 0x98, 0xa6, 0xa3, 0xf4 },
|
||||
{ 0x8e, 0xf4, 0x8f, 0x33, 0xa9, 0xa3, 0x63, 0x15, 0xaa, 0x5f, 0x56, 0x24, 0xd5, 0xb7, 0xf9, 0x89, 0xb6, 0xf1, 0xed, 0x20, 0x7c, 0x5a, 0xe0, 0xfd, 0x36, 0xca, 0xe9, 0x5a, 0x6, 0x42, 0x2c, 0x36 },
|
||||
{ 0xce, 0x29, 0x35, 0x43, 0x4e, 0xfe, 0x98, 0x3d, 0x53, 0x3a, 0xf9, 0x74, 0x73, 0x9a, 0x4b, 0xa7, 0xd0, 0xf5, 0x1f, 0x59, 0x6f, 0x4e, 0x81, 0x86, 0xe, 0x9d, 0xad, 0x81, 0xaf, 0xd8, 0x5a, 0x9f },
|
||||
{ 0xa7, 0x5, 0x6, 0x67, 0xee, 0x34, 0x62, 0x6a, 0x8b, 0xb, 0x28, 0xbe, 0x6e, 0xb9, 0x17, 0x27, 0x47, 0x74, 0x7, 0x26, 0xc6, 0x80, 0x10, 0x3f, 0xe0, 0xa0, 0x7e, 0x6f, 0xc6, 0x7e, 0x48, 0x7b },
|
||||
{ 0xd, 0x55, 0xa, 0xa5, 0x4a, 0xf8, 0xa4, 0xc0, 0x91, 0xe3, 0xe7, 0x9f, 0x97, 0x8e, 0xf1, 0x9e, 0x86, 0x76, 0x72, 0x81, 0x50, 0x60, 0x8d, 0xd4, 0x7e, 0x9e, 0x5a, 0x41, 0xf3, 0xe5, 0xb0, 0x62 },
|
||||
{ 0xfc, 0x9f, 0x1f, 0xec, 0x40, 0x54, 0x20, 0x7a, 0xe3, 0xe4, 0x1a, 0x0, 0xce, 0xf4, 0xc9, 0x84, 0x4f, 0xd7, 0x94, 0xf5, 0x9d, 0xfa, 0x95, 0xd8, 0x55, 0x2e, 0x7e, 0x11, 0x24, 0xc3, 0x54, 0xa5 },
|
||||
{ 0x5b, 0xdf, 0x72, 0x28, 0xbd, 0xfe, 0x6e, 0x28, 0x78, 0xf5, 0x7f, 0xe2, 0xf, 0xa5, 0xc4, 0xb2, 0x5, 0x89, 0x7c, 0xef, 0xee, 0x49, 0xd3, 0x2e, 0x44, 0x7e, 0x93, 0x85, 0xeb, 0x28, 0x59, 0x7f },
|
||||
{ 0x70, 0x5f, 0x69, 0x37, 0xb3, 0x24, 0x31, 0x4a, 0x5e, 0x86, 0x28, 0xf1, 0x1d, 0xd6, 0xe4, 0x65, 0xc7, 0x1b, 0x77, 0x4, 0x51, 0xb9, 0x20, 0xe7, 0x74, 0xfe, 0x43, 0xe8, 0x23, 0xd4, 0x87, 0x8a },
|
||||
{ 0x7d, 0x29, 0xe8, 0xa3, 0x92, 0x76, 0x94, 0xf2, 0xdd, 0xcb, 0x7a, 0x9, 0x9b, 0x30, 0xd9, 0xc1, 0x1d, 0x1b, 0x30, 0xfb, 0x5b, 0xdc, 0x1b, 0xe0, 0xda, 0x24, 0x49, 0x4f, 0xf2, 0x9c, 0x82, 0xbf },
|
||||
{ 0xa4, 0xe7, 0xba, 0x31, 0xb4, 0x70, 0xbf, 0xff, 0xd, 0x32, 0x44, 0x5, 0xde, 0xf8, 0xbc, 0x48, 0x3b, 0xae, 0xfc, 0x32, 0x53, 0xbb, 0xd3, 0x39, 0x45, 0x9f, 0xc3, 0xc1, 0xe0, 0x29, 0x8b, 0xa0 },
|
||||
{ 0xe5, 0xc9, 0x5, 0xfd, 0xf7, 0xae, 0x9, 0xf, 0x94, 0x70, 0x34, 0x12, 0x42, 0x90, 0xf1, 0x34, 0xa2, 0x71, 0xb7, 0x1, 0xe3, 0x44, 0xed, 0x95, 0xe9, 0x3b, 0x8e, 0x36, 0x4f, 0x2f, 0x98, 0x4a },
|
||||
{ 0x88, 0x40, 0x1d, 0x63, 0xa0, 0x6c, 0xf6, 0x15, 0x47, 0xc1, 0x44, 0x4b, 0x87, 0x52, 0xaf, 0xff, 0x7e, 0xbb, 0x4a, 0xf1, 0xe2, 0xa, 0xc6, 0x30, 0x46, 0x70, 0xb6, 0xc5, 0xcc, 0x6e, 0x8c, 0xe6 },
|
||||
{ 0xa4, 0xd5, 0xa4, 0x56, 0xbd, 0x4f, 0xca, 0x0, 0xda, 0x9d, 0x84, 0x4b, 0xc8, 0x3e, 0x18, 0xae, 0x73, 0x57, 0xce, 0x45, 0x30, 0x64, 0xd1, 0xad, 0xe8, 0xa6, 0xce, 0x68, 0x14, 0x5c, 0x25, 0x67 },
|
||||
{ 0xa3, 0xda, 0x8c, 0xf2, 0xcb, 0xe, 0xe1, 0x16, 0x33, 0xe9, 0x6, 0x58, 0x9a, 0x94, 0x99, 0x9a, 0x1f, 0x60, 0xb2, 0x20, 0xc2, 0x6f, 0x84, 0x7b, 0xd1, 0xce, 0xac, 0x7f, 0xa0, 0xd1, 0x85, 0x18 },
|
||||
{ 0x32, 0x59, 0x5b, 0xa1, 0x8d, 0xdd, 0x19, 0xd3, 0x50, 0x9a, 0x1c, 0xc0, 0xaa, 0xa5, 0xb4, 0x46, 0x9f, 0x3d, 0x63, 0x67, 0xe4, 0x4, 0x6b, 0xba, 0xf6, 0xca, 0x19, 0xab, 0xb, 0x56, 0xee, 0x7e },
|
||||
{ 0x1f, 0xb1, 0x79, 0xea, 0xa9, 0x28, 0x21, 0x74, 0xe9, 0xbd, 0xf7, 0x35, 0x3b, 0x36, 0x51, 0xee, 0x1d, 0x57, 0xac, 0x5a, 0x75, 0x50, 0xd3, 0x76, 0x3a, 0x46, 0xc2, 0xfe, 0xa3, 0x7d, 0x70, 0x1 },
|
||||
{ 0xf7, 0x35, 0xc1, 0xaf, 0x98, 0xa4, 0xd8, 0x42, 0x78, 0xed, 0xec, 0x20, 0x9e, 0x6b, 0x67, 0x79, 0x41, 0x83, 0x63, 0x15, 0xea, 0x3a, 0xdb, 0xa8, 0xfa, 0xc3, 0x3b, 0x4d, 0x32, 0x83, 0x2c, 0x83 },
|
||||
{ 0xa7, 0x40, 0x3b, 0x1f, 0x1c, 0x27, 0x47, 0xf3, 0x59, 0x40, 0xf0, 0x34, 0xb7, 0x2d, 0x76, 0x9a, 0xe7, 0x3e, 0x4e, 0x6c, 0xd2, 0x21, 0x4f, 0xfd, 0xb8, 0xfd, 0x8d, 0x39, 0xdc, 0x57, 0x59, 0xef },
|
||||
{ 0x8d, 0x9b, 0xc, 0x49, 0x2b, 0x49, 0xeb, 0xda, 0x5b, 0xa2, 0xd7, 0x49, 0x68, 0xf3, 0x70, 0xd, 0x7d, 0x3b, 0xae, 0xd0, 0x7a, 0x8d, 0x55, 0x84, 0xf5, 0xa5, 0xe9, 0xf0, 0xe4, 0xf8, 0x8e, 0x65 },
|
||||
{ 0xa0, 0xb8, 0xa2, 0xf4, 0x36, 0x10, 0x3b, 0x53, 0xc, 0xa8, 0x7, 0x9e, 0x75, 0x3e, 0xec, 0x5a, 0x91, 0x68, 0x94, 0x92, 0x56, 0xe8, 0x88, 0x4f, 0x5b, 0xb0, 0x5c, 0x55, 0xf8, 0xba, 0xbc, 0x4c },
|
||||
{ 0xe3, 0xbb, 0x3b, 0x99, 0xf3, 0x87, 0x94, 0x7b, 0x75, 0xda, 0xf4, 0xd6, 0x72, 0x6b, 0x1c, 0x5d, 0x64, 0xae, 0xac, 0x28, 0xdc, 0x34, 0xb3, 0x6d, 0x6c, 0x34, 0xa5, 0x50, 0xb8, 0x28, 0xdb, 0x71 },
|
||||
{ 0xf8, 0x61, 0xe2, 0xf2, 0x10, 0x8d, 0x51, 0x2a, 0xe3, 0xdb, 0x64, 0x33, 0x59, 0xdd, 0x75, 0xfc, 0x1c, 0xac, 0xbc, 0xf1, 0x43, 0xce, 0x3f, 0xa2, 0x67, 0xbb, 0xd1, 0x3c, 0x2, 0xe8, 0x43, 0xb0 },
|
||||
{ 0x33, 0xa, 0x5b, 0xca, 0x88, 0x29, 0xa1, 0x75, 0x7f, 0x34, 0x19, 0x4d, 0xb4, 0x16, 0x53, 0x5c, 0x92, 0x3b, 0x94, 0xc3, 0xe, 0x79, 0x4d, 0x1e, 0x79, 0x74, 0x75, 0xd7, 0xb6, 0xee, 0xaf, 0x3f },
|
||||
{ 0xea, 0xa8, 0xd4, 0xf7, 0xbe, 0x1a, 0x39, 0x21, 0x5c, 0xf4, 0x7e, 0x9, 0x4c, 0x23, 0x27, 0x51, 0x26, 0xa3, 0x24, 0x53, 0xba, 0x32, 0x3c, 0xd2, 0x44, 0xa3, 0x17, 0x4a, 0x6d, 0xa6, 0xd5, 0xad },
|
||||
{ 0xb5, 0x1d, 0x3e, 0xa6, 0xaf, 0xf2, 0xc9, 0x8, 0x83, 0x59, 0x3d, 0x98, 0x91, 0x6b, 0x3c, 0x56, 0x4c, 0xf8, 0x7c, 0xa1, 0x72, 0x86, 0x60, 0x4d, 0x46, 0xe2, 0x3e, 0xcc, 0x8, 0x6e, 0xc7, 0xf6 },
|
||||
{ 0x2f, 0x98, 0x33, 0xb3, 0xb1, 0xbc, 0x76, 0x5e, 0x2b, 0xd6, 0x66, 0xa5, 0xef, 0xc4, 0xe6, 0x2a, 0x6, 0xf4, 0xb6, 0xe8, 0xbe, 0xc1, 0xd4, 0x36, 0x74, 0xee, 0x82, 0x15, 0xbc, 0xef, 0x21, 0x63 },
|
||||
{ 0xfd, 0xc1, 0x4e, 0xd, 0xf4, 0x53, 0xc9, 0x69, 0xa7, 0x7d, 0x5a, 0xc4, 0x6, 0x58, 0x58, 0x26, 0x7e, 0xc1, 0x14, 0x16, 0x6, 0xe0, 0xfa, 0x16, 0x7e, 0x90, 0xaf, 0x3d, 0x28, 0x63, 0x9d, 0x3f },
|
||||
{ 0xd2, 0xc9, 0xf2, 0xe3, 0x0, 0x9b, 0xd2, 0xc, 0x5f, 0xaa, 0xce, 0x30, 0xb7, 0xd4, 0xc, 0x30, 0x74, 0x2a, 0x51, 0x16, 0xf2, 0xe0, 0x32, 0x98, 0xd, 0xeb, 0x30, 0xd8, 0xe3, 0xce, 0xf8, 0x9a },
|
||||
{ 0x4b, 0xc5, 0x9e, 0x7b, 0xb5, 0xf1, 0x79, 0x92, 0xff, 0x51, 0xe6, 0x6e, 0x4, 0x86, 0x68, 0xd3, 0x9b, 0x23, 0x4d, 0x57, 0xe6, 0x96, 0x67, 0x31, 0xcc, 0xe6, 0xa6, 0xf3, 0x17, 0xa, 0x75, 0x5 },
|
||||
{ 0xb1, 0x76, 0x81, 0xd9, 0x13, 0x32, 0x6c, 0xce, 0x3c, 0x17, 0x52, 0x84, 0xf8, 0x5, 0xa2, 0x62, 0xf4, 0x2b, 0xcb, 0xb3, 0x78, 0x47, 0x15, 0x47, 0xff, 0x46, 0x54, 0x82, 0x23, 0x93, 0x6a, 0x48 },
|
||||
{ 0x38, 0xdf, 0x58, 0x7, 0x4e, 0x5e, 0x65, 0x65, 0xf2, 0xfc, 0x7c, 0x89, 0xfc, 0x86, 0x50, 0x8e, 0x31, 0x70, 0x2e, 0x44, 0xd0, 0xb, 0xca, 0x86, 0xf0, 0x40, 0x9, 0xa2, 0x30, 0x78, 0x47, 0x4e },
|
||||
{ 0x65, 0xa0, 0xee, 0x39, 0xd1, 0xf7, 0x38, 0x83, 0xf7, 0x5e, 0xe9, 0x37, 0xe4, 0x2c, 0x3a, 0xbd, 0x21, 0x97, 0xb2, 0x26, 0x1, 0x13, 0xf8, 0x6f, 0xa3, 0x44, 0xed, 0xd1, 0xef, 0x9f, 0xde, 0xe7 },
|
||||
{ 0x8b, 0xa0, 0xdf, 0x15, 0x76, 0x25, 0x92, 0xd9, 0x3c, 0x85, 0xf7, 0xf6, 0x12, 0xdc, 0x42, 0xbe, 0xd8, 0xa7, 0xec, 0x7c, 0xab, 0x27, 0xb0, 0x7e, 0x53, 0x8d, 0x7d, 0xda, 0xaa, 0x3e, 0xa8, 0xde },
|
||||
{ 0xaa, 0x25, 0xce, 0x93, 0xbd, 0x2, 0x69, 0xd8, 0x5a, 0xf6, 0x43, 0xfd, 0x1a, 0x73, 0x8, 0xf9, 0xc0, 0x5f, 0xef, 0xda, 0x17, 0x4a, 0x19, 0xa5, 0x97, 0x4d, 0x66, 0x33, 0x4c, 0xfd, 0x21, 0x6a },
|
||||
{ 0x35, 0xb4, 0x98, 0x31, 0xdb, 0x41, 0x15, 0x70, 0xea, 0x1e, 0xf, 0xbb, 0xed, 0xcd, 0x54, 0x9b, 0x9a, 0xd0, 0x63, 0xa1, 0x51, 0x97, 0x40, 0x72, 0xf6, 0x75, 0x9d, 0xbf, 0x91, 0x47, 0x6f, 0xe2 } };
|
||||
|
||||
/* 1344 bytes */
|
||||
__constant__ static __align__(16) uint32_t c_E8_bslice32[42][8] = {
|
||||
// Round 0 (Function0)
|
||||
{ 0xa2ded572, 0x90d6ab81, 0x67f815df, 0xf6875a4d, 0x0a15847b, 0xc54f9f4e, 0x571523b7, 0x402bd1c3 },
|
||||
{ 0xe03a98ea, 0xb4960266, 0x9cfa455c, 0x8a53bbf2, 0x99d2c503, 0x1a1456b5, 0x9a99b266, 0x31a2db88 }, // 1
|
||||
{ 0x5c5aa303, 0x8019051c, 0xdb0e199a, 0x1d959e84, 0x0ab23f40, 0xadeb336f, 0x1044c187, 0xdccde75e }, // 2
|
||||
{ 0x9213ba10, 0x39812c0a, 0x416bbf02, 0x5078aa37, 0x156578dc, 0xd2bf1a3f, 0xd027bbf7, 0xd3910041 }, // 3
|
||||
{ 0x0d5a2d42, 0x0ba75c18, 0x907eccf6, 0xac442bc7, 0x9c9f62dd, 0xd665dfd1, 0xce97c092, 0x23fcc663 }, // 4
|
||||
{ 0x036c6e97, 0xbb03f1ee, 0x1ab8e09e, 0xfa618e5d, 0x7e450521, 0xb29796fd, 0xa8ec6c44, 0x97818394 }, // 5
|
||||
{ 0x37858e4a, 0x8173fe8a, 0x2f3003db, 0x6c69b8f8, 0x2d8d672a, 0x4672c78a, 0x956a9ffb, 0x14427fc0 }, // 6
|
||||
// Round 7 (Function0)
|
||||
{ 0x8f15f4c5, 0xb775de52, 0xc45ec7bd, 0xbc88e4ae, 0xa76f4475, 0x1e00b882, 0x80bb118f, 0xf4a3a698 },
|
||||
{ 0x338ff48e, 0x20edf1b6, 0x1563a3a9, 0xfde05a7c, 0x24565faa, 0x5ae9ca36, 0x89f9b7d5, 0x362c4206 },
|
||||
{ 0x433529ce, 0x591ff5d0, 0x3d98fe4e, 0x86814e6f, 0x74f93a53, 0x81ad9d0e, 0xa74b9a73, 0x9f5ad8af },
|
||||
{ 0x670605a7, 0x26077447, 0x6a6234ee, 0x3f1080c6, 0xbe280b8b, 0x6f7ea0e0, 0x2717b96e, 0x7b487ec6 },
|
||||
{ 0xa50a550d, 0x81727686, 0xc0a4f84a, 0xd48d6050, 0x9fe7e391, 0x415a9e7e, 0x9ef18e97, 0x62b0e5f3 },
|
||||
{ 0xec1f9ffc, 0xf594d74f, 0x7a205440, 0xd895fa9d, 0x001ae4e3, 0x117e2e55, 0x84c9f4ce, 0xa554c324 },
|
||||
{ 0x2872df5b, 0xef7c8905, 0x286efebd, 0x2ed349ee, 0xe27ff578, 0x85937e44, 0xb2c4a50f, 0x7f5928eb },
|
||||
// Round 14 (Function0)
|
||||
{ 0x37695f70, 0x04771bc7, 0x4a3124b3, 0xe720b951, 0xf128865e, 0xe843fe74, 0x65e4d61d, 0x8a87d423 },
|
||||
{ 0xa3e8297d, 0xfb301b1d, 0xf2947692, 0xe01bdc5b, 0x097acbdd, 0x4f4924da, 0xc1d9309b, 0xbf829cf2 },
|
||||
{ 0x31bae7a4, 0x32fcae3b, 0xffbf70b4, 0x39d3bb53, 0x0544320d, 0xc1c39f45, 0x48bcf8de, 0xa08b29e0 },
|
||||
{ 0xfd05c9e5, 0x01b771a2, 0x0f09aef7, 0x95ed44e3, 0x12347094, 0x368e3be9, 0x34f19042, 0x4a982f4f },
|
||||
{ 0x631d4088, 0xf14abb7e, 0x15f66ca0, 0x30c60ae2, 0x4b44c147, 0xc5b67046, 0xffaf5287, 0xe68c6ecc },
|
||||
{ 0x56a4d5a4, 0x45ce5773, 0x00ca4fbd, 0xadd16430, 0x4b849dda, 0x68cea6e8, 0xae183ec8, 0x67255c14 },
|
||||
{ 0xf28cdaa3, 0x20b2601f, 0x16e10ecb, 0x7b846fc2, 0x5806e933, 0x7facced1, 0x9a99949a, 0x1885d1a0 },
|
||||
// Round 21 (Function0)
|
||||
{ 0xa15b5932, 0x67633d9f, 0xd319dd8d, 0xba6b04e4, 0xc01c9a50, 0xab19caf6, 0x46b4a5aa, 0x7eee560b },
|
||||
{ 0xea79b11f, 0x5aac571d, 0x742128a9, 0x76d35075, 0x35f7bde9, 0xfec2463a, 0xee51363b, 0x01707da3 },
|
||||
{ 0xafc135f7, 0x15638341, 0x42d8a498, 0xa8db3aea, 0x20eced78, 0x4d3bc3fa, 0x79676b9e, 0x832c8332 },
|
||||
{ 0x1f3b40a7, 0x6c4e3ee7, 0xf347271c, 0xfd4f21d2, 0x34f04059, 0x398dfdb8, 0x9a762db7, 0xef5957dc },
|
||||
{ 0x490c9b8d, 0xd0ae3b7d, 0xdaeb492b, 0x84558d7a, 0x49d7a25b, 0xf0e9a5f5, 0x0d70f368, 0x658ef8e4 },
|
||||
{ 0xf4a2b8a0, 0x92946891, 0x533b1036, 0x4f88e856, 0x9e07a80c, 0x555cb05b, 0x5aec3e75, 0x4cbcbaf8 },
|
||||
{ 0x993bbbe3, 0x28acae64, 0x7b9487f3, 0x6db334dc, 0xd6f4da75, 0x50a5346c, 0x5d1c6b72, 0x71db28b8 },
|
||||
// Round 28 (Function0)
|
||||
{ 0xf2e261f8, 0xf1bcac1c, 0x2a518d10, 0xa23fce43, 0x3364dbe3, 0x3cd1bb67, 0xfc75dd59, 0xb043e802 },
|
||||
{ 0xca5b0a33, 0xc3943b92, 0x75a12988, 0x1e4d790e, 0x4d19347f, 0xd7757479, 0x5c5316b4, 0x3fafeeb6 },
|
||||
{ 0xf7d4a8ea, 0x5324a326, 0x21391abe, 0xd23c32ba, 0x097ef45c, 0x4a17a344, 0x5127234c, 0xadd5a66d },
|
||||
{ 0xa63e1db5, 0xa17cf84c, 0x08c9f2af, 0x4d608672, 0x983d5983, 0xcc3ee246, 0x563c6b91, 0xf6c76e08 },
|
||||
{ 0xb333982f, 0xe8b6f406, 0x5e76bcb1, 0x36d4c1be, 0xa566d62b, 0x1582ee74, 0x2ae6c4ef, 0x6321efbc },
|
||||
{ 0x0d4ec1fd, 0x1614c17e, 0x69c953f4, 0x16fae006, 0xc45a7da7, 0x3daf907e, 0x26585806, 0x3f9d6328 },
|
||||
{ 0xe3f2c9d2, 0x16512a74, 0x0cd29b00, 0x9832e0f2, 0x30ceaa5f, 0xd830eb0d, 0x300cd4b7, 0x9af8cee3 },
|
||||
// Round 35 (Function0)
|
||||
{ 0x7b9ec54b, 0x574d239b, 0x9279f1b5, 0x316796e6, 0x6ee651ff, 0xf3a6e6cc, 0xd3688604, 0x05750a17 },
|
||||
{ 0xd98176b1, 0xb3cb2bf4, 0xce6c3213, 0x47154778, 0x8452173c, 0x825446ff, 0x62a205f8, 0x486a9323 },
|
||||
{ 0x0758df38, 0x442e7031, 0x65655e4e, 0x86ca0bd0, 0x897cfcf2, 0xa20940f0, 0x8e5086fc, 0x4e477830 },
|
||||
{ 0x39eea065, 0x26b29721, 0x8338f7d1, 0x6ff81301, 0x37e95ef7, 0xd1ed44a3, 0xbd3a2ce4, 0xe7de9fef },
|
||||
{ 0x15dfa08b, 0x7ceca7d8, 0xd9922576, 0x7eb027ab, 0xf6f7853c, 0xda7d8d53, 0xbe42dc12, 0xdea83eaa },
|
||||
{ 0x93ce25aa, 0xdaef5fc0, 0xd86902bd, 0xa5194a17, 0xfd43f65a, 0x33664d97, 0xf908731a, 0x6a21fd4c },
|
||||
{ 0x3198b435, 0xa163d09a, 0x701541db, 0x72409751, 0xbb0f1eea, 0xbf9d75f6, 0x9b54cded, 0xe26f4791 }
|
||||
// 42 rounds...
|
||||
};
|
||||
#define SWAP4(x,y)\
|
||||
y = (x & 0xf0f0f0f0UL); \
|
||||
x = (x ^ y); \
|
||||
y = (y >> 4); \
|
||||
x = (x << 4); \
|
||||
x= x | y;
|
||||
|
||||
#define SWAP2(x,y)\
|
||||
y = (x & 0xccccccccUL); \
|
||||
x = (x ^ y); \
|
||||
y = (y >> 2); \
|
||||
x = (x << 2); \
|
||||
x= x | y;
|
||||
|
||||
#define SWAP1(x,y)\
|
||||
y = (x & 0xaaaaaaaaUL); \
|
||||
x = (x ^ y); \
|
||||
y = (y >> 1); \
|
||||
x = x + x; \
|
||||
x= x | y;
|
||||
/*swapping bits 16i||16i+1||......||16i+7 with bits 16i+8||16i+9||......||16i+15 of 32-bit x*/
|
||||
//#define SWAP8(x) (x) = ((((x) & 0x00ff00ffUL) << 8) | (((x) & 0xff00ff00UL) >> 8));
|
||||
#define SWAP8(x) (x) = __byte_perm(x, x, 0x2301);
|
||||
/*swapping bits 32i||32i+1||......||32i+15 with bits 32i+16||32i+17||......||32i+31 of 32-bit x*/
|
||||
//#define SWAP16(x) (x) = ((((x) & 0x0000ffffUL) << 16) | (((x) & 0xffff0000UL) >> 16));
|
||||
#define SWAP16(x) (x) = __byte_perm(x, x, 0x1032);
|
||||
|
||||
/*swapping bits 16i||16i+1||......||16i+7 with bits 16i+8||16i+9||......||16i+15 of 32-bit x*/
|
||||
//#define SWAP8(x) (x) = ((((x) & 0x00ff00ffUL) << 8) | (((x) & 0xff00ff00UL) >> 8));
|
||||
#define SWAP8(x) (x) = __byte_perm(x, x, 0x2301);
|
||||
|
||||
/*
|
||||
__device__ __forceinline__
|
||||
static void SWAP4(uint32_t &x) {
|
||||
uint32_t y = x & 0xF0F0F0F0;
|
||||
x = (x ^ y) << 4;
|
||||
x |= y >> 4;
|
||||
}
|
||||
__device__ __forceinline__
|
||||
static void SWAP2(uint32_t &x) {
|
||||
uint32_t y = (x & 0xCCCCCCCC);
|
||||
x = (x ^ y) << 2;
|
||||
x |= y >> 2;
|
||||
}
|
||||
__device__ __forceinline__
|
||||
static void SWAP1(uint32_t &x) {
|
||||
uint32_t y = (x & 0xAAAAAAAA);
|
||||
x = (x ^ y) << 1;
|
||||
x |= y >> 1;
|
||||
}
|
||||
*/
|
||||
|
||||
__device__ __forceinline__
|
||||
static void SWAP4x4(uint32_t *x) {
|
||||
#pragma nounroll
|
||||
// y is used as tmp register too
|
||||
for (uint32_t y=0; y<4; y++, ++x) {
|
||||
asm("and.b32 %1, %0, 0xF0F0F0F0;"
|
||||
"xor.b32 %0, %0, %1;"
|
||||
"shr.b32 %1, %1, 4;"
|
||||
"vshl.u32.u32.u32.clamp.add %0, %0, 4, %1;\n\t"
|
||||
: "+r"(*x) : "r"(y));
|
||||
}
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
static void SWAP2x4(uint32_t *x) {
|
||||
#pragma nounroll
|
||||
// y is used as tmp register too
|
||||
for (uint32_t y=0; y<4; y++, ++x) {
|
||||
asm("and.b32 %1, %0, 0xCCCCCCCC;"
|
||||
"xor.b32 %0, %0, %1;"
|
||||
"shr.b32 %1, %1, 2;"
|
||||
"vshl.u32.u32.u32.clamp.add %0, %0, 2, %1;\n\t"
|
||||
: "+r"(*x) : "r"(y));
|
||||
}
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
static void SWAP1x4(uint32_t *x) {
|
||||
#pragma nounroll
|
||||
// y is used as tmp register too
|
||||
for (uint32_t y=0; y<4; y++, ++x) {
|
||||
asm("and.b32 %1, %0, 0xAAAAAAAA;"
|
||||
"xor.b32 %0, %0, %1;"
|
||||
"shr.b32 %1, %1, 1;"
|
||||
"vshl.u32.u32.u32.clamp.add %0, %0, 1, %1;\n\t"
|
||||
: "+r"(*x) : "r"(y));
|
||||
}
|
||||
}
|
||||
|
||||
/* The MDS transform */
|
||||
/*The MDS transform*/
|
||||
#define L(m0,m1,m2,m3,m4,m5,m6,m7) \
|
||||
m4 ^= m1; \
|
||||
m5 ^= m2; \
|
||||
m6 ^= m0 ^ m3; \
|
||||
m7 ^= m0; \
|
||||
m0 ^= m5; \
|
||||
m1 ^= m6; \
|
||||
m2 ^= m4 ^ m7; \
|
||||
m3 ^= m4;
|
||||
(m4) ^= (m1); \
|
||||
(m5) ^= (m2); \
|
||||
(m6) ^= (m0) ^ (m3); \
|
||||
(m7) ^= (m0); \
|
||||
(m0) ^= (m5); \
|
||||
(m1) ^= (m6); \
|
||||
(m2) ^= (m4) ^ (m7); \
|
||||
(m3) ^= (m4);
|
||||
|
||||
/* The Sbox */
|
||||
#define Sbox(m0, m1, m2, m3, cc) \
|
||||
/*The Sbox*/
|
||||
#define Sbox(m0,m1,m2,m3,cc) \
|
||||
m3 = ~(m3); \
|
||||
m0 ^= (~(m2)) & cc; \
|
||||
temp0 = cc ^ (m0 & m1); \
|
||||
m0 ^= m2 & m3; \
|
||||
m3 ^= (~(m1)) & m2; \
|
||||
m1 ^= m0 & m2; \
|
||||
m2 ^= m0 & (~(m3)); \
|
||||
m0 ^= m1 | m3; \
|
||||
m3 ^= m1 & m2; \
|
||||
m1 ^= temp0 & m0; \
|
||||
m0 ^= ((~(m2)) & (cc)); \
|
||||
temp0 = (cc) ^ ((m0) & (m1));\
|
||||
m0 ^= ((m2) & (m3)); \
|
||||
m3 ^= ((~(m1)) & (m2)); \
|
||||
m1 ^= ((m0) & (m2)); \
|
||||
m2 ^= ((m0) & (~(m3))); \
|
||||
m0 ^= ((m1) | (m3)); \
|
||||
m3 ^= ((m1) & (m2)); \
|
||||
m1 ^= (temp0 & (m0)); \
|
||||
m2 ^= temp0;
|
||||
|
||||
__device__ __forceinline__
|
||||
static void Sbox_and_MDS_layer(uint32_t x[8][4], const int rnd)
|
||||
static __device__ __forceinline__ void Sbox_and_MDS_layer(uint32_t x[8][4], uint32_t roundnumber)
|
||||
{
|
||||
uint2* cc = (uint2*) &c_E8_bslice32[rnd];
|
||||
|
||||
// Sbox and MDS layer
|
||||
#pragma unroll
|
||||
for (int i = 0; i < 4; i++, ++cc) {
|
||||
uint32_t temp0;
|
||||
Sbox(x[0][i], x[2][i], x[4][i], x[6][i], cc->x);
|
||||
Sbox(x[1][i], x[3][i], x[5][i], x[7][i], cc->y);
|
||||
uint32_t temp0;
|
||||
uint32_t cc0, cc1;
|
||||
//Sbox and MDS layer
|
||||
#pragma unroll 4
|
||||
for (int i = 0; i < 4; i++) {
|
||||
cc0 = ((uint32_t*)c_E8_bitslice_roundconstant[roundnumber])[i];
|
||||
cc1 = ((uint32_t*)c_E8_bitslice_roundconstant[roundnumber])[i + 4];
|
||||
Sbox(x[0][i], x[2][i], x[4][i], x[6][i], cc0);
|
||||
Sbox(x[1][i], x[3][i], x[5][i], x[7][i], cc1);
|
||||
L(x[0][i], x[2][i], x[4][i], x[6][i], x[1][i], x[3][i], x[5][i], x[7][i]);
|
||||
}
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
static void RoundFunction0(uint32_t x[8][4], const int rnd)
|
||||
static __device__ __forceinline__ void RoundFunction0(uint32_t x[8][4], uint32_t roundnumber)
|
||||
{
|
||||
Sbox_and_MDS_layer(x, rnd + 0); // 0, 7, 14 .. 35
|
||||
#pragma unroll 4
|
||||
for (int j = 1; j < 8; j += 2) { // 1, 3, 5, 7 (Even)
|
||||
SWAP1x4(x[j]);
|
||||
// SWAP1(x[j][0]); SWAP1(x[j][1]); SWAP1(x[j][2]); SWAP1(x[j][3]);
|
||||
}
|
||||
}
|
||||
Sbox_and_MDS_layer(x, roundnumber);
|
||||
|
||||
__device__ __forceinline__
|
||||
static void RoundFunction1(uint32_t x[8][4], const int rnd)
|
||||
{
|
||||
Sbox_and_MDS_layer(x, rnd + 1);
|
||||
|
||||
#pragma unroll 4
|
||||
for (int j = 1; j < 8; j += 2) {
|
||||
SWAP2x4(x[j]);
|
||||
// SWAP2(x[j][0]); SWAP2(x[j][1]); SWAP2(x[j][2]); SWAP2(x[j][3]);
|
||||
}
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
static void RoundFunction2(uint32_t x[8][4], const int rnd)
|
||||
{
|
||||
Sbox_and_MDS_layer(x, rnd + 2);
|
||||
|
||||
#pragma unroll 4
|
||||
for (int j = 1; j < 8; j += 2) {
|
||||
SWAP4x4(x[j]);
|
||||
// SWAP4(x[j][0]); SWAP4(x[j][1]); SWAP4(x[j][2]); SWAP4(x[j][3]);
|
||||
}
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
static void RoundFunction3(uint32_t x[8][4], const int rnd)
|
||||
{
|
||||
Sbox_and_MDS_layer(x, rnd + 3);
|
||||
|
||||
//uint32_t* xj = x[j];
|
||||
#pragma unroll 4
|
||||
for (int j = 1; j < 8; j += 2) {
|
||||
SWAP8(x[j][0]);
|
||||
SWAP8(x[j][1]);
|
||||
SWAP8(x[j][2]);
|
||||
SWAP8(x[j][3]);
|
||||
}
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
static void RoundFunction4(uint32_t x[8][4], const int rnd)
|
||||
{
|
||||
Sbox_and_MDS_layer(x, rnd + 4);
|
||||
|
||||
#pragma unroll 4
|
||||
for (int j = 1; j < 8; j += 2)
|
||||
#pragma unroll 4
|
||||
for (int j = 1; j < 8; j = j + 2)
|
||||
{
|
||||
//uint32_t* xj = x[j];
|
||||
#pragma unroll
|
||||
for (int i = 0; i < 4; i++)
|
||||
SWAP16(x[j][i]);
|
||||
uint32_t y;
|
||||
SWAP1(x[j][0], y);
|
||||
SWAP1(x[j][1], y);
|
||||
SWAP1(x[j][2], y);
|
||||
SWAP1(x[j][3], y);
|
||||
}
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
static void RoundFunction5(uint32_t x[8][4], const int rnd)
|
||||
static __device__ __forceinline__ void RoundFunction1(uint32_t x[8][4], uint32_t roundnumber)
|
||||
{
|
||||
Sbox_and_MDS_layer(x, rnd + 5);
|
||||
Sbox_and_MDS_layer(x, roundnumber);
|
||||
|
||||
#pragma unroll 4
|
||||
for (int j = 1; j < 8; j += 2)
|
||||
#pragma unroll 4
|
||||
for (int j = 1; j < 8; j = j + 2)
|
||||
{
|
||||
xchg(x[j][0], x[j][1]);
|
||||
xchg(x[j][2], x[j][3]);
|
||||
uint32_t y;
|
||||
SWAP2(x[j][0], y);
|
||||
SWAP2(x[j][1], y);
|
||||
SWAP2(x[j][2], y);
|
||||
SWAP2(x[j][3], y);
|
||||
}
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
static void RoundFunction6(uint32_t x[8][4], const int rnd)
|
||||
static __device__ __forceinline__ void RoundFunction2(uint32_t x[8][4], uint32_t roundnumber)
|
||||
{
|
||||
Sbox_and_MDS_layer(x, rnd + 6);
|
||||
Sbox_and_MDS_layer(x, roundnumber);
|
||||
|
||||
#pragma unroll 4
|
||||
for (int j = 1; j < 8; j += 2)
|
||||
#pragma unroll 4
|
||||
for (int j = 1; j < 8; j = j + 2)
|
||||
{
|
||||
xchg(x[j][0], x[j][2]);
|
||||
xchg(x[j][1], x[j][3]);
|
||||
uint32_t y;
|
||||
SWAP4(x[j][0], y);
|
||||
SWAP4(x[j][1], y);
|
||||
SWAP4(x[j][2], y);
|
||||
SWAP4(x[j][3], y);
|
||||
}
|
||||
}
|
||||
|
||||
/* The bijective function E8, in bitslice form */
|
||||
__device__
|
||||
static void E8(uint32_t x[8][4])
|
||||
static __device__ __forceinline__ void RoundFunction3(uint32_t x[8][4], uint32_t roundnumber)
|
||||
{
|
||||
/* perform 6 loops of 7 rounds */
|
||||
for (int r = 0; r < 42; r += 7)
|
||||
Sbox_and_MDS_layer(x, roundnumber);
|
||||
|
||||
#pragma unroll 4
|
||||
for (int j = 1; j < 8; j = j + 2)
|
||||
{
|
||||
RoundFunction0(x, r);
|
||||
RoundFunction1(x, r);
|
||||
RoundFunction2(x, r);
|
||||
RoundFunction3(x, r);
|
||||
RoundFunction4(x, r);
|
||||
RoundFunction5(x, r);
|
||||
RoundFunction6(x, r);
|
||||
#pragma unroll 4
|
||||
for (int i = 0; i < 4; i++) SWAP8(x[j][i]);
|
||||
}
|
||||
}
|
||||
|
||||
static __device__ __forceinline__ void RoundFunction4(uint32_t x[8][4], uint32_t roundnumber)
|
||||
{
|
||||
Sbox_and_MDS_layer(x, roundnumber);
|
||||
|
||||
#pragma unroll 4
|
||||
for (int j = 1; j < 8; j = j + 2)
|
||||
{
|
||||
#pragma unroll 4
|
||||
for (int i = 0; i < 4; i++) SWAP16(x[j][i]);
|
||||
}
|
||||
}
|
||||
|
||||
static __device__ __forceinline__ void RoundFunction5(uint32_t x[8][4], uint32_t roundnumber)
|
||||
{
|
||||
uint32_t temp0;
|
||||
|
||||
Sbox_and_MDS_layer(x, roundnumber);
|
||||
|
||||
#pragma unroll 4
|
||||
for (int j = 1; j < 8; j = j + 2)
|
||||
{
|
||||
#pragma unroll 2
|
||||
for (int i = 0; i < 4; i = i + 2) {
|
||||
temp0 = x[j][i]; x[j][i] = x[j][i + 1]; x[j][i + 1] = temp0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static __device__ __forceinline__ void RoundFunction6(uint32_t x[8][4], uint32_t roundnumber)
|
||||
{
|
||||
uint32_t temp0;
|
||||
|
||||
Sbox_and_MDS_layer(x, roundnumber);
|
||||
|
||||
#pragma unroll 4
|
||||
for (int j = 1; j < 8; j = j + 2)
|
||||
{
|
||||
#pragma unroll 2
|
||||
for (int i = 0; i < 2; i++) {
|
||||
temp0 = x[j][i]; x[j][i] = x[j][i + 2]; x[j][i + 2] = temp0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*The bijective function E8, in bitslice form */
|
||||
static __device__ __forceinline__ void E8(uint32_t x[8][4])
|
||||
{
|
||||
/*perform 6 rounds*/
|
||||
//#pragma unroll 6
|
||||
for (int i = 0; i < 42; i += 7)
|
||||
{
|
||||
RoundFunction0(x, i);
|
||||
RoundFunction1(x, i + 1);
|
||||
RoundFunction2(x, i + 2);
|
||||
RoundFunction3(x, i + 3);
|
||||
RoundFunction4(x, i + 4);
|
||||
RoundFunction5(x, i + 5);
|
||||
RoundFunction6(x, i + 6);
|
||||
}
|
||||
}
|
||||
|
||||
// Die Hash-Funktion
|
||||
__global__ __launch_bounds__(256, 4)
|
||||
void quark_jh512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint32_t* g_hash, const uint32_t *const __restrict__ g_nonceVector)
|
||||
void quark_jh512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint32_t *const __restrict__ g_hash, const uint32_t *const __restrict__ g_nonceVector)
|
||||
{
|
||||
const uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
const uint32_t nounce = (g_nonceVector != NULL) ? g_nonceVector[thread] : (startNounce + thread);
|
||||
uint32_t hashPosition = nounce - startNounce;
|
||||
uint32_t *Hash = &g_hash[hashPosition * 16U];
|
||||
uint32_t x[8][4] = { /* init */
|
||||
const uint32_t hashPosition = nounce - startNounce;
|
||||
uint32_t *const Hash = &g_hash[hashPosition * 16U];
|
||||
uint32_t x[8][4] = {
|
||||
{ 0x964bd16f, 0x17aa003e, 0x052e6a63, 0x43d5157a },
|
||||
{ 0x8d5e228a, 0x0bef970c, 0x591234e9, 0x61c3b3f2 },
|
||||
{ 0xc1a01d89, 0x1e806f53, 0x6b05a92a, 0x806d2bea },
|
||||
@@ -292,22 +250,21 @@ void quark_jh512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint32_t* g
|
||||
{ 0xdffcc2e3, 0xfb1785e6, 0x78465a54, 0x4bdd8ccc }
|
||||
};
|
||||
|
||||
#pragma unroll
|
||||
#pragma unroll 16
|
||||
for (int i = 0; i < 16; i++)
|
||||
x[i/4][i & 3] ^= Hash[i];
|
||||
x[i >> 2][i & 3] ^= Hash[i];
|
||||
|
||||
E8(x);
|
||||
|
||||
#pragma unroll
|
||||
for (uint8_t i = 0; i < 16; i++)
|
||||
x[(i+16)/4][(i+16) & 3] ^= Hash[i];
|
||||
#pragma unroll 16
|
||||
for (int i = 0; i < 16; i++)
|
||||
x[(16 + i) >> 2][(16 + i) & 3] ^= Hash[i];
|
||||
|
||||
x[0][0] ^= 0x80U;
|
||||
x[3][3] ^= 0x00020000U;
|
||||
x[0 >> 2][0 & 3] ^= 0x80;
|
||||
x[15 >> 2][15 & 3] ^= 0x00020000;
|
||||
E8(x);
|
||||
|
||||
x[4][0] ^= 0x80U;
|
||||
x[7][3] ^= 0x00020000U;
|
||||
x[(16 + 0) >> 2][(16 + 0) & 3] ^= 0x80;
|
||||
x[(16 + 15) >> 2][(16 + 15) & 3] ^= 0x00020000;
|
||||
|
||||
Hash[0] = x[4][0];
|
||||
Hash[1] = x[4][1];
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
#include <stdio.h>
|
||||
#include <stdio.h>
|
||||
#include <memory.h>
|
||||
#include <sys/types.h> // off_t
|
||||
|
||||
#include "cuda_helper.h"
|
||||
|
||||
@@ -120,8 +119,12 @@ void quark_blake512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint32_t
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
|
||||
#if USE_SHUFFLE
|
||||
const uint32_t warpBlockID = (thread + 15)>>4; // aufrunden auf volle Warp-Blöcke
|
||||
const int warpID = threadIdx.x & 0x0F; // 16 warps
|
||||
const int warpBlockID = (thread + 15)>>4; // aufrunden auf volle Warp-Blöcke
|
||||
const int maxHashPosition = thread<<3;
|
||||
#endif
|
||||
|
||||
#if USE_SHUFFLE
|
||||
if (warpBlockID < ( (threads+15)>>4 ))
|
||||
#else
|
||||
if (thread < threads)
|
||||
@@ -129,7 +132,7 @@ void quark_blake512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint32_t
|
||||
{
|
||||
uint32_t nounce = (g_nonceVector != NULL) ? g_nonceVector[thread] : (startNounce + thread);
|
||||
|
||||
off_t hashPosition = nounce - startNounce;
|
||||
int hashPosition = nounce - startNounce;
|
||||
uint64_t *inpHash = &g_hash[hashPosition<<3]; // hashPosition * 8
|
||||
|
||||
// 128 Bytes
|
||||
|
||||
@@ -2,7 +2,6 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include <memory.h>
|
||||
#include <sys/types.h> // off_t
|
||||
|
||||
#include "cuda_helper.h"
|
||||
|
||||
@@ -29,19 +28,19 @@ void quark_groestl512_gpu_hash_64_quad(uint32_t threads, uint32_t startNounce, u
|
||||
uint32_t state[8];
|
||||
|
||||
uint32_t nounce = g_nonceVector ? g_nonceVector[thread] : (startNounce + thread);
|
||||
off_t hashPosition = nounce - startNounce;
|
||||
uint32_t *pHash = &g_hash[hashPosition << 4];
|
||||
int hashPosition = nounce - startNounce;
|
||||
uint32_t *inpHash = &g_hash[hashPosition << 4];
|
||||
|
||||
const uint32_t thr = threadIdx.x % THF;
|
||||
const uint16_t thr = threadIdx.x % THF;
|
||||
|
||||
#pragma unroll
|
||||
for(int k=0;k<4;k++) message[k] = pHash[thr + (k * THF)];
|
||||
for(int k=0;k<4;k++) message[k] = inpHash[(k * THF) + thr];
|
||||
|
||||
#pragma unroll
|
||||
for(int k=4;k<8;k++) message[k] = 0;
|
||||
|
||||
if (thr == 0) message[4] = 0x80U;
|
||||
if (thr == 3) message[7] = 0x01000000U;
|
||||
if (thr == 0) message[4] = 0x80;
|
||||
if (thr == 3) message[7] = 0x01000000;
|
||||
|
||||
uint32_t msgBitsliced[8];
|
||||
to_bitslice_quad(message, msgBitsliced);
|
||||
@@ -49,13 +48,15 @@ void quark_groestl512_gpu_hash_64_quad(uint32_t threads, uint32_t startNounce, u
|
||||
groestl512_progressMessage_quad(state, msgBitsliced);
|
||||
|
||||
// Nur der erste von jeweils 4 Threads bekommt das Ergebns-Hash
|
||||
uint32_t *outpHash = inpHash;
|
||||
uint32_t hash[16];
|
||||
from_bitslice_quad(state, hash);
|
||||
|
||||
|
||||
// uint4 = 4x4 uint32_t = 16 bytes
|
||||
if (thr == 0) {
|
||||
uint4 *phash = (uint4*) hash;
|
||||
uint4 *outpt = (uint4*) pHash;
|
||||
uint4 *outpt = (uint4*) outpHash; /* var kept for hash align */
|
||||
outpt[0] = phash[0];
|
||||
outpt[1] = phash[1];
|
||||
outpt[2] = phash[2];
|
||||
@@ -84,7 +85,7 @@ __global__ void __launch_bounds__(TPB, THF)
|
||||
|
||||
uint32_t nounce = g_nonceVector ? g_nonceVector[thread] : (startNounce + thread);
|
||||
|
||||
off_t hashPosition = nounce - startNounce;
|
||||
int hashPosition = nounce - startNounce;
|
||||
uint32_t * inpHash = &g_hash[hashPosition<<4];
|
||||
const uint16_t thr = threadIdx.x % THF;
|
||||
|
||||
|
||||
@@ -230,8 +230,8 @@ void quark_groestl512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint32
|
||||
|
||||
uint32_t nounce = (g_nonceVector != NULL) ? g_nonceVector[thread] : (startNounce + thread);
|
||||
|
||||
off_t hashPosition = nounce - startNounce;
|
||||
uint32_t *inpHash = &g_hash[hashPosition * 16];
|
||||
int hashPosition = nounce - startNounce;
|
||||
uint32_t *inpHash = &g_hash[16 * hashPosition];
|
||||
|
||||
#pragma unroll 16
|
||||
for(int k=0; k<16; k++)
|
||||
@@ -266,7 +266,7 @@ void quark_groestl512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint32
|
||||
for(int u=0;u<32;u++) state[u] ^= message[u];
|
||||
|
||||
// Erzeugten Hash rausschreiben
|
||||
uint32_t *outpHash = &g_hash[hashPosition * 16];
|
||||
uint32_t *outpHash = &g_hash[16 * hashPosition];
|
||||
|
||||
#pragma unroll 16
|
||||
for(int k=0;k<16;k++) outpHash[k] = state[k+16];
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
#include <stdio.h>
|
||||
#include <memory.h>
|
||||
#include <sys/types.h> // off_t
|
||||
|
||||
#include "cuda_helper.h"
|
||||
|
||||
@@ -102,8 +101,8 @@ void quark_keccak512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint64_
|
||||
{
|
||||
uint32_t nounce = (g_nonceVector != NULL) ? g_nonceVector[thread] : (startNounce + thread);
|
||||
|
||||
off_t hashPosition = nounce - startNounce;
|
||||
uint64_t *inpHash = &g_hash[hashPosition * 8];
|
||||
int hashPosition = nounce - startNounce;
|
||||
uint64_t *inpHash = &g_hash[8 * hashPosition];
|
||||
uint2 keccak_gpu_state[25];
|
||||
|
||||
for (int i = 0; i<8; i++) {
|
||||
@@ -201,8 +200,8 @@ void quark_keccak512_gpu_hash_64_v30(uint32_t threads, uint32_t startNounce, uin
|
||||
{
|
||||
uint32_t nounce = (g_nonceVector != NULL) ? g_nonceVector[thread] : (startNounce + thread);
|
||||
|
||||
off_t hashPosition = nounce - startNounce;
|
||||
uint32_t *inpHash = (uint32_t*)&g_hash[hashPosition * 8];
|
||||
int hashPosition = nounce - startNounce;
|
||||
uint32_t *inpHash = (uint32_t*)&g_hash[8 * hashPosition];
|
||||
|
||||
uint32_t message[18];
|
||||
#pragma unroll 16
|
||||
@@ -225,7 +224,7 @@ void quark_keccak512_gpu_hash_64_v30(uint32_t threads, uint32_t startNounce, uin
|
||||
U64TO32_LE((&hash[i/4]), keccak_gpu_state[i / 8]);
|
||||
}
|
||||
|
||||
uint32_t *outpHash = (uint32_t*)&g_hash[hashPosition * 8];
|
||||
uint32_t *outpHash = (uint32_t*)&g_hash[8 * hashPosition];
|
||||
#pragma unroll 16
|
||||
for(int i=0; i<16; i++)
|
||||
outpHash[i] = hash[i];
|
||||
|
||||
+6
-16
@@ -418,19 +418,13 @@ void quark_skein512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint64_t
|
||||
h7 = vectorize(0xAE18A40B660FCC33ull);
|
||||
|
||||
uint2 p[8];
|
||||
// 1st Round -> etype = 480, ptr = 64, bcount = 0, data = msg
|
||||
// 1. Runde -> etype = 480, ptr = 64, bcount = 0, data = msg
|
||||
#pragma unroll 8
|
||||
for (int i = 0; i < 8; i++)
|
||||
p[i] = vectorize(inpHash[i]);
|
||||
|
||||
t0 = vectorize(64); // ptr
|
||||
// t1 = vectorize(480ull << 55); // etype
|
||||
t1 = vectorize(0xf000000000000000ULL);
|
||||
|
||||
//#if CUDA_VERSION >= 7000
|
||||
// doesnt really affect x11 perfs.
|
||||
__threadfence();
|
||||
//#endif
|
||||
t1 = vectorize(480ull << 55); // etype
|
||||
TFBIG_KINIT_UI2(h0, h1, h2, h3, h4, h5, h6, h7, h8, t0, t1, t2);
|
||||
TFBIG_4e_UI2(0);
|
||||
TFBIG_4o_UI2(1);
|
||||
@@ -464,12 +458,10 @@ void quark_skein512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint64_t
|
||||
// 2. Runde -> etype = 510, ptr = 8, bcount = 0, data = 0
|
||||
#pragma unroll 8
|
||||
for(int i=0; i<8; i++)
|
||||
p[i] = vectorize(0);
|
||||
p[i] = vectorize(0ull);
|
||||
|
||||
t0 = vectorize(8); // ptr
|
||||
//t1 = vectorize(510ull << 55); // etype
|
||||
t1 = vectorize(0xff00000000000000ULL);
|
||||
|
||||
t1 = vectorize(510ull << 55); // etype
|
||||
TFBIG_KINIT_UI2(h0, h1, h2, h3, h4, h5, h6, h7, h8, t0, t1, t2);
|
||||
TFBIG_4e_UI2(0);
|
||||
TFBIG_4o_UI2(1);
|
||||
@@ -512,7 +504,7 @@ void quark_skein512_gpu_hash_64_sm3(uint32_t threads, uint32_t startNounce, uint
|
||||
|
||||
uint32_t nounce = (g_nonceVector != NULL) ? g_nonceVector[thread] : (startNounce + thread);
|
||||
|
||||
uint32_t hashPosition = nounce - startNounce;
|
||||
int hashPosition = nounce - startNounce;
|
||||
uint64_t *inpHash = &g_hash[hashPosition * 8];
|
||||
|
||||
// Init
|
||||
@@ -531,9 +523,7 @@ void quark_skein512_gpu_hash_64_sm3(uint32_t threads, uint32_t startNounce, uint
|
||||
p[i] = inpHash[i];
|
||||
|
||||
t0 = 64; // ptr
|
||||
// t1 = 480ull << 55; // etype
|
||||
t1 = 0xf000000000000000ULL;
|
||||
|
||||
t1 = 480ull << 55; // etype
|
||||
TFBIG_KINIT(h0, h1, h2, h3, h4, h5, h6, h7, h8, t0, t1, t2);
|
||||
TFBIG_4e(0);
|
||||
TFBIG_4o(1);
|
||||
|
||||
+16
-13
@@ -19,6 +19,8 @@ static uint32_t *d_hash[MAX_GPUS];
|
||||
extern void qubit_luffa512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void qubit_luffa512_cpu_setBlock_80(void *pdata);
|
||||
extern void qubit_luffa512_cpu_hash_80(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_hash, int order);
|
||||
extern void qubit_luffa512_cpufinal_setBlock_80(void *pdata, const void *ptarget);
|
||||
extern uint32_t qubit_luffa512_cpu_finalhash_80(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_hash, int order);
|
||||
|
||||
extern void x11_cubehash512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void x11_cubehash512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
@@ -28,13 +30,13 @@ extern void x11_echo512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t start
|
||||
|
||||
extern "C" void deephash(void *state, const void *input)
|
||||
{
|
||||
uint8_t _ALIGN(64) hash[64];
|
||||
|
||||
// luffa-80 cubehash-64 echo-64
|
||||
// luffa1-cubehash2-shavite3-simd4-echo5
|
||||
sph_luffa512_context ctx_luffa;
|
||||
sph_cubehash512_context ctx_cubehash;
|
||||
sph_echo512_context ctx_echo;
|
||||
|
||||
uint8_t hash[64];
|
||||
|
||||
sph_luffa512_init(&ctx_luffa);
|
||||
sph_luffa512 (&ctx_luffa, input, 80);
|
||||
sph_luffa512_close(&ctx_luffa, (void*) hash);
|
||||
@@ -52,13 +54,14 @@ extern "C" void deephash(void *state, const void *input)
|
||||
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
|
||||
extern "C" int scanhash_deep(int thr_id, uint32_t *pdata, const uint32_t *ptarget,
|
||||
uint32_t max_nonce, unsigned long *hashes_done)
|
||||
extern "C" int scanhash_deep(int thr_id, uint32_t *pdata,
|
||||
const uint32_t *ptarget, uint32_t max_nonce,
|
||||
unsigned long *hashes_done)
|
||||
{
|
||||
uint32_t _ALIGN(64) endiandata[20];
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
uint32_t endiandata[20];
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1U << 19); // 256*256*8
|
||||
throughput = min(throughput, (max_nonce - first_nonce));
|
||||
throughput = min(throughput, (max_nonce - first_nonce));
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0x0000f;
|
||||
@@ -66,8 +69,7 @@ extern "C" int scanhash_deep(int thr_id, uint32_t *pdata, const uint32_t *ptarge
|
||||
if (!init[thr_id])
|
||||
{
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hash[thr_id], throughput * 64));
|
||||
cudaMalloc(&d_hash[thr_id], 16 * sizeof(uint32_t) * throughput);
|
||||
|
||||
qubit_luffa512_cpu_init(thr_id, throughput);
|
||||
x11_cubehash512_cpu_init(thr_id, throughput);
|
||||
@@ -78,10 +80,10 @@ extern "C" int scanhash_deep(int thr_id, uint32_t *pdata, const uint32_t *ptarge
|
||||
init[thr_id] = true;
|
||||
}
|
||||
|
||||
for (int k=0; k < 19; k++)
|
||||
for (int k=0; k < 20; k++)
|
||||
be32enc(&endiandata[k], pdata[k]);
|
||||
|
||||
qubit_luffa512_cpu_setBlock_80((void*)endiandata);
|
||||
qubit_luffa512_cpufinal_setBlock_80((void*)endiandata,ptarget);
|
||||
cuda_check_cpu_setTarget(ptarget);
|
||||
|
||||
do {
|
||||
@@ -94,11 +96,12 @@ extern "C" int scanhash_deep(int thr_id, uint32_t *pdata, const uint32_t *ptarge
|
||||
uint32_t foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]);
|
||||
if (foundNonce != UINT32_MAX)
|
||||
{
|
||||
uint32_t _ALIGN(64) vhash64[8];
|
||||
const uint32_t Htarg = ptarget[7];
|
||||
uint32_t vhash64[8];
|
||||
be32enc(&endiandata[19], foundNonce);
|
||||
deephash(vhash64, endiandata);
|
||||
|
||||
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
|
||||
if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) {
|
||||
int res = 1;
|
||||
uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1);
|
||||
*hashes_done = pdata[19] - first_nonce + throughput;
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
/*
|
||||
* luffa 80 algo (Introduced by Doomcoin)
|
||||
* qubit algorithm
|
||||
*
|
||||
*/
|
||||
extern "C" {
|
||||
#include "sph/sph_luffa.h"
|
||||
@@ -14,13 +15,16 @@ static uint32_t *d_hash[MAX_GPUS];
|
||||
extern void qubit_luffa512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void qubit_luffa512_cpu_setBlock_80(void *pdata);
|
||||
extern void qubit_luffa512_cpu_hash_80(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_hash, int order);
|
||||
extern void qubit_luffa512_cpufinal_setBlock_80(void *pdata, const void *ptarget);
|
||||
extern uint32_t qubit_luffa512_cpu_finalhash_80(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_hash, int order);
|
||||
|
||||
extern "C" void luffa_hash(void *state, const void *input)
|
||||
extern void doomhash(void *state, const void *input)
|
||||
{
|
||||
uint8_t _ALIGN(64) hash[64];
|
||||
|
||||
// luffa512
|
||||
sph_luffa512_context ctx_luffa;
|
||||
|
||||
uint8_t hash[64];
|
||||
|
||||
sph_luffa512_init(&ctx_luffa);
|
||||
sph_luffa512 (&ctx_luffa, input, 80);
|
||||
sph_luffa512_close(&ctx_luffa, (void*) hash);
|
||||
@@ -30,11 +34,12 @@ extern "C" void luffa_hash(void *state, const void *input)
|
||||
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
|
||||
extern "C" int scanhash_luffa(int thr_id, uint32_t *pdata, const uint32_t *ptarget,
|
||||
uint32_t max_nonce, unsigned long *hashes_done)
|
||||
extern "C" int scanhash_doom(int thr_id, uint32_t *pdata,
|
||||
const uint32_t *ptarget, uint32_t max_nonce,
|
||||
unsigned long *hashes_done)
|
||||
{
|
||||
uint32_t _ALIGN(64) endiandata[20];
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
uint32_t endiandata[20];
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1U << 22); // 256*256*8*8
|
||||
throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
@@ -45,35 +50,31 @@ extern "C" int scanhash_luffa(int thr_id, uint32_t *pdata, const uint32_t *ptarg
|
||||
{
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hash[thr_id], throughput * 64));
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hash[thr_id], 16 * sizeof(uint32_t) * throughput));
|
||||
|
||||
qubit_luffa512_cpu_init(thr_id, throughput);
|
||||
cuda_check_cpu_init(thr_id, throughput);
|
||||
qubit_luffa512_cpu_init(thr_id, (int) throughput);
|
||||
|
||||
init[thr_id] = true;
|
||||
}
|
||||
|
||||
for (int k=0; k < 19; k++)
|
||||
for (int k=0; k < 20; k++)
|
||||
be32enc(&endiandata[k], pdata[k]);
|
||||
|
||||
qubit_luffa512_cpu_setBlock_80((void*)endiandata);
|
||||
cuda_check_cpu_setTarget(ptarget);
|
||||
qubit_luffa512_cpufinal_setBlock_80((void*)endiandata,ptarget);
|
||||
|
||||
do {
|
||||
int order = 0;
|
||||
*hashes_done = pdata[19] - first_nonce + throughput;
|
||||
|
||||
qubit_luffa512_cpu_hash_80(thr_id, (int) throughput, pdata[19], d_hash[thr_id], order++);
|
||||
|
||||
uint32_t foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]);
|
||||
uint32_t foundNonce = qubit_luffa512_cpu_finalhash_80(thr_id, (int) throughput, pdata[19], d_hash[thr_id], order++);
|
||||
if (foundNonce != UINT32_MAX)
|
||||
{
|
||||
uint32_t _ALIGN(64) vhash64[8];
|
||||
const uint32_t Htarg = ptarget[7];
|
||||
uint32_t vhash64[8];
|
||||
be32enc(&endiandata[19], foundNonce);
|
||||
luffa_hash(vhash64, endiandata);
|
||||
doomhash(vhash64, endiandata);
|
||||
|
||||
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
|
||||
//*hashes_done = min(max_nonce - first_nonce, (uint64_t) pdata[19] - first_nonce + throughput);
|
||||
if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) {
|
||||
*hashes_done = min(max_nonce - first_nonce, (uint64_t) pdata[19] - first_nonce + throughput);
|
||||
pdata[19] = foundNonce;
|
||||
return 1;
|
||||
} else {
|
||||
@@ -81,7 +82,7 @@ extern "C" int scanhash_luffa(int thr_id, uint32_t *pdata, const uint32_t *ptarg
|
||||
}
|
||||
}
|
||||
|
||||
if ((uint64_t) throughput + pdata[19] > max_nonce) {
|
||||
if ((uint64_t) pdata[19] + throughput > max_nonce) {
|
||||
// pdata[19] = max_nonce;
|
||||
break;
|
||||
}
|
||||
+291
-290
@@ -1,18 +1,49 @@
|
||||
/*******************************************************************************
|
||||
* luffa512 for 80-bytes input (with midstate precalc by klausT)
|
||||
/*
|
||||
* luffa_for_32.c
|
||||
* Version 2.0 (Sep 15th 2009)
|
||||
*
|
||||
* Copyright (C) 2008-2009 Hitachi, Ltd. All rights reserved.
|
||||
*
|
||||
* Hitachi, Ltd. is the owner of this software and hereby grant
|
||||
* the U.S. Government and any interested party the right to use
|
||||
* this software for the purposes of the SHA-3 evaluation process,
|
||||
* notwithstanding that this software is copyrighted.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <memory.h>
|
||||
|
||||
#include "cuda_helper.h"
|
||||
|
||||
static __constant__ uint64_t c_PaddedMessage80[16]; // padded message (80 bytes + padding)
|
||||
static __constant__ uint32_t statebufferpre[8];
|
||||
static __constant__ uint32_t statechainvpre[40];
|
||||
typedef unsigned char BitSequence;
|
||||
|
||||
#define MULT2(a,j) {\
|
||||
__constant__ uint64_t c_PaddedMessage80[16]; // padded message (80 bytes + padding)
|
||||
__constant__ uint32_t c_Target[8];
|
||||
|
||||
static uint32_t *h_resNounce[MAX_GPUS];
|
||||
static uint32_t *d_resNounce[MAX_GPUS];
|
||||
|
||||
#define NBN 1 /* max results, could be 2, see blake32.cu */
|
||||
#if NBN > 1
|
||||
static uint32_t extra_results[2] = { UINT32_MAX, UINT32_MAX };
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
uint32_t buffer[8]; /* Buffer to be hashed */
|
||||
uint32_t chainv[40]; /* Chaining values */
|
||||
} hashState;
|
||||
|
||||
#define BYTES_SWAP32(x) cuda_swab32(x)
|
||||
|
||||
#define MULT2(a,j)\
|
||||
tmp = a[7+(8*j)];\
|
||||
a[7+(8*j)] = a[6+(8*j)];\
|
||||
a[6+(8*j)] = a[5+(8*j)];\
|
||||
@@ -21,25 +52,22 @@ static __constant__ uint32_t statechainvpre[40];
|
||||
a[3+(8*j)] = a[2+(8*j)] ^ tmp;\
|
||||
a[2+(8*j)] = a[1+(8*j)];\
|
||||
a[1+(8*j)] = a[0+(8*j)] ^ tmp;\
|
||||
a[0+(8*j)] = tmp;\
|
||||
}
|
||||
a[0+(8*j)] = tmp;
|
||||
|
||||
#define TWEAK(a0,a1,a2,a3,j) { \
|
||||
#define TWEAK(a0,a1,a2,a3,j)\
|
||||
a0 = (a0<<(j))|(a0>>(32-j));\
|
||||
a1 = (a1<<(j))|(a1>>(32-j));\
|
||||
a2 = (a2<<(j))|(a2>>(32-j));\
|
||||
a3 = (a3<<(j))|(a3>>(32-j));\
|
||||
}
|
||||
a3 = (a3<<(j))|(a3>>(32-j));
|
||||
|
||||
#define STEP(c0,c1) { \
|
||||
#define STEP(c0,c1)\
|
||||
SUBCRUMB(chainv[0],chainv[1],chainv[2],chainv[3],tmp);\
|
||||
SUBCRUMB(chainv[5],chainv[6],chainv[7],chainv[4],tmp);\
|
||||
MIXWORD(chainv[0],chainv[4]);\
|
||||
MIXWORD(chainv[1],chainv[5]);\
|
||||
MIXWORD(chainv[2],chainv[6]);\
|
||||
MIXWORD(chainv[3],chainv[7]);\
|
||||
ADD_CONSTANT(chainv[0],chainv[4],c0,c1);\
|
||||
}
|
||||
ADD_CONSTANT(chainv[0],chainv[4],c0,c1);
|
||||
|
||||
#define SUBCRUMB(a0,a1,a2,a3,a4)\
|
||||
a4 = a0;\
|
||||
@@ -76,7 +104,7 @@ static __constant__ uint32_t statechainvpre[40];
|
||||
|
||||
/* initial values of chaining variables */
|
||||
__constant__ uint32_t c_IV[40];
|
||||
static const uint32_t h_IV[40] = {
|
||||
const uint32_t h2_IV[40] = {
|
||||
0x6d251e69,0x44b051e0,0x4eaa6fb4,0xdbf78465,
|
||||
0x6e292011,0x90152df4,0xee058139,0xdef610bb,
|
||||
0xc3b44b95,0xd9d2f256,0x70eee9a0,0xde099fa3,
|
||||
@@ -89,7 +117,7 @@ static const uint32_t h_IV[40] = {
|
||||
0xf5df3999,0x0fc688f1,0xb07224cc,0x03e86cea};
|
||||
|
||||
__constant__ uint32_t c_CNS[80];
|
||||
static const uint32_t h_CNS[80] = {
|
||||
uint32_t h2_CNS[80] = {
|
||||
0x303994a6,0xe0337818,0xc0e65299,0x441ba90d,
|
||||
0x6cc33a12,0x7f34d442,0xdc56983e,0x9389217f,
|
||||
0x1e00108f,0xe5a8bce6,0x7800423d,0x5274baf4,
|
||||
@@ -114,305 +142,213 @@ static const uint32_t h_CNS[80] = {
|
||||
|
||||
/***************************************************/
|
||||
__device__ __forceinline__
|
||||
void rnd512(uint32_t *statebuffer, uint32_t *statechainv)
|
||||
void rnd512(hashState *state)
|
||||
{
|
||||
int i,j;
|
||||
uint32_t t[40];
|
||||
uint32_t chainv[8];
|
||||
uint32_t tmp;
|
||||
|
||||
#pragma unroll 8
|
||||
for(i=0; i<8; i++) {
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) {
|
||||
t[i]=0;
|
||||
#pragma unroll 5
|
||||
for(j=0; j<5; j++)
|
||||
t[i] ^= statechainv[i+8*j];
|
||||
#pragma unroll 5
|
||||
for(j=0;j<5;j++) {
|
||||
t[i] ^= state->chainv[i+8*j];
|
||||
}
|
||||
}
|
||||
|
||||
MULT2(t, 0);
|
||||
|
||||
#pragma unroll 5
|
||||
for(j=0; j<5; j++) {
|
||||
#pragma unroll 8
|
||||
for(i=0; i<8; i++)
|
||||
statechainv[i+8*j] ^= t[i];
|
||||
#pragma unroll 5
|
||||
for(j=0;j<5;j++) {
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) {
|
||||
state->chainv[i+8*j] ^= t[i];
|
||||
}
|
||||
}
|
||||
|
||||
#pragma unroll 5
|
||||
for(j=0; j<5; j++) {
|
||||
#pragma unroll 8
|
||||
for(i=0; i<8; i++)
|
||||
t[i+8*j] = statechainv[i+8*j];
|
||||
#pragma unroll 5
|
||||
for(j=0;j<5;j++) {
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) {
|
||||
t[i+8*j] = state->chainv[i+8*j];
|
||||
}
|
||||
}
|
||||
|
||||
#pragma unroll
|
||||
for(j=0; j<5; j++)
|
||||
MULT2(statechainv, j);
|
||||
|
||||
#pragma unroll 5
|
||||
for(j=0; j<5; j++) {
|
||||
#pragma unroll 8
|
||||
for(i=0; i<8; i++)
|
||||
statechainv[8*j+i] ^= t[8*((j+1)%5)+i];
|
||||
#pragma unroll 5
|
||||
for(j=0;j<5;j++) {
|
||||
MULT2(state->chainv, j);
|
||||
}
|
||||
|
||||
#pragma unroll 5
|
||||
for(j=0; j<5; j++) {
|
||||
#pragma unroll 8
|
||||
for(i=0; i<8; i++)
|
||||
t[i+8*j] = statechainv[i+8*j];
|
||||
#pragma unroll 5
|
||||
for(j=0;j<5;j++) {
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) {
|
||||
state->chainv[8*j+i] ^= t[8*((j+1)%5)+i];
|
||||
}
|
||||
}
|
||||
|
||||
#pragma unroll
|
||||
for(j=0; j<5; j++)
|
||||
MULT2(statechainv, j);
|
||||
|
||||
#pragma unroll 5
|
||||
for(j=0; j<5; j++) {
|
||||
#pragma unroll 8
|
||||
for(i=0; i<8; i++)
|
||||
statechainv[8*j+i] ^= t[8*((j+4)%5)+i];
|
||||
#pragma unroll 5
|
||||
for(j=0;j<5;j++) {
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) {
|
||||
t[i+8*j] = state->chainv[i+8*j];
|
||||
}
|
||||
}
|
||||
|
||||
#pragma unroll 5
|
||||
for(j=0; j<5; j++) {
|
||||
#pragma unroll 8
|
||||
for(i=0; i<8; i++)
|
||||
statechainv[i+8*j] ^= statebuffer[i];
|
||||
MULT2(statebuffer, 0);
|
||||
#pragma unroll 5
|
||||
for(j=0;j<5;j++) {
|
||||
MULT2(state->chainv, j);
|
||||
}
|
||||
|
||||
#pragma unroll
|
||||
for(i=0; i<8; i++)
|
||||
chainv[i] = statechainv[i];
|
||||
#pragma unroll 5
|
||||
for(j=0;j<5;j++) {
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) {
|
||||
state->chainv[8*j+i] ^= t[8*((j+4)%5)+i];
|
||||
}
|
||||
}
|
||||
|
||||
#pragma unroll
|
||||
for(i=0; i<8; i++)
|
||||
STEP(c_CNS[(2*i)], c_CNS[(2*i)+1]);
|
||||
#pragma unroll 5
|
||||
for(j=0;j<5;j++) {
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) {
|
||||
state->chainv[i+8*j] ^= state->buffer[i];
|
||||
}
|
||||
MULT2(state->buffer, 0);
|
||||
}
|
||||
|
||||
#pragma unroll
|
||||
for(i=0; i<8; i++) {
|
||||
statechainv[i] = chainv[i];
|
||||
chainv[i] = statechainv[i+8];
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) {
|
||||
chainv[i] = state->chainv[i];
|
||||
}
|
||||
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) {
|
||||
STEP(c_CNS[(2*i)],c_CNS[(2*i)+1]);
|
||||
}
|
||||
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) {
|
||||
state->chainv[i] = chainv[i];
|
||||
chainv[i] = state->chainv[i+8];
|
||||
}
|
||||
|
||||
TWEAK(chainv[4],chainv[5],chainv[6],chainv[7],1);
|
||||
|
||||
#pragma unroll
|
||||
for(i=0; i<8; i++)
|
||||
STEP(c_CNS[(2*i)+16], c_CNS[(2*i)+16+1]);
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) {
|
||||
STEP(c_CNS[(2*i)+16],c_CNS[(2*i)+16+1]);
|
||||
}
|
||||
|
||||
#pragma unroll
|
||||
for(i=0; i<8; i++) {
|
||||
statechainv[i+8] = chainv[i];
|
||||
chainv[i] = statechainv[i+16];
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) {
|
||||
state->chainv[i+8] = chainv[i];
|
||||
chainv[i] = state->chainv[i+16];
|
||||
}
|
||||
|
||||
TWEAK(chainv[4],chainv[5],chainv[6],chainv[7],2);
|
||||
|
||||
#pragma unroll
|
||||
for(i=0; i<8; i++)
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) {
|
||||
STEP(c_CNS[(2*i)+32],c_CNS[(2*i)+32+1]);
|
||||
}
|
||||
|
||||
#pragma unroll
|
||||
for(i=0; i<8; i++) {
|
||||
statechainv[i+16] = chainv[i];
|
||||
chainv[i] = statechainv[i+24];
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) {
|
||||
state->chainv[i+16] = chainv[i];
|
||||
chainv[i] = state->chainv[i+24];
|
||||
}
|
||||
|
||||
TWEAK(chainv[4],chainv[5],chainv[6],chainv[7],3);
|
||||
|
||||
#pragma unroll
|
||||
for(i=0; i<8; i++)
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) {
|
||||
STEP(c_CNS[(2*i)+48],c_CNS[(2*i)+48+1]);
|
||||
}
|
||||
|
||||
#pragma unroll
|
||||
for(i=0; i<8; i++) {
|
||||
statechainv[i+24] = chainv[i];
|
||||
chainv[i] = statechainv[i+32];
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) {
|
||||
state->chainv[i+24] = chainv[i];
|
||||
chainv[i] = state->chainv[i+32];
|
||||
}
|
||||
|
||||
TWEAK(chainv[4],chainv[5],chainv[6],chainv[7],4);
|
||||
|
||||
#pragma unroll
|
||||
for(i=0; i<8; i++)
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) {
|
||||
STEP(c_CNS[(2*i)+64],c_CNS[(2*i)+64+1]);
|
||||
}
|
||||
|
||||
#pragma unroll 8
|
||||
for(i=0; i<8; i++)
|
||||
statechainv[i+32] = chainv[i];
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) {
|
||||
state->chainv[i+32] = chainv[i];
|
||||
}
|
||||
}
|
||||
|
||||
static void rnd512_cpu(uint32_t *statebuffer, uint32_t *statechainv)
|
||||
{
|
||||
int i, j;
|
||||
uint32_t t[40];
|
||||
uint32_t chainv[8];
|
||||
uint32_t tmp;
|
||||
|
||||
for (i = 0; i<8; i++) {
|
||||
t[i] = statechainv[i];
|
||||
for (j = 1; j<5; j++)
|
||||
t[i] ^= statechainv[i + 8 * j];
|
||||
}
|
||||
|
||||
MULT2(t, 0);
|
||||
|
||||
for (j = 0; j<5; j++) {
|
||||
for (i = 0; i<8; i++)
|
||||
statechainv[i + 8 * j] ^= t[i];
|
||||
}
|
||||
|
||||
for (j = 0; j<5; j++) {
|
||||
for (i = 0; i<8; i++)
|
||||
t[i + 8 * j] = statechainv[i + 8 * j];
|
||||
}
|
||||
|
||||
for (j = 0; j<5; j++)
|
||||
MULT2(statechainv, j);
|
||||
|
||||
for (j = 0; j<5; j++) {
|
||||
for (i = 0; i<8; i++)
|
||||
statechainv[8 * j + i] ^= t[8 * ((j + 1) % 5) + i];
|
||||
}
|
||||
|
||||
for (j = 0; j<5; j++) {
|
||||
for (i = 0; i<8; i++)
|
||||
t[i + 8 * j] = statechainv[i + 8 * j];
|
||||
}
|
||||
|
||||
for (j = 0; j<5; j++)
|
||||
MULT2(statechainv, j);
|
||||
|
||||
for (j = 0; j<5; j++) {
|
||||
for (i = 0; i<8; i++)
|
||||
statechainv[8 * j + i] ^= t[8 * ((j + 4) % 5) + i];
|
||||
}
|
||||
|
||||
for (j = 0; j<5; j++) {
|
||||
for (i = 0; i<8; i++)
|
||||
statechainv[i + 8 * j] ^= statebuffer[i];
|
||||
MULT2(statebuffer, 0);
|
||||
}
|
||||
|
||||
for (i = 0; i<8; i++)
|
||||
chainv[i] = statechainv[i];
|
||||
|
||||
for (i = 0; i<8; i++)
|
||||
STEP(h_CNS[(2 * i)], h_CNS[(2 * i) + 1]);
|
||||
|
||||
for (i = 0; i<8; i++) {
|
||||
statechainv[i] = chainv[i];
|
||||
chainv[i] = statechainv[i + 8];
|
||||
}
|
||||
|
||||
TWEAK(chainv[4], chainv[5], chainv[6], chainv[7], 1);
|
||||
|
||||
for (i = 0; i<8; i++)
|
||||
STEP(h_CNS[(2 * i) + 16], h_CNS[(2 * i) + 16 + 1]);
|
||||
|
||||
for (i = 0; i<8; i++) {
|
||||
statechainv[i + 8] = chainv[i];
|
||||
chainv[i] = statechainv[i + 16];
|
||||
}
|
||||
|
||||
TWEAK(chainv[4], chainv[5], chainv[6], chainv[7], 2);
|
||||
|
||||
for (i = 0; i<8; i++)
|
||||
STEP(h_CNS[(2 * i) + 32], h_CNS[(2 * i) + 32 + 1]);
|
||||
|
||||
for (i = 0; i<8; i++) {
|
||||
statechainv[i + 16] = chainv[i];
|
||||
chainv[i] = statechainv[i + 24];
|
||||
}
|
||||
|
||||
TWEAK(chainv[4], chainv[5], chainv[6], chainv[7], 3);
|
||||
|
||||
for (i = 0; i<8; i++)
|
||||
STEP(h_CNS[(2 * i) + 48], h_CNS[(2 * i) + 48 + 1]);
|
||||
|
||||
for (i = 0; i<8; i++) {
|
||||
statechainv[i + 24] = chainv[i];
|
||||
chainv[i] = statechainv[i + 32];
|
||||
}
|
||||
|
||||
TWEAK(chainv[4], chainv[5], chainv[6], chainv[7], 4);
|
||||
|
||||
for (i = 0; i<8; i++)
|
||||
STEP(h_CNS[(2 * i) + 64], h_CNS[(2 * i) + 64 + 1]);
|
||||
|
||||
for (i = 0; i<8; i++)
|
||||
statechainv[i + 32] = chainv[i];
|
||||
}
|
||||
|
||||
/***************************************************/
|
||||
__device__ __forceinline__
|
||||
void Update512(uint32_t* statebuffer, uint32_t *statechainv, const uint32_t *const __restrict__ data)
|
||||
void Update512(hashState *state, const BitSequence *data)
|
||||
{
|
||||
#pragma unroll
|
||||
for (int i = 0; i<8; i++)
|
||||
statebuffer[i] = cuda_swab32((data[i]));
|
||||
rnd512(statebuffer, statechainv);
|
||||
#pragma unroll 8
|
||||
for(int i=0;i<8;i++) state->buffer[i] = BYTES_SWAP32(((uint32_t*)data)[i]);
|
||||
rnd512(state);
|
||||
|
||||
#pragma unroll
|
||||
for(int i=0; i<8; i++)
|
||||
statebuffer[i] = cuda_swab32((data[i+8]));
|
||||
rnd512(statebuffer, statechainv);
|
||||
|
||||
#pragma unroll
|
||||
for(int i=0; i<4; i++)
|
||||
statebuffer[i] = cuda_swab32((data[i+16]));
|
||||
#pragma unroll 8
|
||||
for(int i=0;i<8;i++) state->buffer[i] = BYTES_SWAP32(((uint32_t*)(data+32))[i]);
|
||||
rnd512(state);
|
||||
#pragma unroll 4
|
||||
for(int i=0;i<4;i++) state->buffer[i] = BYTES_SWAP32(((uint32_t*)(data+64))[i]);
|
||||
}
|
||||
|
||||
|
||||
/***************************************************/
|
||||
__device__ __forceinline__
|
||||
void finalization512(uint32_t* statebuffer, uint32_t *statechainv, uint32_t *b)
|
||||
void finalization512(hashState *state, uint32_t *b)
|
||||
{
|
||||
int i,j;
|
||||
|
||||
statebuffer[4] = 0x80000000U;
|
||||
|
||||
#pragma unroll 3
|
||||
for(int i=5; i<8; i++)
|
||||
statebuffer[i] = 0;
|
||||
rnd512(statebuffer, statechainv);
|
||||
state->buffer[4] = 0x80000000;
|
||||
#pragma unroll 3
|
||||
for(int i=5;i<8;i++) state->buffer[i] = 0;
|
||||
rnd512(state);
|
||||
|
||||
/*---- blank round with m=0 ----*/
|
||||
#pragma unroll
|
||||
for(i=0; i<8; i++)
|
||||
statebuffer[i] =0;
|
||||
rnd512(statebuffer, statechainv);
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) state->buffer[i] =0;
|
||||
rnd512(state);
|
||||
|
||||
#pragma unroll
|
||||
for(i=0; i<8; i++) {
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) {
|
||||
b[i] = 0;
|
||||
#pragma unroll 5
|
||||
for(j=0; j<5; j++)
|
||||
b[i] ^= statechainv[i+8*j];
|
||||
b[i] = cuda_swab32((b[i]));
|
||||
#pragma unroll 5
|
||||
for(j=0;j<5;j++) {
|
||||
b[i] ^= state->chainv[i+8*j];
|
||||
}
|
||||
b[i] = BYTES_SWAP32((b[i]));
|
||||
}
|
||||
|
||||
#pragma unroll
|
||||
for(i=0; i<8; i++)
|
||||
statebuffer[i]=0;
|
||||
rnd512(statebuffer, statechainv);
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) state->buffer[i]=0;
|
||||
rnd512(state);
|
||||
|
||||
#pragma unroll
|
||||
for(i=0; i<8; i++)
|
||||
{
|
||||
#pragma unroll 8
|
||||
for(i=0;i<8;i++) {
|
||||
b[8+i] = 0;
|
||||
#pragma unroll 5
|
||||
for(j=0; j<5; j++)
|
||||
b[8+i] ^= statechainv[i+8*j];
|
||||
b[8+i] = cuda_swab32((b[8+i]));
|
||||
#pragma unroll 5
|
||||
for(j=0;j<5;j++) {
|
||||
b[8+i] ^= state->chainv[i+8*j];
|
||||
}
|
||||
b[8+i] = BYTES_SWAP32((b[8+i]));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/***************************************************/
|
||||
// Die Hash-Funktion
|
||||
__global__
|
||||
void qubit_luffa512_gpu_hash_80(uint32_t threads, uint32_t startNounce, uint32_t *outputHash)
|
||||
void qubit_luffa512_gpu_hash_80(uint32_t threads, uint32_t startNounce, void *outputHash)
|
||||
{
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
@@ -423,37 +359,118 @@ void qubit_luffa512_gpu_hash_80(uint32_t threads, uint32_t startNounce, uint32_t
|
||||
uint32_t buf32[32];
|
||||
} buff;
|
||||
|
||||
#pragma unroll 8
|
||||
for (int i=8; i < 16; i++)
|
||||
buff.buf64[i] = c_PaddedMessage80[i];
|
||||
#pragma unroll 16
|
||||
for (int i=0; i < 16; ++i) buff.buf64[i] = c_PaddedMessage80[i];
|
||||
|
||||
// die Nounce durch die thread-spezifische ersetzen
|
||||
buff.buf64[9] = REPLACE_HIDWORD(buff.buf64[9], cuda_swab32(nounce));
|
||||
|
||||
uint32_t statebuffer[8], statechainv[40];
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 0; i<4; i++)
|
||||
statebuffer[i] = cuda_swab32(buff.buf32[i + 16]);
|
||||
hashState state;
|
||||
#pragma unroll 40
|
||||
for(int i=0;i<40;i++) state.chainv[i] = c_IV[i];
|
||||
#pragma unroll 8
|
||||
for(int i=0;i<8;i++) state.buffer[i] = 0;
|
||||
Update512(&state, (BitSequence*)buff.buf32);
|
||||
uint32_t *outHash = (uint32_t *)outputHash + 16 * thread;
|
||||
finalization512(&state, (uint32_t*)outHash);
|
||||
}
|
||||
}
|
||||
|
||||
#pragma unroll 4
|
||||
for (int i = 4; i<8; i++)
|
||||
statebuffer[i] = statebufferpre[i];
|
||||
__global__
|
||||
void qubit_luffa512_gpu_finalhash_80(uint32_t threads, uint32_t startNounce, void *outputHash, uint32_t *resNounce)
|
||||
{
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
uint32_t nounce = startNounce + thread;
|
||||
union {
|
||||
uint64_t buf64[16];
|
||||
uint32_t buf32[32];
|
||||
} buff;
|
||||
uint32_t Hash[16];
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 0; i<40; i++)
|
||||
statechainv[i] = statechainvpre[i];
|
||||
#pragma unroll 16
|
||||
for (int i=0; i < 16; ++i) buff.buf64[i] = c_PaddedMessage80[i];
|
||||
|
||||
uint32_t *outHash = &outputHash[thread * 16];
|
||||
finalization512(statebuffer, statechainv, outHash);
|
||||
// Tested nonce
|
||||
buff.buf64[9] = REPLACE_HIDWORD(buff.buf64[9], cuda_swab32(nounce));
|
||||
|
||||
hashState state;
|
||||
#pragma unroll 40
|
||||
for(int i=0;i<40;i++) state.chainv[i] = c_IV[i];
|
||||
|
||||
#pragma unroll 8
|
||||
for(int i=0;i<8;i++) state.buffer[i] = 0;
|
||||
|
||||
Update512(&state, (BitSequence*)buff.buf32);
|
||||
finalization512(&state, Hash);
|
||||
|
||||
/* dont ask me why not a simple if (Hash[i] > c_Target[i]) return;
|
||||
* we lose 20% in perfs without the position test */
|
||||
int position = -1;
|
||||
#pragma unroll 8
|
||||
for (int i = 7; i >= 0; i--) {
|
||||
if (Hash[i] > c_Target[i]) {
|
||||
if (position < i) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (Hash[i] < c_Target[i]) {
|
||||
if (position < i) {
|
||||
position = i;
|
||||
//break; /* impact perfs, unroll ? */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#if NBN == 1
|
||||
if (resNounce[0] > nounce) {
|
||||
resNounce[0] = nounce;
|
||||
}
|
||||
#else
|
||||
/* keep the smallest nounce, + extra one if found */
|
||||
if (resNounce[0] > nounce) {
|
||||
resNounce[1] = resNounce[0];
|
||||
resNounce[0] = nounce;
|
||||
} else {
|
||||
resNounce[1] = nounce;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
__host__
|
||||
void qubit_luffa512_cpu_init(int thr_id, uint32_t threads)
|
||||
{
|
||||
CUDA_SAFE_CALL(cudaMemcpyToSymbol(c_IV, h_IV, sizeof(h_IV), 0, cudaMemcpyHostToDevice));
|
||||
CUDA_SAFE_CALL(cudaMemcpyToSymbol(c_CNS, h_CNS, sizeof(h_CNS), 0, cudaMemcpyHostToDevice));
|
||||
CUDA_SAFE_CALL(cudaMemcpyToSymbol(c_IV, h2_IV, sizeof(h2_IV), 0, cudaMemcpyHostToDevice));
|
||||
CUDA_SAFE_CALL(cudaMemcpyToSymbol(c_CNS, h2_CNS, sizeof(h2_CNS), 0, cudaMemcpyHostToDevice));
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_resNounce[thr_id], NBN * sizeof(uint32_t)));
|
||||
CUDA_SAFE_CALL(cudaMallocHost(&h_resNounce[thr_id], NBN * sizeof(uint32_t)));
|
||||
}
|
||||
|
||||
__host__
|
||||
uint32_t qubit_luffa512_cpu_finalhash_80(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_outputHash,int order)
|
||||
{
|
||||
uint32_t result = UINT32_MAX;
|
||||
cudaMemset(d_resNounce[thr_id], 0xff, NBN * sizeof(uint32_t));
|
||||
const uint32_t threadsperblock = 256;
|
||||
|
||||
dim3 grid((threads + threadsperblock-1)/threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
|
||||
size_t shared_size = 0;
|
||||
|
||||
qubit_luffa512_gpu_finalhash_80 <<<grid, block, shared_size>>> (threads, startNounce, d_outputHash, d_resNounce[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
if (cudaSuccess == cudaMemcpy(h_resNounce[thr_id], d_resNounce[thr_id], NBN * sizeof(uint32_t), cudaMemcpyDeviceToHost)) {
|
||||
//cudaThreadSynchronize();
|
||||
result = h_resNounce[thr_id][0];
|
||||
#if NBN > 1
|
||||
extra_results[0] = h_resNounce[thr_id][1];
|
||||
#endif
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
__host__
|
||||
@@ -468,37 +485,6 @@ void qubit_luffa512_cpu_hash_80(int thr_id, uint32_t threads, uint32_t startNoun
|
||||
qubit_luffa512_gpu_hash_80 <<<grid, block, shared_size>>> (threads, startNounce, d_outputHash);
|
||||
}
|
||||
|
||||
__host__
|
||||
void qubit_cpu_precalc(uint32_t* message)
|
||||
{
|
||||
uint32_t statebuffer[8];
|
||||
uint32_t statechainv[40] =
|
||||
{
|
||||
0x6d251e69, 0x44b051e0, 0x4eaa6fb4, 0xdbf78465,
|
||||
0x6e292011, 0x90152df4, 0xee058139, 0xdef610bb,
|
||||
0xc3b44b95, 0xd9d2f256, 0x70eee9a0, 0xde099fa3,
|
||||
0x5d9b0557, 0x8fc944b3, 0xcf1ccf0e, 0x746cd581,
|
||||
0xf7efc89d, 0x5dba5781, 0x04016ce5, 0xad659c05,
|
||||
0x0306194f, 0x666d1836, 0x24aa230a, 0x8b264ae7,
|
||||
0x858075d5, 0x36d79cce, 0xe571f7d7, 0x204b1f67,
|
||||
0x35870c6a, 0x57e9e923, 0x14bcb808, 0x7cde72ce,
|
||||
0x6c68e9be, 0x5ec41e22, 0xc825b7c7, 0xaffb4363,
|
||||
0xf5df3999, 0x0fc688f1, 0xb07224cc, 0x03e86cea
|
||||
};
|
||||
|
||||
for (int i = 0; i<8; i++)
|
||||
statebuffer[i] = cuda_swab32(message[i]);
|
||||
rnd512_cpu(statebuffer, statechainv);
|
||||
|
||||
for (int i = 0; i<8; i++)
|
||||
statebuffer[i] = cuda_swab32(message[i+8]);
|
||||
|
||||
rnd512_cpu(statebuffer, statechainv);
|
||||
|
||||
cudaMemcpyToSymbol(statebufferpre, statebuffer, sizeof(statebuffer), 0, cudaMemcpyHostToDevice);
|
||||
cudaMemcpyToSymbol(statechainvpre, statechainv, sizeof(statechainv), 0, cudaMemcpyHostToDevice);
|
||||
}
|
||||
|
||||
__host__
|
||||
void qubit_luffa512_cpu_setBlock_80(void *pdata)
|
||||
{
|
||||
@@ -511,6 +497,21 @@ void qubit_luffa512_cpu_setBlock_80(void *pdata)
|
||||
PaddedMessage[126] = 0x02;
|
||||
PaddedMessage[127] = 0x80;
|
||||
|
||||
CUDA_SAFE_CALL(cudaMemcpyToSymbol(c_PaddedMessage80, PaddedMessage, sizeof(PaddedMessage), 0, cudaMemcpyHostToDevice));
|
||||
qubit_cpu_precalc((uint32_t*) PaddedMessage);
|
||||
CUDA_SAFE_CALL(cudaMemcpyToSymbol( c_PaddedMessage80, PaddedMessage, 16*sizeof(uint64_t), 0, cudaMemcpyHostToDevice));
|
||||
}
|
||||
|
||||
__host__
|
||||
void qubit_luffa512_cpufinal_setBlock_80(void *pdata, const void *ptarget)
|
||||
{
|
||||
unsigned char PaddedMessage[128];
|
||||
|
||||
memcpy(PaddedMessage, pdata, 80);
|
||||
memset(PaddedMessage+80, 0, 48);
|
||||
PaddedMessage[80] = 0x80;
|
||||
PaddedMessage[111] = 1;
|
||||
PaddedMessage[126] = 0x02;
|
||||
PaddedMessage[127] = 0x80;
|
||||
|
||||
CUDA_SAFE_CALL(cudaMemcpyToSymbol(c_Target, ptarget, 8*sizeof(uint32_t), 0, cudaMemcpyHostToDevice));
|
||||
CUDA_SAFE_CALL(cudaMemcpyToSymbol(c_PaddedMessage80, PaddedMessage, 16*sizeof(uint64_t), 0, cudaMemcpyHostToDevice));
|
||||
}
|
||||
+4
-4
@@ -60,8 +60,8 @@ IDI_ICON1 ICON "ccminer.ico"
|
||||
//
|
||||
|
||||
VS_VERSION_INFO VERSIONINFO
|
||||
FILEVERSION 1,6,5,0
|
||||
PRODUCTVERSION 1,6,5,0
|
||||
FILEVERSION 1,6,0,0
|
||||
PRODUCTVERSION 1,6,0,0
|
||||
FILEFLAGSMASK 0x3fL
|
||||
#ifdef _DEBUG
|
||||
FILEFLAGS 0x21L
|
||||
@@ -76,10 +76,10 @@ BEGIN
|
||||
BEGIN
|
||||
BLOCK "040904e4"
|
||||
BEGIN
|
||||
VALUE "FileVersion", "1.6.5"
|
||||
VALUE "FileVersion", "1.6"
|
||||
VALUE "LegalCopyright", "Copyright (C) 2015"
|
||||
VALUE "ProductName", "ccminer"
|
||||
VALUE "ProductVersion", "1.6.5"
|
||||
VALUE "ProductVersion", "1.6"
|
||||
END
|
||||
END
|
||||
BLOCK "VarFileInfo"
|
||||
|
||||
@@ -23,6 +23,7 @@ extern char *device_name[MAX_GPUS];
|
||||
extern bool opt_autotune;
|
||||
extern int opt_nfactor;
|
||||
extern char *jane_params;
|
||||
extern bool abort_flag;
|
||||
extern int parallel;
|
||||
|
||||
extern void get_currentalgo(char* buf, int sz);
|
||||
|
||||
-860
@@ -1,860 +0,0 @@
|
||||
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
||||
// Copyright (c) 2009-2014 The Bitcoin Core developers
|
||||
// Distributed under the MIT software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
#ifndef BITCOIN_SERIALIZE_H
|
||||
#define BITCOIN_SERIALIZE_H
|
||||
|
||||
//#include "compat/endian.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <assert.h>
|
||||
#include <ios>
|
||||
#include <limits>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <stdint.h>
|
||||
#include <string>
|
||||
#include <string.h>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
class CScript;
|
||||
|
||||
static const unsigned int MAX_SIZE = 0x02000000;
|
||||
|
||||
/**
|
||||
* Used to bypass the rule against non-const reference to temporary
|
||||
* where it makes sense with wrappers such as CFlatData or CTxDB
|
||||
*/
|
||||
template<typename T>
|
||||
inline T& REF(const T& val)
|
||||
{
|
||||
return const_cast<T&>(val);
|
||||
}
|
||||
|
||||
/**
|
||||
* Used to acquire a non-const pointer "this" to generate bodies
|
||||
* of const serialization operations from a template
|
||||
*/
|
||||
template<typename T>
|
||||
inline T* NCONST_PTR(const T* val)
|
||||
{
|
||||
return const_cast<T*>(val);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get begin pointer of vector (non-const version).
|
||||
* @note These functions avoid the undefined case of indexing into an empty
|
||||
* vector, as well as that of indexing after the end of the vector.
|
||||
*/
|
||||
template <class T, class TAl>
|
||||
inline T* begin_ptr(std::vector<T,TAl>& v)
|
||||
{
|
||||
return v.empty() ? NULL : &v[0];
|
||||
}
|
||||
/** Get begin pointer of vector (const version) */
|
||||
template <class T, class TAl>
|
||||
inline const T* begin_ptr(const std::vector<T,TAl>& v)
|
||||
{
|
||||
return v.empty() ? NULL : &v[0];
|
||||
}
|
||||
/** Get end pointer of vector (non-const version) */
|
||||
template <class T, class TAl>
|
||||
inline T* end_ptr(std::vector<T,TAl>& v)
|
||||
{
|
||||
return v.empty() ? NULL : (&v[0] + v.size());
|
||||
}
|
||||
/** Get end pointer of vector (const version) */
|
||||
template <class T, class TAl>
|
||||
inline const T* end_ptr(const std::vector<T,TAl>& v)
|
||||
{
|
||||
return v.empty() ? NULL : (&v[0] + v.size());
|
||||
}
|
||||
|
||||
/*
|
||||
* Lowest-level serialization and conversion.
|
||||
* @note Sizes of these types are verified in the tests
|
||||
*/
|
||||
template<typename Stream> inline void ser_writedata8(Stream &s, uint8_t obj)
|
||||
{
|
||||
s.write((char*)&obj, 1);
|
||||
}
|
||||
template<typename Stream> inline void ser_writedata16(Stream &s, uint16_t obj)
|
||||
{
|
||||
obj = htole16(obj);
|
||||
s.write((char*)&obj, 2);
|
||||
}
|
||||
template<typename Stream> inline void ser_writedata32(Stream &s, uint32_t obj)
|
||||
{
|
||||
obj = htole32(obj);
|
||||
s.write((char*)&obj, 4);
|
||||
}
|
||||
template<typename Stream> inline void ser_writedata64(Stream &s, uint64_t obj)
|
||||
{
|
||||
obj = htole64(obj);
|
||||
s.write((char*)&obj, 8);
|
||||
}
|
||||
template<typename Stream> inline uint8_t ser_readdata8(Stream &s)
|
||||
{
|
||||
uint8_t obj;
|
||||
s.read((char*)&obj, 1);
|
||||
return obj;
|
||||
}
|
||||
template<typename Stream> inline uint16_t ser_readdata16(Stream &s)
|
||||
{
|
||||
uint16_t obj;
|
||||
s.read((char*)&obj, 2);
|
||||
return le16toh(obj);
|
||||
}
|
||||
template<typename Stream> inline uint32_t ser_readdata32(Stream &s)
|
||||
{
|
||||
uint32_t obj;
|
||||
s.read((char*)&obj, 4);
|
||||
return le32toh(obj);
|
||||
}
|
||||
template<typename Stream> inline uint64_t ser_readdata64(Stream &s)
|
||||
{
|
||||
uint64_t obj;
|
||||
s.read((char*)&obj, 8);
|
||||
return le64toh(obj);
|
||||
}
|
||||
inline uint64_t ser_double_to_uint64(double x)
|
||||
{
|
||||
union { double x; uint64_t y; } tmp;
|
||||
tmp.x = x;
|
||||
return tmp.y;
|
||||
}
|
||||
inline uint32_t ser_float_to_uint32(float x)
|
||||
{
|
||||
union { float x; uint32_t y; } tmp;
|
||||
tmp.x = x;
|
||||
return tmp.y;
|
||||
}
|
||||
inline double ser_uint64_to_double(uint64_t y)
|
||||
{
|
||||
union { double x; uint64_t y; } tmp;
|
||||
tmp.y = y;
|
||||
return tmp.x;
|
||||
}
|
||||
inline float ser_uint32_to_float(uint32_t y)
|
||||
{
|
||||
union { float x; uint32_t y; } tmp;
|
||||
tmp.y = y;
|
||||
return tmp.x;
|
||||
}
|
||||
|
||||
|
||||
/////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Templates for serializing to anything that looks like a stream,
|
||||
// i.e. anything that supports .read(char*, size_t) and .write(char*, size_t)
|
||||
//
|
||||
|
||||
enum
|
||||
{
|
||||
// primary actions
|
||||
SER_NETWORK = (1 << 0),
|
||||
SER_DISK = (1 << 1),
|
||||
SER_GETHASH = (1 << 2),
|
||||
};
|
||||
|
||||
#define READWRITE(obj) (::SerReadWrite(s, (obj), nType, nVersion, ser_action))
|
||||
|
||||
/**
|
||||
* Implement three methods for serializable objects. These are actually wrappers over
|
||||
* "SerializationOp" template, which implements the body of each class' serialization
|
||||
* code. Adding "ADD_SERIALIZE_METHODS" in the body of the class causes these wrappers to be
|
||||
* added as members.
|
||||
*/
|
||||
#define ADD_SERIALIZE_METHODS \
|
||||
size_t GetSerializeSize(int nType, int nVersion) const { \
|
||||
CSizeComputer s(nType, nVersion); \
|
||||
NCONST_PTR(this)->SerializationOp(s, CSerActionSerialize(), nType, nVersion);\
|
||||
return s.size(); \
|
||||
} \
|
||||
template<typename Stream> \
|
||||
void Serialize(Stream& s, int nType, int nVersion) const { \
|
||||
NCONST_PTR(this)->SerializationOp(s, CSerActionSerialize(), nType, nVersion);\
|
||||
} \
|
||||
template<typename Stream> \
|
||||
void Unserialize(Stream& s, int nType, int nVersion) { \
|
||||
SerializationOp(s, CSerActionUnserialize(), nType, nVersion); \
|
||||
}
|
||||
|
||||
/*
|
||||
* Basic Types
|
||||
*/
|
||||
inline unsigned int GetSerializeSize(char a, int, int=0) { return 1; }
|
||||
inline unsigned int GetSerializeSize(int8_t a, int, int=0) { return 1; }
|
||||
inline unsigned int GetSerializeSize(uint8_t a, int, int=0) { return 1; }
|
||||
inline unsigned int GetSerializeSize(int16_t a, int, int=0) { return 2; }
|
||||
inline unsigned int GetSerializeSize(uint16_t a, int, int=0) { return 2; }
|
||||
inline unsigned int GetSerializeSize(int32_t a, int, int=0) { return 4; }
|
||||
inline unsigned int GetSerializeSize(uint32_t a, int, int=0) { return 4; }
|
||||
inline unsigned int GetSerializeSize(int64_t a, int, int=0) { return 8; }
|
||||
inline unsigned int GetSerializeSize(uint64_t a, int, int=0) { return 8; }
|
||||
inline unsigned int GetSerializeSize(float a, int, int=0) { return 4; }
|
||||
inline unsigned int GetSerializeSize(double a, int, int=0) { return 8; }
|
||||
|
||||
template<typename Stream> inline void Serialize(Stream& s, char a, int, int=0) { ser_writedata8(s, a); } // TODO Get rid of bare char
|
||||
template<typename Stream> inline void Serialize(Stream& s, int8_t a, int, int=0) { ser_writedata8(s, a); }
|
||||
template<typename Stream> inline void Serialize(Stream& s, uint8_t a, int, int=0) { ser_writedata8(s, a); }
|
||||
template<typename Stream> inline void Serialize(Stream& s, int16_t a, int, int=0) { ser_writedata16(s, a); }
|
||||
template<typename Stream> inline void Serialize(Stream& s, uint16_t a, int, int=0) { ser_writedata16(s, a); }
|
||||
template<typename Stream> inline void Serialize(Stream& s, int32_t a, int, int=0) { ser_writedata32(s, a); }
|
||||
template<typename Stream> inline void Serialize(Stream& s, uint32_t a, int, int=0) { ser_writedata32(s, a); }
|
||||
template<typename Stream> inline void Serialize(Stream& s, int64_t a, int, int=0) { ser_writedata64(s, a); }
|
||||
template<typename Stream> inline void Serialize(Stream& s, uint64_t a, int, int=0) { ser_writedata64(s, a); }
|
||||
template<typename Stream> inline void Serialize(Stream& s, float a, int, int=0) { ser_writedata32(s, ser_float_to_uint32(a)); }
|
||||
template<typename Stream> inline void Serialize(Stream& s, double a, int, int=0) { ser_writedata64(s, ser_double_to_uint64(a)); }
|
||||
|
||||
template<typename Stream> inline void Unserialize(Stream& s, char& a, int, int=0) { a = ser_readdata8(s); } // TODO Get rid of bare char
|
||||
template<typename Stream> inline void Unserialize(Stream& s, int8_t& a, int, int=0) { a = ser_readdata8(s); }
|
||||
template<typename Stream> inline void Unserialize(Stream& s, uint8_t& a, int, int=0) { a = ser_readdata8(s); }
|
||||
template<typename Stream> inline void Unserialize(Stream& s, int16_t& a, int, int=0) { a = ser_readdata16(s); }
|
||||
template<typename Stream> inline void Unserialize(Stream& s, uint16_t& a, int, int=0) { a = ser_readdata16(s); }
|
||||
template<typename Stream> inline void Unserialize(Stream& s, int32_t& a, int, int=0) { a = ser_readdata32(s); }
|
||||
template<typename Stream> inline void Unserialize(Stream& s, uint32_t& a, int, int=0) { a = ser_readdata32(s); }
|
||||
template<typename Stream> inline void Unserialize(Stream& s, int64_t& a, int, int=0) { a = ser_readdata64(s); }
|
||||
template<typename Stream> inline void Unserialize(Stream& s, uint64_t& a, int, int=0) { a = ser_readdata64(s); }
|
||||
template<typename Stream> inline void Unserialize(Stream& s, float& a, int, int=0) { a = ser_uint32_to_float(ser_readdata32(s)); }
|
||||
template<typename Stream> inline void Unserialize(Stream& s, double& a, int, int=0) { a = ser_uint64_to_double(ser_readdata64(s)); }
|
||||
|
||||
inline unsigned int GetSerializeSize(bool a, int, int=0) { return sizeof(char); }
|
||||
template<typename Stream> inline void Serialize(Stream& s, bool a, int, int=0) { char f=a; ser_writedata8(s, f); }
|
||||
template<typename Stream> inline void Unserialize(Stream& s, bool& a, int, int=0) { char f=ser_readdata8(s); a=f; }
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Compact Size
|
||||
* size < 253 -- 1 byte
|
||||
* size <= USHRT_MAX -- 3 bytes (253 + 2 bytes)
|
||||
* size <= UINT_MAX -- 5 bytes (254 + 4 bytes)
|
||||
* size > UINT_MAX -- 9 bytes (255 + 8 bytes)
|
||||
*/
|
||||
inline unsigned int GetSizeOfCompactSize(uint64_t nSize)
|
||||
{
|
||||
if (nSize < 253) return sizeof(unsigned char);
|
||||
else if (nSize <= std::numeric_limits<unsigned short>::max()) return sizeof(unsigned char) + sizeof(unsigned short);
|
||||
else if (nSize <= std::numeric_limits<unsigned int>::max()) return sizeof(unsigned char) + sizeof(unsigned int);
|
||||
else return sizeof(unsigned char) + sizeof(uint64_t);
|
||||
}
|
||||
|
||||
template<typename Stream>
|
||||
void WriteCompactSize(Stream& os, uint64_t nSize)
|
||||
{
|
||||
if (nSize < 253)
|
||||
{
|
||||
ser_writedata8(os, nSize);
|
||||
}
|
||||
else if (nSize <= std::numeric_limits<unsigned short>::max())
|
||||
{
|
||||
ser_writedata8(os, 253);
|
||||
ser_writedata16(os, nSize);
|
||||
}
|
||||
else if (nSize <= std::numeric_limits<unsigned int>::max())
|
||||
{
|
||||
ser_writedata8(os, 254);
|
||||
ser_writedata32(os, nSize);
|
||||
}
|
||||
else
|
||||
{
|
||||
ser_writedata8(os, 255);
|
||||
ser_writedata64(os, nSize);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
template<typename Stream>
|
||||
uint64_t ReadCompactSize(Stream& is)
|
||||
{
|
||||
uint8_t chSize = ser_readdata8(is);
|
||||
uint64_t nSizeRet = 0;
|
||||
if (chSize < 253)
|
||||
{
|
||||
nSizeRet = chSize;
|
||||
}
|
||||
else if (chSize == 253)
|
||||
{
|
||||
nSizeRet = ser_readdata16(is);
|
||||
if (nSizeRet < 253)
|
||||
throw std::ios_base::failure("non-canonical ReadCompactSize()");
|
||||
}
|
||||
else if (chSize == 254)
|
||||
{
|
||||
nSizeRet = ser_readdata32(is);
|
||||
if (nSizeRet < 0x10000u)
|
||||
throw std::ios_base::failure("non-canonical ReadCompactSize()");
|
||||
}
|
||||
else
|
||||
{
|
||||
nSizeRet = ser_readdata64(is);
|
||||
if (nSizeRet < 0x100000000ULL)
|
||||
throw std::ios_base::failure("non-canonical ReadCompactSize()");
|
||||
}
|
||||
if (nSizeRet > (uint64_t)MAX_SIZE)
|
||||
throw std::ios_base::failure("ReadCompactSize(): size too large");
|
||||
return nSizeRet;
|
||||
}
|
||||
|
||||
/**
|
||||
* Variable-length integers: bytes are a MSB base-128 encoding of the number.
|
||||
* The high bit in each byte signifies whether another digit follows. To make
|
||||
* sure the encoding is one-to-one, one is subtracted from all but the last digit.
|
||||
* Thus, the byte sequence a[] with length len, where all but the last byte
|
||||
* has bit 128 set, encodes the number:
|
||||
*
|
||||
* (a[len-1] & 0x7F) + sum(i=1..len-1, 128^i*((a[len-i-1] & 0x7F)+1))
|
||||
*
|
||||
* Properties:
|
||||
* * Very small (0-127: 1 byte, 128-16511: 2 bytes, 16512-2113663: 3 bytes)
|
||||
* * Every integer has exactly one encoding
|
||||
* * Encoding does not depend on size of original integer type
|
||||
* * No redundancy: every (infinite) byte sequence corresponds to a list
|
||||
* of encoded integers.
|
||||
*
|
||||
* 0: [0x00] 256: [0x81 0x00]
|
||||
* 1: [0x01] 16383: [0xFE 0x7F]
|
||||
* 127: [0x7F] 16384: [0xFF 0x00]
|
||||
* 128: [0x80 0x00] 16511: [0x80 0xFF 0x7F]
|
||||
* 255: [0x80 0x7F] 65535: [0x82 0xFD 0x7F]
|
||||
* 2^32: [0x8E 0xFE 0xFE 0xFF 0x00]
|
||||
*/
|
||||
|
||||
template<typename I>
|
||||
inline unsigned int GetSizeOfVarInt(I n)
|
||||
{
|
||||
int nRet = 0;
|
||||
while(true) {
|
||||
nRet++;
|
||||
if (n <= 0x7F)
|
||||
break;
|
||||
n = (n >> 7) - 1;
|
||||
}
|
||||
return nRet;
|
||||
}
|
||||
|
||||
template<typename Stream, typename I>
|
||||
void WriteVarInt(Stream& os, I n)
|
||||
{
|
||||
unsigned char tmp[(sizeof(n)*8+6)/7];
|
||||
int len=0;
|
||||
while(true) {
|
||||
tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
|
||||
if (n <= 0x7F)
|
||||
break;
|
||||
n = (n >> 7) - 1;
|
||||
len++;
|
||||
}
|
||||
do {
|
||||
ser_writedata8(os, tmp[len]);
|
||||
} while(len--);
|
||||
}
|
||||
|
||||
template<typename Stream, typename I>
|
||||
I ReadVarInt(Stream& is)
|
||||
{
|
||||
I n = 0;
|
||||
while(true) {
|
||||
unsigned char chData = ser_readdata8(is);
|
||||
n = (n << 7) | (chData & 0x7F);
|
||||
if (chData & 0x80)
|
||||
n++;
|
||||
else
|
||||
return n;
|
||||
}
|
||||
}
|
||||
|
||||
#define FLATDATA(obj) REF(CFlatData((char*)&(obj), (char*)&(obj) + sizeof(obj)))
|
||||
#define VARINT(obj) REF(WrapVarInt(REF(obj)))
|
||||
#define LIMITED_STRING(obj,n) REF(LimitedString< n >(REF(obj)))
|
||||
|
||||
/**
|
||||
* Wrapper for serializing arrays and POD.
|
||||
*/
|
||||
class CFlatData
|
||||
{
|
||||
protected:
|
||||
char* pbegin;
|
||||
char* pend;
|
||||
public:
|
||||
CFlatData(void* pbeginIn, void* pendIn) : pbegin((char*)pbeginIn), pend((char*)pendIn) { }
|
||||
template <class T, class TAl>
|
||||
explicit CFlatData(std::vector<T,TAl> &v)
|
||||
{
|
||||
pbegin = (char*)begin_ptr(v);
|
||||
pend = (char*)end_ptr(v);
|
||||
}
|
||||
char* begin() { return pbegin; }
|
||||
const char* begin() const { return pbegin; }
|
||||
char* end() { return pend; }
|
||||
const char* end() const { return pend; }
|
||||
|
||||
unsigned int GetSerializeSize(int, int=0) const
|
||||
{
|
||||
return pend - pbegin;
|
||||
}
|
||||
|
||||
template<typename Stream>
|
||||
void Serialize(Stream& s, int, int=0) const
|
||||
{
|
||||
s.write(pbegin, pend - pbegin);
|
||||
}
|
||||
|
||||
template<typename Stream>
|
||||
void Unserialize(Stream& s, int, int=0)
|
||||
{
|
||||
s.read(pbegin, pend - pbegin);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename I>
|
||||
class CVarInt
|
||||
{
|
||||
protected:
|
||||
I &n;
|
||||
public:
|
||||
CVarInt(I& nIn) : n(nIn) { }
|
||||
|
||||
unsigned int GetSerializeSize(int, int) const {
|
||||
return GetSizeOfVarInt<I>(n);
|
||||
}
|
||||
|
||||
template<typename Stream>
|
||||
void Serialize(Stream &s, int, int) const {
|
||||
WriteVarInt<Stream,I>(s, n);
|
||||
}
|
||||
|
||||
template<typename Stream>
|
||||
void Unserialize(Stream& s, int, int) {
|
||||
n = ReadVarInt<Stream,I>(s);
|
||||
}
|
||||
};
|
||||
|
||||
template<size_t Limit>
|
||||
class LimitedString
|
||||
{
|
||||
protected:
|
||||
std::string& string;
|
||||
public:
|
||||
LimitedString(std::string& string) : string(string) {}
|
||||
|
||||
template<typename Stream>
|
||||
void Unserialize(Stream& s, int, int=0)
|
||||
{
|
||||
size_t size = ReadCompactSize(s);
|
||||
if (size > Limit) {
|
||||
throw std::ios_base::failure("String length limit exceeded");
|
||||
}
|
||||
string.resize(size);
|
||||
if (size != 0)
|
||||
s.read((char*)&string[0], size);
|
||||
}
|
||||
|
||||
template<typename Stream>
|
||||
void Serialize(Stream& s, int, int=0) const
|
||||
{
|
||||
WriteCompactSize(s, string.size());
|
||||
if (!string.empty())
|
||||
s.write((char*)&string[0], string.size());
|
||||
}
|
||||
|
||||
unsigned int GetSerializeSize(int, int=0) const
|
||||
{
|
||||
return GetSizeOfCompactSize(string.size()) + string.size();
|
||||
}
|
||||
};
|
||||
|
||||
template<typename I>
|
||||
CVarInt<I> WrapVarInt(I& n) { return CVarInt<I>(n); }
|
||||
|
||||
/**
|
||||
* Forward declarations
|
||||
*/
|
||||
|
||||
/**
|
||||
* string
|
||||
*/
|
||||
template<typename C> unsigned int GetSerializeSize(const std::basic_string<C>& str, int, int=0);
|
||||
template<typename Stream, typename C> void Serialize(Stream& os, const std::basic_string<C>& str, int, int=0);
|
||||
template<typename Stream, typename C> void Unserialize(Stream& is, std::basic_string<C>& str, int, int=0);
|
||||
|
||||
/**
|
||||
* vector
|
||||
* vectors of unsigned char are a special case and are intended to be serialized as a single opaque blob.
|
||||
*/
|
||||
template<typename T, typename A> unsigned int GetSerializeSize_impl(const std::vector<T, A>& v, int nType, int nVersion, const unsigned char&);
|
||||
template<typename T, typename A, typename V> unsigned int GetSerializeSize_impl(const std::vector<T, A>& v, int nType, int nVersion, const V&);
|
||||
template<typename T, typename A> inline unsigned int GetSerializeSize(const std::vector<T, A>& v, int nType, int nVersion);
|
||||
template<typename Stream, typename T, typename A> void Serialize_impl(Stream& os, const std::vector<T, A>& v, int nType, int nVersion, const unsigned char&);
|
||||
template<typename Stream, typename T, typename A, typename V> void Serialize_impl(Stream& os, const std::vector<T, A>& v, int nType, int nVersion, const V&);
|
||||
template<typename Stream, typename T, typename A> inline void Serialize(Stream& os, const std::vector<T, A>& v, int nType, int nVersion);
|
||||
template<typename Stream, typename T, typename A> void Unserialize_impl(Stream& is, std::vector<T, A>& v, int nType, int nVersion, const unsigned char&);
|
||||
template<typename Stream, typename T, typename A, typename V> void Unserialize_impl(Stream& is, std::vector<T, A>& v, int nType, int nVersion, const V&);
|
||||
template<typename Stream, typename T, typename A> inline void Unserialize(Stream& is, std::vector<T, A>& v, int nType, int nVersion);
|
||||
|
||||
/**
|
||||
* others derived from vector
|
||||
*/
|
||||
extern inline unsigned int GetSerializeSize(const CScript& v, int nType, int nVersion);
|
||||
template<typename Stream> void Serialize(Stream& os, const CScript& v, int nType, int nVersion);
|
||||
template<typename Stream> void Unserialize(Stream& is, CScript& v, int nType, int nVersion);
|
||||
|
||||
/**
|
||||
* pair
|
||||
*/
|
||||
template<typename K, typename T> unsigned int GetSerializeSize(const std::pair<K, T>& item, int nType, int nVersion);
|
||||
template<typename Stream, typename K, typename T> void Serialize(Stream& os, const std::pair<K, T>& item, int nType, int nVersion);
|
||||
template<typename Stream, typename K, typename T> void Unserialize(Stream& is, std::pair<K, T>& item, int nType, int nVersion);
|
||||
|
||||
/**
|
||||
* map
|
||||
*/
|
||||
template<typename K, typename T, typename Pred, typename A> unsigned int GetSerializeSize(const std::map<K, T, Pred, A>& m, int nType, int nVersion);
|
||||
template<typename Stream, typename K, typename T, typename Pred, typename A> void Serialize(Stream& os, const std::map<K, T, Pred, A>& m, int nType, int nVersion);
|
||||
template<typename Stream, typename K, typename T, typename Pred, typename A> void Unserialize(Stream& is, std::map<K, T, Pred, A>& m, int nType, int nVersion);
|
||||
|
||||
/**
|
||||
* set
|
||||
*/
|
||||
template<typename K, typename Pred, typename A> unsigned int GetSerializeSize(const std::set<K, Pred, A>& m, int nType, int nVersion);
|
||||
template<typename Stream, typename K, typename Pred, typename A> void Serialize(Stream& os, const std::set<K, Pred, A>& m, int nType, int nVersion);
|
||||
template<typename Stream, typename K, typename Pred, typename A> void Unserialize(Stream& is, std::set<K, Pred, A>& m, int nType, int nVersion);
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* If none of the specialized versions above matched, default to calling member function.
|
||||
* "int nType" is changed to "long nType" to keep from getting an ambiguous overload error.
|
||||
* The compiler will only cast int to long if none of the other templates matched.
|
||||
* Thanks to Boost serialization for this idea.
|
||||
*/
|
||||
template<typename T>
|
||||
inline unsigned int GetSerializeSize(const T& a, long nType, int nVersion)
|
||||
{
|
||||
return a.GetSerializeSize((int)nType, nVersion);
|
||||
}
|
||||
|
||||
template<typename Stream, typename T>
|
||||
inline void Serialize(Stream& os, const T& a, long nType, int nVersion)
|
||||
{
|
||||
a.Serialize(os, (int)nType, nVersion);
|
||||
}
|
||||
|
||||
template<typename Stream, typename T>
|
||||
inline void Unserialize(Stream& is, T& a, long nType, int nVersion)
|
||||
{
|
||||
a.Unserialize(is, (int)nType, nVersion);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* string
|
||||
*/
|
||||
template<typename C>
|
||||
unsigned int GetSerializeSize(const std::basic_string<C>& str, int, int)
|
||||
{
|
||||
return GetSizeOfCompactSize(str.size()) + str.size() * sizeof(str[0]);
|
||||
}
|
||||
|
||||
template<typename Stream, typename C>
|
||||
void Serialize(Stream& os, const std::basic_string<C>& str, int, int)
|
||||
{
|
||||
WriteCompactSize(os, str.size());
|
||||
if (!str.empty())
|
||||
os.write((char*)&str[0], str.size() * sizeof(str[0]));
|
||||
}
|
||||
|
||||
template<typename Stream, typename C>
|
||||
void Unserialize(Stream& is, std::basic_string<C>& str, int, int)
|
||||
{
|
||||
unsigned int nSize = ReadCompactSize(is);
|
||||
str.resize(nSize);
|
||||
if (nSize != 0)
|
||||
is.read((char*)&str[0], nSize * sizeof(str[0]));
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* vector
|
||||
*/
|
||||
template<typename T, typename A>
|
||||
unsigned int GetSerializeSize_impl(const std::vector<T, A>& v, int nType, int nVersion, const unsigned char&)
|
||||
{
|
||||
return (GetSizeOfCompactSize(v.size()) + v.size() * sizeof(T));
|
||||
}
|
||||
|
||||
template<typename T, typename A, typename V>
|
||||
unsigned int GetSerializeSize_impl(const std::vector<T, A>& v, int nType, int nVersion, const V&)
|
||||
{
|
||||
unsigned int nSize = GetSizeOfCompactSize(v.size());
|
||||
for (typename std::vector<T, A>::const_iterator vi = v.begin(); vi != v.end(); ++vi)
|
||||
nSize += GetSerializeSize((*vi), nType, nVersion);
|
||||
return nSize;
|
||||
}
|
||||
|
||||
template<typename T, typename A>
|
||||
inline unsigned int GetSerializeSize(const std::vector<T, A>& v, int nType, int nVersion)
|
||||
{
|
||||
return GetSerializeSize_impl(v, nType, nVersion, T());
|
||||
}
|
||||
|
||||
|
||||
template<typename Stream, typename T, typename A>
|
||||
void Serialize_impl(Stream& os, const std::vector<T, A>& v, int nType, int nVersion, const unsigned char&)
|
||||
{
|
||||
WriteCompactSize(os, v.size());
|
||||
if (!v.empty())
|
||||
os.write((char*)&v[0], v.size() * sizeof(T));
|
||||
}
|
||||
|
||||
template<typename Stream, typename T, typename A, typename V>
|
||||
void Serialize_impl(Stream& os, const std::vector<T, A>& v, int nType, int nVersion, const V&)
|
||||
{
|
||||
WriteCompactSize(os, v.size());
|
||||
for (typename std::vector<T, A>::const_iterator vi = v.begin(); vi != v.end(); ++vi)
|
||||
::Serialize(os, (*vi), nType, nVersion);
|
||||
}
|
||||
|
||||
template<typename Stream, typename T, typename A>
|
||||
inline void Serialize(Stream& os, const std::vector<T, A>& v, int nType, int nVersion)
|
||||
{
|
||||
Serialize_impl(os, v, nType, nVersion, T());
|
||||
}
|
||||
|
||||
|
||||
template<typename Stream, typename T, typename A>
|
||||
void Unserialize_impl(Stream& is, std::vector<T, A>& v, int nType, int nVersion, const unsigned char&)
|
||||
{
|
||||
// Limit size per read so bogus size value won't cause out of memory
|
||||
v.clear();
|
||||
unsigned int nSize = ReadCompactSize(is);
|
||||
unsigned int i = 0;
|
||||
while (i < nSize)
|
||||
{
|
||||
unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
|
||||
v.resize(i + blk);
|
||||
is.read((char*)&v[i], blk * sizeof(T));
|
||||
i += blk;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename Stream, typename T, typename A, typename V>
|
||||
void Unserialize_impl(Stream& is, std::vector<T, A>& v, int nType, int nVersion, const V&)
|
||||
{
|
||||
v.clear();
|
||||
unsigned int nSize = ReadCompactSize(is);
|
||||
unsigned int i = 0;
|
||||
unsigned int nMid = 0;
|
||||
while (nMid < nSize)
|
||||
{
|
||||
nMid += 5000000 / sizeof(T);
|
||||
if (nMid > nSize)
|
||||
nMid = nSize;
|
||||
v.resize(nMid);
|
||||
for (; i < nMid; i++)
|
||||
Unserialize(is, v[i], nType, nVersion);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename Stream, typename T, typename A>
|
||||
inline void Unserialize(Stream& is, std::vector<T, A>& v, int nType, int nVersion)
|
||||
{
|
||||
Unserialize_impl(is, v, nType, nVersion, T());
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* others derived from vector
|
||||
*/
|
||||
inline unsigned int GetSerializeSize(const CScript& v, int nType, int nVersion)
|
||||
{
|
||||
return GetSerializeSize((const std::vector<unsigned char>&)v, nType, nVersion);
|
||||
}
|
||||
|
||||
template<typename Stream>
|
||||
void Serialize(Stream& os, const CScript& v, int nType, int nVersion)
|
||||
{
|
||||
Serialize(os, (const std::vector<unsigned char>&)v, nType, nVersion);
|
||||
}
|
||||
|
||||
template<typename Stream>
|
||||
void Unserialize(Stream& is, CScript& v, int nType, int nVersion)
|
||||
{
|
||||
Unserialize(is, (std::vector<unsigned char>&)v, nType, nVersion);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* pair
|
||||
*/
|
||||
template<typename K, typename T>
|
||||
unsigned int GetSerializeSize(const std::pair<K, T>& item, int nType, int nVersion)
|
||||
{
|
||||
return GetSerializeSize(item.first, nType, nVersion) + GetSerializeSize(item.second, nType, nVersion);
|
||||
}
|
||||
|
||||
template<typename Stream, typename K, typename T>
|
||||
void Serialize(Stream& os, const std::pair<K, T>& item, int nType, int nVersion)
|
||||
{
|
||||
Serialize(os, item.first, nType, nVersion);
|
||||
Serialize(os, item.second, nType, nVersion);
|
||||
}
|
||||
|
||||
template<typename Stream, typename K, typename T>
|
||||
void Unserialize(Stream& is, std::pair<K, T>& item, int nType, int nVersion)
|
||||
{
|
||||
Unserialize(is, item.first, nType, nVersion);
|
||||
Unserialize(is, item.second, nType, nVersion);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* map
|
||||
*/
|
||||
template<typename K, typename T, typename Pred, typename A>
|
||||
unsigned int GetSerializeSize(const std::map<K, T, Pred, A>& m, int nType, int nVersion)
|
||||
{
|
||||
unsigned int nSize = GetSizeOfCompactSize(m.size());
|
||||
for (typename std::map<K, T, Pred, A>::const_iterator mi = m.begin(); mi != m.end(); ++mi)
|
||||
nSize += GetSerializeSize((*mi), nType, nVersion);
|
||||
return nSize;
|
||||
}
|
||||
|
||||
template<typename Stream, typename K, typename T, typename Pred, typename A>
|
||||
void Serialize(Stream& os, const std::map<K, T, Pred, A>& m, int nType, int nVersion)
|
||||
{
|
||||
WriteCompactSize(os, m.size());
|
||||
for (typename std::map<K, T, Pred, A>::const_iterator mi = m.begin(); mi != m.end(); ++mi)
|
||||
Serialize(os, (*mi), nType, nVersion);
|
||||
}
|
||||
|
||||
template<typename Stream, typename K, typename T, typename Pred, typename A>
|
||||
void Unserialize(Stream& is, std::map<K, T, Pred, A>& m, int nType, int nVersion)
|
||||
{
|
||||
m.clear();
|
||||
unsigned int nSize = ReadCompactSize(is);
|
||||
typename std::map<K, T, Pred, A>::iterator mi = m.begin();
|
||||
for (unsigned int i = 0; i < nSize; i++)
|
||||
{
|
||||
std::pair<K, T> item;
|
||||
Unserialize(is, item, nType, nVersion);
|
||||
mi = m.insert(mi, item);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* set
|
||||
*/
|
||||
template<typename K, typename Pred, typename A>
|
||||
unsigned int GetSerializeSize(const std::set<K, Pred, A>& m, int nType, int nVersion)
|
||||
{
|
||||
unsigned int nSize = GetSizeOfCompactSize(m.size());
|
||||
for (typename std::set<K, Pred, A>::const_iterator it = m.begin(); it != m.end(); ++it)
|
||||
nSize += GetSerializeSize((*it), nType, nVersion);
|
||||
return nSize;
|
||||
}
|
||||
|
||||
template<typename Stream, typename K, typename Pred, typename A>
|
||||
void Serialize(Stream& os, const std::set<K, Pred, A>& m, int nType, int nVersion)
|
||||
{
|
||||
WriteCompactSize(os, m.size());
|
||||
for (typename std::set<K, Pred, A>::const_iterator it = m.begin(); it != m.end(); ++it)
|
||||
Serialize(os, (*it), nType, nVersion);
|
||||
}
|
||||
|
||||
template<typename Stream, typename K, typename Pred, typename A>
|
||||
void Unserialize(Stream& is, std::set<K, Pred, A>& m, int nType, int nVersion)
|
||||
{
|
||||
m.clear();
|
||||
unsigned int nSize = ReadCompactSize(is);
|
||||
typename std::set<K, Pred, A>::iterator it = m.begin();
|
||||
for (unsigned int i = 0; i < nSize; i++)
|
||||
{
|
||||
K key;
|
||||
Unserialize(is, key, nType, nVersion);
|
||||
it = m.insert(it, key);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Support for ADD_SERIALIZE_METHODS and READWRITE macro
|
||||
*/
|
||||
struct CSerActionSerialize
|
||||
{
|
||||
bool ForRead() const { return false; }
|
||||
};
|
||||
struct CSerActionUnserialize
|
||||
{
|
||||
bool ForRead() const { return true; }
|
||||
};
|
||||
|
||||
template<typename Stream, typename T>
|
||||
inline void SerReadWrite(Stream& s, const T& obj, int nType, int nVersion, CSerActionSerialize ser_action)
|
||||
{
|
||||
::Serialize(s, obj, nType, nVersion);
|
||||
}
|
||||
|
||||
template<typename Stream, typename T>
|
||||
inline void SerReadWrite(Stream& s, T& obj, int nType, int nVersion, CSerActionUnserialize ser_action)
|
||||
{
|
||||
::Unserialize(s, obj, nType, nVersion);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class CSizeComputer
|
||||
{
|
||||
protected:
|
||||
size_t nSize;
|
||||
|
||||
public:
|
||||
int nType;
|
||||
int nVersion;
|
||||
|
||||
CSizeComputer(int nTypeIn, int nVersionIn) : nSize(0), nType(nTypeIn), nVersion(nVersionIn) {}
|
||||
|
||||
CSizeComputer& write(const char *psz, size_t nSize)
|
||||
{
|
||||
this->nSize += nSize;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
CSizeComputer& operator<<(const T& obj)
|
||||
{
|
||||
::Serialize(*this, obj, nType, nVersion);
|
||||
return (*this);
|
||||
}
|
||||
|
||||
size_t size() const {
|
||||
return nSize;
|
||||
}
|
||||
};
|
||||
|
||||
#endif // BITCOIN_SERIALIZE_H
|
||||
@@ -355,7 +355,6 @@ extern "C" int scanhash_skeincoin(int thr_id, uint32_t *pdata, const uint32_t *p
|
||||
const int swap = 1;
|
||||
|
||||
bool sm5 = (device_sm[device_map[thr_id]] >= 500);
|
||||
bool checkSecnonce = (have_stratum || have_longpoll) && !sm5;
|
||||
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1U << 20);
|
||||
throughput = min(throughput, (max_nonce - first_nonce));
|
||||
@@ -417,7 +416,7 @@ extern "C" int scanhash_skeincoin(int thr_id, uint32_t *pdata, const uint32_t *p
|
||||
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
|
||||
int res = 1;
|
||||
uint8_t num = res;
|
||||
if (checkSecnonce) {
|
||||
if (!sm5) {
|
||||
secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], num);
|
||||
}
|
||||
while (secNonce != 0 && res < 2) /* todo: up to 6 */
|
||||
@@ -430,10 +429,7 @@ extern "C" int scanhash_skeincoin(int thr_id, uint32_t *pdata, const uint32_t *p
|
||||
res++;
|
||||
}
|
||||
num++;
|
||||
//if (checkSecnonce)
|
||||
// secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], num);
|
||||
//else
|
||||
break; // only one secNonce...
|
||||
secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], num);
|
||||
}
|
||||
if (res > 1 && opt_debug)
|
||||
applog(LOG_BLUE, "GPU #%d: %d/%d valid nonces !!!", device_map[thr_id], res, (int)num);
|
||||
@@ -445,8 +441,7 @@ extern "C" int scanhash_skeincoin(int thr_id, uint32_t *pdata, const uint32_t *p
|
||||
}
|
||||
}
|
||||
|
||||
if ((uint64_t) throughput + pdata[19] > max_nonce) {
|
||||
//applog(LOG_DEBUG, "done... max=%u", max_nonce);
|
||||
if ((uint64_t) pdata[19] + throughput > max_nonce) {
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
pdata[19] = max_nonce;
|
||||
break;
|
||||
|
||||
+1
-1
@@ -101,7 +101,7 @@ int scanhash_skein2(int thr_id, uint32_t *pdata, const uint32_t *ptarget,
|
||||
}
|
||||
}
|
||||
|
||||
if ((uint64_t) throughput + pdata[19] > max_nonce) {
|
||||
if ((uint64_t) pdata[19] + throughput > max_nonce) {
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
pdata[19] = max_nonce;
|
||||
break;
|
||||
|
||||
@@ -1770,9 +1770,9 @@ void do_gpu_tests(void)
|
||||
//memcpy(buf, zrtest, 80);
|
||||
//scanhash_zr5(0, (uint32_t*)buf, tgt, zrtest[19]+1, &done);
|
||||
|
||||
//struct timeval tv;
|
||||
//memset(buf, 0, sizeof buf);
|
||||
//scanhash_scrypt_jane(0, (uint32_t*)buf, tgt, NULL, 1, &done, &tv, &tv);
|
||||
struct timeval tv;
|
||||
memset(buf, 0, sizeof buf);
|
||||
scanhash_scrypt_jane(0, (uint32_t*)buf, tgt, NULL, 1, &done, &tv, &tv);
|
||||
|
||||
memset(buf, 0, sizeof buf);
|
||||
scanhash_x11(0, (uint32_t*)buf, tgt, 1, &done);
|
||||
@@ -1814,9 +1814,6 @@ void print_hash_tests(void)
|
||||
blake256hash(&hash[0], &buf[0], 14);
|
||||
printpfx("blake", hash);
|
||||
|
||||
c11hash(&hash[0], &buf[0]);
|
||||
printpfx("c11", hash);
|
||||
|
||||
deephash(&hash[0], &buf[0]);
|
||||
printpfx("deep", hash);
|
||||
|
||||
@@ -1838,7 +1835,7 @@ void print_hash_tests(void)
|
||||
keccak256_hash(&hash[0], &buf[0]);
|
||||
printpfx("keccak", hash);
|
||||
|
||||
luffa_hash(&hash[0], &buf[0]);
|
||||
doomhash(&hash[0], &buf[0]);
|
||||
printpfx("luffa", hash);
|
||||
|
||||
lyra2_hash(&hash[0], &buf[0]);
|
||||
@@ -1856,6 +1853,9 @@ void print_hash_tests(void)
|
||||
pentablakehash(&hash[0], &buf[0]);
|
||||
printpfx("pentablake", hash);
|
||||
|
||||
pluckhash((uint32_t*)&hash[0], (uint32_t*)&buf[0], scratchbuf, 128);
|
||||
printpfx("pluck", hash);
|
||||
|
||||
quarkhash(&hash[0], &buf[0]);
|
||||
printpfx("quark", hash);
|
||||
|
||||
@@ -1877,9 +1877,6 @@ void print_hash_tests(void)
|
||||
s3hash(&hash[0], &buf[0]);
|
||||
printpfx("S3", hash);
|
||||
|
||||
whirlxHash(&hash[0], &buf[0]);
|
||||
printpfx("whirlpoolx", hash);
|
||||
|
||||
x11hash(&hash[0], &buf[0]);
|
||||
printpfx("X11", hash);
|
||||
|
||||
|
||||
-242
@@ -1,242 +0,0 @@
|
||||
extern "C"
|
||||
{
|
||||
#include "sph/sph_blake.h"
|
||||
#include "sph/sph_bmw.h"
|
||||
#include "sph/sph_groestl.h"
|
||||
#include "sph/sph_skein.h"
|
||||
#include "sph/sph_jh.h"
|
||||
#include "sph/sph_keccak.h"
|
||||
|
||||
#include "sph/sph_luffa.h"
|
||||
#include "sph/sph_cubehash.h"
|
||||
#include "sph/sph_shavite.h"
|
||||
#include "sph/sph_simd.h"
|
||||
#include "sph/sph_echo.h"
|
||||
}
|
||||
|
||||
#include "miner.h"
|
||||
#include "cuda_helper.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <memory.h>
|
||||
|
||||
static uint32_t *d_hash[MAX_GPUS];
|
||||
|
||||
extern void quark_blake512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_blake512_cpu_setBlock_80(int thr_id, uint32_t *pdata);
|
||||
extern void quark_blake512_cpu_hash_80(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_hash);
|
||||
|
||||
extern void quark_bmw512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_bmw512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void quark_groestl512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_groestl512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
extern void quark_doublegroestl512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void quark_skein512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_skein512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void quark_keccak512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_keccak512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void quark_jh512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_jh512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void x11_luffaCubehash512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void x11_luffaCubehash512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t *d_hash, int order);
|
||||
|
||||
extern void x11_shavite512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void x11_shavite512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern int x11_simd512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void x11_simd512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void x11_echo512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void x11_echo512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void quark_compactTest_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_compactTest_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *inpHashes,
|
||||
uint32_t *d_noncesTrue, size_t *nrmTrue, uint32_t *d_noncesFalse, size_t *nrmFalse, int order);
|
||||
|
||||
// Flax/C11 CPU Hash
|
||||
extern "C" void c11hash(void *output, const void *input)
|
||||
{
|
||||
// blake1-bmw2-grs3-skein4-jh5-keccak6-luffa7-cubehash8-shavite9-simd10-echo11
|
||||
|
||||
sph_blake512_context ctx_blake;
|
||||
sph_bmw512_context ctx_bmw;
|
||||
sph_groestl512_context ctx_groestl;
|
||||
sph_jh512_context ctx_jh;
|
||||
sph_keccak512_context ctx_keccak;
|
||||
sph_skein512_context ctx_skein;
|
||||
sph_luffa512_context ctx_luffa;
|
||||
sph_cubehash512_context ctx_cubehash;
|
||||
sph_shavite512_context ctx_shavite;
|
||||
sph_simd512_context ctx_simd;
|
||||
sph_echo512_context ctx_echo;
|
||||
|
||||
unsigned char hash[128];
|
||||
memset(hash, 0, sizeof hash);
|
||||
|
||||
sph_blake512_init(&ctx_blake);
|
||||
sph_blake512 (&ctx_blake, input, 80);
|
||||
sph_blake512_close(&ctx_blake, (void*) hash);
|
||||
|
||||
sph_bmw512_init(&ctx_bmw);
|
||||
sph_bmw512 (&ctx_bmw, (const void*) hash, 64);
|
||||
sph_bmw512_close(&ctx_bmw, (void*) hash);
|
||||
|
||||
sph_groestl512_init(&ctx_groestl);
|
||||
sph_groestl512 (&ctx_groestl, (const void*) hash, 64);
|
||||
sph_groestl512_close(&ctx_groestl, (void*) hash);
|
||||
|
||||
sph_jh512_init(&ctx_jh);
|
||||
sph_jh512 (&ctx_jh, (const void*) hash, 64);
|
||||
sph_jh512_close(&ctx_jh, (void*) hash);
|
||||
|
||||
sph_keccak512_init(&ctx_keccak);
|
||||
sph_keccak512 (&ctx_keccak, (const void*) hash, 64);
|
||||
sph_keccak512_close(&ctx_keccak, (void*) hash);
|
||||
|
||||
sph_skein512_init(&ctx_skein);
|
||||
sph_skein512 (&ctx_skein, (const void*) hash, 64);
|
||||
sph_skein512_close(&ctx_skein, (void*) hash);
|
||||
|
||||
sph_luffa512_init(&ctx_luffa);
|
||||
sph_luffa512 (&ctx_luffa, (const void*) hash, 64);
|
||||
sph_luffa512_close (&ctx_luffa, (void*) hash);
|
||||
|
||||
sph_cubehash512_init(&ctx_cubehash);
|
||||
sph_cubehash512 (&ctx_cubehash, (const void*) hash, 64);
|
||||
sph_cubehash512_close(&ctx_cubehash, (void*) hash);
|
||||
|
||||
sph_shavite512_init(&ctx_shavite);
|
||||
sph_shavite512 (&ctx_shavite, (const void*) hash, 64);
|
||||
sph_shavite512_close(&ctx_shavite, (void*) hash);
|
||||
|
||||
sph_simd512_init(&ctx_simd);
|
||||
sph_simd512 (&ctx_simd, (const void*) hash, 64);
|
||||
sph_simd512_close(&ctx_simd, (void*) hash);
|
||||
|
||||
sph_echo512_init(&ctx_echo);
|
||||
sph_echo512 (&ctx_echo, (const void*) hash, 64);
|
||||
sph_echo512_close(&ctx_echo, (void*) hash);
|
||||
|
||||
memcpy(output, hash, 32);
|
||||
}
|
||||
|
||||
#ifdef _DEBUG
|
||||
#define TRACE(algo) { \
|
||||
if (max_nonce == 1 && pdata[19] <= 1) { \
|
||||
uint32_t* debugbuf = NULL; \
|
||||
cudaMallocHost(&debugbuf, 8*sizeof(uint32_t)); \
|
||||
cudaMemcpy(debugbuf, d_hash[thr_id], 8*sizeof(uint32_t), cudaMemcpyDeviceToHost); \
|
||||
printf("X11 %s %08x %08x %08x %08x...\n", algo, swab32(debugbuf[0]), swab32(debugbuf[1]), \
|
||||
swab32(debugbuf[2]), swab32(debugbuf[3])); \
|
||||
cudaFreeHost(debugbuf); \
|
||||
} \
|
||||
}
|
||||
#else
|
||||
#define TRACE(algo) {}
|
||||
#endif
|
||||
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
|
||||
extern "C" int scanhash_c11(int thr_id, uint32_t *pdata, const uint32_t *ptarget, uint32_t max_nonce, unsigned long *hashes_done)
|
||||
{
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
int intensity = (device_sm[device_map[thr_id]] >= 500 && !is_windows()) ? 20 : 19;
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1U << intensity); // 19=256*256*8;
|
||||
throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0x5;
|
||||
|
||||
if (!init[thr_id])
|
||||
{
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
|
||||
quark_blake512_cpu_init(thr_id, throughput);
|
||||
quark_bmw512_cpu_init(thr_id, throughput);
|
||||
quark_groestl512_cpu_init(thr_id, throughput);
|
||||
quark_skein512_cpu_init(thr_id, throughput);
|
||||
quark_keccak512_cpu_init(thr_id, throughput);
|
||||
quark_jh512_cpu_init(thr_id, throughput);
|
||||
x11_luffaCubehash512_cpu_init(thr_id, throughput);
|
||||
x11_shavite512_cpu_init(thr_id, throughput);
|
||||
x11_echo512_cpu_init(thr_id, throughput);
|
||||
if (x11_simd512_cpu_init(thr_id, throughput) != 0) {
|
||||
return 0;
|
||||
}
|
||||
CUDA_CALL_OR_RET_X(cudaMalloc(&d_hash[thr_id], 64 * throughput), 0); // why 64 ?
|
||||
|
||||
cuda_check_cpu_init(thr_id, throughput);
|
||||
|
||||
init[thr_id] = true;
|
||||
}
|
||||
|
||||
uint32_t endiandata[20];
|
||||
for (int k=0; k < 20; k++)
|
||||
be32enc(&endiandata[k], pdata[k]);
|
||||
|
||||
quark_blake512_cpu_setBlock_80(thr_id, endiandata);
|
||||
cuda_check_cpu_setTarget(ptarget);
|
||||
|
||||
do {
|
||||
int order = 0;
|
||||
uint32_t foundNonce;
|
||||
|
||||
// Hash with CUDA
|
||||
quark_blake512_cpu_hash_80(thr_id, throughput, pdata[19], d_hash[thr_id]); order++;
|
||||
TRACE("blake :");
|
||||
quark_bmw512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
TRACE("bmw :");
|
||||
quark_groestl512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
TRACE("groestl:");
|
||||
quark_jh512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
TRACE("jh512 :");
|
||||
quark_keccak512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
TRACE("keccak :");
|
||||
quark_skein512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
TRACE("skein :");
|
||||
x11_luffaCubehash512_cpu_hash_64(thr_id, throughput, d_hash[thr_id], order++);
|
||||
TRACE("luffa+c:");
|
||||
x11_shavite512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
TRACE("shavite:");
|
||||
x11_simd512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
TRACE("simd :");
|
||||
x11_echo512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
TRACE("echo => ");
|
||||
|
||||
foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]);
|
||||
if (foundNonce != UINT32_MAX)
|
||||
{
|
||||
const uint32_t Htarg = ptarget[7];
|
||||
uint32_t vhash64[8];
|
||||
be32enc(&endiandata[19], foundNonce);
|
||||
c11hash(vhash64, endiandata);
|
||||
|
||||
if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) {
|
||||
int res = 1;
|
||||
// check if there was some other ones...
|
||||
uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1);
|
||||
*hashes_done = pdata[19] - first_nonce + throughput;
|
||||
if (secNonce != 0) {
|
||||
pdata[21] = secNonce;
|
||||
res++;
|
||||
}
|
||||
pdata[19] = foundNonce;
|
||||
return res;
|
||||
} else {
|
||||
applog(LOG_WARNING, "GPU #%d: result for %08x does not validate on CPU!", device_map[thr_id], foundNonce);
|
||||
pdata[19] = foundNonce + 1;
|
||||
}
|
||||
}
|
||||
|
||||
pdata[19] += throughput;
|
||||
|
||||
} while (pdata[19] < max_nonce && !work_restart[thr_id].restart);
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce + 1;
|
||||
return 0;
|
||||
}
|
||||
+486
-674
File diff suppressed because it is too large.
Load diff
+2
-3
@@ -43,7 +43,7 @@ extern void quark_jh512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_jh512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void x11_luffaCubehash512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void x11_luffaCubehash512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t *d_hash, int order);
|
||||
extern void x11_luffaCubehash512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void x11_shavite512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void x11_shavite512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
@@ -201,7 +201,7 @@ extern "C" int scanhash_x11(int thr_id, uint32_t *pdata,
|
||||
TRACE("jh512 :");
|
||||
quark_keccak512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
TRACE("keccak :");
|
||||
x11_luffaCubehash512_cpu_hash_64(thr_id, throughput, d_hash[thr_id], order++);
|
||||
x11_luffaCubehash512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
TRACE("luffa+c:");
|
||||
x11_shavite512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
TRACE("shavite:");
|
||||
@@ -231,7 +231,6 @@ extern "C" int scanhash_x11(int thr_id, uint32_t *pdata,
|
||||
return res;
|
||||
} else {
|
||||
applog(LOG_WARNING, "GPU #%d: result for %08x does not validate on CPU!", device_map[thr_id], foundNonce);
|
||||
pdata[19] = foundNonce + 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+2
-2
@@ -45,7 +45,7 @@ extern void quark_jh512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_jh512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void x11_luffaCubehash512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void x11_luffaCubehash512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t *d_hash, int order);
|
||||
extern void x11_luffaCubehash512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void x11_shavite512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void x11_shavite512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
@@ -200,7 +200,7 @@ extern "C" int scanhash_x13(int thr_id, uint32_t *pdata,
|
||||
quark_skein512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
quark_jh512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
quark_keccak512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
x11_luffaCubehash512_cpu_hash_64(thr_id, throughput, d_hash[thr_id], order++);
|
||||
x11_luffaCubehash512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
x11_shavite512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
x11_simd512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
x11_echo512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
|
||||
@@ -1,585 +0,0 @@
|
||||
/*
|
||||
* Built on cbuchner1's implementation, actual hashing code
|
||||
* based on sphlib 3.0
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <memory.h>
|
||||
|
||||
#define threadsPerBlock 1024
|
||||
|
||||
#include "cuda_helper.h"
|
||||
|
||||
__constant__ uint64_t c_PaddedMessage80[16]; // padded message (80 bytes + padding)
|
||||
__constant__ uint64_t c_xtra[8];
|
||||
__constant__ uint64_t c_tmp[72];
|
||||
__constant__ uint64_t pTarget[4];
|
||||
|
||||
static uint32_t *h_wxnounce[MAX_GPUS] = { 0 };
|
||||
static uint32_t *d_WXNonce[MAX_GPUS] = { 0 };
|
||||
|
||||
/**
|
||||
* Whirlpool CUDA kernel implementation.
|
||||
*
|
||||
* ==========================(LICENSE BEGIN)============================
|
||||
*
|
||||
* Copyright (c) 2014 djm34 & tpruvot & SP & Provos Alexis
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining
|
||||
* a copy of this software and associated documentation files (the
|
||||
* "Software"), to deal in the Software without restriction, including
|
||||
* without limitation the rights to use, copy, modify, merge, publish,
|
||||
* distribute, sublicense, and/or sell copies of the Software, and to
|
||||
* permit persons to whom the Software is furnished to do so, subject to
|
||||
* the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be
|
||||
* included in all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* ===========================(LICENSE END)=============================
|
||||
* @author djm34
|
||||
* @author tpruvot
|
||||
* @author SP
|
||||
* @author Provos Alexis
|
||||
*/
|
||||
|
||||
__constant__ __align__(64) uint64_t mixTob0Tox[256];
|
||||
|
||||
const uint64_t plain_T0[256]= {
|
||||
0xD83078C018601818,0x2646AF05238C2323,0xB891F97EC63FC6C6,0xFBCD6F13E887E8E8,0xCB13A14C87268787,0x116D62A9B8DAB8B8,0x0902050801040101,0x0D9E6E424F214F4F,0x9B6CEEAD36D83636,
|
||||
0xFF510459A6A2A6A6,0x0CB9BDDED26FD2D2,0x0EF706FBF5F3F5F5,0x96F280EF79F97979,0x30DECE5F6FA16F6F,0x6D3FEFFC917E9191,0xF8A407AA52555252,0x47C0FD27609D6060,0x35657689BCCABCBC,
|
||||
0x372BCDAC9B569B9B,0x8A018C048E028E8E,0xD25B1571A3B6A3A3,0x6C183C600C300C0C,0x84F68AFF7BF17B7B,0x806AE1B535D43535,0xF53A69E81D741D1D,0xB3DD4753E0A7E0E0,0x21B3ACF6D77BD7D7,
|
||||
0x9C99ED5EC22FC2C2,0x435C966D2EB82E2E,0x29967A624B314B4B,0x5DE121A3FEDFFEFE,0xD5AE168257415757,0xBD2A41A815541515,0xE8EEB69F77C17777,0x926EEBA537DC3737,0x9ED7567BE5B3E5E5,
|
||||
0x1323D98C9F469F9F,0x23FD17D3F0E7F0F0,0x20947F6A4A354A4A,0x44A9959EDA4FDADA,0xA2B025FA587D5858,0xCF8FCA06C903C9C9,0x7C528D5529A42929,0x5A1422500A280A0A,0x507F4FE1B1FEB1B1,
|
||||
0xC95D1A69A0BAA0A0,0x14D6DA7F6BB16B6B,0xD917AB5C852E8585,0x3C677381BDCEBDBD,0x8FBA34D25D695D5D,0x9020508010401010,0x07F503F3F4F7F4F4,0xDD8BC016CB0BCBCB,0xD37CC6ED3EF83E3E,
|
||||
0x2D0A112805140505,0x78CEE61F67816767,0x97D55373E4B7E4E4,0x024EBB25279C2727,0x7382583241194141,0xA70B9D2C8B168B8B,0xF6530151A7A6A7A7,0xB2FA94CF7DE97D7D,0x4937FBDC956E9595,
|
||||
0x56AD9F8ED847D8D8,0x70EB308BFBCBFBFB,0xCDC17123EE9FEEEE,0xBBF891C77CED7C7C,0x71CCE31766856666,0x7BA78EA6DD53DDDD,0xAF2E4BB8175C1717,0x458E460247014747,0x1A21DC849E429E9E,
|
||||
0xD489C51ECA0FCACA,0x585A99752DB42D2D,0x2E637991BFC6BFBF,0x3F0E1B38071C0707,0xAC472301AD8EADAD,0xB0B42FEA5A755A5A,0xEF1BB56C83368383,0xB666FF8533CC3333,0x5CC6F23F63916363,
|
||||
0x12040A1002080202,0x93493839AA92AAAA,0xDEE2A8AF71D97171,0xC68DCF0EC807C8C8,0xD1327DC819641919,0x3B92707249394949,0x5FAF9A86D943D9D9,0x31F91DC3F2EFF2F2,0xA8DB484BE3ABE3E3,
|
||||
0xB9B62AE25B715B5B,0xBC0D9234881A8888,0x3E29C8A49A529A9A,0x0B4CBE2D26982626,0xBF64FA8D32C83232,0x597D4AE9B0FAB0B0,0xF2CF6A1BE983E9E9,0x771E33780F3C0F0F,0x33B7A6E6D573D5D5,
|
||||
0xF41DBA74803A8080,0x27617C99BEC2BEBE,0xEB87DE26CD13CDCD,0x8968E4BD34D03434,0x3290757A483D4848,0x54E324ABFFDBFFFF,0x8DF48FF77AF57A7A,0x643DEAF4907A9090,0x9DBE3EC25F615F5F,
|
||||
0x3D40A01D20802020,0x0FD0D56768BD6868,0xCA3472D01A681A1A,0xB7412C19AE82AEAE,0x7D755EC9B4EAB4B4,0xCEA8199A544D5454,0x7F3BE5EC93769393,0x2F44AA0D22882222,0x63C8E907648D6464,
|
||||
0x2AFF12DBF1E3F1F1,0xCCE6A2BF73D17373,0x82245A9012481212,0x7A805D3A401D4040,0x4810284008200808,0x959BE856C32BC3C3,0xDFC57B33EC97ECEC,0x4DAB9096DB4BDBDB,0xC05F1F61A1BEA1A1,
|
||||
0x9107831C8D0E8D8D,0xC87AC9F53DF43D3D,0x5B33F1CC97669797,0x0000000000000000,0xF983D436CF1BCFCF,0x6E5687452BAC2B2B,0xE1ECB39776C57676,0xE619B06482328282,0x28B1A9FED67FD6D6,
|
||||
0xC33677D81B6C1B1B,0x74775BC1B5EEB5B5,0xBE432911AF86AFAF,0x1DD4DF776AB56A6A,0xEAA00DBA505D5050,0x578A4C1245094545,0x38FB18CBF3EBF3F3,0xAD60F09D30C03030,0xC4C3742BEF9BEFEF,
|
||||
0xDA7EC3E53FFC3F3F,0xC7AA1C9255495555,0xDB591079A2B2A2A2,0xE9C96503EA8FEAEA,0x6ACAEC0F65896565,0x036968B9BAD2BABA,0x4A5E93652FBC2F2F,0x8E9DE74EC027C0C0,0x60A181BEDE5FDEDE,
|
||||
0xFC386CE01C701C1C,0x46E72EBBFDD3FDFD,0x1F9A64524D294D4D,0x7639E0E492729292,0xFAEABC8F75C97575,0x360C1E3006180606,0xAE0998248A128A8A,0x4B7940F9B2F2B2B2,0x85D15963E6BFE6E6,
|
||||
0x7E1C36700E380E0E,0xE73E63F81F7C1F1F,0x55C4F73762956262,0x3AB5A3EED477D4D4,0x814D3229A89AA8A8,0x5231F4C496629696,0x62EF3A9BF9C3F9F9,0xA397F666C533C5C5,0x104AB13525942525,
|
||||
0xABB220F259795959,0xD015AE54842A8484,0xC5E4A7B772D57272,0xEC72DDD539E43939,0x1698615A4C2D4C4C,0x94BC3BCA5E655E5E,0x9FF085E778FD7878,0xE570D8DD38E03838,0x980586148C0A8C8C,
|
||||
0x17BFB2C6D163D1D1,0xE4570B41A5AEA5A5,0xA1D94D43E2AFE2E2,0x4EC2F82F61996161,0x427B45F1B3F6B3B3,0x3442A51521842121,0x0825D6949C4A9C9C,0xEE3C66F01E781E1E,0x6186522243114343,
|
||||
0xB193FC76C73BC7C7,0x4FE52BB3FCD7FCFC,0x2408142004100404,0xE3A208B251595151,0x252FC7BC995E9999,0x22DAC44F6DA96D6D,0x651A39680D340D0D,0x79E93583FACFFAFA,0x69A384B6DF5BDFDF,
|
||||
0xA9FC9BD77EE57E7E,0x1948B43D24902424,0xFE76D7C53BEC3B3B,0x9A4B3D31AB96ABAB,0xF081D13ECE1FCECE,0x9922558811441111,0x8303890C8F068F8F,0x049C6B4A4E254E4E,0x667351D1B7E6B7B7,
|
||||
0xE0CB600BEB8BEBEB,0xC178CCFD3CF03C3C,0xFD1FBF7C813E8181,0x4035FED4946A9494,0x1CF30CEBF7FBF7F7,0x186F67A1B9DEB9B9,0x8B265F98134C1313,0x51589C7D2CB02C2C,0x05BBB8D6D36BD3D3,
|
||||
0x8CD35C6BE7BBE7E7,0x39DCCB576EA56E6E,0xAA95F36EC437C4C4,0x1B060F18030C0303,0xDCAC138A56455656,0x5E88491A440D4444,0xA0FE9EDF7FE17F7F,0x884F3721A99EA9A9,0x6754824D2AA82A2A,
|
||||
0x0A6B6DB1BBD6BBBB,0x879FE246C123C1C1,0xF1A602A253515353,0x72A58BAEDC57DCDC,0x531627580B2C0B0B,0x0127D39C9D4E9D9D,0x2BD8C1476CAD6C6C,0xA462F59531C43131,0xF3E8B98774CD7474,
|
||||
0x15F109E3F6FFF6F6,0x4C8C430A46054646,0xA5452609AC8AACAC,0xB50F973C891E8989,0xB42844A014501414,0xBADF425BE1A3E1E1,0xA62C4EB016581616,0xF774D2CD3AE83A3A,0x06D2D06F69B96969,
|
||||
0x41122D4809240909,0xD7E0ADA770DD7070,0x6F7154D9B6E2B6B6,0x1EBDB7CED067D0D0,0xD6C77E3BED93EDED,0xE285DB2ECC17CCCC,0x6884572A42154242,0x2C2DC2B4985A9898,0xED550E49A4AAA4A4,
|
||||
0x7550885D28A02828,0x86B831DA5C6D5C5C,0x6BED3F93F8C7F8F8,0xC211A44486228686
|
||||
};
|
||||
|
||||
/**
|
||||
* Round constants.
|
||||
*/
|
||||
__constant__ uint64_t InitVector_RC[10];
|
||||
|
||||
const uint64_t plain_RC[10] = {
|
||||
0x4F01B887E8C62318,0x52916F79F5D2A636,0x357B0CA38E9BBC60,0x57FE4B2EC2D7E01D,0xDA4AF09FE5377715,
|
||||
0x856BA0B10A29C958,0x67053ECBF4105DBD,0xD8957DA78B4127E4,0x9E4717DD667CEEFB,0x33835AAD07BF2DCA
|
||||
};
|
||||
|
||||
/* ====================================================================== */
|
||||
|
||||
__device__ __forceinline__
|
||||
static uint64_t ROUND_ELT(const uint64_t* sharedMemory, const uint64_t* __restrict__ in, const int i0, const int i1, const int i2, const int i3, const int i4, const int i5, const int i6, const int i7)
|
||||
{
|
||||
uint32_t* in32 = (uint32_t*)in;
|
||||
return xor8( sharedMemory[__byte_perm(in32[(i0 << 1)], 0, 0x4440)],
|
||||
sharedMemory[__byte_perm(in32[(i1 << 1)], 0, 0x4441) + 256],
|
||||
sharedMemory[__byte_perm(in32[(i2 << 1)], 0, 0x4442) + 512],
|
||||
sharedMemory[__byte_perm(in32[(i3 << 1)], 0, 0x4443) + 768],
|
||||
sharedMemory[__byte_perm(in32[(i4 << 1) + 1], 0, 0x4440) + 1024],
|
||||
sharedMemory[__byte_perm(in32[(i5 << 1) + 1], 0, 0x4441) + 1280],
|
||||
sharedMemory[__byte_perm(in32[(i6 << 1) + 1], 0, 0x4442) + 1536],
|
||||
sharedMemory[__byte_perm(in32[(i7 << 1) + 1], 0, 0x4443) + 1792]);
|
||||
}
|
||||
|
||||
#define TRANSFER(dst, src) { \
|
||||
dst[0] = src ## 0; \
|
||||
dst[1] = src ## 1; \
|
||||
dst[2] = src ## 2; \
|
||||
dst[3] = src ## 3; \
|
||||
dst[4] = src ## 4; \
|
||||
dst[5] = src ## 5; \
|
||||
dst[6] = src ## 6; \
|
||||
dst[7] = src ## 7; \
|
||||
}
|
||||
|
||||
#define ROUND(table, in, out, c0, c1, c2, c3, c4, c5, c6, c7) { \
|
||||
out ## 0 = xor1(ROUND_ELT(table, in, 0, 7, 6, 5, 4, 3, 2, 1), c0); \
|
||||
out ## 1 = xor1(ROUND_ELT(table, in, 1, 0, 7, 6, 5, 4, 3, 2), c1); \
|
||||
out ## 2 = xor1(ROUND_ELT(table, in, 2, 1, 0, 7, 6, 5, 4, 3), c2); \
|
||||
out ## 3 = xor1(ROUND_ELT(table, in, 3, 2, 1, 0, 7, 6, 5, 4), c3); \
|
||||
out ## 4 = xor1(ROUND_ELT(table, in, 4, 3, 2, 1, 0, 7, 6, 5), c4); \
|
||||
out ## 5 = xor1(ROUND_ELT(table, in, 5, 4, 3, 2, 1, 0, 7, 6), c5); \
|
||||
out ## 6 = xor1(ROUND_ELT(table, in, 6, 5, 4, 3, 2, 1, 0, 7), c6); \
|
||||
out ## 7 = xor1(ROUND_ELT(table, in, 7, 6, 5, 4, 3, 2, 1, 0), c7); \
|
||||
}
|
||||
|
||||
#define ROUND1(table, in, out, c) { \
|
||||
out ## 0 = xor1(ROUND_ELT(table, in, 0, 7, 6, 5, 4, 3, 2, 1), c); \
|
||||
out ## 1 = ROUND_ELT(table, in, 1, 0, 7, 6, 5, 4, 3, 2); \
|
||||
out ## 2 = ROUND_ELT(table, in, 2, 1, 0, 7, 6, 5, 4, 3); \
|
||||
out ## 3 = ROUND_ELT(table, in, 3, 2, 1, 0, 7, 6, 5, 4); \
|
||||
out ## 4 = ROUND_ELT(table, in, 4, 3, 2, 1, 0, 7, 6, 5); \
|
||||
out ## 5 = ROUND_ELT(table, in, 5, 4, 3, 2, 1, 0, 7, 6); \
|
||||
out ## 6 = ROUND_ELT(table, in, 6, 5, 4, 3, 2, 1, 0, 7); \
|
||||
out ## 7 = ROUND_ELT(table, in, 7, 6, 5, 4, 3, 2, 1, 0); \
|
||||
}
|
||||
|
||||
#define ROUND_KSCHED(table, in, out, c) \
|
||||
ROUND1(table, in, out, c) \
|
||||
TRANSFER(in, out)
|
||||
|
||||
#define ROUND_WENC(table, in, key, out) \
|
||||
ROUND(table, in, out, key[0], key[1], key[2],key[3], key[4], key[5], key[6], key[7]) \
|
||||
TRANSFER(in, out)
|
||||
|
||||
static uint64_t* d_xtra[MAX_GPUS] = { 0 };
|
||||
static uint64_t* d_tmp[MAX_GPUS] = { 0 };
|
||||
|
||||
__device__ __forceinline__
|
||||
static void whirlpoolx_getShared(uint64_t* sharedMemory)
|
||||
{
|
||||
if (threadIdx.x < 256) {
|
||||
sharedMemory[threadIdx.x] = mixTob0Tox[threadIdx.x];
|
||||
sharedMemory[threadIdx.x+256] = ROTL64(sharedMemory[threadIdx.x], 8);
|
||||
sharedMemory[threadIdx.x+512] = ROTL64(sharedMemory[threadIdx.x],16);
|
||||
sharedMemory[threadIdx.x+768] = ROTL64(sharedMemory[threadIdx.x],24);
|
||||
sharedMemory[threadIdx.x+1024] = ROTL64(sharedMemory[threadIdx.x],32);
|
||||
sharedMemory[threadIdx.x+1280] = ROTR64(sharedMemory[threadIdx.x],24);
|
||||
sharedMemory[threadIdx.x+1536] = ROTR64(sharedMemory[threadIdx.x],16);
|
||||
sharedMemory[threadIdx.x+1792] = ROTR64(sharedMemory[threadIdx.x], 8);
|
||||
}
|
||||
__syncthreads();
|
||||
}
|
||||
|
||||
|
||||
__global__
|
||||
void whirlpoolx_gpu_precompute(uint32_t threads, uint64_t* d_xtra, uint64_t* d_tmp)
|
||||
{
|
||||
__shared__ uint64_t sharedMemory[2048];
|
||||
|
||||
whirlpoolx_getShared(sharedMemory);
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
uint64_t n[8];
|
||||
uint64_t h[8] = { 0 };
|
||||
|
||||
#pragma unroll 8
|
||||
for (int i=0; i<8; i++) {
|
||||
n[i] = c_PaddedMessage80[i]; // read data
|
||||
}
|
||||
//#pragma unroll 10
|
||||
for (unsigned int r=0; r < 10; r++) {
|
||||
uint64_t tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
|
||||
ROUND_KSCHED(sharedMemory, h, tmp, InitVector_RC[r]);
|
||||
ROUND_WENC(sharedMemory, n, h, tmp);
|
||||
}
|
||||
#pragma unroll 8
|
||||
for (int i=0; i < 8; i++) {
|
||||
h[i] = xor1(n[i],c_PaddedMessage80[i]);
|
||||
}
|
||||
|
||||
if(threadIdx.x==0)d_xtra[threadIdx.x]=h[1];
|
||||
uint64_t atLastCalc=xor1(h[3],h[5]);
|
||||
|
||||
//////////////////////////////////
|
||||
n[0] = c_PaddedMessage80[8]; //read data
|
||||
n[1] = c_PaddedMessage80[9]; //whirlpool
|
||||
n[2] = 0x0000000000000080; //whirlpool
|
||||
n[3] = 0;
|
||||
n[4] = 0;
|
||||
n[5] = 0;
|
||||
n[6] = 0;
|
||||
n[7] = 0x8002000000000000;
|
||||
|
||||
n[0] = xor1(n[0],h[0]);
|
||||
n[2] = xor1(n[2],h[2]); n[3] = h[3];
|
||||
n[4] = h[4]; n[5] = h[5];
|
||||
n[6] = h[6]; n[7] = xor1(n[7],h[7]);
|
||||
uint64_t tmp[8];
|
||||
tmp[0] = xor1(ROUND_ELT(sharedMemory, h, 0, 7, 6, 5, 4, 3, 2, 1),InitVector_RC[0]);
|
||||
tmp[1] = ROUND_ELT(sharedMemory, h, 1, 0, 7, 6, 5, 4, 3, 2);
|
||||
tmp[2] = ROUND_ELT(sharedMemory, h, 2, 1, 0, 7, 6, 5, 4, 3);
|
||||
tmp[3] = ROUND_ELT(sharedMemory, h, 3, 2, 1, 0, 7, 6, 5, 4);
|
||||
tmp[4] = ROUND_ELT(sharedMemory, h, 4, 3, 2, 1, 0, 7, 6, 5);
|
||||
tmp[5] = ROUND_ELT(sharedMemory, h, 5, 4, 3, 2, 1, 0, 7, 6);
|
||||
tmp[6] = ROUND_ELT(sharedMemory, h, 6, 5, 4, 3, 2, 1, 0, 7);
|
||||
tmp[7] = ROUND_ELT(sharedMemory, h, 7, 6, 5, 4, 3, 2, 1, 0);
|
||||
|
||||
uint64_t tmp2[8];
|
||||
uint32_t* n32 = (uint32_t*)n;
|
||||
tmp2[0]=xor8( sharedMemory[__byte_perm(n32[ 0], 0, 0x4440)] ,sharedMemory[__byte_perm(n32[14], 0, 0x4441) + 256],
|
||||
sharedMemory[__byte_perm(n32[12], 0, 0x4442) + 512] ,sharedMemory[__byte_perm(n32[10], 0, 0x4443) + 768],
|
||||
sharedMemory[__byte_perm(n32[ 9], 0, 0x4440) + 1024] ,sharedMemory[__byte_perm(n32[ 7], 0, 0x4441) + 1280],
|
||||
sharedMemory[__byte_perm(n32[ 5], 0, 0x4442) + 1536] ,tmp[0]);
|
||||
|
||||
tmp2[1]=xor8( tmp[1] ,sharedMemory[__byte_perm(n32[ 0], 0, 0x4441) + 256],
|
||||
sharedMemory[__byte_perm(n32[14], 0, 0x4442) + 512] ,sharedMemory[__byte_perm(n32[12], 0, 0x4443) + 768],
|
||||
sharedMemory[__byte_perm(n32[11], 0, 0x4440) + 1024] ,sharedMemory[__byte_perm(n32[ 9], 0, 0x4441) + 1280],
|
||||
sharedMemory[__byte_perm(n32[ 7], 0, 0x4442) + 1536] ,sharedMemory[__byte_perm(n32[ 5], 0, 0x4443) + 1792]);
|
||||
|
||||
tmp2[2]=xor8( sharedMemory[__byte_perm(n32[ 4], 0, 0x4440)] ,tmp[2] ,
|
||||
sharedMemory[__byte_perm(n32[ 0], 0, 0x4442) + 512] ,sharedMemory[__byte_perm(n32[14], 0, 0x4443) + 768],
|
||||
sharedMemory[__byte_perm(n32[13], 0, 0x4440) + 1024] ,sharedMemory[__byte_perm(n32[11], 0, 0x4441) + 1280],
|
||||
sharedMemory[__byte_perm(n32[ 9], 0, 0x4442) + 1536] ,sharedMemory[__byte_perm(n32[ 7], 0, 0x4443) + 1792]);
|
||||
|
||||
tmp2[3]=xor8( sharedMemory[__byte_perm(n32[ 6], 0, 0x4440)] ,sharedMemory[__byte_perm(n32[ 4], 0, 0x4441) + 256],
|
||||
tmp[3] ,sharedMemory[__byte_perm(n32[ 0], 0, 0x4443) + 768],
|
||||
sharedMemory[__byte_perm(n32[15], 0, 0x4440) + 1024] ,sharedMemory[__byte_perm(n32[13], 0, 0x4441) + 1280],
|
||||
sharedMemory[__byte_perm(n32[11], 0, 0x4442) + 1536] ,sharedMemory[__byte_perm(n32[ 9], 0, 0x4443) + 1792]);
|
||||
|
||||
tmp2[4]=xor8( sharedMemory[__byte_perm(n32[ 8], 0, 0x4440)] ,sharedMemory[__byte_perm(n32[ 6], 0, 0x4441) + 256] ,
|
||||
sharedMemory[__byte_perm(n32[ 4], 0, 0x4442) + 512] ,tmp[4] ,
|
||||
sharedMemory[__byte_perm(n32[ 1], 0, 0x4440) + 1024] ,sharedMemory[__byte_perm(n32[15], 0, 0x4441) + 1280] ,
|
||||
sharedMemory[__byte_perm(n32[13], 0, 0x4442) + 1536] ,sharedMemory[__byte_perm(n32[11], 0, 0x4443) + 1792]);
|
||||
|
||||
tmp2[5]=xor8( sharedMemory[__byte_perm(n32[10], 0, 0x4440)] ,sharedMemory[__byte_perm(n32[ 8], 0, 0x4441) + 256],
|
||||
sharedMemory[__byte_perm(n32[ 6], 0, 0x4442) + 512] ,sharedMemory[__byte_perm(n32[ 4], 0, 0x4443) + 768],
|
||||
tmp[5] ,sharedMemory[__byte_perm(n32[ 1], 0, 0x4441) + 1280],
|
||||
sharedMemory[__byte_perm(n32[15], 0, 0x4442) + 1536] ,sharedMemory[__byte_perm(n32[13], 0, 0x4443) + 1792]);
|
||||
|
||||
tmp2[6]=xor8( sharedMemory[__byte_perm(n32[12], 0, 0x4440)] ,sharedMemory[__byte_perm(n32[10], 0, 0x4441) + 256],
|
||||
sharedMemory[__byte_perm(n32[ 8], 0, 0x4442) + 512] ,sharedMemory[__byte_perm(n32[ 6], 0, 0x4443) + 768],
|
||||
sharedMemory[__byte_perm(n32[ 5], 0, 0x4440) + 1024] ,tmp[6],
|
||||
sharedMemory[__byte_perm(n32[ 1], 0, 0x4442) + 1536] ,sharedMemory[__byte_perm(n32[15], 0, 0x4443) + 1792]);
|
||||
|
||||
tmp2[7]=xor8( sharedMemory[__byte_perm(n32[14], 0, 0x4440)] ,sharedMemory[__byte_perm(n32[12], 0, 0x4441) + 256],
|
||||
sharedMemory[__byte_perm(n32[10], 0, 0x4442) + 512] ,sharedMemory[__byte_perm(n32[ 8], 0, 0x4443) + 768],
|
||||
sharedMemory[__byte_perm(n32[ 7], 0, 0x4440) + 1024] ,sharedMemory[__byte_perm(n32[ 5], 0, 0x4441) + 1280],
|
||||
tmp[7] ,sharedMemory[__byte_perm(n32[ 1], 0, 0x4443) + 1792]);
|
||||
|
||||
n[1] ^= h[1];
|
||||
tmp2[1]^=sharedMemory[__byte_perm(n32[2], 0, 0x4440)];
|
||||
tmp2[2]^=sharedMemory[__byte_perm(n32[2], 0, 0x4441) + 256];
|
||||
tmp2[3]^=sharedMemory[__byte_perm(n32[2], 0, 0x4442) + 512];
|
||||
tmp2[4]^=sharedMemory[__byte_perm(n32[2], 0, 0x4443) + 768];
|
||||
|
||||
d_tmp[threadIdx.x]=tmp2[threadIdx.x];
|
||||
|
||||
uint64_t tmp3[8];
|
||||
tmp3[0] = xor1(ROUND_ELT(sharedMemory, tmp, 0, 7, 6, 5, 4, 3, 2, 1), InitVector_RC[1]);
|
||||
tmp3[1] = ROUND_ELT(sharedMemory, tmp, 1, 0, 7, 6, 5, 4, 3, 2);
|
||||
tmp3[2] = ROUND_ELT(sharedMemory, tmp, 2, 1, 0, 7, 6, 5, 4, 3);
|
||||
tmp3[3] = ROUND_ELT(sharedMemory, tmp, 3, 2, 1, 0, 7, 6, 5, 4);
|
||||
tmp3[4] = ROUND_ELT(sharedMemory, tmp, 4, 3, 2, 1, 0, 7, 6, 5);
|
||||
tmp3[5] = ROUND_ELT(sharedMemory, tmp, 5, 4, 3, 2, 1, 0, 7, 6);
|
||||
tmp3[6] = ROUND_ELT(sharedMemory, tmp, 6, 5, 4, 3, 2, 1, 0, 7);
|
||||
tmp3[7] = ROUND_ELT(sharedMemory, tmp, 7, 6, 5, 4, 3, 2, 1, 0);
|
||||
|
||||
n32 = (uint32_t*)tmp2;
|
||||
uint64_t tmp4[8];
|
||||
tmp4[0]=( sharedMemory[__byte_perm(n32[ 9], 0, 0x4440) + 1024] ^sharedMemory[__byte_perm(n32[ 7], 0, 0x4441) + 1280]^
|
||||
sharedMemory[__byte_perm(n32[ 5], 0, 0x4442) + 1536] ^sharedMemory[__byte_perm(n32[ 3], 0, 0x4443) + 1792]) ^tmp3[0];
|
||||
|
||||
tmp4[1]=(sharedMemory[__byte_perm(n32[ 2], 0, 0x4440)] ^sharedMemory[__byte_perm(n32[ 9], 0, 0x4441) + 1280]^
|
||||
sharedMemory[__byte_perm(n32[ 7], 0, 0x4442) + 1536] ^sharedMemory[__byte_perm(n32[ 5], 0, 0x4443) + 1792]) ^tmp3[1];
|
||||
|
||||
tmp4[2]=(sharedMemory[__byte_perm(n32[ 4], 0, 0x4440)] ^sharedMemory[__byte_perm(n32[ 2], 0, 0x4441) + 256]^
|
||||
sharedMemory[__byte_perm(n32[ 9], 0, 0x4442) + 1536] ^sharedMemory[__byte_perm(n32[ 7], 0, 0x4443) + 1792]) ^tmp3[2];
|
||||
|
||||
tmp4[3]=(sharedMemory[__byte_perm(n32[ 6], 0, 0x4440)] ^sharedMemory[__byte_perm(n32[ 4], 0, 0x4441) + 256]^
|
||||
sharedMemory[__byte_perm(n32[ 2], 0, 0x4442) + 512] ^sharedMemory[__byte_perm(n32[ 9], 0, 0x4443) + 1792]) ^tmp3[3];
|
||||
|
||||
tmp4[4]=(sharedMemory[__byte_perm(n32[ 8], 0, 0x4440)] ^sharedMemory[__byte_perm(n32[ 6], 0, 0x4441) + 256]^
|
||||
sharedMemory[__byte_perm(n32[ 4], 0, 0x4442) + 512] ^sharedMemory[__byte_perm(n32[ 2], 0, 0x4443) + 768]) ^tmp3[4];
|
||||
|
||||
tmp4[5]=(sharedMemory[__byte_perm(n32[ 8], 0, 0x4441) + 256] ^sharedMemory[__byte_perm(n32[ 6], 0, 0x4442) + 512]^
|
||||
sharedMemory[__byte_perm(n32[ 4], 0, 0x4443) + 768] ^sharedMemory[__byte_perm(n32[ 3], 0, 0x4440) + 1024]) ^tmp3[5];
|
||||
|
||||
tmp4[6]=(sharedMemory[__byte_perm(n32[ 8], 0, 0x4442) + 512] ^sharedMemory[__byte_perm(n32[ 6], 0, 0x4443) + 768]^
|
||||
sharedMemory[__byte_perm(n32[ 5], 0, 0x4440) + 1024] ^sharedMemory[__byte_perm(n32[ 3], 0, 0x4441) + 1280]) ^tmp3[6];
|
||||
|
||||
tmp4[7]=(sharedMemory[__byte_perm(n32[ 8], 0, 0x4443) + 768] ^sharedMemory[__byte_perm(n32[ 7], 0, 0x4440) + 1024]^
|
||||
sharedMemory[__byte_perm(n32[ 5], 0, 0x4441) + 1280] ^sharedMemory[__byte_perm(n32[ 3], 0, 0x4442) + 1536]) ^tmp3[7];
|
||||
|
||||
d_tmp[threadIdx.x+16]=tmp4[threadIdx.x];
|
||||
|
||||
uint64_t tmp5[8];
|
||||
tmp5[0] = xor1(ROUND_ELT(sharedMemory, tmp3, 0, 7, 6, 5, 4, 3, 2, 1), InitVector_RC[2]);
|
||||
tmp5[1] = ROUND_ELT(sharedMemory, tmp3, 1, 0, 7, 6, 5, 4, 3, 2);
|
||||
tmp5[2] = ROUND_ELT(sharedMemory, tmp3, 2, 1, 0, 7, 6, 5, 4, 3);
|
||||
tmp5[3] = ROUND_ELT(sharedMemory, tmp3, 3, 2, 1, 0, 7, 6, 5, 4);
|
||||
tmp5[4] = ROUND_ELT(sharedMemory, tmp3, 4, 3, 2, 1, 0, 7, 6, 5);
|
||||
tmp5[5] = ROUND_ELT(sharedMemory, tmp3, 5, 4, 3, 2, 1, 0, 7, 6);
|
||||
tmp5[6] = ROUND_ELT(sharedMemory, tmp3, 6, 5, 4, 3, 2, 1, 0, 7);
|
||||
tmp5[7] = ROUND_ELT(sharedMemory, tmp3, 7, 6, 5, 4, 3, 2, 1, 0);
|
||||
|
||||
d_tmp[threadIdx.x+8]=tmp5[threadIdx.x];
|
||||
|
||||
uint64_t tmp6[8];
|
||||
tmp6[0] = xor1(ROUND_ELT(sharedMemory, tmp5, 0, 7, 6, 5, 4, 3, 2, 1), InitVector_RC[3]);
|
||||
tmp6[1] = ROUND_ELT(sharedMemory, tmp5, 1, 0, 7, 6, 5, 4, 3, 2);
|
||||
tmp6[2] = ROUND_ELT(sharedMemory, tmp5, 2, 1, 0, 7, 6, 5, 4, 3);
|
||||
tmp6[3] = ROUND_ELT(sharedMemory, tmp5, 3, 2, 1, 0, 7, 6, 5, 4);
|
||||
tmp6[4] = ROUND_ELT(sharedMemory, tmp5, 4, 3, 2, 1, 0, 7, 6, 5);
|
||||
tmp6[5] = ROUND_ELT(sharedMemory, tmp5, 5, 4, 3, 2, 1, 0, 7, 6);
|
||||
tmp6[6] = ROUND_ELT(sharedMemory, tmp5, 6, 5, 4, 3, 2, 1, 0, 7);
|
||||
tmp6[7] = ROUND_ELT(sharedMemory, tmp5, 7, 6, 5, 4, 3, 2, 1, 0);
|
||||
|
||||
d_tmp[threadIdx.x+24]=tmp6[threadIdx.x];
|
||||
|
||||
uint64_t tmp7[8];
|
||||
tmp7[0] = xor1(ROUND_ELT(sharedMemory, tmp6, 0, 7, 6, 5, 4, 3, 2, 1), InitVector_RC[4]);
|
||||
tmp7[1] = ROUND_ELT(sharedMemory, tmp6, 1, 0, 7, 6, 5, 4, 3, 2);
|
||||
tmp7[2] = ROUND_ELT(sharedMemory, tmp6, 2, 1, 0, 7, 6, 5, 4, 3);
|
||||
tmp7[3] = ROUND_ELT(sharedMemory, tmp6, 3, 2, 1, 0, 7, 6, 5, 4);
|
||||
tmp7[4] = ROUND_ELT(sharedMemory, tmp6, 4, 3, 2, 1, 0, 7, 6, 5);
|
||||
tmp7[5] = ROUND_ELT(sharedMemory, tmp6, 5, 4, 3, 2, 1, 0, 7, 6);
|
||||
tmp7[6] = ROUND_ELT(sharedMemory, tmp6, 6, 5, 4, 3, 2, 1, 0, 7);
|
||||
tmp7[7] = ROUND_ELT(sharedMemory, tmp6, 7, 6, 5, 4, 3, 2, 1, 0);
|
||||
|
||||
d_tmp[threadIdx.x+32]=tmp7[threadIdx.x];
|
||||
|
||||
uint64_t tmp8[8];
|
||||
tmp8[0] = xor1(ROUND_ELT(sharedMemory, tmp7, 0, 7, 6, 5, 4, 3, 2, 1), InitVector_RC[5]);
|
||||
tmp8[1] = ROUND_ELT(sharedMemory, tmp7, 1, 0, 7, 6, 5, 4, 3, 2);
|
||||
tmp8[2] = ROUND_ELT(sharedMemory, tmp7, 2, 1, 0, 7, 6, 5, 4, 3);
|
||||
tmp8[3] = ROUND_ELT(sharedMemory, tmp7, 3, 2, 1, 0, 7, 6, 5, 4);
|
||||
tmp8[4] = ROUND_ELT(sharedMemory, tmp7, 4, 3, 2, 1, 0, 7, 6, 5);
|
||||
tmp8[5] = ROUND_ELT(sharedMemory, tmp7, 5, 4, 3, 2, 1, 0, 7, 6);
|
||||
tmp8[6] = ROUND_ELT(sharedMemory, tmp7, 6, 5, 4, 3, 2, 1, 0, 7);
|
||||
tmp8[7] = ROUND_ELT(sharedMemory, tmp7, 7, 6, 5, 4, 3, 2, 1, 0);
|
||||
|
||||
d_tmp[threadIdx.x+40]=tmp8[threadIdx.x];
|
||||
|
||||
uint64_t tmp9[8];
|
||||
tmp9[0] = xor1(ROUND_ELT(sharedMemory, tmp8, 0, 7, 6, 5, 4, 3, 2, 1), InitVector_RC[6]);
|
||||
tmp9[1] = ROUND_ELT(sharedMemory, tmp8, 1, 0, 7, 6, 5, 4, 3, 2);
|
||||
tmp9[2] = ROUND_ELT(sharedMemory, tmp8, 2, 1, 0, 7, 6, 5, 4, 3);
|
||||
tmp9[3] = ROUND_ELT(sharedMemory, tmp8, 3, 2, 1, 0, 7, 6, 5, 4);
|
||||
tmp9[4] = ROUND_ELT(sharedMemory, tmp8, 4, 3, 2, 1, 0, 7, 6, 5);
|
||||
tmp9[5] = ROUND_ELT(sharedMemory, tmp8, 5, 4, 3, 2, 1, 0, 7, 6);
|
||||
tmp9[6] = ROUND_ELT(sharedMemory, tmp8, 6, 5, 4, 3, 2, 1, 0, 7);
|
||||
tmp9[7] = ROUND_ELT(sharedMemory, tmp8, 7, 6, 5, 4, 3, 2, 1, 0);
|
||||
|
||||
d_tmp[threadIdx.x+48]=tmp9[threadIdx.x];
|
||||
|
||||
uint64_t tmp10[8];
|
||||
tmp10[0] = xor1(ROUND_ELT(sharedMemory, tmp9, 0, 7, 6, 5, 4, 3, 2, 1), InitVector_RC[7]);
|
||||
tmp10[1] = ROUND_ELT(sharedMemory, tmp9, 1, 0, 7, 6, 5, 4, 3, 2);
|
||||
tmp10[2] = ROUND_ELT(sharedMemory, tmp9, 2, 1, 0, 7, 6, 5, 4, 3);
|
||||
tmp10[3] = ROUND_ELT(sharedMemory, tmp9, 3, 2, 1, 0, 7, 6, 5, 4);
|
||||
tmp10[4] = ROUND_ELT(sharedMemory, tmp9, 4, 3, 2, 1, 0, 7, 6, 5);
|
||||
tmp10[5] = ROUND_ELT(sharedMemory, tmp9, 5, 4, 3, 2, 1, 0, 7, 6);
|
||||
tmp10[6] = ROUND_ELT(sharedMemory, tmp9, 6, 5, 4, 3, 2, 1, 0, 7);
|
||||
tmp10[7] = ROUND_ELT(sharedMemory, tmp9, 7, 6, 5, 4, 3, 2, 1, 0);
|
||||
|
||||
|
||||
d_tmp[threadIdx.x+56]=tmp10[threadIdx.x];
|
||||
|
||||
uint64_t tmp11[8];
|
||||
tmp11[0] = xor1(ROUND_ELT(sharedMemory, tmp10, 0, 7, 6, 5, 4, 3, 2, 1), InitVector_RC[8]);
|
||||
tmp11[1] = ROUND_ELT(sharedMemory, tmp10, 1, 0, 7, 6, 5, 4, 3, 2);
|
||||
tmp11[2] = ROUND_ELT(sharedMemory, tmp10, 2, 1, 0, 7, 6, 5, 4, 3);
|
||||
tmp11[3] = ROUND_ELT(sharedMemory, tmp10, 3, 2, 1, 0, 7, 6, 5, 4);
|
||||
tmp11[4] = ROUND_ELT(sharedMemory, tmp10, 4, 3, 2, 1, 0, 7, 6, 5);
|
||||
tmp11[5] = ROUND_ELT(sharedMemory, tmp10, 5, 4, 3, 2, 1, 0, 7, 6);
|
||||
tmp11[6] = ROUND_ELT(sharedMemory, tmp10, 6, 5, 4, 3, 2, 1, 0, 7);
|
||||
tmp11[7] = ROUND_ELT(sharedMemory, tmp10, 7, 6, 5, 4, 3, 2, 1, 0);
|
||||
|
||||
d_tmp[threadIdx.x+64]=tmp11[threadIdx.x];
|
||||
|
||||
if(threadIdx.x==1){
|
||||
tmp[0]=ROUND_ELT(sharedMemory,tmp11, 3, 2, 1, 0, 7, 6, 5, 4);
|
||||
tmp[1]=ROUND_ELT(sharedMemory,tmp11, 5, 4, 3, 2, 1, 0, 7, 6);
|
||||
tmp[4] = xor3(tmp[0],tmp[1],atLastCalc);
|
||||
d_xtra[threadIdx.x]=tmp[4];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
__global__ __launch_bounds__(threadsPerBlock,2)
|
||||
void whirlpoolx_gpu_hash(uint32_t threads, uint32_t startNounce, uint32_t *resNounce)
|
||||
{
|
||||
__shared__ uint64_t sharedMemory[2048];
|
||||
|
||||
whirlpoolx_getShared(sharedMemory);
|
||||
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
uint64_t n[8];
|
||||
uint64_t tmp[8];
|
||||
uint32_t nounce = startNounce + thread;
|
||||
|
||||
n[1] = xor1(REPLACE_HIDWORD(c_PaddedMessage80[9], cuda_swab32(nounce)),c_xtra[0]);
|
||||
|
||||
uint32_t* n32 = (uint32_t*)&n[0];
|
||||
n[0]=sharedMemory[__byte_perm(n32[3], 0, 0x4443) + 1792];
|
||||
n[5]=sharedMemory[__byte_perm(n32[3], 0, 0x4440) + 1024];
|
||||
n[6]=sharedMemory[__byte_perm(n32[3], 0, 0x4441) + 1280];
|
||||
n[7]=sharedMemory[__byte_perm(n32[3], 0, 0x4442) + 1536];
|
||||
n[0]=xor1(c_tmp[0],n[0]);
|
||||
n[1]=c_tmp[1];
|
||||
n[2]=c_tmp[2];
|
||||
n[3]=c_tmp[3];
|
||||
n[4]=c_tmp[4];
|
||||
n[5]=xor1(c_tmp[5],n[5]);
|
||||
n[6]=xor1(c_tmp[6],n[6]);
|
||||
n[7]=xor1(c_tmp[7],n[7]);
|
||||
|
||||
tmp[0]=xor3(sharedMemory[__byte_perm(n32[10],0,0x4443)+768],sharedMemory[__byte_perm(n32[12],0,0x4442)+512],sharedMemory[__byte_perm(n32[14],0,0x4441)+256]);
|
||||
tmp[1]=xor3(sharedMemory[__byte_perm(n32[11],0,0x4440)+1024],sharedMemory[__byte_perm(n32[12],0,0x4443)+768],sharedMemory[__byte_perm(n32[14],0,0x4442)+512]);
|
||||
tmp[2]=xor3(sharedMemory[__byte_perm(n32[11],0,0x4441)+1280],sharedMemory[__byte_perm(n32[13],0,0x4440)+1024],sharedMemory[__byte_perm(n32[14],0,0x4443)+768]);
|
||||
tmp[3]=xor3(sharedMemory[__byte_perm(n32[11],0,0x4442)+1536],sharedMemory[__byte_perm(n32[13],0,0x4441)+1280],sharedMemory[__byte_perm(n32[15],0,0x4440)+1024]);
|
||||
tmp[4]=xor3(sharedMemory[__byte_perm(n32[11],0,0x4443)+1792],sharedMemory[__byte_perm(n32[13],0,0x4442)+1536],sharedMemory[__byte_perm(n32[15],0,0x4441)+1280]);
|
||||
tmp[5]=xor3(sharedMemory[__byte_perm(n32[10],0,0x4440)],sharedMemory[__byte_perm(n32[13],0,0x4443)+1792],sharedMemory[__byte_perm(n32[15],0,0x4442)+1536]);
|
||||
tmp[6]=xor3(sharedMemory[__byte_perm(n32[12],0,0x4440)],sharedMemory[__byte_perm(n32[10],0,0x4441)+256],sharedMemory[__byte_perm(n32[15],0,0x4443)+1792]);
|
||||
tmp[7]=xor3(sharedMemory[__byte_perm(n32[14],0,0x4440)],sharedMemory[__byte_perm(n32[12],0,0x4441)+256],sharedMemory[__byte_perm(n32[10],0,0x4442)+ 512]);
|
||||
|
||||
tmp[0]=xor3(sharedMemory[__byte_perm(n32[ 0], 0, 0x4440)],tmp[0],c_tmp[0+16]);
|
||||
tmp[1]=xor3(sharedMemory[__byte_perm(n32[ 0], 0, 0x4441) + 256],tmp[1],c_tmp[1+16]);
|
||||
tmp[2]=xor3(sharedMemory[__byte_perm(n32[ 0], 0, 0x4442) + 512],tmp[2],c_tmp[2+16]);
|
||||
tmp[3]=xor3(sharedMemory[__byte_perm(n32[ 0], 0, 0x4443) + 768],tmp[3],c_tmp[3+16]);
|
||||
tmp[4]=xor3(sharedMemory[__byte_perm(n32[ 1], 0, 0x4440) + 1024],tmp[4],c_tmp[4+16]);
|
||||
tmp[5]=xor3(sharedMemory[__byte_perm(n32[ 1], 0, 0x4441) + 1280],tmp[5],c_tmp[5+16]);
|
||||
tmp[6]=xor3(sharedMemory[__byte_perm(n32[ 1], 0, 0x4442) + 1536],tmp[6],c_tmp[6+16]);
|
||||
tmp[7]=xor3(sharedMemory[__byte_perm(n32[ 1], 0, 0x4443) + 1792],tmp[7],c_tmp[7+16]);
|
||||
|
||||
n[0]=tmp[0];
|
||||
n[1]=tmp[1];
|
||||
n[2]=tmp[2];
|
||||
n[3]=tmp[3];
|
||||
n[4]=tmp[4];
|
||||
n[5]=tmp[5];
|
||||
n[6]=tmp[6];
|
||||
n[7]=tmp[7];
|
||||
|
||||
tmp[0] = xor1(ROUND_ELT(sharedMemory, n, 0, 7, 6, 5, 4, 3, 2, 1), c_tmp[0+8]);
|
||||
tmp[1] = xor1(ROUND_ELT(sharedMemory, n, 1, 0, 7, 6, 5, 4, 3, 2), c_tmp[1+8]);
|
||||
tmp[2] = xor1(ROUND_ELT(sharedMemory, n, 2, 1, 0, 7, 6, 5, 4, 3), c_tmp[2+8]);
|
||||
tmp[3] = xor1(ROUND_ELT(sharedMemory, n, 3, 2, 1, 0, 7, 6, 5, 4), c_tmp[3+8]);
|
||||
tmp[4] = xor1(ROUND_ELT(sharedMemory, n, 4, 3, 2, 1, 0, 7, 6, 5), c_tmp[4+8]);
|
||||
tmp[5] = xor1(ROUND_ELT(sharedMemory, n, 5, 4, 3, 2, 1, 0, 7, 6), c_tmp[5+8]);
|
||||
tmp[6] = xor1(ROUND_ELT(sharedMemory, n, 6, 5, 4, 3, 2, 1, 0, 7), c_tmp[6+8]);
|
||||
tmp[7] = xor1(ROUND_ELT(sharedMemory, n, 7, 6, 5, 4, 3, 2, 1, 0), c_tmp[7+8]);
|
||||
|
||||
n[0] = xor1(ROUND_ELT(sharedMemory, tmp, 0, 7, 6, 5, 4, 3, 2, 1), c_tmp[0+24]);
|
||||
n[1] = xor1(ROUND_ELT(sharedMemory, tmp, 1, 0, 7, 6, 5, 4, 3, 2), c_tmp[1+24]);
|
||||
n[2] = xor1(ROUND_ELT(sharedMemory, tmp, 2, 1, 0, 7, 6, 5, 4, 3), c_tmp[2+24]);
|
||||
n[3] = xor1(ROUND_ELT(sharedMemory, tmp, 3, 2, 1, 0, 7, 6, 5, 4), c_tmp[3+24]);
|
||||
n[4] = xor1(ROUND_ELT(sharedMemory, tmp, 4, 3, 2, 1, 0, 7, 6, 5), c_tmp[4+24]);
|
||||
n[5] = xor1(ROUND_ELT(sharedMemory, tmp, 5, 4, 3, 2, 1, 0, 7, 6), c_tmp[5+24]);
|
||||
n[6] = xor1(ROUND_ELT(sharedMemory, tmp, 6, 5, 4, 3, 2, 1, 0, 7), c_tmp[6+24]);
|
||||
n[7] = xor1(ROUND_ELT(sharedMemory, tmp, 7, 6, 5, 4, 3, 2, 1, 0), c_tmp[7+24]);
|
||||
|
||||
tmp[0] = xor1(ROUND_ELT(sharedMemory, n, 0, 7, 6, 5, 4, 3, 2, 1), c_tmp[0+32]);
|
||||
tmp[1] = xor1(ROUND_ELT(sharedMemory, n, 1, 0, 7, 6, 5, 4, 3, 2), c_tmp[1+32]);
|
||||
tmp[2] = xor1(ROUND_ELT(sharedMemory, n, 2, 1, 0, 7, 6, 5, 4, 3), c_tmp[2+32]);
|
||||
tmp[3] = xor1(ROUND_ELT(sharedMemory, n, 3, 2, 1, 0, 7, 6, 5, 4), c_tmp[3+32]);
|
||||
tmp[4] = xor1(ROUND_ELT(sharedMemory, n, 4, 3, 2, 1, 0, 7, 6, 5), c_tmp[4+32]);
|
||||
tmp[5] = xor1(ROUND_ELT(sharedMemory, n, 5, 4, 3, 2, 1, 0, 7, 6), c_tmp[5+32]);
|
||||
tmp[6] = xor1(ROUND_ELT(sharedMemory, n, 6, 5, 4, 3, 2, 1, 0, 7), c_tmp[6+32]);
|
||||
tmp[7] = xor1(ROUND_ELT(sharedMemory, n, 7, 6, 5, 4, 3, 2, 1, 0), c_tmp[7+32]);
|
||||
|
||||
n[0] = xor1(ROUND_ELT(sharedMemory, tmp, 0, 7, 6, 5, 4, 3, 2, 1), c_tmp[0+40]);
|
||||
n[1] = xor1(ROUND_ELT(sharedMemory, tmp, 1, 0, 7, 6, 5, 4, 3, 2), c_tmp[1+40]);
|
||||
n[2] = xor1(ROUND_ELT(sharedMemory, tmp, 2, 1, 0, 7, 6, 5, 4, 3), c_tmp[2+40]);
|
||||
n[3] = xor1(ROUND_ELT(sharedMemory, tmp, 3, 2, 1, 0, 7, 6, 5, 4), c_tmp[3+40]);
|
||||
n[4] = xor1(ROUND_ELT(sharedMemory, tmp, 4, 3, 2, 1, 0, 7, 6, 5), c_tmp[4+40]);
|
||||
n[5] = xor1(ROUND_ELT(sharedMemory, tmp, 5, 4, 3, 2, 1, 0, 7, 6), c_tmp[5+40]);
|
||||
n[6] = xor1(ROUND_ELT(sharedMemory, tmp, 6, 5, 4, 3, 2, 1, 0, 7), c_tmp[6+40]);
|
||||
n[7] = xor1(ROUND_ELT(sharedMemory, tmp, 7, 6, 5, 4, 3, 2, 1, 0), c_tmp[7+40]);
|
||||
|
||||
tmp[0] = xor1(ROUND_ELT(sharedMemory, n, 0, 7, 6, 5, 4, 3, 2, 1), c_tmp[0+48]);
|
||||
tmp[1] = xor1(ROUND_ELT(sharedMemory, n, 1, 0, 7, 6, 5, 4, 3, 2), c_tmp[1+48]);
|
||||
tmp[2] = xor1(ROUND_ELT(sharedMemory, n, 2, 1, 0, 7, 6, 5, 4, 3), c_tmp[2+48]);
|
||||
tmp[3] = xor1(ROUND_ELT(sharedMemory, n, 3, 2, 1, 0, 7, 6, 5, 4), c_tmp[3+48]);
|
||||
tmp[4] = xor1(ROUND_ELT(sharedMemory, n, 4, 3, 2, 1, 0, 7, 6, 5), c_tmp[4+48]);
|
||||
tmp[5] = xor1(ROUND_ELT(sharedMemory, n, 5, 4, 3, 2, 1, 0, 7, 6), c_tmp[5+48]);
|
||||
tmp[6] = xor1(ROUND_ELT(sharedMemory, n, 6, 5, 4, 3, 2, 1, 0, 7), c_tmp[6+48]);
|
||||
tmp[7] = xor1(ROUND_ELT(sharedMemory, n, 7, 6, 5, 4, 3, 2, 1, 0), c_tmp[7+48]);
|
||||
|
||||
n[0] = xor1(ROUND_ELT(sharedMemory, tmp, 0, 7, 6, 5, 4, 3, 2, 1), c_tmp[0+56]);
|
||||
n[1] = xor1(ROUND_ELT(sharedMemory, tmp, 1, 0, 7, 6, 5, 4, 3, 2), c_tmp[1+56]);
|
||||
n[2] = xor1(ROUND_ELT(sharedMemory, tmp, 2, 1, 0, 7, 6, 5, 4, 3), c_tmp[2+56]);
|
||||
n[3] = xor1(ROUND_ELT(sharedMemory, tmp, 3, 2, 1, 0, 7, 6, 5, 4), c_tmp[3+56]);
|
||||
n[4] = xor1(ROUND_ELT(sharedMemory, tmp, 4, 3, 2, 1, 0, 7, 6, 5), c_tmp[4+56]);
|
||||
n[5] = xor1(ROUND_ELT(sharedMemory, tmp, 5, 4, 3, 2, 1, 0, 7, 6), c_tmp[5+56]);
|
||||
n[6] = xor1(ROUND_ELT(sharedMemory, tmp, 6, 5, 4, 3, 2, 1, 0, 7), c_tmp[6+56]);
|
||||
n[7] = xor1(ROUND_ELT(sharedMemory, tmp, 7, 6, 5, 4, 3, 2, 1, 0), c_tmp[7+56]);
|
||||
|
||||
tmp[0] = xor1(ROUND_ELT(sharedMemory, n, 0, 7, 6, 5, 4, 3, 2, 1), c_tmp[0+64]);
|
||||
tmp[1] = xor1(ROUND_ELT(sharedMemory, n, 1, 0, 7, 6, 5, 4, 3, 2), c_tmp[1+64]);
|
||||
tmp[2] = xor1(ROUND_ELT(sharedMemory, n, 2, 1, 0, 7, 6, 5, 4, 3), c_tmp[2+64]);
|
||||
tmp[3] = xor1(ROUND_ELT(sharedMemory, n, 3, 2, 1, 0, 7, 6, 5, 4), c_tmp[3+64]);
|
||||
tmp[4] = xor1(ROUND_ELT(sharedMemory, n, 4, 3, 2, 1, 0, 7, 6, 5), c_tmp[4+64]);
|
||||
tmp[5] = xor1(ROUND_ELT(sharedMemory, n, 5, 4, 3, 2, 1, 0, 7, 6), c_tmp[5+64]);
|
||||
tmp[6] = xor1(ROUND_ELT(sharedMemory, n, 6, 5, 4, 3, 2, 1, 0, 7), c_tmp[6+64]);
|
||||
tmp[7] = xor1(ROUND_ELT(sharedMemory, n, 7, 6, 5, 4, 3, 2, 1, 0), c_tmp[7+64]);
|
||||
|
||||
if (xor3(c_xtra[1], ROUND_ELT(sharedMemory, tmp, 3, 2, 1, 0, 7, 6, 5, 4), ROUND_ELT(sharedMemory, tmp, 5, 4, 3, 2, 1, 0, 7, 6)) <= pTarget[3]) {
|
||||
atomicMin(&resNounce[0], nounce);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
__host__
|
||||
extern void whirlpoolx_cpu_init(int thr_id, uint32_t threads)
|
||||
{
|
||||
cudaMemcpyToSymbol(InitVector_RC, plain_RC, sizeof(plain_RC), 0, cudaMemcpyHostToDevice);
|
||||
cudaMemcpyToSymbol(mixTob0Tox, plain_T0, sizeof(plain_T0), 0, cudaMemcpyHostToDevice);
|
||||
cudaMalloc(&d_WXNonce[thr_id], sizeof(uint32_t));
|
||||
cudaMallocHost(&h_wxnounce[thr_id], sizeof(uint32_t));
|
||||
cudaMalloc(&d_xtra[thr_id], 8 * sizeof(uint64_t));
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_tmp[thr_id], 8 * 9 * sizeof(uint64_t))); // d_tmp[threadIdx.x+64] (7+64)
|
||||
}
|
||||
|
||||
__host__
|
||||
void whirlpoolx_setBlock_80(void *pdata, const void *ptarget)
|
||||
{
|
||||
uint64_t PaddedMessage[16];
|
||||
memcpy(PaddedMessage, pdata, 80);
|
||||
memset((uint8_t*)&PaddedMessage+80, 0, 48);
|
||||
((uint8_t*)PaddedMessage)[80] = 0x80; /* ending */
|
||||
cudaMemcpyToSymbol(pTarget, ptarget, 4*sizeof(uint64_t), 0, cudaMemcpyHostToDevice);
|
||||
CUDA_SAFE_CALL(cudaMemcpyToSymbol(c_PaddedMessage80, PaddedMessage, 16 * sizeof(uint64_t), 0, cudaMemcpyHostToDevice));
|
||||
}
|
||||
|
||||
__host__
|
||||
void whirlpoolx_precompute(int thr_id)
|
||||
{
|
||||
dim3 grid(1);
|
||||
dim3 block(256);
|
||||
|
||||
whirlpoolx_gpu_precompute <<<grid, block>>>(8, d_xtra[thr_id], d_tmp[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
cudaMemcpyToSymbol(c_xtra, d_xtra[thr_id], 8 * sizeof(uint64_t), 0, cudaMemcpyDeviceToDevice);
|
||||
CUDA_SAFE_CALL(cudaMemcpyToSymbol(c_tmp, d_tmp[thr_id], 8 * 9 * sizeof(uint64_t), 0, cudaMemcpyDeviceToDevice));
|
||||
}
|
||||
|
||||
__host__
|
||||
uint32_t whirlpoolx_cpu_hash(int thr_id, uint32_t threads, uint32_t startNounce)
|
||||
{
|
||||
dim3 grid((threads + threadsPerBlock-1) / threadsPerBlock);
|
||||
dim3 block(threadsPerBlock);
|
||||
|
||||
cudaMemset(d_WXNonce[thr_id], 0xff, sizeof(uint32_t));
|
||||
|
||||
whirlpoolx_gpu_hash<<<grid, block>>>(threads, startNounce, d_WXNonce[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
cudaMemcpy(h_wxnounce[thr_id], d_WXNonce[thr_id], sizeof(uint32_t), cudaMemcpyDeviceToHost);
|
||||
|
||||
return *(h_wxnounce[thr_id]);
|
||||
}
|
||||
@@ -1,97 +0,0 @@
|
||||
/*
|
||||
* whirlpool routine (djm)
|
||||
* whirlpoolx routine (provos alexis, tpruvot)
|
||||
*/
|
||||
extern "C" {
|
||||
#include "sph/sph_whirlpool.h"
|
||||
}
|
||||
|
||||
#include "miner.h"
|
||||
#include "cuda_helper.h"
|
||||
|
||||
static uint32_t *d_hash[MAX_GPUS];
|
||||
|
||||
extern void whirlpoolx_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void whirlpoolx_setBlock_80(void *pdata, const void *ptarget);
|
||||
extern uint32_t whirlpoolx_cpu_hash(int thr_id, uint32_t threads, uint32_t startNounce);
|
||||
extern void whirlpoolx_precompute(int thr_id);
|
||||
|
||||
// CPU Hash function
|
||||
extern "C" void whirlxHash(void *state, const void *input)
|
||||
{
|
||||
sph_whirlpool_context ctx_whirlpool;
|
||||
|
||||
unsigned char hash[64];
|
||||
unsigned char hash_xored[32];
|
||||
|
||||
sph_whirlpool_init(&ctx_whirlpool);
|
||||
sph_whirlpool(&ctx_whirlpool, input, 80);
|
||||
sph_whirlpool_close(&ctx_whirlpool, hash);
|
||||
|
||||
// compress the 48 first bytes of the hash to 32
|
||||
for (int i = 0; i < 32; i++) {
|
||||
hash_xored[i] = hash[i] ^ hash[i + 16];
|
||||
}
|
||||
memcpy(state, hash_xored, 32);
|
||||
}
|
||||
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
|
||||
extern "C" int scanhash_whirlpoolx(int thr_id, uint32_t *pdata, const uint32_t *ptarget,
|
||||
uint32_t max_nonce, unsigned long *hashes_done)
|
||||
{
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
uint32_t endiandata[20];
|
||||
int intensity = is_windows() ? 20 : 22;
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1U << intensity);
|
||||
throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0x0000ff;
|
||||
|
||||
if (!init[thr_id]) {
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
|
||||
CUDA_CALL_OR_RET_X(cudaMalloc(&d_hash[thr_id], 64 * throughput), 0);
|
||||
|
||||
whirlpoolx_cpu_init(thr_id, throughput);
|
||||
|
||||
init[thr_id] = true;
|
||||
}
|
||||
|
||||
for (int k=0; k < 20; k++) {
|
||||
be32enc(&endiandata[k], pdata[k]);
|
||||
}
|
||||
|
||||
whirlpoolx_setBlock_80((void*)endiandata, ptarget);
|
||||
whirlpoolx_precompute(thr_id);
|
||||
do {
|
||||
uint32_t foundNonce = whirlpoolx_cpu_hash(thr_id, throughput, pdata[19]);
|
||||
if (foundNonce != UINT32_MAX)
|
||||
{
|
||||
const uint32_t Htarg = ptarget[7];
|
||||
uint32_t vhash64[8];
|
||||
be32enc(&endiandata[19], foundNonce);
|
||||
whirlxHash(vhash64, endiandata);
|
||||
|
||||
if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) {
|
||||
*hashes_done = pdata[19] - first_nonce + throughput;
|
||||
pdata[19] = foundNonce;
|
||||
return 1;
|
||||
} else {
|
||||
applog(LOG_WARNING, "GPU #%d: result for %08x does not validate on CPU!", device_map[thr_id], foundNonce);
|
||||
}
|
||||
}
|
||||
|
||||
pdata[19] += throughput;
|
||||
|
||||
if (((uint64_t)pdata[19]+throughput) >= max_nonce) {
|
||||
break;
|
||||
}
|
||||
|
||||
} while (!work_restart[thr_id].restart);
|
||||
|
||||
*(hashes_done) = pdata[19] - first_nonce + 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
+2
-2
@@ -49,7 +49,7 @@ extern void quark_jh512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_jh512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void x11_luffaCubehash512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void x11_luffaCubehash512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t *d_hash, int order);
|
||||
extern void x11_luffaCubehash512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void x11_shavite512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void x11_shavite512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
@@ -208,7 +208,7 @@ extern "C" int scanhash_x14(int thr_id, uint32_t *pdata,
|
||||
quark_skein512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
quark_jh512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
quark_keccak512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
x11_luffaCubehash512_cpu_hash_64(thr_id, throughput, d_hash[thr_id], order++);
|
||||
x11_luffaCubehash512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
x11_shavite512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
x11_simd512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
x11_echo512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
|
||||
+2
-2
@@ -50,7 +50,7 @@ extern void quark_jh512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_jh512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void x11_luffaCubehash512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void x11_luffaCubehash512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t *d_hash, int order);
|
||||
extern void x11_luffaCubehash512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void x11_shavite512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void x11_shavite512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
@@ -219,7 +219,7 @@ extern "C" int scanhash_x15(int thr_id, uint32_t *pdata,
|
||||
quark_skein512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
quark_jh512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
quark_keccak512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
x11_luffaCubehash512_cpu_hash_64(thr_id, throughput, d_hash[thr_id], order++);
|
||||
x11_luffaCubehash512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
x11_shavite512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
x11_simd512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
x11_echo512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
|
||||
+2
-2
@@ -53,7 +53,7 @@ extern void quark_jh512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_jh512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void x11_luffaCubehash512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void x11_luffaCubehash512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t *d_hash, int order);
|
||||
extern void x11_luffaCubehash512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void x11_shavite512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void x11_shavite512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
@@ -243,7 +243,7 @@ extern "C" int scanhash_x17(int thr_id, uint32_t *pdata,
|
||||
quark_skein512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
quark_jh512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
quark_keccak512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
x11_luffaCubehash512_cpu_hash_64(thr_id, throughput, d_hash[thr_id], order++);
|
||||
x11_luffaCubehash512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
x11_shavite512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
x11_simd512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
x11_echo512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
|
||||
@@ -33,9 +33,6 @@ static uint32_t* d_groes[MAX_GPUS];
|
||||
static uint32_t* d_jh512[MAX_GPUS];
|
||||
static uint32_t* d_skein[MAX_GPUS];
|
||||
|
||||
static uint8_t* d_txs[MAX_GPUS];
|
||||
__constant__ uint16_t c_txlens[POK_MAX_TXS];
|
||||
|
||||
__constant__ uint8_t c_permut[24][4];
|
||||
static const uint8_t permut[24][4] = {
|
||||
{0, 1, 2, 3},
|
||||
@@ -115,8 +112,8 @@ extern "C" void zr5hash(void *output, const void *input)
|
||||
|
||||
extern "C" void zr5hash_pok(void *output, uint32_t *pdata)
|
||||
{
|
||||
const uint32_t version = pdata[0] & (~POK_DATA_MASK);
|
||||
uint32_t _ALIGN(64) hash[8];
|
||||
const uint32_t version = (pdata[0] & (~POK_DATA_MASK)) | (use_pok ? POK_BOOL_MASK : 0);
|
||||
|
||||
pdata[0] = version;
|
||||
zr5hash(hash, pdata);
|
||||
@@ -211,7 +208,7 @@ void zr5_move_data_to_hash(int thr_id, uint32_t threads, int rnd)
|
||||
|
||||
|
||||
__global__ __launch_bounds__(128, 8)
|
||||
void zr5_get_poks_gpu(uint32_t threads, uint32_t** const d_buffers, uint8_t* const d_permut, uint16_t *d_poks)
|
||||
void zr5_get_poks_gpu(uint32_t threads, uint32_t** const d_buffers, uint8_t* const d_permut, uint32_t *d_hash, uint16_t *d_poks)
|
||||
{
|
||||
const uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
@@ -226,54 +223,14 @@ void zr5_get_poks_gpu(uint32_t threads, uint32_t** const d_buffers, uint8_t* con
|
||||
}
|
||||
}
|
||||
|
||||
__global__ __launch_bounds__(128, 4)
|
||||
void zr5_get_poks_xor_gpu(uint32_t threads, uint32_t** const d_buffers, uint8_t* d_permut, uint16_t* d_poks, uint8_t* d_txs, uint8_t txs)
|
||||
{
|
||||
const uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
const uint8_t norder = d_permut[thread];
|
||||
const uint8_t algo = c_permut[norder][3];
|
||||
const uint8_t ntx = norder % txs; // generally 0 on testnet...
|
||||
const uint32_t offset = thread * 16U; // 64 / 4;
|
||||
uint32_t* hash = (uint32_t*) (d_buffers[algo] + offset);
|
||||
uint32_t randNdx = hash[1] % c_txlens[ntx];
|
||||
uint8_t* ptx = &d_txs[POK_MAX_TX_SZ*ntx] + randNdx;
|
||||
uint32_t x = 0x100UL * ptx[3] + ptx[2];
|
||||
|
||||
d_poks[thread] = x ^ (hash[2] >> 16);
|
||||
}
|
||||
}
|
||||
|
||||
__host__
|
||||
void zr5_get_poks(int thr_id, uint32_t threads, uint16_t* d_poks, struct work* work)
|
||||
void zr5_get_poks(int thr_id, uint32_t threads, uint16_t* d_poks)
|
||||
{
|
||||
const uint32_t threadsperblock = 128;
|
||||
dim3 grid((threads + threadsperblock - 1) / threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
|
||||
uint8_t txs = (uint8_t) work->tx_count;
|
||||
|
||||
if (txs && use_pok)
|
||||
{
|
||||
uint32_t txlens[POK_MAX_TXS];
|
||||
uint8_t* txdata = (uint8_t*) calloc(POK_MAX_TXS, POK_MAX_TX_SZ);
|
||||
if (!txdata) {
|
||||
applog(LOG_ERR, "%s: error, memory alloc failure", __func__);
|
||||
return;
|
||||
}
|
||||
// create blocs to copy on device
|
||||
for (uint8_t tx=0; tx < txs; tx++) {
|
||||
txlens[tx] = (uint32_t) (work->txs[tx].len - 3U);
|
||||
memcpy(&txdata[POK_MAX_TX_SZ*tx], work->txs[tx].data, min(POK_MAX_TX_SZ, txlens[tx]+3U));
|
||||
}
|
||||
cudaMemcpy(d_txs[thr_id], txdata, txs * POK_MAX_TX_SZ, cudaMemcpyHostToDevice);
|
||||
CUDA_SAFE_CALL(cudaMemcpyToSymbol(c_txlens, txlens, txs * sizeof(uint32_t), 0, cudaMemcpyHostToDevice));
|
||||
zr5_get_poks_xor_gpu <<<grid, block>>> (threads, d_buffers[thr_id], d_permut[thr_id], d_poks, d_txs[thr_id], txs);
|
||||
free(txdata);
|
||||
} else {
|
||||
zr5_get_poks_gpu <<<grid, block>>> (threads, d_buffers[thr_id], d_permut[thr_id], d_poks);
|
||||
}
|
||||
zr5_get_poks_gpu <<<grid, block>>> (threads, d_buffers[thr_id], d_permut[thr_id], d_hash[thr_id], d_poks);
|
||||
}
|
||||
|
||||
|
||||
@@ -328,21 +285,18 @@ extern void quark_skein512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t st
|
||||
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
|
||||
extern "C" int scanhash_zr5(int thr_id, struct work *work,
|
||||
extern "C" int scanhash_zr5(int thr_id, uint32_t *pdata, const uint32_t *ptarget,
|
||||
uint32_t max_nonce, unsigned long *hashes_done)
|
||||
{
|
||||
uint32_t _ALIGN(64) tmpdata[20];
|
||||
uint32_t *pdata = work->data;
|
||||
uint32_t *ptarget = work->target;
|
||||
const uint32_t oldp0 = pdata[0];
|
||||
const uint32_t version = (oldp0 & (~POK_DATA_MASK)) | (use_pok ? POK_BOOL_MASK : 0);
|
||||
const uint32_t version = pdata[0] & (~POK_DATA_MASK);
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1U << 18);
|
||||
throughput = min(throughput, (1U << 20)-1024);
|
||||
throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
if (opt_benchmark)
|
||||
ptarget[7] = 0x0000ff;
|
||||
((uint32_t*)ptarget)[7] = 0x0000ff;
|
||||
|
||||
memcpy(tmpdata, pdata, 80);
|
||||
|
||||
@@ -365,8 +319,6 @@ extern "C" int scanhash_zr5(int thr_id, struct work *work,
|
||||
cudaMalloc(&d_jh512[thr_id], 64 * throughput);
|
||||
cudaMalloc(&d_skein[thr_id], 64 * throughput);
|
||||
|
||||
cudaMalloc(&d_txs[thr_id], POK_MAX_TXS * POK_MAX_TX_SZ);
|
||||
|
||||
jackpot_keccak512_cpu_init(thr_id, throughput);
|
||||
|
||||
quark_blake512_cpu_init(thr_id, throughput);
|
||||
@@ -402,7 +354,7 @@ extern "C" int scanhash_zr5(int thr_id, struct work *work,
|
||||
}
|
||||
|
||||
// store on device d_poks all hash[0] prefixes
|
||||
zr5_get_poks(thr_id, throughput, d_poks[thr_id], work);
|
||||
zr5_get_poks(thr_id, throughput, d_poks[thr_id]);
|
||||
|
||||
// Keccak512 with pok
|
||||
zr5_keccak512_cpu_hash_pok(thr_id, throughput, pdata[19], pdata, d_hash[thr_id], d_poks[thr_id]);
|
||||
@@ -422,6 +374,7 @@ extern "C" int scanhash_zr5(int thr_id, struct work *work,
|
||||
if (foundNonce != UINT32_MAX)
|
||||
{
|
||||
uint32_t vhash64[8];
|
||||
uint32_t oldp0 = pdata[0];
|
||||
uint32_t oldp19 = pdata[19];
|
||||
uint32_t offset = foundNonce - pdata[19];
|
||||
uint32_t pok = 0;
|
||||
@@ -453,6 +406,9 @@ extern "C" int scanhash_zr5(int thr_id, struct work *work,
|
||||
} else {
|
||||
applog(LOG_WARNING, "GPU #%d: result for %08x does not validate on CPU!", device_map[thr_id], foundNonce);
|
||||
|
||||
// reinit the card.. segfault so no
|
||||
// cuda_reset_device(thr_id, init);
|
||||
|
||||
pdata[19]++;
|
||||
pdata[0] = oldp0;
|
||||
}
|
||||
@@ -461,8 +417,6 @@ extern "C" int scanhash_zr5(int thr_id, struct work *work,
|
||||
|
||||
} while (pdata[19] < max_nonce && !work_restart[thr_id].restart);
|
||||
|
||||
pdata[0] = oldp0;
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce + 1;
|
||||
return 0;
|
||||
}
|
||||
Reference in new issue
Block a user