Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
f262850270 | ||
|
|
4a8e3d9aaa | ||
|
|
710d9292af | ||
|
|
8658718791 | ||
|
|
415b01f2c0 | ||
|
|
1c3a95213d | ||
|
|
b6a2c5c2ec | ||
|
|
b1db3a230b | ||
|
|
e22aca94f1 | ||
|
|
ee042e5381 | ||
|
|
a1d448d4e0 | ||
|
|
35b728907c | ||
|
|
dcbcf6ba7e | ||
|
|
81051dd75f | ||
|
|
8d67f0f774 | ||
|
|
929eb7ce3d | ||
|
|
dad0110557 | ||
|
|
e7ed0dea5f | ||
|
|
838f108dd4 | ||
|
|
fbd30f784c | ||
|
|
446e1abd66 | ||
|
|
c0fca5c932 | ||
|
|
ebf885d482 | ||
|
|
be1f64446a | ||
|
|
054af6526c | ||
|
|
1d111c0ec1 | ||
|
|
5a69056ee5 | ||
|
|
7ffe65c262 | ||
|
|
24f452adf6 | ||
|
|
6f4a1baa00 | ||
|
|
d58490911a | ||
|
|
35738cec23 | ||
|
|
e1fd687b9b | ||
|
|
099195e39d | ||
|
|
f2f11b2331 | ||
|
|
7a62bf37fa | ||
|
|
a823cca7f9 | ||
|
|
c3c977da04 | ||
|
|
096f136c36 | ||
|
|
4944e1a098 | ||
|
|
08d58aebb1 | ||
|
|
7c9ec8629f | ||
|
|
6cd53a2305 | ||
|
|
b0617ba0fc | ||
|
|
4e769915d8 | ||
|
|
7d4c48d1d8 | ||
|
|
7fd2df5ba9 | ||
|
|
9bb9af49b2 | ||
|
|
fc27c25436 | ||
|
|
e18355ea9a | ||
|
|
47530cf9ba | ||
|
|
fcf6c1167b | ||
|
|
6e95407dcf | ||
|
|
6e9fe540b6 | ||
|
|
e584c86d88 | ||
|
|
da64c50059 | ||
|
|
7c1137f335 | ||
|
|
934f0e5054 | ||
|
|
4a7e239d7c | ||
|
|
a237601747 | ||
|
|
2e16d00f63 | ||
|
|
76a22479b1 | ||
|
|
394d50987c | ||
|
|
8ceb5cfd65 | ||
|
|
d796a801c5 | ||
|
|
e75b26feb4 | ||
|
|
0cc87b68a9 | ||
|
|
a4404bc325 | ||
|
|
be73cd1ae0 | ||
|
|
5fb84189b2 | ||
|
|
55932ee6f0 | ||
|
|
94d86ca3b3 | ||
|
|
41543b5c0b | ||
|
|
e4476a5eee | ||
|
|
d7c2168f2b | ||
|
|
64e14b7d82 | ||
|
|
2247605d23 | ||
|
|
21115b7fc6 | ||
|
|
e50556b637 | ||
|
|
1e3db41a8d | ||
|
|
e9b88b45e4 | ||
|
|
d3e2088398 | ||
|
|
113e22de2e | ||
|
|
61ff92b5b4 | ||
|
|
2308f555c3 | ||
|
|
0d9d3520ac | ||
|
|
03b2bddc16 | ||
|
|
47f309ffb4 | ||
|
|
2673b3aeff | ||
|
|
c4d6310143 | ||
|
|
31bd1697b1 | ||
|
|
8d4d4d65ce | ||
|
|
26c7316a08 | ||
|
|
2d83f74a7e | ||
|
|
098310abc6 | ||
|
|
d43dc9a021 | ||
|
|
e12d666d36 | ||
|
|
957d919a6a | ||
|
|
3b7ef923c7 | ||
|
|
82a7e62b30 | ||
|
|
ef817df79a | ||
|
|
dec6dbed77 | ||
|
|
e90ade048a | ||
|
|
59a6cd133b | ||
|
|
355b835ae0 | ||
|
|
4868c412b0 | ||
|
|
a7d54cd7ef | ||
|
|
c3d10db873 | ||
|
|
e5d1cf8416 | ||
|
|
6a9280a045 | ||
|
|
5a08c21355 | ||
|
|
32f212469b | ||
|
|
5bf1f98200 | ||
|
|
8fd2739a65 | ||
|
|
fc84c719e9 | ||
|
|
9dfa757dc7 | ||
|
|
8fbfe2cfda | ||
|
|
58c0bb5c02 | ||
|
|
d195f2e8a2 | ||
|
|
c6dcc5e5cf | ||
|
|
8db5a0bc9e | ||
|
|
c7cfe0e2ca | ||
|
|
ab5cc7162e | ||
|
|
c2214091ae | ||
|
|
4e1e03b891 | ||
|
|
934555994d | ||
|
|
922c2a5cd7 | ||
|
|
ee93927fac | ||
|
|
42789f1a0d | ||
|
|
5f12943de5 | ||
|
|
b641bfdf8b | ||
|
|
3f589cc4db | ||
|
|
87edf84bf3 | ||
|
|
b3adebdf2a | ||
|
|
2ebcd1fbd5 |
No files matched your search
+359
-277
@@ -1,24 +1,20 @@
|
||||
/**
|
||||
* Blake-256 Cuda Kernel (Tested on SM 5.0)
|
||||
* Blake-256 Cuda Kernel (Tested on SM 5/5.2)
|
||||
*
|
||||
* Tanguy Pruvot - Nov. 2014
|
||||
* Tanguy Pruvot / SP - Jan 2016
|
||||
*/
|
||||
|
||||
#define PRECALC64 1
|
||||
#include <stdint.h>
|
||||
#include <memory.h>
|
||||
|
||||
#include "miner.h"
|
||||
|
||||
extern "C" {
|
||||
#include "sph/sph_blake.h"
|
||||
#include <stdint.h>
|
||||
#include <memory.h>
|
||||
}
|
||||
|
||||
/* threads per block and throughput (intensity) */
|
||||
#define TPB 128
|
||||
|
||||
/* added in sph_blake.c */
|
||||
extern "C" int blake256_rounds = 14;
|
||||
/* threads per block */
|
||||
#define TPB 512
|
||||
|
||||
/* hash by cpu with blake 256 */
|
||||
extern "C" void blake256hash(void *output, const void *input, int8_t rounds = 14)
|
||||
@@ -26,7 +22,7 @@ extern "C" void blake256hash(void *output, const void *input, int8_t rounds = 14
|
||||
uchar hash[64];
|
||||
sph_blake256_context ctx;
|
||||
|
||||
blake256_rounds = rounds;
|
||||
sph_blake256_set_rounds(rounds);
|
||||
|
||||
sph_blake256_init(&ctx);
|
||||
sph_blake256(&ctx, input, 80);
|
||||
@@ -37,17 +33,12 @@ extern "C" void blake256hash(void *output, const void *input, int8_t rounds = 14
|
||||
|
||||
#include "cuda_helper.h"
|
||||
|
||||
#if PRECALC64
|
||||
__constant__ uint32_t _ALIGN(32) d_data[12];
|
||||
#else
|
||||
__constant__ static uint32_t _ALIGN(32) c_data[20];
|
||||
/* midstate hash cache, this algo is run on 2 parts */
|
||||
__device__ static uint32_t cache[8];
|
||||
__device__ static uint32_t prevsum = 0;
|
||||
/* crc32.c */
|
||||
extern "C" uint32_t crc32_u32t(const uint32_t *buf, size_t size);
|
||||
#ifdef __INTELLISENSE__
|
||||
#define __byte_perm(x, y, b) x
|
||||
#endif
|
||||
|
||||
__constant__ uint32_t _ALIGN(32) d_data[12];
|
||||
|
||||
/* 8 adapters max */
|
||||
static uint32_t *d_resNonce[MAX_GPUS];
|
||||
static uint32_t *h_resNonce[MAX_GPUS];
|
||||
@@ -56,74 +47,19 @@ static uint32_t *h_resNonce[MAX_GPUS];
|
||||
#define NBN 2
|
||||
static uint32_t extra_results[NBN] = { UINT32_MAX };
|
||||
|
||||
/* prefer uint32_t to prevent size conversions = speed +5/10 % */
|
||||
__constant__
|
||||
static uint32_t _ALIGN(32) c_sigma[16][16] = {
|
||||
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
|
||||
{14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
|
||||
{11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
|
||||
{ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
|
||||
{ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
|
||||
{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },
|
||||
{12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
|
||||
{13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
|
||||
{ 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 },
|
||||
{10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13 , 0 },
|
||||
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
|
||||
{14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
|
||||
{11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
|
||||
{ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
|
||||
{ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
|
||||
{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 }
|
||||
};
|
||||
|
||||
#if !PRECALC64
|
||||
__device__ __constant__
|
||||
static const uint32_t __align__(32) c_IV256[8] = {
|
||||
SPH_C32(0x6A09E667), SPH_C32(0xBB67AE85),
|
||||
SPH_C32(0x3C6EF372), SPH_C32(0xA54FF53A),
|
||||
SPH_C32(0x510E527F), SPH_C32(0x9B05688C),
|
||||
SPH_C32(0x1F83D9AB), SPH_C32(0x5BE0CD19)
|
||||
};
|
||||
#endif
|
||||
|
||||
__device__ __constant__
|
||||
static const uint32_t __align__(32) c_u256[16] = {
|
||||
SPH_C32(0x243F6A88), SPH_C32(0x85A308D3),
|
||||
SPH_C32(0x13198A2E), SPH_C32(0x03707344),
|
||||
SPH_C32(0xA4093822), SPH_C32(0x299F31D0),
|
||||
SPH_C32(0x082EFA98), SPH_C32(0xEC4E6C89),
|
||||
SPH_C32(0x452821E6), SPH_C32(0x38D01377),
|
||||
SPH_C32(0xBE5466CF), SPH_C32(0x34E90C6C),
|
||||
SPH_C32(0xC0AC29B7), SPH_C32(0xC97C50DD),
|
||||
SPH_C32(0x3F84D5B5), SPH_C32(0xB5470917)
|
||||
};
|
||||
|
||||
#define GS(a,b,c,d,x) { \
|
||||
const uint32_t idx1 = c_sigma[r][x]; \
|
||||
const uint32_t idx2 = c_sigma[r][x+1]; \
|
||||
v[a] += (m[idx1] ^ c_u256[idx2]) + v[b]; \
|
||||
v[d] = SPH_ROTL32(v[d] ^ v[a], 16); \
|
||||
#define GSPREC(a,b,c,d,x,y) { \
|
||||
v[a] += (m[x] ^ c_u256[y]) + v[b]; \
|
||||
v[d] = __byte_perm(v[d] ^ v[a],0, 0x1032); \
|
||||
v[c] += v[d]; \
|
||||
v[b] = SPH_ROTR32(v[b] ^ v[c], 12); \
|
||||
\
|
||||
v[a] += (m[idx2] ^ c_u256[idx1]) + v[b]; \
|
||||
v[d] = SPH_ROTR32(v[d] ^ v[a], 8); \
|
||||
v[a] += (m[y] ^ c_u256[x]) + v[b]; \
|
||||
v[d] = __byte_perm(v[d] ^ v[a],0, 0x0321); \
|
||||
v[c] += v[d]; \
|
||||
v[b] = SPH_ROTR32(v[b] ^ v[c], 7); \
|
||||
}
|
||||
}
|
||||
|
||||
/* Second part (64-80) msg never change, store it */
|
||||
__device__ __constant__
|
||||
static const uint32_t __align__(32) c_Padding[16] = {
|
||||
0, 0, 0, 0,
|
||||
0x80000000UL, 0, 0, 0,
|
||||
0, 0, 0, 0,
|
||||
0, 1, 0, 640,
|
||||
};
|
||||
|
||||
__device__ static
|
||||
void blake256_compress(uint32_t *h, const uint32_t *block, const uint32_t T0, const int rounds)
|
||||
__device__ __forceinline__
|
||||
void blake256_compress_14(uint32_t *h, const uint32_t *block, const uint32_t T0)
|
||||
{
|
||||
uint32_t /*_ALIGN(8)*/ m[16];
|
||||
uint32_t v[16];
|
||||
@@ -133,12 +69,22 @@ void blake256_compress(uint32_t *h, const uint32_t *block, const uint32_t T0, co
|
||||
m[2] = block[2];
|
||||
m[3] = block[3];
|
||||
|
||||
for (uint32_t i = 4; i < 16; i++) {
|
||||
#if PRECALC64
|
||||
m[i] = c_Padding[i];
|
||||
#else
|
||||
m[i] = (T0 == 0x200) ? block[i] : c_Padding[i];
|
||||
#endif
|
||||
const uint32_t c_u256[16] = {
|
||||
0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344,
|
||||
0xA4093822, 0x299F31D0, 0x082EFA98, 0xEC4E6C89,
|
||||
0x452821E6, 0x38D01377, 0xBE5466CF, 0x34E90C6C,
|
||||
0xC0AC29B7, 0xC97C50DD, 0x3F84D5B5, 0xB5470917
|
||||
};
|
||||
|
||||
const uint32_t c_Padding[12] = {
|
||||
0x80000000UL, 0, 0, 0,
|
||||
0, 0, 0, 0,
|
||||
0, 1, 0, 640,
|
||||
};
|
||||
|
||||
#pragma unroll
|
||||
for (uint32_t i = 0; i < 12; i++) {
|
||||
m[i+4] = c_Padding[i];
|
||||
}
|
||||
|
||||
//#pragma unroll 8
|
||||
@@ -155,132 +101,143 @@ void blake256_compress(uint32_t *h, const uint32_t *block, const uint32_t T0, co
|
||||
v[14] = c_u256[6];
|
||||
v[15] = c_u256[7];
|
||||
|
||||
for (int r = 0; r < rounds; r++) {
|
||||
/* column step */
|
||||
GS(0, 4, 0x8, 0xC, 0x0);
|
||||
GS(1, 5, 0x9, 0xD, 0x2);
|
||||
GS(2, 6, 0xA, 0xE, 0x4);
|
||||
GS(3, 7, 0xB, 0xF, 0x6);
|
||||
/* diagonal step */
|
||||
GS(0, 5, 0xA, 0xF, 0x8);
|
||||
GS(1, 6, 0xB, 0xC, 0xA);
|
||||
GS(2, 7, 0x8, 0xD, 0xC);
|
||||
GS(3, 4, 0x9, 0xE, 0xE);
|
||||
}
|
||||
#if PRECALC64
|
||||
// { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
|
||||
GSPREC(0, 4, 0x8, 0xC,0,1);
|
||||
GSPREC(1, 5, 0x9, 0xD,2,3);
|
||||
GSPREC(2, 6, 0xA, 0xE, 4,5);
|
||||
GSPREC(3, 7, 0xB, 0xF, 6,7);
|
||||
GSPREC(0, 5, 0xA, 0xF, 8,9);
|
||||
GSPREC(1, 6, 0xB, 0xC, 10,11);
|
||||
GSPREC(2, 7, 0x8, 0xD, 12,13);
|
||||
GSPREC(3, 4, 0x9, 0xE, 14,15);
|
||||
// { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 14, 10);
|
||||
GSPREC(1, 5, 0x9, 0xD, 4, 8);
|
||||
GSPREC(2, 6, 0xA, 0xE, 9, 15);
|
||||
GSPREC(3, 7, 0xB, 0xF, 13, 6);
|
||||
GSPREC(0, 5, 0xA, 0xF, 1, 12);
|
||||
GSPREC(1, 6, 0xB, 0xC, 0, 2);
|
||||
GSPREC(2, 7, 0x8, 0xD, 11, 7);
|
||||
GSPREC(3, 4, 0x9, 0xE, 5, 3);
|
||||
// { 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 11, 8);
|
||||
GSPREC(1, 5, 0x9, 0xD, 12, 0);
|
||||
GSPREC(2, 6, 0xA, 0xE, 5, 2);
|
||||
GSPREC(3, 7, 0xB, 0xF, 15, 13);
|
||||
GSPREC(0, 5, 0xA, 0xF, 10, 14);
|
||||
GSPREC(1, 6, 0xB, 0xC, 3, 6);
|
||||
GSPREC(2, 7, 0x8, 0xD, 7, 1);
|
||||
GSPREC(3, 4, 0x9, 0xE, 9, 4);
|
||||
// { 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 7, 9);
|
||||
GSPREC(1, 5, 0x9, 0xD, 3, 1);
|
||||
GSPREC(2, 6, 0xA, 0xE, 13, 12);
|
||||
GSPREC(3, 7, 0xB, 0xF, 11, 14);
|
||||
GSPREC(0, 5, 0xA, 0xF, 2, 6);
|
||||
GSPREC(1, 6, 0xB, 0xC, 5, 10);
|
||||
GSPREC(2, 7, 0x8, 0xD, 4, 0);
|
||||
GSPREC(3, 4, 0x9, 0xE, 15, 8);
|
||||
// { 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 9, 0);
|
||||
GSPREC(1, 5, 0x9, 0xD, 5, 7);
|
||||
GSPREC(2, 6, 0xA, 0xE, 2, 4);
|
||||
GSPREC(3, 7, 0xB, 0xF, 10, 15);
|
||||
GSPREC(0, 5, 0xA, 0xF, 14, 1);
|
||||
GSPREC(1, 6, 0xB, 0xC, 11, 12);
|
||||
GSPREC(2, 7, 0x8, 0xD, 6, 8);
|
||||
GSPREC(3, 4, 0x9, 0xE, 3, 13);
|
||||
// { 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 2, 12);
|
||||
GSPREC(1, 5, 0x9, 0xD, 6, 10);
|
||||
GSPREC(2, 6, 0xA, 0xE, 0, 11);
|
||||
GSPREC(3, 7, 0xB, 0xF, 8, 3);
|
||||
GSPREC(0, 5, 0xA, 0xF, 4, 13);
|
||||
GSPREC(1, 6, 0xB, 0xC, 7, 5);
|
||||
GSPREC(2, 7, 0x8, 0xD, 15, 14);
|
||||
GSPREC(3, 4, 0x9, 0xE, 1, 9);
|
||||
// { 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 12, 5);
|
||||
GSPREC(1, 5, 0x9, 0xD, 1, 15);
|
||||
GSPREC(2, 6, 0xA, 0xE, 14, 13);
|
||||
GSPREC(3, 7, 0xB, 0xF, 4, 10);
|
||||
GSPREC(0, 5, 0xA, 0xF, 0, 7);
|
||||
GSPREC(1, 6, 0xB, 0xC, 6, 3);
|
||||
GSPREC(2, 7, 0x8, 0xD, 9, 2);
|
||||
GSPREC(3, 4, 0x9, 0xE, 8, 11);
|
||||
// { 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 13, 11);
|
||||
GSPREC(1, 5, 0x9, 0xD, 7, 14);
|
||||
GSPREC(2, 6, 0xA, 0xE, 12, 1);
|
||||
GSPREC(3, 7, 0xB, 0xF, 3, 9);
|
||||
GSPREC(0, 5, 0xA, 0xF, 5, 0);
|
||||
GSPREC(1, 6, 0xB, 0xC, 15, 4);
|
||||
GSPREC(2, 7, 0x8, 0xD, 8, 6);
|
||||
GSPREC(3, 4, 0x9, 0xE, 2, 10);
|
||||
// { 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 6, 15);
|
||||
GSPREC(1, 5, 0x9, 0xD, 14, 9);
|
||||
GSPREC(2, 6, 0xA, 0xE, 11, 3);
|
||||
GSPREC(3, 7, 0xB, 0xF, 0, 8);
|
||||
GSPREC(0, 5, 0xA, 0xF, 12, 2);
|
||||
GSPREC(1, 6, 0xB, 0xC, 13, 7);
|
||||
GSPREC(2, 7, 0x8, 0xD, 1, 4);
|
||||
GSPREC(3, 4, 0x9, 0xE, 10, 5);
|
||||
// { 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 10, 2);
|
||||
GSPREC(1, 5, 0x9, 0xD, 8, 4);
|
||||
GSPREC(2, 6, 0xA, 0xE, 7, 6);
|
||||
GSPREC(3, 7, 0xB, 0xF, 1, 5);
|
||||
GSPREC(0, 5, 0xA, 0xF, 15, 11);
|
||||
GSPREC(1, 6, 0xB, 0xC, 9, 14);
|
||||
GSPREC(2, 7, 0x8, 0xD, 3, 12);
|
||||
GSPREC(3, 4, 0x9, 0xE, 13, 0);
|
||||
// { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 0, 1);
|
||||
GSPREC(1, 5, 0x9, 0xD, 2, 3);
|
||||
GSPREC(2, 6, 0xA, 0xE, 4, 5);
|
||||
GSPREC(3, 7, 0xB, 0xF, 6, 7);
|
||||
GSPREC(0, 5, 0xA, 0xF, 8, 9);
|
||||
GSPREC(1, 6, 0xB, 0xC, 10, 11);
|
||||
GSPREC(2, 7, 0x8, 0xD, 12, 13);
|
||||
GSPREC(3, 4, 0x9, 0xE, 14, 15);
|
||||
// { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 14, 10);
|
||||
GSPREC(1, 5, 0x9, 0xD, 4, 8);
|
||||
GSPREC(2, 6, 0xA, 0xE, 9, 15);
|
||||
GSPREC(3, 7, 0xB, 0xF, 13, 6);
|
||||
GSPREC(0, 5, 0xA, 0xF, 1, 12);
|
||||
GSPREC(1, 6, 0xB, 0xC, 0, 2);
|
||||
GSPREC(2, 7, 0x8, 0xD, 11, 7);
|
||||
GSPREC(3, 4, 0x9, 0xE, 5, 3);
|
||||
// { 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 11, 8);
|
||||
GSPREC(1, 5, 0x9, 0xD, 12, 0);
|
||||
GSPREC(2, 6, 0xA, 0xE, 5, 2);
|
||||
GSPREC(3, 7, 0xB, 0xF, 15, 13);
|
||||
GSPREC(0, 5, 0xA, 0xF, 10, 14);
|
||||
GSPREC(1, 6, 0xB, 0xC, 3, 6);
|
||||
GSPREC(2, 7, 0x8, 0xD, 7, 1);
|
||||
GSPREC(3, 4, 0x9, 0xE, 9, 4);
|
||||
// { 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 7, 9);
|
||||
GSPREC(1, 5, 0x9, 0xD, 3, 1);
|
||||
GSPREC(2, 6, 0xA, 0xE, 13, 12);
|
||||
GSPREC(3, 7, 0xB, 0xF, 11, 14);
|
||||
GSPREC(0, 5, 0xA, 0xF, 2, 6);
|
||||
GSPREC(1, 6, 0xB, 0xC, 5, 10);
|
||||
GSPREC(2, 7, 0x8, 0xD, 4, 0);
|
||||
GSPREC(3, 4, 0x9, 0xE, 15, 8);
|
||||
|
||||
// only compute h6 & 7
|
||||
h[6U] ^= v[6U] ^ v[14U];
|
||||
h[7U] ^= v[7U] ^ v[15U];
|
||||
#else
|
||||
//#pragma unroll 16
|
||||
for (uint32_t i = 0; i < 16; i++) {
|
||||
uint32_t j = i % 8U;
|
||||
h[j] ^= v[i];
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#if !PRECALC64 /* original method */
|
||||
__global__
|
||||
void blake256_gpu_hash_80(const uint32_t threads, const uint32_t startNonce, uint32_t *resNonce,
|
||||
const uint64_t highTarget, const int crcsum, const int rounds)
|
||||
{
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
const uint32_t nonce = startNonce + thread;
|
||||
uint32_t h[8];
|
||||
|
||||
#pragma unroll
|
||||
for(int i=0; i<8; i++) {
|
||||
h[i] = c_IV256[i];
|
||||
}
|
||||
|
||||
if (crcsum != prevsum) {
|
||||
prevsum = crcsum;
|
||||
blake256_compress(h, c_data, 512, rounds);
|
||||
#pragma unroll
|
||||
for(int i=0; i<8; i++) {
|
||||
cache[i] = h[i];
|
||||
}
|
||||
} else {
|
||||
#pragma unroll
|
||||
for(int i=0; i<8; i++) {
|
||||
h[i] = cache[i];
|
||||
}
|
||||
}
|
||||
|
||||
// ------ Close: Bytes 64 to 80 ------
|
||||
|
||||
uint32_t ending[4];
|
||||
ending[0] = c_data[16];
|
||||
ending[1] = c_data[17];
|
||||
ending[2] = c_data[18];
|
||||
ending[3] = nonce; /* our tested value */
|
||||
|
||||
blake256_compress(h, ending, 640, rounds);
|
||||
|
||||
// not sure why, h[7] is ok
|
||||
h[6] = cuda_swab32(h[6]);
|
||||
|
||||
// compare count of leading zeros h[6] + h[7]
|
||||
uint64_t high64 = ((uint64_t*)h)[3];
|
||||
if (high64 <= highTarget)
|
||||
#if NBN == 2
|
||||
/* keep the smallest nonce, + extra one if found */
|
||||
if (resNonce[0] > nonce) {
|
||||
// printf("%llx %llx \n", high64, highTarget);
|
||||
resNonce[1] = resNonce[0];
|
||||
resNonce[0] = nonce;
|
||||
}
|
||||
else
|
||||
resNonce[1] = nonce;
|
||||
#else
|
||||
resNonce[0] = nonce;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
__host__
|
||||
uint32_t blake256_cpu_hash_80(const int thr_id, const uint32_t threads, const uint32_t startNonce, const uint64_t highTarget,
|
||||
const uint32_t crcsum, const int8_t rounds)
|
||||
{
|
||||
const uint32_t threadsperblock = TPB;
|
||||
uint32_t result = UINT32_MAX;
|
||||
|
||||
dim3 grid((threads + threadsperblock-1)/threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
size_t shared_size = 0;
|
||||
|
||||
/* Check error on Ctrl+C or kill to prevent segfaults on exit */
|
||||
if (cudaMemset(d_resNonce[thr_id], 0xff, NBN*sizeof(uint32_t)) != cudaSuccess)
|
||||
return result;
|
||||
|
||||
blake256_gpu_hash_80<<<grid, block, shared_size>>>(threads, startNonce, d_resNonce[thr_id], highTarget, crcsum, (int) rounds);
|
||||
MyStreamSynchronize(NULL, 0, thr_id);
|
||||
if (cudaSuccess == cudaMemcpy(h_resNonce[thr_id], d_resNonce[thr_id], NBN*sizeof(uint32_t), cudaMemcpyDeviceToHost)) {
|
||||
result = h_resNonce[thr_id][0];
|
||||
for (int n=0; n < (NBN-1); n++)
|
||||
extra_results[n] = h_resNonce[thr_id][n+1];
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
__host__
|
||||
void blake256_cpu_setBlock_80(uint32_t *pdata, const uint32_t *ptarget)
|
||||
{
|
||||
uint32_t data[20];
|
||||
memcpy(data, pdata, 80);
|
||||
CUDA_SAFE_CALL(cudaMemcpyToSymbol(c_data, data, sizeof(data), 0, cudaMemcpyHostToDevice));
|
||||
}
|
||||
#else
|
||||
|
||||
/* ############################################################################################################################### */
|
||||
/* Precalculated 1st 64-bytes block (midstate) method */
|
||||
|
||||
__global__
|
||||
void blake256_gpu_hash_16(const uint32_t threads, const uint32_t startNonce, uint32_t *resNonce,
|
||||
const uint64_t highTarget, const int rounds, const bool trace)
|
||||
__global__ __launch_bounds__(1024,1)
|
||||
void blake256_gpu_hash_16(const uint32_t threads, const uint32_t startNonce, uint32_t *resNonce, const uint64_t highTarget)
|
||||
{
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
@@ -301,28 +258,161 @@ void blake256_gpu_hash_16(const uint32_t threads, const uint32_t startNonce, uin
|
||||
ending[2] = d_data[10];
|
||||
ending[3] = nonce; /* our tested value */
|
||||
|
||||
blake256_compress(h, ending, 640, rounds);
|
||||
blake256_compress_14(h, ending, 640);
|
||||
|
||||
if (h[7] == 0 && cuda_swab32(h[6]) <= highTarget) {
|
||||
#if NBN == 2
|
||||
/* keep the smallest nonce, + extra one if found */
|
||||
if (resNonce[0] > nonce) {
|
||||
resNonce[1] = resNonce[0];
|
||||
resNonce[0] = nonce;
|
||||
}
|
||||
else
|
||||
if (resNonce[0] != UINT32_MAX)
|
||||
resNonce[1] = nonce;
|
||||
else
|
||||
resNonce[0] = nonce;
|
||||
#else
|
||||
resNonce[0] = nonce;
|
||||
#endif
|
||||
#ifdef _DEBUG
|
||||
if (trace) {
|
||||
uint64_t high64 = ((uint64_t*)h)[3];
|
||||
printf("gpu: %16llx\n", high64);
|
||||
printf("gpu: %08x.%08x\n", h[7], h[6]);
|
||||
printf("tgt: %16llx\n", highTarget);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
__global__
|
||||
#if __CUDA_ARCH__ >= 500
|
||||
__launch_bounds__(512, 3) /* 40 regs */
|
||||
#endif
|
||||
void blake256_gpu_hash_16_8(const uint32_t threads, const uint32_t startNonce, uint32_t *resNonce, const uint64_t highTarget)
|
||||
{
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
uint32_t h[8];
|
||||
const uint32_t nonce = startNonce + thread;
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 0; i < 8; i++) {
|
||||
h[i] = d_data[i];
|
||||
}
|
||||
|
||||
// ------ Close: Bytes 64 to 80 ------
|
||||
|
||||
uint32_t m[16] = {
|
||||
d_data[8], d_data[9], d_data[10], nonce,
|
||||
0x80000000UL, 0, 0, 0,
|
||||
0, 0, 0, 0,
|
||||
0, 1, 0, 640,
|
||||
};
|
||||
|
||||
const uint32_t c_u256[16] = {
|
||||
0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344,
|
||||
0xA4093822, 0x299F31D0, 0x082EFA98, 0xEC4E6C89,
|
||||
0x452821E6, 0x38D01377, 0xBE5466CF, 0x34E90C6C,
|
||||
0xC0AC29B7, 0xC97C50DD, 0x3F84D5B5, 0xB5470917
|
||||
};
|
||||
|
||||
uint32_t v[16];
|
||||
|
||||
#pragma unroll
|
||||
for (uint32_t i = 0; i < 8; i++)
|
||||
v[i] = h[i];
|
||||
|
||||
v[8] = c_u256[0];
|
||||
v[9] = c_u256[1];
|
||||
v[10] = c_u256[2];
|
||||
v[11] = c_u256[3];
|
||||
|
||||
v[12] = c_u256[4] ^ 640U;
|
||||
v[13] = c_u256[5] ^ 640U;
|
||||
v[14] = c_u256[6];
|
||||
v[15] = c_u256[7];
|
||||
|
||||
// { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 0, 1);
|
||||
GSPREC(1, 5, 0x9, 0xD, 2, 3);
|
||||
GSPREC(2, 6, 0xA, 0xE, 4, 5);
|
||||
GSPREC(3, 7, 0xB, 0xF, 6, 7);
|
||||
GSPREC(0, 5, 0xA, 0xF, 8, 9);
|
||||
GSPREC(1, 6, 0xB, 0xC, 10, 11);
|
||||
GSPREC(2, 7, 0x8, 0xD, 12, 13);
|
||||
GSPREC(3, 4, 0x9, 0xE, 14, 15);
|
||||
// { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 14, 10);
|
||||
GSPREC(1, 5, 0x9, 0xD, 4, 8);
|
||||
GSPREC(2, 6, 0xA, 0xE, 9, 15);
|
||||
GSPREC(3, 7, 0xB, 0xF, 13, 6);
|
||||
GSPREC(0, 5, 0xA, 0xF, 1, 12);
|
||||
GSPREC(1, 6, 0xB, 0xC, 0, 2);
|
||||
GSPREC(2, 7, 0x8, 0xD, 11, 7);
|
||||
GSPREC(3, 4, 0x9, 0xE, 5, 3);
|
||||
// { 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 11, 8);
|
||||
GSPREC(1, 5, 0x9, 0xD, 12, 0);
|
||||
GSPREC(2, 6, 0xA, 0xE, 5, 2);
|
||||
GSPREC(3, 7, 0xB, 0xF, 15, 13);
|
||||
GSPREC(0, 5, 0xA, 0xF, 10, 14);
|
||||
GSPREC(1, 6, 0xB, 0xC, 3, 6);
|
||||
GSPREC(2, 7, 0x8, 0xD, 7, 1);
|
||||
GSPREC(3, 4, 0x9, 0xE, 9, 4);
|
||||
// { 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 7, 9);
|
||||
GSPREC(1, 5, 0x9, 0xD, 3, 1);
|
||||
GSPREC(2, 6, 0xA, 0xE, 13, 12);
|
||||
GSPREC(3, 7, 0xB, 0xF, 11, 14);
|
||||
GSPREC(0, 5, 0xA, 0xF, 2, 6);
|
||||
GSPREC(1, 6, 0xB, 0xC, 5, 10);
|
||||
GSPREC(2, 7, 0x8, 0xD, 4, 0);
|
||||
GSPREC(3, 4, 0x9, 0xE, 15, 8);
|
||||
// { 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 9, 0);
|
||||
GSPREC(1, 5, 0x9, 0xD, 5, 7);
|
||||
GSPREC(2, 6, 0xA, 0xE, 2, 4);
|
||||
GSPREC(3, 7, 0xB, 0xF, 10, 15);
|
||||
GSPREC(0, 5, 0xA, 0xF, 14, 1);
|
||||
GSPREC(1, 6, 0xB, 0xC, 11, 12);
|
||||
GSPREC(2, 7, 0x8, 0xD, 6, 8);
|
||||
GSPREC(3, 4, 0x9, 0xE, 3, 13);
|
||||
// { 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 2, 12);
|
||||
GSPREC(1, 5, 0x9, 0xD, 6, 10);
|
||||
GSPREC(2, 6, 0xA, 0xE, 0, 11);
|
||||
GSPREC(3, 7, 0xB, 0xF, 8, 3);
|
||||
GSPREC(0, 5, 0xA, 0xF, 4, 13);
|
||||
GSPREC(1, 6, 0xB, 0xC, 7, 5);
|
||||
GSPREC(2, 7, 0x8, 0xD, 15, 14);
|
||||
GSPREC(3, 4, 0x9, 0xE, 1, 9);
|
||||
// { 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 12, 5);
|
||||
GSPREC(1, 5, 0x9, 0xD, 1, 15);
|
||||
GSPREC(2, 6, 0xA, 0xE, 14, 13);
|
||||
GSPREC(3, 7, 0xB, 0xF, 4, 10);
|
||||
GSPREC(0, 5, 0xA, 0xF, 0, 7);
|
||||
GSPREC(1, 6, 0xB, 0xC, 6, 3);
|
||||
GSPREC(2, 7, 0x8, 0xD, 9, 2);
|
||||
GSPREC(3, 4, 0x9, 0xE, 8, 11);
|
||||
// { 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 13, 11);
|
||||
GSPREC(1, 5, 0x9, 0xD, 7, 14);
|
||||
GSPREC(2, 6, 0xA, 0xE, 12, 1);
|
||||
GSPREC(3, 7, 0xB, 0xF, 3, 9);
|
||||
GSPREC(0, 5, 0xA, 0xF, 5, 0);
|
||||
GSPREC(1, 6, 0xB, 0xC, 15, 4);
|
||||
GSPREC(2, 7, 0x8, 0xD, 8, 6);
|
||||
//GSPREC(3, 4, 0x9, 0xE, 2, 10);
|
||||
// { 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 },
|
||||
|
||||
// only compute h6 & 7
|
||||
//h[6] ^= v[6] ^ v[14];
|
||||
//h[7] ^= v[7] ^ v[15];
|
||||
|
||||
if ((h[7]^v[7]^v[15]) == 0) // h7
|
||||
{
|
||||
GSPREC(3, 4, 0x9, 0xE, 2, 10);
|
||||
if (cuda_swab32(h[6]^v[6]^v[14]) <= highTarget) {
|
||||
#if NBN == 2
|
||||
if (resNonce[0] != UINT32_MAX)
|
||||
resNonce[1] = nonce;
|
||||
else
|
||||
resNonce[0] = nonce;
|
||||
#else
|
||||
resNonce[0] = nonce;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -331,18 +421,20 @@ __host__
|
||||
static uint32_t blake256_cpu_hash_16(const int thr_id, const uint32_t threads, const uint32_t startNonce, const uint64_t highTarget,
|
||||
const int8_t rounds)
|
||||
{
|
||||
const uint32_t threadsperblock = TPB;
|
||||
uint32_t result = UINT32_MAX;
|
||||
|
||||
dim3 grid((threads + threadsperblock-1)/threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
dim3 grid((threads + TPB-1)/TPB);
|
||||
dim3 block(TPB);
|
||||
|
||||
/* Check error on Ctrl+C or kill to prevent segfaults on exit */
|
||||
if (cudaMemset(d_resNonce[thr_id], 0xff, NBN*sizeof(uint32_t)) != cudaSuccess)
|
||||
return result;
|
||||
|
||||
blake256_gpu_hash_16 <<<grid, block>>> (threads, startNonce, d_resNonce[thr_id], highTarget, (int) rounds, opt_tracegpu);
|
||||
MyStreamSynchronize(NULL, 0, thr_id);
|
||||
if (rounds == 8)
|
||||
blake256_gpu_hash_16_8 <<<grid, block>>> (threads, startNonce, d_resNonce[thr_id], highTarget);
|
||||
else
|
||||
blake256_gpu_hash_16 <<<grid, block>>> (threads, startNonce, d_resNonce[thr_id], highTarget);
|
||||
|
||||
if (cudaSuccess == cudaMemcpy(h_resNonce[thr_id], d_resNonce[thr_id], NBN*sizeof(uint32_t), cudaMemcpyDeviceToHost)) {
|
||||
result = h_resNonce[thr_id][0];
|
||||
for (int n=0; n < (NBN-1); n++)
|
||||
@@ -356,8 +448,7 @@ static void blake256mid(uint32_t *output, const uint32_t *input, int8_t rounds =
|
||||
{
|
||||
sph_blake256_context ctx;
|
||||
|
||||
/* in sph_blake.c */
|
||||
blake256_rounds = rounds;
|
||||
sph_blake256_set_rounds(rounds);
|
||||
|
||||
sph_blake256_init(&ctx);
|
||||
sph_blake256(&ctx, input, 64);
|
||||
@@ -375,118 +466,108 @@ void blake256_cpu_setBlock_16(uint32_t *penddata, const uint32_t *midstate, cons
|
||||
data[10]= penddata[2];
|
||||
CUDA_SAFE_CALL(cudaMemcpyToSymbol(d_data, data, 32 + 12, 0, cudaMemcpyHostToDevice));
|
||||
}
|
||||
#endif
|
||||
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
|
||||
extern "C" int scanhash_blake256(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done, int8_t blakerounds=14)
|
||||
{
|
||||
uint32_t _ALIGN(64) endiandata[20];
|
||||
#if PRECALC64
|
||||
uint32_t _ALIGN(64) midstate[8];
|
||||
#else
|
||||
uint32_t crcsum;
|
||||
#endif
|
||||
|
||||
uint32_t *pdata = work->data;
|
||||
uint32_t *ptarget = work->target;
|
||||
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
uint64_t targetHigh = ((uint64_t*)ptarget)[3];
|
||||
int intensity = (device_sm[device_map[thr_id]] > 500) ? 22 : 20;
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1U << intensity);
|
||||
throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
int dev_id = device_map[thr_id];
|
||||
int intensity = (device_sm[dev_id] > 500 && !is_windows()) ? 30 : 26;
|
||||
if (device_sm[dev_id] < 350) intensity = 22;
|
||||
|
||||
uint32_t throughput = cuda_default_throughput(thr_id, 1U << intensity);
|
||||
if (init[thr_id]) throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
int rc = 0;
|
||||
|
||||
if (opt_benchmark) {
|
||||
targetHigh = 0x1ULL << 32;
|
||||
((uint32_t*)ptarget)[6] = swab32(0xff);
|
||||
ptarget[6] = swab32(0xff);
|
||||
}
|
||||
|
||||
if (opt_tracegpu) {
|
||||
/* test call from util.c */
|
||||
throughput = 1;
|
||||
for (int k = 0; k < 20; k++)
|
||||
pdata[k] = swab32(pdata[k]);
|
||||
}
|
||||
if (!init[thr_id])
|
||||
{
|
||||
cudaSetDevice(dev_id);
|
||||
if (opt_cudaschedule == -1 && gpu_threads == 1) {
|
||||
cudaDeviceReset();
|
||||
// reduce cpu usage (linux)
|
||||
cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);
|
||||
cudaDeviceSetCacheConfig(cudaFuncCachePreferL1);
|
||||
CUDA_LOG_ERROR();
|
||||
}
|
||||
|
||||
if (!init[thr_id]) {
|
||||
if (active_gpus > 1)
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
CUDA_CALL_OR_RET_X(cudaMallocHost(&h_resNonce[thr_id], NBN * sizeof(uint32_t)), 0);
|
||||
CUDA_CALL_OR_RET_X(cudaMalloc(&d_resNonce[thr_id], NBN * sizeof(uint32_t)), 0);
|
||||
CUDA_CALL_OR_RET_X(cudaMalloc(&d_resNonce[thr_id], NBN * sizeof(uint32_t)), -1);
|
||||
CUDA_CALL_OR_RET_X(cudaMallocHost(&h_resNonce[thr_id], NBN * sizeof(uint32_t)), -1);
|
||||
init[thr_id] = true;
|
||||
}
|
||||
|
||||
#if PRECALC64
|
||||
for (int k = 0; k < 16; k++)
|
||||
be32enc(&endiandata[k], pdata[k]);
|
||||
|
||||
blake256mid(midstate, endiandata, blakerounds);
|
||||
blake256_cpu_setBlock_16(&pdata[16], midstate, ptarget);
|
||||
#else
|
||||
blake256_cpu_setBlock_80(pdata, ptarget);
|
||||
crcsum = crc32_u32t(pdata, 64);
|
||||
#endif /* PRECALC64 */
|
||||
|
||||
do {
|
||||
uint32_t foundNonce =
|
||||
#if PRECALC64
|
||||
// GPU HASH (second block only, first is midstate)
|
||||
blake256_cpu_hash_16(thr_id, throughput, pdata[19], targetHigh, blakerounds);
|
||||
#else
|
||||
// GPU FULL HASH
|
||||
blake256_cpu_hash_80(thr_id, throughput, pdata[19], targetHigh, crcsum, blakerounds);
|
||||
#endif
|
||||
uint32_t foundNonce = blake256_cpu_hash_16(thr_id, throughput, pdata[19], targetHigh, blakerounds);
|
||||
|
||||
if (foundNonce != UINT32_MAX)
|
||||
{
|
||||
uint32_t vhashcpu[8];
|
||||
uint32_t Htarg = (uint32_t)targetHigh;
|
||||
uint32_t Htarg = ptarget[6];
|
||||
|
||||
for (int k=0; k < 19; k++)
|
||||
for (int k=16; k < 19; k++)
|
||||
be32enc(&endiandata[k], pdata[k]);
|
||||
|
||||
be32enc(&endiandata[19], foundNonce);
|
||||
blake256hash(vhashcpu, endiandata, blakerounds);
|
||||
|
||||
//applog(LOG_BLUE, "%08x %16llx", vhashcpu[6], targetHigh);
|
||||
if (vhashcpu[6] <= Htarg && fulltest(vhashcpu, ptarget))
|
||||
{
|
||||
rc = 1;
|
||||
work_set_target_ratio(work, vhashcpu);
|
||||
*hashes_done = pdata[19] - first_nonce + throughput;
|
||||
pdata[19] = foundNonce;
|
||||
*hashes_done = pdata[19] - first_nonce + 1;
|
||||
#if NBN > 1
|
||||
if (extra_results[0] != UINT32_MAX) {
|
||||
be32enc(&endiandata[19], extra_results[0]);
|
||||
blake256hash(vhashcpu, endiandata, blakerounds);
|
||||
if (vhashcpu[6] <= Htarg /* && fulltest(vhashcpu, ptarget) */) {
|
||||
if (vhashcpu[6] <= Htarg && fulltest(vhashcpu, ptarget)) {
|
||||
pdata[21] = extra_results[0];
|
||||
applog(LOG_BLUE, "1:%x 2:%x", foundNonce, extra_results[0]);
|
||||
*hashes_done = max(*hashes_done, extra_results[0] - first_nonce + 1);
|
||||
if (bn_hash_target_ratio(vhashcpu, ptarget) > work->shareratio) {
|
||||
work_set_target_ratio(work, vhashcpu);
|
||||
xchg(pdata[21], pdata[19]);
|
||||
}
|
||||
rc = 2;
|
||||
}
|
||||
extra_results[0] = UINT32_MAX;
|
||||
}
|
||||
#endif
|
||||
//applog_hash((uint8_t*)ptarget);
|
||||
//applog_compare_hash((uint8_t*)vhashcpu,(uint8_t*)ptarget);
|
||||
return rc;
|
||||
}
|
||||
else if (opt_debug) {
|
||||
applog_hash((uchar*)ptarget);
|
||||
applog_compare_hash((uchar*)vhashcpu, (uchar*)ptarget);
|
||||
applog(LOG_WARNING, "GPU #%d: result for nonce %08x does not validate on CPU!", device_map[thr_id], foundNonce);
|
||||
gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", foundNonce);
|
||||
}
|
||||
}
|
||||
|
||||
if ((uint64_t) pdata[19] + throughput > (uint64_t) max_nonce) {
|
||||
break;
|
||||
}
|
||||
|
||||
pdata[19] += throughput;
|
||||
|
||||
} while (!work_restart[thr_id].restart);
|
||||
} while (!work_restart[thr_id].restart && max_nonce > (uint64_t)throughput + pdata[19]);
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
|
||||
MyStreamSynchronize(NULL, 0, device_map[thr_id]);
|
||||
return rc;
|
||||
}
|
||||
|
||||
@@ -496,7 +577,7 @@ extern "C" void free_blake256(int thr_id)
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaDeviceSynchronize();
|
||||
|
||||
cudaFreeHost(h_resNonce[thr_id]);
|
||||
cudaFree(d_resNonce[thr_id]);
|
||||
@@ -504,4 +585,5 @@ extern "C" void free_blake256(int thr_id)
|
||||
init[thr_id] = false;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,515 @@
|
||||
/**
|
||||
* Blake2-S 256 CUDA implementation
|
||||
* @author tpruvot@github March 2016
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdint.h>
|
||||
#include <memory.h>
|
||||
|
||||
#include "miner.h"
|
||||
|
||||
extern "C" {
|
||||
#define NATIVE_LITTLE_ENDIAN
|
||||
#include <sph/blake2s.h>
|
||||
}
|
||||
|
||||
//#define GPU_MIDSTATE
|
||||
#define MIDLEN 76
|
||||
#define A 64
|
||||
|
||||
static __thread blake2s_state ALIGN(A) s_midstate;
|
||||
static __thread blake2s_state ALIGN(A) s_ctx;
|
||||
|
||||
#include "cuda_helper.h"
|
||||
|
||||
#ifdef __INTELLISENSE__
|
||||
#define __byte_perm(x, y, b) x
|
||||
#endif
|
||||
|
||||
#ifndef GPU_MIDSTATE
|
||||
__constant__ uint2 d_data[10];
|
||||
#else
|
||||
__constant__ blake2s_state ALIGN(8) d_state[1];
|
||||
#endif
|
||||
|
||||
/* 16 adapters max */
|
||||
static uint32_t *d_resNonce[MAX_GPUS];
|
||||
static uint32_t *h_resNonce[MAX_GPUS];
|
||||
|
||||
/* threads per block */
|
||||
#define TPB 512
|
||||
|
||||
/* max count of found nonces in one call */
|
||||
#define NBN 2
|
||||
#if NBN > 1
|
||||
static uint32_t extra_results[NBN] = { UINT32_MAX };
|
||||
#endif
|
||||
|
||||
extern "C" void blake2s_hash(void *output, const void *input)
|
||||
{
|
||||
uint8_t _ALIGN(A) hash[BLAKE2S_OUTBYTES];
|
||||
blake2s_state blake2_ctx;
|
||||
|
||||
blake2s_init(&blake2_ctx, BLAKE2S_OUTBYTES);
|
||||
blake2s_update(&blake2_ctx, (uint8_t*) input, 80);
|
||||
blake2s_final(&blake2_ctx, hash, BLAKE2S_OUTBYTES);
|
||||
|
||||
memcpy(output, hash, 32);
|
||||
}
|
||||
|
||||
__host__
|
||||
inline void blake2s_hash_end(uint32_t *output, const uint32_t *input)
|
||||
{
|
||||
s_ctx.buflen = MIDLEN;
|
||||
memcpy(&s_ctx, &s_midstate, 32 + 16 + MIDLEN);
|
||||
blake2s_update(&s_ctx, (uint8_t*) &input[MIDLEN/4], 80-MIDLEN);
|
||||
blake2s_final(&s_ctx, (uint8_t*) output, BLAKE2S_OUTBYTES);
|
||||
}
|
||||
|
||||
__host__
|
||||
void blake2s_setBlock(uint32_t *penddata, blake2s_state *pstate)
|
||||
{
|
||||
#ifndef GPU_MIDSTATE
|
||||
CUDA_SAFE_CALL(cudaMemcpyToSymbol(d_data, penddata, 80, 0, cudaMemcpyHostToDevice));
|
||||
#else
|
||||
CUDA_SAFE_CALL(cudaMemcpyToSymbol(d_state, pstate, sizeof(blake2s_state), 0, cudaMemcpyHostToDevice));
|
||||
#endif
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
uint64_t gpu_load64(void *src) {
|
||||
return *(uint64_t*)(src);
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
void gpu_store32(void *dst, uint32_t dw) {
|
||||
*(uint32_t*)(dst) = dw;
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
void gpu_store64(void *dst, uint64_t lw) {
|
||||
*(uint64_t*)(dst) = lw;
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
void gpu_blake2s_set_lastnode(blake2s_state *S) {
|
||||
S->f[1] = ~0U;
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
void gpu_blake2s_clear_lastnode(blake2s_state *S) {
|
||||
S->f[1] = 0U;
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
void gpu_blake2s_increment_counter(blake2s_state *S, const uint32_t inc)
|
||||
{
|
||||
S->t[0] += inc;
|
||||
S->t[1] += ( S->t[0] < inc );
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
void gpu_blake2s_set_lastblock(blake2s_state *S)
|
||||
{
|
||||
if (S->last_node) gpu_blake2s_set_lastnode(S);
|
||||
S->f[0] = ~0U;
|
||||
}
|
||||
|
||||
__device__
|
||||
void gpu_blake2s_compress(blake2s_state *S, const uint32_t *block)
|
||||
{
|
||||
uint32_t m[16];
|
||||
uint32_t v[16];
|
||||
|
||||
const uint32_t blake2s_IV[8] = {
|
||||
0x6A09E667UL, 0xBB67AE85UL, 0x3C6EF372UL, 0xA54FF53AUL,
|
||||
0x510E527FUL, 0x9B05688CUL, 0x1F83D9ABUL, 0x5BE0CD19UL
|
||||
};
|
||||
|
||||
const uint8_t blake2s_sigma[10][16] = {
|
||||
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
|
||||
{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
|
||||
{ 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
|
||||
{ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
|
||||
{ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
|
||||
{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },
|
||||
{ 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
|
||||
{ 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
|
||||
{ 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 },
|
||||
{ 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13 , 0 },
|
||||
};
|
||||
|
||||
#pragma unroll
|
||||
for(int i = 0; i < 16; i++)
|
||||
m[i] = block[i];
|
||||
|
||||
#pragma unroll
|
||||
for(int i = 0; i < 8; i++)
|
||||
v[i] = S->h[i];
|
||||
|
||||
v[ 8] = blake2s_IV[0];
|
||||
v[ 9] = blake2s_IV[1];
|
||||
v[10] = blake2s_IV[2];
|
||||
v[11] = blake2s_IV[3];
|
||||
v[12] = S->t[0] ^ blake2s_IV[4];
|
||||
v[13] = S->t[1] ^ blake2s_IV[5];
|
||||
v[14] = S->f[0] ^ blake2s_IV[6];
|
||||
v[15] = S->f[1] ^ blake2s_IV[7];
|
||||
|
||||
#define G(r,i,a,b,c,d) { \
|
||||
a += b + m[blake2s_sigma[r][2*i+0]]; \
|
||||
d = __byte_perm(d ^ a, 0, 0x1032); /* d = ROTR32(d ^ a, 16); */ \
|
||||
c = c + d; \
|
||||
b = ROTR32(b ^ c, 12); \
|
||||
a += b + m[blake2s_sigma[r][2*i+1]]; \
|
||||
d = __byte_perm(d ^ a, 0, 0x0321); /* ROTR32(d ^ a, 8); */ \
|
||||
c = c + d; \
|
||||
b = ROTR32(b ^ c, 7); \
|
||||
}
|
||||
|
||||
#define ROUND(r) { \
|
||||
G(r,0,v[ 0],v[ 4],v[ 8],v[12]); \
|
||||
G(r,1,v[ 1],v[ 5],v[ 9],v[13]); \
|
||||
G(r,2,v[ 2],v[ 6],v[10],v[14]); \
|
||||
G(r,3,v[ 3],v[ 7],v[11],v[15]); \
|
||||
G(r,4,v[ 0],v[ 5],v[10],v[15]); \
|
||||
G(r,5,v[ 1],v[ 6],v[11],v[12]); \
|
||||
G(r,6,v[ 2],v[ 7],v[ 8],v[13]); \
|
||||
G(r,7,v[ 3],v[ 4],v[ 9],v[14]); \
|
||||
}
|
||||
|
||||
ROUND( 0 );
|
||||
ROUND( 1 );
|
||||
ROUND( 2 );
|
||||
ROUND( 3 );
|
||||
ROUND( 4 );
|
||||
ROUND( 5 );
|
||||
ROUND( 6 );
|
||||
ROUND( 7 );
|
||||
ROUND( 8 );
|
||||
ROUND( 9 );
|
||||
|
||||
#pragma unroll
|
||||
for(int i = 0; i < 8; i++)
|
||||
S->h[i] = S->h[i] ^ v[i] ^ v[i + 8];
|
||||
|
||||
#undef G
|
||||
#undef ROUND
|
||||
}
|
||||
|
||||
#if 0
|
||||
/* unused but kept as reference */
|
||||
__device__ __forceinline__
|
||||
void gpu_blake2s_update(blake2s_state *S, const uint8_t *in, uint64_t inlen)
|
||||
{
|
||||
while(inlen > 0)
|
||||
{
|
||||
const int left = S->buflen;
|
||||
size_t fill = 2 * BLAKE2S_BLOCKBYTES - left;
|
||||
if(inlen > fill)
|
||||
{
|
||||
memcpy(S->buf + left, in, fill); // Fill buffer
|
||||
S->buflen += fill;
|
||||
|
||||
gpu_blake2s_increment_counter(S, BLAKE2S_BLOCKBYTES);
|
||||
gpu_blake2s_compress(S, (uint32_t*) S->buf); // Compress
|
||||
memcpy(S->buf, S->buf + BLAKE2S_BLOCKBYTES, BLAKE2S_BLOCKBYTES); // Shift buffer left
|
||||
S->buflen -= BLAKE2S_BLOCKBYTES;
|
||||
in += fill;
|
||||
inlen -= fill;
|
||||
}
|
||||
else // inlen <= fill
|
||||
{
|
||||
memcpy(S->buf + left, in, (size_t) inlen);
|
||||
S->buflen += (size_t) inlen; // Be lazy, do not compress
|
||||
in += inlen;
|
||||
inlen -= inlen;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef GPU_MIDSTATE
|
||||
__device__ __forceinline__
|
||||
void gpu_blake2s_fill_data(blake2s_state *S, const uint32_t nonce)
|
||||
{
|
||||
uint2 *b2 = (uint2*) S->buf;
|
||||
#pragma unroll
|
||||
for (int i=0; i < 9; i++)
|
||||
b2[i] = d_data[i];
|
||||
b2[9].x = d_data[9].x;
|
||||
b2[9].y = nonce;
|
||||
S->buflen = 80;
|
||||
}
|
||||
#endif
|
||||
|
||||
__device__ __forceinline__
|
||||
void gpu_blake2s_update_nonce(blake2s_state *S, const uint32_t nonce)
|
||||
{
|
||||
gpu_store32(&S->buf[76], nonce);
|
||||
S->buflen = 80;
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
uint2 gpu_blake2s_final(blake2s_state *S)
|
||||
{
|
||||
//if (S->buflen > BLAKE2S_BLOCKBYTES)
|
||||
{
|
||||
gpu_blake2s_increment_counter(S, BLAKE2S_BLOCKBYTES);
|
||||
gpu_blake2s_compress(S, (uint32_t*) S->buf);
|
||||
S->buflen -= BLAKE2S_BLOCKBYTES;
|
||||
//memcpy(S->buf, S->buf + BLAKE2S_BLOCKBYTES, S->buflen);
|
||||
}
|
||||
|
||||
gpu_blake2s_increment_counter(S, (uint32_t)S->buflen);
|
||||
gpu_blake2s_set_lastblock(S);
|
||||
//memset(&S->buf[S->buflen], 0, 2 * BLAKE2S_BLOCKBYTES - S->buflen); /* Padding */
|
||||
gpu_blake2s_compress(S, (uint32_t*) (S->buf + BLAKE2S_BLOCKBYTES));
|
||||
|
||||
//#pragma unroll
|
||||
//for (int i = 0; i < 8; i++)
|
||||
// out[i] = S->h[i];
|
||||
return make_uint2(S->h[6], S->h[7]);
|
||||
}
|
||||
|
||||
/* init2 xors IV with input parameter block */
|
||||
__device__ __forceinline__
|
||||
void gpu_blake2s_init_param(blake2s_state *S, const blake2s_param *P)
|
||||
{
|
||||
//blake2s_IV
|
||||
S->h[0] = 0x6A09E667UL;
|
||||
S->h[1] = 0xBB67AE85UL;
|
||||
S->h[2] = 0x3C6EF372UL;
|
||||
S->h[3] = 0xA54FF53AUL;
|
||||
S->h[4] = 0x510E527FUL;
|
||||
S->h[5] = 0x9B05688CUL;
|
||||
S->h[6] = 0x1F83D9ABUL;
|
||||
S->h[7] = 0x5BE0CD19UL;
|
||||
|
||||
S->t[0] = 0; S->t[1] = 0;
|
||||
S->f[0] = 0; S->f[1] = 0;
|
||||
S->last_node = 0;
|
||||
|
||||
S->buflen = 0;
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 8; i < sizeof(S->buf)/8; i++)
|
||||
gpu_store64(S->buf + (8*i), 0);
|
||||
|
||||
uint64_t *p = (uint64_t*) P;
|
||||
|
||||
/* IV XOR ParamBlock */
|
||||
#pragma unroll
|
||||
for (int i = 0; i < 4; i++)
|
||||
S->h[i] ^= gpu_load64(&p[i]);
|
||||
}
|
||||
|
||||
// Sequential blake2s initialization
|
||||
__device__ __forceinline__
|
||||
void gpu_blake2s_init(blake2s_state *S, const uint8_t outlen)
|
||||
{
|
||||
blake2s_param P[1];
|
||||
|
||||
// if (!outlen || outlen > BLAKE2S_OUTBYTES) return;
|
||||
|
||||
P->digest_length = outlen;
|
||||
P->key_length = 0;
|
||||
P->fanout = 1;
|
||||
P->depth = 1;
|
||||
|
||||
P->leaf_length = 0;
|
||||
gpu_store64(P->node_offset, 0);
|
||||
//P->node_depth = 0;
|
||||
//P->inner_length = 0;
|
||||
|
||||
gpu_store64(&P->salt, 0);
|
||||
gpu_store64(&P->personal, 0);
|
||||
|
||||
gpu_blake2s_init_param(S, P);
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
void gpu_copystate(blake2s_state *dst, blake2s_state *src)
|
||||
{
|
||||
uint64_t* d64 = (uint64_t*) dst;
|
||||
uint64_t* s64 = (uint64_t*) src;
|
||||
#pragma unroll
|
||||
for (int i=0; i < (32 + 16 + 2 * BLAKE2S_BLOCKBYTES)/8; i++)
|
||||
gpu_store64(&d64[i], s64[i]);
|
||||
dst->buflen = src->buflen;
|
||||
dst->last_node = src->last_node;
|
||||
}
|
||||
|
||||
__global__
|
||||
void blake2s_gpu_hash(const uint32_t threads, const uint32_t startNonce, uint32_t *resNonce, const uint2 target2, const int swap)
|
||||
{
|
||||
const uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
const uint32_t nonce = swap ? cuda_swab32(startNonce + thread) : startNonce + thread;
|
||||
blake2s_state ALIGN(8) blake2_ctx;
|
||||
|
||||
#ifndef GPU_MIDSTATE
|
||||
gpu_blake2s_init(&blake2_ctx, BLAKE2S_OUTBYTES);
|
||||
//gpu_blake2s_update(&blake2_ctx, (uint8_t*) d_data, 76);
|
||||
gpu_blake2s_fill_data(&blake2_ctx, nonce);
|
||||
#else
|
||||
gpu_copystate(&blake2_ctx, &d_state[0]);
|
||||
gpu_blake2s_update_nonce(&blake2_ctx, nonce);
|
||||
#endif
|
||||
|
||||
uint2 h2 = gpu_blake2s_final(&blake2_ctx);
|
||||
if (h2.y <= target2.y && h2.x <= target2.x) {
|
||||
#if NBN == 2
|
||||
if (resNonce[0] != UINT32_MAX)
|
||||
resNonce[1] = nonce;
|
||||
else
|
||||
resNonce[0] = nonce;
|
||||
#else
|
||||
resNonce[0] = nonce;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
static __inline uint32_t swab32_if(uint32_t val, bool iftrue) {
|
||||
return iftrue ? swab32(val) : val;
|
||||
}
|
||||
|
||||
__host__
|
||||
uint32_t blake2s_hash_cuda(const int thr_id, const uint32_t threads, const uint32_t startNonce, const uint2 target2, const int swap)
|
||||
{
|
||||
uint32_t result = UINT32_MAX;
|
||||
|
||||
dim3 grid((threads + TPB-1)/TPB);
|
||||
dim3 block(TPB);
|
||||
|
||||
/* Check error on Ctrl+C or kill to prevent segfaults on exit */
|
||||
if (cudaMemset(d_resNonce[thr_id], 0xff, NBN*sizeof(uint32_t)) != cudaSuccess)
|
||||
return result;
|
||||
|
||||
blake2s_gpu_hash <<<grid, block>>> (threads, startNonce, d_resNonce[thr_id], target2, swap);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
if (cudaSuccess == cudaMemcpy(h_resNonce[thr_id], d_resNonce[thr_id], NBN*sizeof(uint32_t), cudaMemcpyDeviceToHost)) {
|
||||
result = swab32_if(h_resNonce[thr_id][0], swap);
|
||||
#if NBN > 1
|
||||
for (int n=0; n < (NBN-1); n++)
|
||||
extra_results[n] = swab32_if(h_resNonce[thr_id][n+1], swap);
|
||||
#endif
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
|
||||
extern "C" int scanhash_blake2s(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done)
|
||||
{
|
||||
uint32_t _ALIGN(64) endiandata[20];
|
||||
uint32_t *pdata = work->data;
|
||||
uint32_t *ptarget = work->target;
|
||||
const int swap = 1; // to toggle nonce endian
|
||||
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
|
||||
int dev_id = device_map[thr_id];
|
||||
int intensity = (device_sm[dev_id] >= 500 && !is_windows()) ? 28 : 25;
|
||||
if (device_sm[dev_id] < 350) intensity = 22;
|
||||
|
||||
uint32_t throughput = cuda_default_throughput(thr_id, 1U << intensity);
|
||||
if (init[thr_id]) throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
if (opt_benchmark) {
|
||||
ptarget[6] = swab32(0xFFFF0);
|
||||
ptarget[7] = 0;
|
||||
}
|
||||
|
||||
if (!init[thr_id])
|
||||
{
|
||||
cudaSetDevice(dev_id);
|
||||
if (opt_cudaschedule == -1 && gpu_threads == 1) {
|
||||
cudaDeviceReset();
|
||||
// reduce cpu usage (linux)
|
||||
cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);
|
||||
cudaDeviceSetCacheConfig(cudaFuncCachePreferL1);
|
||||
CUDA_LOG_ERROR();
|
||||
}
|
||||
|
||||
CUDA_CALL_OR_RET_X(cudaMalloc(&d_resNonce[thr_id], NBN * sizeof(uint32_t)), -1);
|
||||
CUDA_CALL_OR_RET_X(cudaMallocHost(&h_resNonce[thr_id], NBN * sizeof(uint32_t)), -1);
|
||||
init[thr_id] = true;
|
||||
}
|
||||
|
||||
for (int i=0; i < 19; i++) {
|
||||
be32enc(&endiandata[i], pdata[i]);
|
||||
}
|
||||
|
||||
// midstate
|
||||
memset(s_midstate.buf, 0, sizeof(s_midstate.buf));
|
||||
blake2s_init(&s_midstate, BLAKE2S_OUTBYTES);
|
||||
blake2s_update(&s_midstate, (uint8_t*) endiandata, MIDLEN);
|
||||
memcpy(&s_ctx, &s_midstate, sizeof(blake2s_state));
|
||||
|
||||
blake2s_setBlock(endiandata, &s_midstate);
|
||||
|
||||
const uint2 target = make_uint2(ptarget[6], ptarget[7]);
|
||||
|
||||
do {
|
||||
uint32_t foundNonce = blake2s_hash_cuda(thr_id, throughput, pdata[19], target, swap);
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce + throughput;
|
||||
|
||||
if (foundNonce != UINT32_MAX)
|
||||
{
|
||||
uint32_t _ALIGN(A) vhashcpu[8];
|
||||
|
||||
//blake2s_hash(vhashcpu, endiandata);
|
||||
endiandata[19] = swab32_if(foundNonce, swap);
|
||||
blake2s_hash_end(vhashcpu, endiandata);
|
||||
|
||||
if (vhashcpu[7] <= target.y && fulltest(vhashcpu, ptarget)) {
|
||||
work_set_target_ratio(work, vhashcpu);
|
||||
pdata[19] = work->nonces[0] = swab32_if(foundNonce, !swap);
|
||||
#if NBN > 1
|
||||
if (extra_results[0] != UINT32_MAX) {
|
||||
endiandata[19] = swab32_if(extra_results[0], swap);
|
||||
blake2s_hash_end(vhashcpu, endiandata);
|
||||
if (vhashcpu[7] <= target.y && fulltest(vhashcpu, ptarget)) {
|
||||
work->nonces[1] = swab32_if(extra_results[0], !swap);
|
||||
if (bn_hash_target_ratio(vhashcpu, ptarget) > work->shareratio) {
|
||||
work_set_target_ratio(work, vhashcpu);
|
||||
xchg(work->nonces[1], pdata[19]);
|
||||
}
|
||||
return 2;
|
||||
}
|
||||
extra_results[0] = UINT32_MAX;
|
||||
}
|
||||
#endif
|
||||
return 1;
|
||||
} else {
|
||||
gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", foundNonce);
|
||||
}
|
||||
}
|
||||
|
||||
pdata[19] += throughput;
|
||||
|
||||
} while (!work_restart[thr_id].restart && max_nonce > (uint64_t)throughput + pdata[19]);
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// cleanup
|
||||
extern "C" void free_blake2s(int thr_id)
|
||||
{
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
|
||||
cudaFreeHost(h_resNonce[thr_id]);
|
||||
cudaFree(d_resNonce[thr_id]);
|
||||
|
||||
init[thr_id] = false;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
+12
-10
@@ -13,6 +13,7 @@ extern "C" {
|
||||
static uint32_t *d_hash[MAX_GPUS];
|
||||
|
||||
extern void bmw256_midstate_init(int thr_id, uint32_t threads);
|
||||
extern void bmw256_midstate_free(int thr_id);
|
||||
extern void bmw256_setBlock_80(int thr_id, void *pdata);
|
||||
extern void bmw256_cpu_hash_80(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_outputHash, int swap);
|
||||
|
||||
@@ -44,11 +45,11 @@ extern "C" int scanhash_bmw(int thr_id, struct work* work, uint32_t max_nonce, u
|
||||
uint32_t *ptarget = work->target;
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
bool swapnonce = true;
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1U << 21);
|
||||
throughput = min(throughput, max_nonce - first_nonce);
|
||||
uint32_t throughput = cuda_default_throughput(thr_id, 1U << 21);
|
||||
if (init[thr_id]) throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0x0005;
|
||||
ptarget[7] = 0x0005;
|
||||
|
||||
if (!init[thr_id]) {
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
@@ -65,6 +66,7 @@ extern "C" int scanhash_bmw(int thr_id, struct work* work, uint32_t max_nonce, u
|
||||
be32enc(&endiandata[k], ((uint32_t*)pdata)[k]);
|
||||
}
|
||||
|
||||
cudaGetLastError();
|
||||
bmw256_setBlock_80(thr_id, (void*)endiandata);
|
||||
|
||||
cuda_check_cpu_setTarget(ptarget);
|
||||
@@ -81,15 +83,15 @@ extern "C" int scanhash_bmw(int thr_id, struct work* work, uint32_t max_nonce, u
|
||||
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
|
||||
*hashes_done = foundNonce - first_nonce + 1;
|
||||
pdata[19] = swab32_if(foundNonce,!swapnonce);
|
||||
bn_store_hash_target_ratio(vhash64, ptarget, work);
|
||||
work_set_target_ratio(work, vhash64);
|
||||
return 1;
|
||||
}
|
||||
else {
|
||||
applog(LOG_DEBUG, "GPU #%d: result for nounce %08x does not validate on CPU!", thr_id, foundNonce);
|
||||
gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", foundNonce);
|
||||
}
|
||||
}
|
||||
|
||||
if ((uint64_t) throughput + pdata[19] > max_nonce) {
|
||||
if ((uint64_t) throughput + pdata[19] >= max_nonce) {
|
||||
pdata[19] = max_nonce;
|
||||
break;
|
||||
}
|
||||
@@ -108,12 +110,12 @@ extern "C" void free_bmw(int thr_id)
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
cudaFree(d_hash[thr_id]);
|
||||
|
||||
bmw256_midstate_free(thr_id);
|
||||
cuda_check_cpu_free(thr_id);
|
||||
init[thr_id] = false;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
init[thr_id] = false;
|
||||
}
|
||||
+562
-91
@@ -8,17 +8,28 @@ extern "C" {
|
||||
}
|
||||
|
||||
#include "cuda_helper.h"
|
||||
|
||||
#include <memory.h>
|
||||
|
||||
static __device__ uint64_t cuda_swab32ll(uint64_t x) {
|
||||
return MAKE_ULONGLONG(cuda_swab32(_LODWORD(x)), cuda_swab32(_HIDWORD(x)));
|
||||
#define UINT2(x,y) make_uint2(x,y)
|
||||
|
||||
__device__ __inline__ uint2 ROR8(const uint2 a)
|
||||
{
|
||||
uint2 result;
|
||||
result.x = __byte_perm(a.y, a.x, 0x0765);
|
||||
result.y = __byte_perm(a.x, a.y, 0x0765);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
__constant__ static uint32_t c_data[3+1];
|
||||
|
||||
__constant__ static uint32_t sigma[16][16];
|
||||
static uint32_t c_sigma[16][16] = {
|
||||
//static __device__ uint64_t cuda_swab32ll(uint64_t x) {
|
||||
// return MAKE_ULONGLONG(cuda_swab32(_LOWORD(x)), cuda_swab32(_HIWORD(x)));
|
||||
//}
|
||||
|
||||
__constant__ static uint32_t c_data[3];
|
||||
|
||||
//__constant__ static uint8_t sigma[16][16];
|
||||
static uint8_t c_sigma[16][16] = {
|
||||
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
|
||||
{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
|
||||
{ 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
|
||||
@@ -46,7 +57,7 @@ static const uint32_t c_IV256[8] = {
|
||||
|
||||
__device__ __constant__ static uint32_t cpu_h[8];
|
||||
|
||||
__device__ __constant__ static uint32_t u256[16];
|
||||
//__device__ __constant__ static uint32_t u256[16];
|
||||
static const uint32_t c_u256[16] = {
|
||||
0x243F6A88, 0x85A308D3,
|
||||
0x13198A2E, 0x03707344,
|
||||
@@ -59,24 +70,22 @@ static const uint32_t c_u256[16] = {
|
||||
};
|
||||
|
||||
#define GS2(a,b,c,d,x) { \
|
||||
const uint32_t idx1 = sigma[r][x]; \
|
||||
const uint32_t idx2 = sigma[r][x+1]; \
|
||||
const uint8_t idx1 = sigma[r][x]; \
|
||||
const uint8_t idx2 = sigma[r][x+1]; \
|
||||
v[a] += (m[idx1] ^ u256[idx2]) + v[b]; \
|
||||
v[d] = SPH_ROTL32(v[d] ^ v[a], 16); \
|
||||
v[d] = __byte_perm(v[d] ^ v[a],0, 0x1032); \
|
||||
v[c] += v[d]; \
|
||||
v[b] = SPH_ROTR32(v[b] ^ v[c], 12); \
|
||||
\
|
||||
v[a] += (m[idx2] ^ u256[idx1]) + v[b]; \
|
||||
v[d] = SPH_ROTR32(v[d] ^ v[a], 8); \
|
||||
v[d] = __byte_perm(v[d] ^ v[a],0, 0x0321); \
|
||||
v[c] += v[d]; \
|
||||
v[b] = SPH_ROTR32(v[b] ^ v[c], 7); \
|
||||
}
|
||||
|
||||
//#define ROTL32(x, n) ((x) << (n)) | ((x) >> (32 - (n)))
|
||||
//#define ROTR32(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
|
||||
#define hostGS(a,b,c,d,x) { \
|
||||
const uint32_t idx1 = c_sigma[r][x]; \
|
||||
const uint32_t idx2 = c_sigma[r][x+1]; \
|
||||
const uint8_t idx1 = c_sigma[r][x]; \
|
||||
const uint8_t idx2 = c_sigma[r][x+1]; \
|
||||
v[a] += (m[idx1] ^ c_u256[idx2]) + v[b]; \
|
||||
v[d] = ROTR32(v[d] ^ v[a], 16); \
|
||||
v[c] += v[d]; \
|
||||
@@ -86,14 +95,47 @@ static const uint32_t c_u256[16] = {
|
||||
v[d] = ROTR32(v[d] ^ v[a], 8); \
|
||||
v[c] += v[d]; \
|
||||
v[b] = ROTR32(v[b] ^ v[c], 7); \
|
||||
}
|
||||
}
|
||||
|
||||
/* Second part (64-80) msg never change, store it */
|
||||
__device__ __constant__ static const uint32_t c_Padding[16] = {
|
||||
0, 0, 0, 0,
|
||||
0x80000000, 0, 0, 0,
|
||||
0, 0, 0, 0,
|
||||
0, 1, 0, 640,
|
||||
#define GSPREC(a,b,c,d,x,y) { \
|
||||
v[a] += (m[x] ^ u256[y]) + v[b]; \
|
||||
v[d] = __byte_perm(v[d] ^ v[a],0, 0x1032); \
|
||||
v[c] += v[d]; \
|
||||
v[b] = SPH_ROTR32(v[b] ^ v[c], 12); \
|
||||
v[a] += (m[y] ^ u256[x]) + v[b]; \
|
||||
v[d] = __byte_perm(v[d] ^ v[a],0, 0x0321); \
|
||||
v[c] += v[d]; \
|
||||
v[b] = SPH_ROTR32(v[b] ^ v[c], 7); \
|
||||
}
|
||||
|
||||
__constant__ uint64_t 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
|
||||
};
|
||||
|
||||
__constant__ uint2 keccak_round_constants35[24] = {
|
||||
{ 0x00000001ul, 0x00000000 }, { 0x00008082ul, 0x00000000 },
|
||||
{ 0x0000808aul, 0x80000000 }, { 0x80008000ul, 0x80000000 },
|
||||
{ 0x0000808bul, 0x00000000 }, { 0x80000001ul, 0x00000000 },
|
||||
{ 0x80008081ul, 0x80000000 }, { 0x00008009ul, 0x80000000 },
|
||||
{ 0x0000008aul, 0x00000000 }, { 0x00000088ul, 0x00000000 },
|
||||
{ 0x80008009ul, 0x00000000 }, { 0x8000000aul, 0x00000000 },
|
||||
{ 0x8000808bul, 0x00000000 }, { 0x0000008bul, 0x80000000 },
|
||||
{ 0x00008089ul, 0x80000000 }, { 0x00008003ul, 0x80000000 },
|
||||
{ 0x00008002ul, 0x80000000 }, { 0x00000080ul, 0x80000000 },
|
||||
{ 0x0000800aul, 0x00000000 }, { 0x8000000aul, 0x80000000 },
|
||||
{ 0x80008081ul, 0x80000000 }, { 0x00008080ul, 0x80000000 },
|
||||
{ 0x80000001ul, 0x00000000 }, { 0x80008008ul, 0x80000000 }
|
||||
};
|
||||
|
||||
__host__ __forceinline__
|
||||
@@ -132,116 +174,545 @@ static void blake256_compress1st(uint32_t *h, const uint32_t *block, const uint3
|
||||
hostGS(3, 4, 0x9, 0xE, 0xE);
|
||||
}
|
||||
|
||||
for (int i = 0; i < 16; i++) {
|
||||
int j = i & 7;
|
||||
h[j] ^= v[i];
|
||||
}
|
||||
h[0] ^= v[0] ^ v[8];
|
||||
h[1] ^= v[1] ^ v[9];
|
||||
h[2] ^= v[2] ^ v[10];
|
||||
h[3] ^= v[3] ^ v[11];
|
||||
h[4] ^= v[4] ^ v[12];
|
||||
h[5] ^= v[5] ^ v[13];
|
||||
h[6] ^= v[6] ^ v[14];
|
||||
h[7] ^= v[7] ^ v[15];
|
||||
}
|
||||
#define bitselect(a, b, c) ((a) ^ ((c) & ((b) ^ (a))))
|
||||
|
||||
__device__ __forceinline__
|
||||
static void blake256_compress2nd(uint32_t *h, const uint32_t *block, const uint32_t T0)
|
||||
static void __forceinline__ __device__ keccak_block(uint2 *s)
|
||||
{
|
||||
uint32_t m[16];
|
||||
uint32_t v[16];
|
||||
uint2 bc[5], tmpxor[5], tmp1, tmp2;
|
||||
// uint2 s[25];
|
||||
|
||||
m[0] = block[0];
|
||||
m[1] = block[1];
|
||||
m[2] = block[2];
|
||||
m[3] = block[3];
|
||||
#pragma unroll 1
|
||||
for (int i = 0; i < 24; i++)
|
||||
{
|
||||
#pragma unroll
|
||||
for (uint32_t x = 0; x < 5; x++)
|
||||
tmpxor[x] = s[x] ^ s[x + 5] ^ s[x + 10] ^ s[x + 15] ^ s[x + 20];
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 4; i < 16; i++) {
|
||||
m[i] = c_Padding[i];
|
||||
}
|
||||
bc[0] = tmpxor[0] ^ ROL2(tmpxor[2], 1);
|
||||
bc[1] = tmpxor[1] ^ ROL2(tmpxor[3], 1);
|
||||
bc[2] = tmpxor[2] ^ ROL2(tmpxor[4], 1);
|
||||
bc[3] = tmpxor[3] ^ ROL2(tmpxor[0], 1);
|
||||
bc[4] = tmpxor[4] ^ ROL2(tmpxor[1], 1);
|
||||
|
||||
#pragma unroll 8
|
||||
for (int i = 0; i < 8; i++)
|
||||
v[i] = h[i];
|
||||
tmp1 = s[1] ^ bc[0];
|
||||
|
||||
v[8] = u256[0];
|
||||
v[9] = u256[1];
|
||||
v[10] = u256[2];
|
||||
v[11] = u256[3];
|
||||
s[0] ^= bc[4];
|
||||
s[1] = ROL2(s[6] ^ bc[0], 44);
|
||||
s[6] = ROL2(s[9] ^ bc[3], 20);
|
||||
s[9] = ROL2(s[22] ^ bc[1], 61);
|
||||
s[22] = ROL2(s[14] ^ bc[3], 39);
|
||||
s[14] = ROL2(s[20] ^ bc[4], 18);
|
||||
s[20] = ROL2(s[2] ^ bc[1], 62);
|
||||
s[2] = ROL2(s[12] ^ bc[1], 43);
|
||||
s[12] = ROL2(s[13] ^ bc[2], 25);
|
||||
s[13] = ROL8(s[19] ^ bc[3]);
|
||||
s[19] = ROR8(s[23] ^ bc[2]);
|
||||
s[23] = ROL2(s[15] ^ bc[4], 41);
|
||||
s[15] = ROL2(s[4] ^ bc[3], 27);
|
||||
s[4] = ROL2(s[24] ^ bc[3], 14);
|
||||
s[24] = ROL2(s[21] ^ bc[0], 2);
|
||||
s[21] = ROL2(s[8] ^ bc[2], 55);
|
||||
s[8] = ROL2(s[16] ^ bc[0], 45);
|
||||
s[16] = ROL2(s[5] ^ bc[4], 36);
|
||||
s[5] = ROL2(s[3] ^ bc[2], 28);
|
||||
s[3] = ROL2(s[18] ^ bc[2], 21);
|
||||
s[18] = ROL2(s[17] ^ bc[1], 15);
|
||||
s[17] = ROL2(s[11] ^ bc[0], 10);
|
||||
s[11] = ROL2(s[7] ^ bc[1], 6);
|
||||
s[7] = ROL2(s[10] ^ bc[4], 3);
|
||||
s[10] = ROL2(tmp1, 1);
|
||||
|
||||
v[12] = u256[4] ^ T0;
|
||||
v[13] = u256[5] ^ T0;
|
||||
v[14] = u256[6];
|
||||
v[15] = u256[7];
|
||||
|
||||
#pragma unroll 14
|
||||
for (int r = 0; r < 14; r++) {
|
||||
/* column step */
|
||||
GS2(0, 4, 0x8, 0xC, 0x0);
|
||||
GS2(1, 5, 0x9, 0xD, 0x2);
|
||||
GS2(2, 6, 0xA, 0xE, 0x4);
|
||||
GS2(3, 7, 0xB, 0xF, 0x6);
|
||||
/* diagonal step */
|
||||
GS2(0, 5, 0xA, 0xF, 0x8);
|
||||
GS2(1, 6, 0xB, 0xC, 0xA);
|
||||
GS2(2, 7, 0x8, 0xD, 0xC);
|
||||
GS2(3, 4, 0x9, 0xE, 0xE);
|
||||
}
|
||||
|
||||
#pragma unroll 16
|
||||
for (int i = 0; i < 16; i++) {
|
||||
int j = i & 7;
|
||||
h[j] ^= v[i];
|
||||
tmp1 = s[0]; tmp2 = s[1]; s[0] = bitselect(s[0] ^ s[2], s[0], s[1]); s[1] = bitselect(s[1] ^ s[3], s[1], s[2]); s[2] = bitselect(s[2] ^ s[4], s[2], s[3]); s[3] = bitselect(s[3] ^ tmp1, s[3], s[4]); s[4] = bitselect(s[4] ^ tmp2, s[4], tmp1);
|
||||
tmp1 = s[5]; tmp2 = s[6]; s[5] = bitselect(s[5] ^ s[7], s[5], s[6]); s[6] = bitselect(s[6] ^ s[8], s[6], s[7]); s[7] = bitselect(s[7] ^ s[9], s[7], s[8]); s[8] = bitselect(s[8] ^ tmp1, s[8], s[9]); s[9] = bitselect(s[9] ^ tmp2, s[9], tmp1);
|
||||
tmp1 = s[10]; tmp2 = s[11]; s[10] = bitselect(s[10] ^ s[12], s[10], s[11]); s[11] = bitselect(s[11] ^ s[13], s[11], s[12]); s[12] = bitselect(s[12] ^ s[14], s[12], s[13]); s[13] = bitselect(s[13] ^ tmp1, s[13], s[14]); s[14] = bitselect(s[14] ^ tmp2, s[14], tmp1);
|
||||
tmp1 = s[15]; tmp2 = s[16]; s[15] = bitselect(s[15] ^ s[17], s[15], s[16]); s[16] = bitselect(s[16] ^ s[18], s[16], s[17]); s[17] = bitselect(s[17] ^ s[19], s[17], s[18]); s[18] = bitselect(s[18] ^ tmp1, s[18], s[19]); s[19] = bitselect(s[19] ^ tmp2, s[19], tmp1);
|
||||
tmp1 = s[20]; tmp2 = s[21]; s[20] = bitselect(s[20] ^ s[22], s[20], s[21]); s[21] = bitselect(s[21] ^ s[23], s[21], s[22]); s[22] = bitselect(s[22] ^ s[24], s[22], s[23]); s[23] = bitselect(s[23] ^ tmp1, s[23], s[24]); s[24] = bitselect(s[24] ^ tmp2, s[24], tmp1);
|
||||
s[0] ^= keccak_round_constants35[i];
|
||||
}
|
||||
}
|
||||
|
||||
__global__ __launch_bounds__(256,3)
|
||||
void blake256_gpu_hash_80(const uint32_t threads, const uint32_t startNonce, uint64_t * Hash)
|
||||
//__launch_bounds__(256)
|
||||
__global__
|
||||
void blakeKeccak256_gpu_hash_80(const uint32_t threads, const uint32_t startNonce, uint32_t * Hash)
|
||||
{
|
||||
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];
|
||||
// uint32_t input[4];
|
||||
const uint32_t T0 = 640;
|
||||
#pragma unroll 8
|
||||
for (int i = 0; i<8; i++) { h[i] = cpu_h[i]; }
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 0; i < 8; i++) h[i] = cpu_h[i];
|
||||
uint32_t v[16];
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 0; i < 3; ++i) input[i] = c_data[i];
|
||||
const uint32_t c_Padding[12] = {
|
||||
0x80000000, 0, 0, 0,
|
||||
0, 0, 0, 0,
|
||||
0, 1, 0, 640
|
||||
};
|
||||
|
||||
input[3] = startNonce + thread;
|
||||
blake256_compress2nd(h, input, 640);
|
||||
const uint32_t u256[16] =
|
||||
{
|
||||
0x243F6A88, 0x85A308D3,
|
||||
0x13198A2E, 0x03707344,
|
||||
0xA4093822, 0x299F31D0,
|
||||
0x082EFA98, 0xEC4E6C89,
|
||||
0x452821E6, 0x38D01377,
|
||||
0xBE5466CF, 0x34E90C6C,
|
||||
0xC0AC29B7, 0xC97C50DD,
|
||||
0x3F84D5B5, 0xB5470917
|
||||
};
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 0; i<4; i++) {
|
||||
Hash[i*threads + thread] = cuda_swab32ll(MAKE_ULONGLONG(h[2 * i], h[2*i+1]));
|
||||
}
|
||||
uint32_t m[16] =
|
||||
{
|
||||
c_data[0], c_data[1], c_data[2], nonce,
|
||||
c_Padding[0], c_Padding[1], c_Padding[2], c_Padding[3],
|
||||
c_Padding[4], c_Padding[5], c_Padding[6], c_Padding[7],
|
||||
c_Padding[8], c_Padding[9], c_Padding[10], c_Padding[11]
|
||||
};
|
||||
|
||||
#pragma unroll 8
|
||||
for (int i = 0; i < 8; i++)
|
||||
v[i] = h[i];
|
||||
|
||||
v[8] = u256[0];
|
||||
v[9] = u256[1];
|
||||
v[10] = u256[2];
|
||||
v[11] = u256[3];
|
||||
v[12] = u256[4] ^ T0;
|
||||
v[13] = u256[5] ^ T0;
|
||||
v[14] = u256[6];
|
||||
v[15] = u256[7];
|
||||
|
||||
// { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 0, 1);
|
||||
GSPREC(1, 5, 0x9, 0xD, 2, 3);
|
||||
GSPREC(2, 6, 0xA, 0xE, 4, 5);
|
||||
GSPREC(3, 7, 0xB, 0xF, 6, 7);
|
||||
GSPREC(0, 5, 0xA, 0xF, 8, 9);
|
||||
GSPREC(1, 6, 0xB, 0xC, 10, 11);
|
||||
GSPREC(2, 7, 0x8, 0xD, 12, 13);
|
||||
GSPREC(3, 4, 0x9, 0xE, 14, 15);
|
||||
// { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 14, 10);
|
||||
GSPREC(1, 5, 0x9, 0xD, 4, 8);
|
||||
GSPREC(2, 6, 0xA, 0xE, 9, 15);
|
||||
GSPREC(3, 7, 0xB, 0xF, 13, 6);
|
||||
GSPREC(0, 5, 0xA, 0xF, 1, 12);
|
||||
GSPREC(1, 6, 0xB, 0xC, 0, 2);
|
||||
GSPREC(2, 7, 0x8, 0xD, 11, 7);
|
||||
GSPREC(3, 4, 0x9, 0xE, 5, 3);
|
||||
// { 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 11, 8);
|
||||
GSPREC(1, 5, 0x9, 0xD, 12, 0);
|
||||
GSPREC(2, 6, 0xA, 0xE, 5, 2);
|
||||
GSPREC(3, 7, 0xB, 0xF, 15, 13);
|
||||
GSPREC(0, 5, 0xA, 0xF, 10, 14);
|
||||
GSPREC(1, 6, 0xB, 0xC, 3, 6);
|
||||
GSPREC(2, 7, 0x8, 0xD, 7, 1);
|
||||
GSPREC(3, 4, 0x9, 0xE, 9, 4);
|
||||
// { 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 7, 9);
|
||||
GSPREC(1, 5, 0x9, 0xD, 3, 1);
|
||||
GSPREC(2, 6, 0xA, 0xE, 13, 12);
|
||||
GSPREC(3, 7, 0xB, 0xF, 11, 14);
|
||||
GSPREC(0, 5, 0xA, 0xF, 2, 6);
|
||||
GSPREC(1, 6, 0xB, 0xC, 5, 10);
|
||||
GSPREC(2, 7, 0x8, 0xD, 4, 0);
|
||||
GSPREC(3, 4, 0x9, 0xE, 15, 8);
|
||||
|
||||
// { 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 9, 0);
|
||||
GSPREC(1, 5, 0x9, 0xD, 5, 7);
|
||||
GSPREC(2, 6, 0xA, 0xE, 2, 4);
|
||||
GSPREC(3, 7, 0xB, 0xF, 10, 15);
|
||||
GSPREC(0, 5, 0xA, 0xF, 14, 1);
|
||||
GSPREC(1, 6, 0xB, 0xC, 11, 12);
|
||||
GSPREC(2, 7, 0x8, 0xD, 6, 8);
|
||||
GSPREC(3, 4, 0x9, 0xE, 3, 13);
|
||||
// { 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 2, 12);
|
||||
GSPREC(1, 5, 0x9, 0xD, 6, 10);
|
||||
GSPREC(2, 6, 0xA, 0xE, 0, 11);
|
||||
GSPREC(3, 7, 0xB, 0xF, 8, 3);
|
||||
GSPREC(0, 5, 0xA, 0xF, 4, 13);
|
||||
GSPREC(1, 6, 0xB, 0xC, 7, 5);
|
||||
GSPREC(2, 7, 0x8, 0xD, 15, 14);
|
||||
GSPREC(3, 4, 0x9, 0xE, 1, 9);
|
||||
|
||||
// { 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 12, 5);
|
||||
GSPREC(1, 5, 0x9, 0xD, 1, 15);
|
||||
GSPREC(2, 6, 0xA, 0xE, 14, 13);
|
||||
GSPREC(3, 7, 0xB, 0xF, 4, 10);
|
||||
GSPREC(0, 5, 0xA, 0xF, 0, 7);
|
||||
GSPREC(1, 6, 0xB, 0xC, 6, 3);
|
||||
GSPREC(2, 7, 0x8, 0xD, 9, 2);
|
||||
GSPREC(3, 4, 0x9, 0xE, 8, 11);
|
||||
|
||||
// { 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 13, 11);
|
||||
GSPREC(1, 5, 0x9, 0xD, 7, 14);
|
||||
GSPREC(2, 6, 0xA, 0xE, 12, 1);
|
||||
GSPREC(3, 7, 0xB, 0xF, 3, 9);
|
||||
GSPREC(0, 5, 0xA, 0xF, 5, 0);
|
||||
GSPREC(1, 6, 0xB, 0xC, 15, 4);
|
||||
GSPREC(2, 7, 0x8, 0xD, 8, 6);
|
||||
GSPREC(3, 4, 0x9, 0xE, 2, 10);
|
||||
// { 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 6, 15);
|
||||
GSPREC(1, 5, 0x9, 0xD, 14, 9);
|
||||
GSPREC(2, 6, 0xA, 0xE, 11, 3);
|
||||
GSPREC(3, 7, 0xB, 0xF, 0, 8);
|
||||
GSPREC(0, 5, 0xA, 0xF, 12, 2);
|
||||
GSPREC(1, 6, 0xB, 0xC, 13, 7);
|
||||
GSPREC(2, 7, 0x8, 0xD, 1, 4);
|
||||
GSPREC(3, 4, 0x9, 0xE, 10, 5);
|
||||
// { 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 10, 2);
|
||||
GSPREC(1, 5, 0x9, 0xD, 8, 4);
|
||||
GSPREC(2, 6, 0xA, 0xE, 7, 6);
|
||||
GSPREC(3, 7, 0xB, 0xF, 1, 5);
|
||||
GSPREC(0, 5, 0xA, 0xF, 15, 11);
|
||||
GSPREC(1, 6, 0xB, 0xC, 9, 14);
|
||||
GSPREC(2, 7, 0x8, 0xD, 3, 12);
|
||||
GSPREC(3, 4, 0x9, 0xE, 13, 0);
|
||||
// { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 0, 1);
|
||||
GSPREC(1, 5, 0x9, 0xD, 2, 3);
|
||||
GSPREC(2, 6, 0xA, 0xE, 4, 5);
|
||||
GSPREC(3, 7, 0xB, 0xF, 6, 7);
|
||||
GSPREC(0, 5, 0xA, 0xF, 8, 9);
|
||||
GSPREC(1, 6, 0xB, 0xC, 10, 11);
|
||||
GSPREC(2, 7, 0x8, 0xD, 12, 13);
|
||||
GSPREC(3, 4, 0x9, 0xE, 14, 15);
|
||||
|
||||
// { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 14, 10);
|
||||
GSPREC(1, 5, 0x9, 0xD, 4, 8);
|
||||
GSPREC(2, 6, 0xA, 0xE, 9, 15);
|
||||
GSPREC(3, 7, 0xB, 0xF, 13, 6);
|
||||
GSPREC(0, 5, 0xA, 0xF, 1, 12);
|
||||
GSPREC(1, 6, 0xB, 0xC, 0, 2);
|
||||
GSPREC(2, 7, 0x8, 0xD, 11, 7);
|
||||
GSPREC(3, 4, 0x9, 0xE, 5, 3);
|
||||
|
||||
// { 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 11, 8);
|
||||
GSPREC(1, 5, 0x9, 0xD, 12, 0);
|
||||
GSPREC(2, 6, 0xA, 0xE, 5, 2);
|
||||
GSPREC(3, 7, 0xB, 0xF, 15, 13);
|
||||
GSPREC(0, 5, 0xA, 0xF, 10, 14);
|
||||
GSPREC(1, 6, 0xB, 0xC, 3, 6);
|
||||
GSPREC(2, 7, 0x8, 0xD, 7, 1);
|
||||
GSPREC(3, 4, 0x9, 0xE, 9, 4);
|
||||
// { 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 7, 9);
|
||||
GSPREC(1, 5, 0x9, 0xD, 3, 1);
|
||||
GSPREC(2, 6, 0xA, 0xE, 13, 12);
|
||||
GSPREC(3, 7, 0xB, 0xF, 11, 14);
|
||||
GSPREC(0, 5, 0xA, 0xF, 2, 6);
|
||||
GSPREC(1, 6, 0xB, 0xC, 5, 10);
|
||||
GSPREC(2, 7, 0x8, 0xD, 4, 0);
|
||||
GSPREC(3, 4, 0x9, 0xE, 15, 8);
|
||||
|
||||
|
||||
|
||||
|
||||
h[0] = cuda_swab32(h[0] ^ v[0] ^ v[8]);
|
||||
h[1] = cuda_swab32(h[1] ^ v[1] ^ v[9]);
|
||||
h[2] = cuda_swab32(h[2] ^ v[2] ^ v[10]);
|
||||
h[3] = cuda_swab32(h[3] ^ v[3] ^ v[11]);
|
||||
h[4] = cuda_swab32(h[4] ^ v[4] ^ v[12]);
|
||||
h[5] = cuda_swab32(h[5] ^ v[5] ^ v[13]);
|
||||
h[6] = cuda_swab32(h[6] ^ v[6] ^ v[14]);
|
||||
h[7] = cuda_swab32(h[7] ^ v[7] ^ v[15]);
|
||||
|
||||
uint2 keccak_gpu_state[25] = { 0 };
|
||||
keccak_gpu_state[0].x = h[0];
|
||||
keccak_gpu_state[0].y = h[1];
|
||||
keccak_gpu_state[1].x = h[2];
|
||||
keccak_gpu_state[1].y = h[3];
|
||||
keccak_gpu_state[2].x = h[4];
|
||||
keccak_gpu_state[2].y = h[5];
|
||||
keccak_gpu_state[3].x = h[6];
|
||||
keccak_gpu_state[3].y = h[7];
|
||||
keccak_gpu_state[4] = UINT2(1, 0);
|
||||
|
||||
keccak_gpu_state[16] = UINT2(0, 0x80000000);
|
||||
keccak_block(keccak_gpu_state);
|
||||
uint64_t *outputHash = (uint64_t *)Hash;
|
||||
#pragma unroll 4
|
||||
for (int i = 0; i<4; i++)
|
||||
outputHash[i*threads + thread] = devectorize(keccak_gpu_state[i]);
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
__global__ __launch_bounds__(256, 4)
|
||||
void blake256_gpu_hash_80(const uint32_t threads, const uint32_t startNonce, uint32_t * Hash)
|
||||
{
|
||||
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];
|
||||
const uint32_t T0 = 640;
|
||||
#pragma unroll 8
|
||||
for (int i = 0; i<8; i++) { h[i] = cpu_h[i]; }
|
||||
|
||||
uint32_t v[16];
|
||||
|
||||
const uint32_t c_Padding[12] = {
|
||||
0x80000000, 0, 0, 0,
|
||||
0, 0, 0, 0,
|
||||
0, 1, 0, 640
|
||||
};
|
||||
|
||||
const uint32_t u256[16] =
|
||||
{
|
||||
0x243F6A88, 0x85A308D3,
|
||||
0x13198A2E, 0x03707344,
|
||||
0xA4093822, 0x299F31D0,
|
||||
0x082EFA98, 0xEC4E6C89,
|
||||
0x452821E6, 0x38D01377,
|
||||
0xBE5466CF, 0x34E90C6C,
|
||||
0xC0AC29B7, 0xC97C50DD,
|
||||
0x3F84D5B5, 0xB5470917
|
||||
};
|
||||
|
||||
uint32_t m[16] =
|
||||
{
|
||||
c_data[0], c_data[1], c_data[2], nonce,
|
||||
c_Padding[0], c_Padding[1], c_Padding[2], c_Padding[3],
|
||||
c_Padding[4], c_Padding[5], c_Padding[6], c_Padding[7],
|
||||
c_Padding[8], c_Padding[9], c_Padding[10], c_Padding[11]
|
||||
};
|
||||
|
||||
#pragma unroll 8
|
||||
for (int i = 0; i < 8; i++)
|
||||
v[i] = h[i];
|
||||
|
||||
v[8] = u256[0];
|
||||
v[9] = u256[1];
|
||||
v[10] = u256[2];
|
||||
v[11] = u256[3];
|
||||
v[12] = u256[4] ^ T0;
|
||||
v[13] = u256[5] ^ T0;
|
||||
v[14] = u256[6];
|
||||
v[15] = u256[7];
|
||||
|
||||
// { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 0, 1);
|
||||
GSPREC(1, 5, 0x9, 0xD, 2, 3);
|
||||
GSPREC(2, 6, 0xA, 0xE, 4, 5);
|
||||
GSPREC(3, 7, 0xB, 0xF, 6, 7);
|
||||
GSPREC(0, 5, 0xA, 0xF, 8, 9);
|
||||
GSPREC(1, 6, 0xB, 0xC, 10, 11);
|
||||
GSPREC(2, 7, 0x8, 0xD, 12, 13);
|
||||
GSPREC(3, 4, 0x9, 0xE, 14, 15);
|
||||
// { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 14, 10);
|
||||
GSPREC(1, 5, 0x9, 0xD, 4, 8);
|
||||
GSPREC(2, 6, 0xA, 0xE, 9, 15);
|
||||
GSPREC(3, 7, 0xB, 0xF, 13, 6);
|
||||
GSPREC(0, 5, 0xA, 0xF, 1, 12);
|
||||
GSPREC(1, 6, 0xB, 0xC, 0, 2);
|
||||
GSPREC(2, 7, 0x8, 0xD, 11, 7);
|
||||
GSPREC(3, 4, 0x9, 0xE, 5, 3);
|
||||
// { 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 11, 8);
|
||||
GSPREC(1, 5, 0x9, 0xD, 12, 0);
|
||||
GSPREC(2, 6, 0xA, 0xE, 5, 2);
|
||||
GSPREC(3, 7, 0xB, 0xF, 15, 13);
|
||||
GSPREC(0, 5, 0xA, 0xF, 10, 14);
|
||||
GSPREC(1, 6, 0xB, 0xC, 3, 6);
|
||||
GSPREC(2, 7, 0x8, 0xD, 7, 1);
|
||||
GSPREC(3, 4, 0x9, 0xE, 9, 4);
|
||||
// { 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 7, 9);
|
||||
GSPREC(1, 5, 0x9, 0xD, 3, 1);
|
||||
GSPREC(2, 6, 0xA, 0xE, 13, 12);
|
||||
GSPREC(3, 7, 0xB, 0xF, 11, 14);
|
||||
GSPREC(0, 5, 0xA, 0xF, 2, 6);
|
||||
GSPREC(1, 6, 0xB, 0xC, 5, 10);
|
||||
GSPREC(2, 7, 0x8, 0xD, 4, 0);
|
||||
GSPREC(3, 4, 0x9, 0xE, 15, 8);
|
||||
|
||||
// { 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 9, 0);
|
||||
GSPREC(1, 5, 0x9, 0xD, 5, 7);
|
||||
GSPREC(2, 6, 0xA, 0xE, 2, 4);
|
||||
GSPREC(3, 7, 0xB, 0xF, 10, 15);
|
||||
GSPREC(0, 5, 0xA, 0xF, 14, 1);
|
||||
GSPREC(1, 6, 0xB, 0xC, 11, 12);
|
||||
GSPREC(2, 7, 0x8, 0xD, 6, 8);
|
||||
GSPREC(3, 4, 0x9, 0xE, 3, 13);
|
||||
// { 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 2, 12);
|
||||
GSPREC(1, 5, 0x9, 0xD, 6, 10);
|
||||
GSPREC(2, 6, 0xA, 0xE, 0, 11);
|
||||
GSPREC(3, 7, 0xB, 0xF, 8, 3);
|
||||
GSPREC(0, 5, 0xA, 0xF, 4, 13);
|
||||
GSPREC(1, 6, 0xB, 0xC, 7, 5);
|
||||
GSPREC(2, 7, 0x8, 0xD, 15, 14);
|
||||
GSPREC(3, 4, 0x9, 0xE, 1, 9);
|
||||
|
||||
// { 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 12, 5);
|
||||
GSPREC(1, 5, 0x9, 0xD, 1, 15);
|
||||
GSPREC(2, 6, 0xA, 0xE, 14, 13);
|
||||
GSPREC(3, 7, 0xB, 0xF, 4, 10);
|
||||
GSPREC(0, 5, 0xA, 0xF, 0, 7);
|
||||
GSPREC(1, 6, 0xB, 0xC, 6, 3);
|
||||
GSPREC(2, 7, 0x8, 0xD, 9, 2);
|
||||
GSPREC(3, 4, 0x9, 0xE, 8, 11);
|
||||
|
||||
// { 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 13, 11);
|
||||
GSPREC(1, 5, 0x9, 0xD, 7, 14);
|
||||
GSPREC(2, 6, 0xA, 0xE, 12, 1);
|
||||
GSPREC(3, 7, 0xB, 0xF, 3, 9);
|
||||
GSPREC(0, 5, 0xA, 0xF, 5, 0);
|
||||
GSPREC(1, 6, 0xB, 0xC, 15, 4);
|
||||
GSPREC(2, 7, 0x8, 0xD, 8, 6);
|
||||
GSPREC(3, 4, 0x9, 0xE, 2, 10);
|
||||
// { 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 6, 15);
|
||||
GSPREC(1, 5, 0x9, 0xD, 14, 9);
|
||||
GSPREC(2, 6, 0xA, 0xE, 11, 3);
|
||||
GSPREC(3, 7, 0xB, 0xF, 0, 8);
|
||||
GSPREC(0, 5, 0xA, 0xF, 12, 2);
|
||||
GSPREC(1, 6, 0xB, 0xC, 13, 7);
|
||||
GSPREC(2, 7, 0x8, 0xD, 1, 4);
|
||||
GSPREC(3, 4, 0x9, 0xE, 10, 5);
|
||||
// { 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 10, 2);
|
||||
GSPREC(1, 5, 0x9, 0xD, 8, 4);
|
||||
GSPREC(2, 6, 0xA, 0xE, 7, 6);
|
||||
GSPREC(3, 7, 0xB, 0xF, 1, 5);
|
||||
GSPREC(0, 5, 0xA, 0xF, 15, 11);
|
||||
GSPREC(1, 6, 0xB, 0xC, 9, 14);
|
||||
GSPREC(2, 7, 0x8, 0xD, 3, 12);
|
||||
GSPREC(3, 4, 0x9, 0xE, 13, 0);
|
||||
// { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 0, 1);
|
||||
GSPREC(1, 5, 0x9, 0xD, 2, 3);
|
||||
GSPREC(2, 6, 0xA, 0xE, 4, 5);
|
||||
GSPREC(3, 7, 0xB, 0xF, 6, 7);
|
||||
GSPREC(0, 5, 0xA, 0xF, 8, 9);
|
||||
GSPREC(1, 6, 0xB, 0xC, 10, 11);
|
||||
GSPREC(2, 7, 0x8, 0xD, 12, 13);
|
||||
GSPREC(3, 4, 0x9, 0xE, 14, 15);
|
||||
|
||||
// { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 14, 10);
|
||||
GSPREC(1, 5, 0x9, 0xD, 4, 8);
|
||||
GSPREC(2, 6, 0xA, 0xE, 9, 15);
|
||||
GSPREC(3, 7, 0xB, 0xF, 13, 6);
|
||||
GSPREC(0, 5, 0xA, 0xF, 1, 12);
|
||||
GSPREC(1, 6, 0xB, 0xC, 0, 2);
|
||||
GSPREC(2, 7, 0x8, 0xD, 11, 7);
|
||||
GSPREC(3, 4, 0x9, 0xE, 5, 3);
|
||||
|
||||
// { 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 11, 8);
|
||||
GSPREC(1, 5, 0x9, 0xD, 12, 0);
|
||||
GSPREC(2, 6, 0xA, 0xE, 5, 2);
|
||||
GSPREC(3, 7, 0xB, 0xF, 15, 13);
|
||||
GSPREC(0, 5, 0xA, 0xF, 10, 14);
|
||||
GSPREC(1, 6, 0xB, 0xC, 3, 6);
|
||||
GSPREC(2, 7, 0x8, 0xD, 7, 1);
|
||||
GSPREC(3, 4, 0x9, 0xE, 9, 4);
|
||||
// { 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
|
||||
GSPREC(0, 4, 0x8, 0xC, 7, 9);
|
||||
GSPREC(1, 5, 0x9, 0xD, 3, 1);
|
||||
GSPREC(2, 6, 0xA, 0xE, 13, 12);
|
||||
GSPREC(3, 7, 0xB, 0xF, 11, 14);
|
||||
GSPREC(0, 5, 0xA, 0xF, 2, 6);
|
||||
GSPREC(1, 6, 0xB, 0xC, 5, 10);
|
||||
GSPREC(2, 7, 0x8, 0xD, 4, 0);
|
||||
GSPREC(3, 4, 0x9, 0xE, 15, 8);
|
||||
|
||||
h[0] = cuda_swab32(h[0] ^ v[0] ^ v[8]);
|
||||
h[1] = cuda_swab32(h[1] ^ v[1] ^ v[9]);
|
||||
h[2] = cuda_swab32(h[2] ^ v[2] ^ v[10]);
|
||||
h[3] = cuda_swab32(h[3] ^ v[3] ^ v[11]);
|
||||
h[4] = cuda_swab32(h[4] ^ v[4] ^ v[12]);
|
||||
h[5] = cuda_swab32(h[5] ^ v[5] ^ v[13]);
|
||||
h[6] = cuda_swab32(h[6] ^ v[6] ^ v[14]);
|
||||
h[7] = cuda_swab32(h[7] ^ v[7] ^ v[15]);
|
||||
|
||||
Hash[((0 * threads) + thread) * 2] = (h[0]);
|
||||
Hash[((0 * threads) + thread) * 2 + 1] = (h[1]);
|
||||
Hash[((1 * threads) + thread) * 2] = (h[2]);
|
||||
Hash[((1 * threads) + thread) * 2 + 1] = (h[3]);
|
||||
Hash[((2 * threads) + thread) * 2] = (h[4]);
|
||||
Hash[((2 * threads) + thread) * 2 + 1] = (h[5]);
|
||||
Hash[((3 * threads) + thread) * 2] = (h[6]);
|
||||
Hash[((3 * threads) + thread) * 2 + 1] = (h[7]);
|
||||
}
|
||||
}
|
||||
|
||||
__host__
|
||||
void blake256_cpu_hash_80(const int thr_id, const uint32_t threads, const uint32_t startNonce, uint64_t *Hash, int order)
|
||||
{
|
||||
const uint32_t threadsperblock = 256;
|
||||
const uint32_t threadsperblock = 64;
|
||||
|
||||
dim3 grid((threads + threadsperblock - 1) / threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
|
||||
blake256_gpu_hash_80 <<<grid, block>>> (threads, startNonce, Hash);
|
||||
MyStreamSynchronize(NULL, order, thr_id);
|
||||
blake256_gpu_hash_80 << <grid, block >> > (threads, startNonce, (uint32_t *)Hash);
|
||||
}
|
||||
|
||||
__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[16], 3 * 4, 0, cudaMemcpyHostToDevice);
|
||||
}
|
||||
|
||||
__host__
|
||||
void blake256_cpu_init(int thr_id, uint32_t threads)
|
||||
void blakeKeccak256_cpu_hash_80(const int thr_id, const uint32_t threads, const uint32_t startNonce, uint64_t *Hash, int order)
|
||||
{
|
||||
cudaMemcpyToSymbol(u256, c_u256, sizeof(c_u256), 0, cudaMemcpyHostToDevice);
|
||||
cudaMemcpyToSymbol(sigma, c_sigma, sizeof(c_sigma), 0, cudaMemcpyHostToDevice);
|
||||
const uint32_t threadsperblock = 256;
|
||||
|
||||
dim3 grid((threads + threadsperblock - 1) / threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
|
||||
blakeKeccak256_gpu_hash_80 << <grid, block >> > (threads, startNonce, (uint32_t *)Hash);
|
||||
}
|
||||
|
||||
__host__
|
||||
void blakeKeccak256_cpu_hash_80(const int thr_id, const uint32_t threads, const uint32_t startNonce, uint64_t *Hash, int order, cudaStream_t stream)
|
||||
{
|
||||
const uint32_t threadsperblock = 256;
|
||||
|
||||
dim3 grid((threads + threadsperblock - 1) / threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
|
||||
blakeKeccak256_gpu_hash_80 << <grid, block, 0, stream >> > (threads, startNonce, (uint32_t *)Hash);
|
||||
}
|
||||
@@ -372,3 +372,9 @@ void bmw256_midstate_init(int thr_id, uint32_t threads)
|
||||
{
|
||||
cudaMalloc(&d_midstate[thr_id], sizeof(sph_bmw256_context));
|
||||
}
|
||||
|
||||
__host__
|
||||
void bmw256_midstate_free(int thr_id)
|
||||
{
|
||||
cudaFree(d_midstate[thr_id]);
|
||||
}
|
||||
+244
-142
@@ -14,149 +14,57 @@ __constant__ uint64_t pTarget[4];
|
||||
#define shl(x, n) ((x) << (n))
|
||||
#define shr(x, n) ((x) >> (n))
|
||||
|
||||
#define ss0(x) (shr((x), 1) ^ shl((x), 3) ^ SPH_ROTL32((x), 4) ^ SPH_ROTL32((x), 19))
|
||||
#define ss1(x) (shr((x), 1) ^ shl((x), 2) ^ SPH_ROTL32((x), 8) ^ SPH_ROTL32((x), 23))
|
||||
#define ss2(x) (shr((x), 2) ^ shl((x), 1) ^ SPH_ROTL32((x), 12) ^ SPH_ROTL32((x), 25))
|
||||
#define ss3(x) (shr((x), 2) ^ shl((x), 2) ^ SPH_ROTL32((x), 15) ^ SPH_ROTL32((x), 29))
|
||||
#define ss4(x) (shr((x), 1) ^ (x))
|
||||
#define ss5(x) (shr((x), 2) ^ (x))
|
||||
|
||||
#define ss0(x) (shr((x), 1) ^ shl((x), 3) ^ SPH_ROTL32((x), 4) ^ SPH_ROTL32((x), 19))
|
||||
#define ss1(x) (shr((x), 1) ^ shl((x), 2) ^ __byte_perm(x,0,0x2103) ^ SPH_ROTL32((x), 23))
|
||||
#define ss2(x) (shr((x), 2) ^ shl((x), 1) ^ SPH_ROTL32((x), 12) ^ SPH_ROTL32((x), 25))
|
||||
#define ss3(x) (shr((x), 2) ^ shl((x), 2) ^ SPH_ROTL32((x), 15) ^ SPH_ROTL32((x), 29))
|
||||
#define ss4(x) (shr((x), 1) ^ (x))
|
||||
#define ss5(x) (shr((x), 2) ^ (x))
|
||||
#define rs1(x) SPH_ROTL32((x), 3)
|
||||
#define rs2(x) SPH_ROTL32((x), 7)
|
||||
#define rs3(x) SPH_ROTL32((x), 13)
|
||||
#define rs4(x) SPH_ROTL32((x), 16)
|
||||
#define rs4(x) __byte_perm(x,0,0x1032)
|
||||
#define rs5(x) SPH_ROTL32((x), 19)
|
||||
#define rs6(x) SPH_ROTL32((x), 23)
|
||||
#define rs7(x) SPH_ROTL32((x), 27)
|
||||
|
||||
/* Message expansion function 1 */
|
||||
__forceinline__ __device__
|
||||
uint32_t expand32_1(int i, uint32_t *M32, const uint32_t *H, uint32_t *Q)
|
||||
__forceinline__ __device__ uint32_t expand32_1(int i, uint32_t *M32, const uint32_t *H, uint32_t *Q)
|
||||
{
|
||||
return (ss1(Q[i - 16]) + ss2(Q[i - 15]) + ss3(Q[i - 14]) + ss0(Q[i - 13])
|
||||
+ ss1(Q[i - 12]) + ss2(Q[i - 11]) + ss3(Q[i - 10]) + ss0(Q[i - 9])
|
||||
+ ss1(Q[i - 8]) + ss2(Q[i - 7]) + ss3(Q[i - 6]) + ss0(Q[i - 5])
|
||||
+ ss1(Q[i - 4]) + ss2(Q[i - 3]) + ss3(Q[i - 2]) + ss0(Q[i - 1])
|
||||
+ ((i*(0x05555555ul) + SPH_ROTL32(M32[(i - 16) % 16], ((i - 16) % 16) + 1)
|
||||
+ SPH_ROTL32(M32[(i - 13) % 16], ((i - 13) % 16) + 1)
|
||||
- SPH_ROTL32(M32[(i - 6) % 16], ((i - 6) % 16) + 1)) ^ H[(i - 16 + 7) % 16]));
|
||||
+ ((i*(0x05555555ul) + SPH_ROTL32(M32[(i - 16) % 16], ((i - 16) % 16) + 1) + SPH_ROTL32(M32[(i - 13) % 16], ((i - 13) % 16) + 1) - SPH_ROTL32(M32[(i - 6) % 16], ((i - 6) % 16) + 1)) ^ H[(i - 16 + 7) % 16]));
|
||||
}
|
||||
|
||||
/* Message expansion function 2 */
|
||||
__forceinline__ __device__
|
||||
uint32_t expand32_2(int i, uint32_t *M32, const uint32_t *H, uint32_t *Q)
|
||||
__forceinline__ __device__ uint32_t expand32_2(const int i, uint32_t *M32, const uint32_t *H, uint32_t *Q)
|
||||
{
|
||||
return (Q[i - 16] + rs1(Q[i - 15]) + Q[i - 14] + rs2(Q[i - 13])
|
||||
+ Q[i - 12] + rs3(Q[i - 11]) + Q[i - 10] + rs4(Q[i - 9])
|
||||
+ Q[i - 8] + rs5(Q[i - 7]) + Q[i - 6] + rs6(Q[i - 5])
|
||||
+ Q[i - 4] + rs7(Q[i - 3]) + ss4(Q[i - 2]) + ss5(Q[i - 1])
|
||||
+ ((i*(0x05555555ul) + SPH_ROTL32(M32[(i - 16) % 16], ((i - 16) % 16) + 1)
|
||||
+ SPH_ROTL32(M32[(i - 13) % 16], ((i - 13) % 16) + 1)
|
||||
- SPH_ROTL32(M32[(i - 6) % 16], ((i - 6) % 16) + 1)) ^ H[(i - 16 + 7) % 16]));
|
||||
return (
|
||||
rs2(Q[i - 13]) + rs3(Q[i - 11]) + rs4(Q[i - 9]) + rs1(Q[i - 15]) +
|
||||
+rs5(Q[i - 7]) + rs6(Q[i - 5]) + rs7(Q[i - 3]) + ss4(Q[i - 2]) + ss5(Q[i - 1]));
|
||||
}
|
||||
|
||||
__forceinline__ __device__
|
||||
void Compression256(uint32_t * M32)
|
||||
__forceinline__ __device__ void Compression256(uint32_t M32[16])
|
||||
{
|
||||
uint32_t Q[32], XL32, XH32;
|
||||
|
||||
const uint32_t H[16] = {
|
||||
0x40414243, 0x44454647, 0x48494A4B, 0x4C4D4E4F,
|
||||
0x50515253, 0x54555657, 0x58595A5B, 0x5C5D5E5F,
|
||||
0x60616263, 0x64656667, 0x68696A6B, 0x6C6D6E6F,
|
||||
0x70717273, 0x74757677, 0x78797A7B, 0x7C7D7E7F
|
||||
(0x40414243), (0x44454647),
|
||||
(0x48494A4B), (0x4C4D4E4F),
|
||||
(0x50515253), (0x54555657),
|
||||
(0x58595A5B), (0x5C5D5E5F),
|
||||
(0x60616263), (0x64656667),
|
||||
(0x68696A6B), (0x6C6D6E6F),
|
||||
(0x70717273), (0x74757677),
|
||||
(0x78797A7B), (0x7C7D7E7F)
|
||||
};
|
||||
|
||||
Q[0] = (M32[5] ^ H[5]) - (M32[7] ^ H[7]) + (M32[10] ^ H[10]) + (M32[13] ^ H[13]) + (M32[14] ^ H[14]);
|
||||
Q[1] = (M32[6] ^ H[6]) - (M32[8] ^ H[8]) + (M32[11] ^ H[11]) + (M32[14] ^ H[14]) - (M32[15] ^ H[15]);
|
||||
Q[2] = (M32[0] ^ H[0]) + (M32[7] ^ H[7]) + (M32[9] ^ H[9]) - (M32[12] ^ H[12]) + (M32[15] ^ H[15]);
|
||||
Q[3] = (M32[0] ^ H[0]) - (M32[1] ^ H[1]) + (M32[8] ^ H[8]) - (M32[10] ^ H[10]) + (M32[13] ^ H[13]);
|
||||
Q[4] = (M32[1] ^ H[1]) + (M32[2] ^ H[2]) + (M32[9] ^ H[9]) - (M32[11] ^ H[11]) - (M32[14] ^ H[14]);
|
||||
Q[5] = (M32[3] ^ H[3]) - (M32[2] ^ H[2]) + (M32[10] ^ H[10]) - (M32[12] ^ H[12]) + (M32[15] ^ H[15]);
|
||||
Q[6] = (M32[4] ^ H[4]) - (M32[0] ^ H[0]) - (M32[3] ^ H[3]) - (M32[11] ^ H[11]) + (M32[13] ^ H[13]);
|
||||
Q[7] = (M32[1] ^ H[1]) - (M32[4] ^ H[4]) - (M32[5] ^ H[5]) - (M32[12] ^ H[12]) - (M32[14] ^ H[14]);
|
||||
Q[8] = (M32[2] ^ H[2]) - (M32[5] ^ H[5]) - (M32[6] ^ H[6]) + (M32[13] ^ H[13]) - (M32[15] ^ H[15]);
|
||||
Q[9] = (M32[0] ^ H[0]) - (M32[3] ^ H[3]) + (M32[6] ^ H[6]) - (M32[7] ^ H[7]) + (M32[14] ^ H[14]);
|
||||
Q[10] = (M32[8] ^ H[8]) - (M32[1] ^ H[1]) - (M32[4] ^ H[4]) - (M32[7] ^ H[7]) + (M32[15] ^ H[15]);
|
||||
Q[11] = (M32[8] ^ H[8]) - (M32[0] ^ H[0]) - (M32[2] ^ H[2]) - (M32[5] ^ H[5]) + (M32[9] ^ H[9]);
|
||||
Q[12] = (M32[1] ^ H[1]) + (M32[3] ^ H[3]) - (M32[6] ^ H[6]) - (M32[9] ^ H[9]) + (M32[10] ^ H[10]);
|
||||
Q[13] = (M32[2] ^ H[2]) + (M32[4] ^ H[4]) + (M32[7] ^ H[7]) + (M32[10] ^ H[10]) + (M32[11] ^ H[11]);
|
||||
Q[14] = (M32[3] ^ H[3]) - (M32[5] ^ H[5]) + (M32[8] ^ H[8]) - (M32[11] ^ H[11]) - (M32[12] ^ H[12]);
|
||||
Q[15] = (M32[12] ^ H[12]) - (M32[4] ^ H[4]) - (M32[6] ^ H[6]) - (M32[9] ^ H[9]) + (M32[13] ^ H[13]);
|
||||
M32[8] = 0x80;
|
||||
M32[14] = 0x100;
|
||||
|
||||
/* Diffuse the differences in every word in a bijective manner with ssi, and then add the values of the previous double pipe. */
|
||||
Q[0] = ss0(Q[0]) + H[1];
|
||||
Q[1] = ss1(Q[1]) + H[2];
|
||||
Q[2] = ss2(Q[2]) + H[3];
|
||||
Q[3] = ss3(Q[3]) + H[4];
|
||||
Q[4] = ss4(Q[4]) + H[5];
|
||||
Q[5] = ss0(Q[5]) + H[6];
|
||||
Q[6] = ss1(Q[6]) + H[7];
|
||||
Q[7] = ss2(Q[7]) + H[8];
|
||||
Q[8] = ss3(Q[8]) + H[9];
|
||||
Q[9] = ss4(Q[9]) + H[10];
|
||||
Q[10] = ss0(Q[10]) + H[11];
|
||||
Q[11] = ss1(Q[11]) + H[12];
|
||||
Q[12] = ss2(Q[12]) + H[13];
|
||||
Q[13] = ss3(Q[13]) + H[14];
|
||||
Q[14] = ss4(Q[14]) + H[15];
|
||||
Q[15] = ss0(Q[15]) + H[0];
|
||||
|
||||
/* This is the Message expansion or f_1 in the documentation. */
|
||||
/* It has 16 rounds. */
|
||||
/* Blue Midnight Wish has two tunable security parameters. */
|
||||
/* The parameters are named EXPAND_1_ROUNDS and EXPAND_2_ROUNDS. */
|
||||
/* The following relation for these parameters should is satisfied: */
|
||||
/* EXPAND_1_ROUNDS + EXPAND_2_ROUNDS = 16 */
|
||||
|
||||
#pragma unroll
|
||||
for (int i=16; i<18; i++)
|
||||
Q[i] = expand32_1(i, M32, H, Q);
|
||||
|
||||
#pragma nounroll
|
||||
for (int i=18; i<32; i++)
|
||||
Q[i] = expand32_2(i, M32, H, Q);
|
||||
|
||||
/* Blue Midnight Wish has two temporary cummulative variables that accumulate via XORing */
|
||||
/* 16 new variables that are prooduced in the Message Expansion part. */
|
||||
XL32 = Q[16] ^ Q[17] ^ Q[18] ^ Q[19] ^ Q[20] ^ Q[21] ^ Q[22] ^ Q[23];
|
||||
XH32 = XL32^Q[24] ^ Q[25] ^ Q[26] ^ Q[27] ^ Q[28] ^ Q[29] ^ Q[30] ^ Q[31];
|
||||
|
||||
|
||||
/* This part is the function f_2 - in the documentation */
|
||||
|
||||
/* Compute the double chaining pipe for the next message block. */
|
||||
M32[0] = (shl(XH32, 5) ^ shr(Q[16], 5) ^ M32[0]) + (XL32 ^ Q[24] ^ Q[0]);
|
||||
M32[1] = (shr(XH32, 7) ^ shl(Q[17], 8) ^ M32[1]) + (XL32 ^ Q[25] ^ Q[1]);
|
||||
M32[2] = (shr(XH32, 5) ^ shl(Q[18], 5) ^ M32[2]) + (XL32 ^ Q[26] ^ Q[2]);
|
||||
M32[3] = (shr(XH32, 1) ^ shl(Q[19], 5) ^ M32[3]) + (XL32 ^ Q[27] ^ Q[3]);
|
||||
M32[4] = (shr(XH32, 3) ^ Q[20] ^ M32[4]) + (XL32 ^ Q[28] ^ Q[4]);
|
||||
M32[5] = (shl(XH32, 6) ^ shr(Q[21], 6) ^ M32[5]) + (XL32 ^ Q[29] ^ Q[5]);
|
||||
M32[6] = (shr(XH32, 4) ^ shl(Q[22], 6) ^ M32[6]) + (XL32 ^ Q[30] ^ Q[6]);
|
||||
M32[7] = (shr(XH32, 11) ^ shl(Q[23], 2) ^ M32[7]) + (XL32 ^ Q[31] ^ Q[7]);
|
||||
|
||||
M32[8] = SPH_ROTL32(M32[4], 9) + (XH32 ^ Q[24] ^ M32[8]) + (shl(XL32, 8) ^ Q[23] ^ Q[8]);
|
||||
M32[9] = SPH_ROTL32(M32[5], 10) + (XH32 ^ Q[25] ^ M32[9]) + (shr(XL32, 6) ^ Q[16] ^ Q[9]);
|
||||
M32[10] = SPH_ROTL32(M32[6], 11) + (XH32 ^ Q[26] ^ M32[10]) + (shl(XL32, 6) ^ Q[17] ^ Q[10]);
|
||||
M32[11] = SPH_ROTL32(M32[7], 12) + (XH32 ^ Q[27] ^ M32[11]) + (shl(XL32, 4) ^ Q[18] ^ Q[11]);
|
||||
M32[12] = SPH_ROTL32(M32[0], 13) + (XH32 ^ Q[28] ^ M32[12]) + (shr(XL32, 3) ^ Q[19] ^ Q[12]);
|
||||
M32[13] = SPH_ROTL32(M32[1], 14) + (XH32 ^ Q[29] ^ M32[13]) + (shr(XL32, 4) ^ Q[20] ^ Q[13]);
|
||||
M32[14] = SPH_ROTL32(M32[2], 15) + (XH32 ^ Q[30] ^ M32[14]) + (shr(XL32, 7) ^ Q[21] ^ Q[14]);
|
||||
M32[15] = SPH_ROTL32(M32[3], 16) + (XH32 ^ Q[31] ^ M32[15]) + (shr(XL32, 2) ^ Q[22] ^ Q[15]);
|
||||
}
|
||||
|
||||
__forceinline__ __device__
|
||||
void Compression256_2(uint32_t * M32)
|
||||
{
|
||||
// int i;
|
||||
uint32_t XL32, XH32, Q[32];
|
||||
|
||||
const uint32_t H[16] = {
|
||||
0xaaaaaaa0, 0xaaaaaaa1, 0xaaaaaaa2, 0xaaaaaaa3,
|
||||
0xaaaaaaa4, 0xaaaaaaa5, 0xaaaaaaa6, 0xaaaaaaa7,
|
||||
0xaaaaaaa8, 0xaaaaaaa9, 0xaaaaaaaa, 0xaaaaaaab,
|
||||
0xaaaaaaac, 0xaaaaaaad, 0xaaaaaaae, 0xaaaaaaaf
|
||||
};
|
||||
|
||||
Q[0] = (M32[5] ^ H[5]) - (M32[7] ^ H[7]) + (M32[10] ^ H[10]) + (M32[13] ^ H[13]) + (M32[14] ^ H[14]);
|
||||
Q[1] = (M32[6] ^ H[6]) - (M32[8] ^ H[8]) + (M32[11] ^ H[11]) + (M32[14] ^ H[14]) - (M32[15] ^ H[15]);
|
||||
Q[2] = (M32[0] ^ H[0]) + (M32[7] ^ H[7]) + (M32[9] ^ H[9]) - (M32[12] ^ H[12]) + (M32[15] ^ H[15]);
|
||||
@@ -199,45 +107,238 @@ void Compression256_2(uint32_t * M32)
|
||||
/* The following relation for these parameters should is satisfied: */
|
||||
/* EXPAND_1_ROUNDS + EXPAND_2_ROUNDS = 16 */
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 16; i<18; i++)
|
||||
Q[i] = expand32_1(i, M32, H, Q);
|
||||
// #pragma unroll
|
||||
// for (i = 0; i<2; i++)
|
||||
// Q[i + 16] = expand32_1(i + 16, M32, H, Q);
|
||||
|
||||
#pragma nounroll
|
||||
for (int i = 18; i<32; i++)
|
||||
Q[i] = expand32_2(i, M32, H, Q);
|
||||
Q[16] = ss1(Q[16 - 16]) + ss2(Q[16 - 15]) + ss3(Q[16 - 14]) + ss0(Q[16 - 13])
|
||||
+ ss1(Q[16 - 12]) + ss2(Q[16 - 11]) + ss3(Q[16 - 10]) + ss0(Q[16 - 9])
|
||||
+ ss1(Q[16 - 8]) + ss2(Q[16 - 7]) + ss3(Q[16 - 6]) + ss0(Q[16 - 5])
|
||||
+ ss1(Q[16 - 4]) + ss2(Q[16 - 3]) + ss3(Q[16 - 2]) + ss0(Q[16 - 1])
|
||||
+ ((16 * (0x05555555ul) + SPH_ROTL32(M32[0], ((16 - 16) % 16) + 1) + SPH_ROTL32(M32[3], ((16 - 13) % 16) + 1)) ^ H[(16 - 16 + 7) % 16]);
|
||||
|
||||
Q[17] = ss1(Q[17 - 16]) + ss2(Q[17 - 15]) + ss3(Q[17 - 14]) + ss0(Q[17 - 13])
|
||||
+ ss1(Q[17 - 12]) + ss2(Q[17 - 11]) + ss3(Q[17 - 10]) + ss0(Q[17 - 9])
|
||||
+ ss1(Q[17 - 8]) + ss2(Q[17 - 7]) + ss3(Q[17 - 6]) + ss0(Q[17 - 5])
|
||||
+ ss1(Q[17 - 4]) + ss2(Q[17 - 3]) + ss3(Q[17 - 2]) + ss0(Q[17 - 1])
|
||||
+ ((17 * (0x05555555ul) + SPH_ROTL32(M32[(17 - 16) % 16], ((17 - 16) % 16) + 1) + SPH_ROTL32(M32[(17 - 13) % 16], ((17 - 13) % 16) + 1)) ^ H[(17 - 16 + 7) % 16]);
|
||||
|
||||
|
||||
uint32_t precalc = Q[18 - 16] + Q[18 - 14] + Q[18 - 12] + Q[18 - 10] + Q[18 - 8] + Q[18 - 6]; //+ Q[18 - 4]
|
||||
uint32_t precalc2 = Q[19 - 16] + Q[19 - 14] + Q[19 - 12] + Q[19 - 10] + Q[19 - 8] + Q[19 - 6];//+ Q[19 - 4]
|
||||
|
||||
// #pragma unroll
|
||||
// for (i = 2 + 16; i < 16 + 16; i+=2)
|
||||
// {
|
||||
precalc = precalc + Q[18 - 4];
|
||||
precalc2 = precalc2 + Q[18 + 1 - 4];
|
||||
uint32_t p1 = ((18 * (0x05555555ul) + SPH_ROTL32(M32[2], ((18 - 16) % 16) + 1) + SPH_ROTL32(M32[5], ((18 - 13) % 16) + 1)) ^ H[(18 - 16 + 7) % 16]);
|
||||
uint32_t p2 = (((18 + 1)*(0x05555555ul) + SPH_ROTL32(M32[3], (((18 + 1) - 16) % 16) + 1) + SPH_ROTL32(M32[6], (((18 + 1) - 13) % 16) + 1)) ^ H[((18 + 1) - 16 + 7) % 16]);
|
||||
Q[18] = precalc + expand32_2(18, M32, H, Q) + p1;
|
||||
Q[18 + 1] = precalc2 + expand32_2(18 + 1, M32, H, Q) + p2;
|
||||
precalc = precalc - Q[18 - 16];
|
||||
precalc2 = precalc2 - Q[18 + 1 - 16];
|
||||
|
||||
precalc = precalc + Q[20 - 4];
|
||||
precalc2 = precalc2 + Q[20 + 1 - 4];
|
||||
p1 = ((20 * (0x05555555ul) + SPH_ROTL32(M32[4], ((20 - 16) % 16) + 1) + SPH_ROTL32(M32[7], ((20 - 13) % 16) + 1) - (0x100 << 15)) ^ H[(20 - 16 + 7) % 16]);
|
||||
p2 = (((20 + 1)*(0x05555555ul) + SPH_ROTL32(M32[5], (((20 + 1) - 16) % 16) + 1) + (0x80 << 9)) ^ H[((20 + 1) - 16 + 7) % 16]);
|
||||
Q[20] = precalc + expand32_2(20, M32, H, Q) + p1;
|
||||
Q[20 + 1] = precalc2 + expand32_2(20 + 1, M32, H, Q) + p2;
|
||||
precalc = precalc - Q[20 - 16];
|
||||
precalc2 = precalc2 - Q[20 + 1 - 16];
|
||||
|
||||
precalc = precalc + Q[22 - 4];
|
||||
precalc2 = precalc2 + Q[22 + 1 - 4];
|
||||
p1 = ((22 * (0x05555555ul) + SPH_ROTL32(M32[6], ((22 - 16) % 16) + 1) - SPH_ROTL32(M32[0], ((22 - 6) % 16) + 1)) ^ H[(22 - 16 + 7) % 16]);
|
||||
p2 = (((22 + 1)*(0x05555555ul) + SPH_ROTL32(M32[7], (((22 + 1) - 16) % 16) + 1) - SPH_ROTL32(M32[1], (((22 + 1) - 6) % 16) + 1)) ^ H[((22 + 1) - 16 + 7) % 16]);
|
||||
Q[22] = precalc + expand32_2(22, M32, H, Q) + p1;
|
||||
Q[22 + 1] = precalc2 + expand32_2(22 + 1, M32, H, Q) + p2;
|
||||
precalc = precalc - Q[22 - 16];
|
||||
precalc2 = precalc2 - Q[22 + 1 - 16];
|
||||
|
||||
precalc = precalc + Q[24 - 4];
|
||||
precalc2 = precalc2 + Q[24 + 1 - 4];
|
||||
p1 = ((24 * (0x05555555ul) + (0x80 << 9) - SPH_ROTL32(M32[2], ((24 - 6) % 16) + 1)) ^ H[(24 - 16 + 7) % 16]);
|
||||
p2 = (((24 + 1)*(0x05555555ul) - SPH_ROTL32(M32[3], (((24 + 1) - 6) % 16) + 1)) ^ H[((24 + 1) - 16 + 7) % 16]);
|
||||
Q[24] = precalc + expand32_2(24, M32, H, Q) + p1;
|
||||
Q[24 + 1] = precalc2 + expand32_2(24 + 1, M32, H, Q) + p2;
|
||||
precalc = precalc - Q[24 - 16];
|
||||
precalc2 = precalc2 - Q[24 + 1 - 16];
|
||||
|
||||
precalc = precalc + Q[26 - 4];
|
||||
precalc2 = precalc2 + Q[26 + 1 - 4];
|
||||
p1 = ((26 * (0x05555555ul) - SPH_ROTL32(M32[4], ((26 - 6) % 16) + 1)) ^ H[(26 - 16 + 7) % 16]);
|
||||
p2 = (((26 + 1)*(0x05555555ul) + (0x100 << 15) - SPH_ROTL32(M32[5], (((26 + 1) - 6) % 16) + 1)) ^ H[((26 + 1) - 16 + 7) % 16]);
|
||||
Q[26] = precalc + expand32_2(26, M32, H, Q) + p1;
|
||||
Q[26 + 1] = precalc2 + expand32_2(26 + 1, M32, H, Q) + p2;
|
||||
precalc = precalc - Q[26 - 16];
|
||||
precalc2 = precalc2 - Q[26 + 1 - 16];
|
||||
|
||||
precalc = precalc + Q[28 - 4];
|
||||
precalc2 = precalc2 + Q[28 + 1 - 4];
|
||||
p1 = ((28 * (0x05555555ul) - SPH_ROTL32(M32[6], ((28 - 6) % 16) + 1)) ^ H[(28 - 16 + 7) % 16]);
|
||||
p2 = (((28 + 1)*(0x05555555ul) + SPH_ROTL32(M32[0], (((28 + 1) - 13) % 16) + 1) - SPH_ROTL32(M32[7], (((28 + 1) - 6) % 16) + 1)) ^ H[((28 + 1) - 16 + 7) % 16]);
|
||||
Q[28] = precalc + expand32_2(28, M32, H, Q) + p1;
|
||||
Q[28 + 1] = precalc2 + expand32_2(28 + 1, M32, H, Q) + p2;
|
||||
precalc = precalc - Q[28 - 16];
|
||||
precalc2 = precalc2 - Q[28 + 1 - 16];
|
||||
|
||||
precalc = precalc + Q[30 - 4];
|
||||
precalc2 = precalc2 + Q[30 + 1 - 4];
|
||||
p1 = ((30 * (0x05555555ul) + (0x100 << 15) + SPH_ROTL32(M32[1], ((30 - 13) % 16) + 1) - (0x80 << 9)) ^ H[(30 - 16 + 7) % 16]);
|
||||
p2 = (((30 + 1)*(0x05555555ul) + SPH_ROTL32(M32[2], (((30 + 1) - 13) % 16) + 1)) ^ H[((30 + 1) - 16 + 7) % 16]);
|
||||
Q[30] = precalc + expand32_2(30, M32, H, Q) + p1;
|
||||
Q[30 + 1] = precalc2 + expand32_2(30 + 1, M32, H, Q) + p2;
|
||||
precalc = precalc - Q[30 - 16];
|
||||
precalc2 = precalc2 - Q[30 + 1 - 16];
|
||||
|
||||
/* Blue Midnight Wish has two temporary cummulative variables that accumulate via XORing */
|
||||
/* 16 new variables that are prooduced in the Message Expansion part. */
|
||||
XL32 = Q[16] ^ Q[17] ^ Q[18] ^ Q[19] ^ Q[20] ^ Q[21] ^ Q[22] ^ Q[23];
|
||||
XH32 = XL32 ^ Q[24] ^ Q[25] ^ Q[26] ^ Q[27] ^ Q[28] ^ Q[29] ^ Q[30] ^ Q[31];
|
||||
XH32 = XL32^Q[24] ^ Q[25] ^ Q[26] ^ Q[27] ^ Q[28] ^ Q[29] ^ Q[30] ^ Q[31];
|
||||
|
||||
|
||||
/* This part is the function f_2 - in the documentation */
|
||||
|
||||
/* Compute the double chaining pipe for the next message block. */
|
||||
M32[0] = (shl(XH32, 5) ^ shr(Q[16], 5) ^ M32[0]) + (XL32 ^ Q[24] ^ Q[0]);
|
||||
M32[1] = (shr(XH32, 7) ^ shl(Q[17], 8) ^ M32[1]) + (XL32 ^ Q[25] ^ Q[1]);
|
||||
M32[2] = (shr(XH32, 5) ^ shl(Q[18], 5) ^ M32[2]) + (XL32 ^ Q[26] ^ Q[2]);
|
||||
M32[3] = (shr(XH32, 1) ^ shl(Q[19], 5) ^ M32[3]) + (XL32 ^ Q[27] ^ Q[3]);
|
||||
M32[4] = (shr(XH32, 3) ^ Q[20] ^ M32[4]) + (XL32 ^ Q[28] ^ Q[4]);
|
||||
M32[5] = (shl(XH32, 6) ^ shr(Q[21], 6) ^ M32[5]) + (XL32 ^ Q[29] ^ Q[5]);
|
||||
M32[6] = (shr(XH32, 4) ^ shl(Q[22], 6) ^ M32[6]) + (XL32 ^ Q[30] ^ Q[6]);
|
||||
M32[7] = (shr(XH32, 11) ^ shl(Q[23], 2) ^ M32[7]) + (XL32 ^ Q[31] ^ Q[7]);
|
||||
|
||||
M32[8] = SPH_ROTL32(M32[4], 9) + (XH32 ^ Q[24] ^ M32[8]) + (shl(XL32, 8) ^ Q[23] ^ Q[8]);
|
||||
M32[9] = SPH_ROTL32(M32[5], 10) + (XH32 ^ Q[25] ^ M32[9]) + (shr(XL32, 6) ^ Q[16] ^ Q[9]);
|
||||
M32[10] = SPH_ROTL32(M32[6], 11) + (XH32 ^ Q[26] ^ M32[10]) + (shl(XL32, 6) ^ Q[17] ^ Q[10]);
|
||||
M32[11] = SPH_ROTL32(M32[7], 12) + (XH32 ^ Q[27] ^ M32[11]) + (shl(XL32, 4) ^ Q[18] ^ Q[11]);
|
||||
M32[12] = SPH_ROTL32(M32[0], 13) + (XH32 ^ Q[28] ^ M32[12]) + (shr(XL32, 3) ^ Q[19] ^ Q[12]);
|
||||
M32[13] = SPH_ROTL32(M32[1], 14) + (XH32 ^ Q[29] ^ M32[13]) + (shr(XL32, 4) ^ Q[20] ^ Q[13]);
|
||||
M32[14] = SPH_ROTL32(M32[2], 15) + (XH32 ^ Q[30] ^ M32[14]) + (shr(XL32, 7) ^ Q[21] ^ Q[14]);
|
||||
M32[15] = SPH_ROTL32(M32[3], 16) + (XH32 ^ Q[31] ^ M32[15]) + (shr(XL32, 2) ^ Q[22] ^ Q[15]);
|
||||
}
|
||||
|
||||
__forceinline__ __device__ void Compression256_2(uint32_t M32[16])
|
||||
{
|
||||
const uint32_t H[16] = {
|
||||
(0xaaaaaaa0), (0xaaaaaaa1), (0xaaaaaaa2),
|
||||
(0xaaaaaaa3), (0xaaaaaaa4), (0xaaaaaaa5),
|
||||
(0xaaaaaaa6), (0xaaaaaaa7), (0xaaaaaaa8),
|
||||
(0xaaaaaaa9), (0xaaaaaaaa), (0xaaaaaaab),
|
||||
(0xaaaaaaac), (0xaaaaaaad), (0xaaaaaaae),
|
||||
(0xaaaaaaaf)
|
||||
};
|
||||
int i;
|
||||
uint32_t XL32, XH32, Q[32];
|
||||
|
||||
Q[0] = (M32[5] ^ H[5]) - (M32[7] ^ H[7]) + (M32[10] ^ H[10]) + (M32[13] ^ H[13]) + (M32[14] ^ H[14]);
|
||||
Q[1] = (M32[6] ^ H[6]) - (M32[8] ^ H[8]) + (M32[11] ^ H[11]) + (M32[14] ^ H[14]) - (M32[15] ^ H[15]);
|
||||
Q[2] = (M32[0] ^ H[0]) + (M32[7] ^ H[7]) + (M32[9] ^ H[9]) - (M32[12] ^ H[12]) + (M32[15] ^ H[15]);
|
||||
Q[3] = (M32[0] ^ H[0]) - (M32[1] ^ H[1]) + (M32[8] ^ H[8]) - (M32[10] ^ H[10]) + (M32[13] ^ H[13]);
|
||||
Q[4] = (M32[1] ^ H[1]) + (M32[2] ^ H[2]) + (M32[9] ^ H[9]) - (M32[11] ^ H[11]) - (M32[14] ^ H[14]);
|
||||
Q[5] = (M32[3] ^ H[3]) - (M32[2] ^ H[2]) + (M32[10] ^ H[10]) - (M32[12] ^ H[12]) + (M32[15] ^ H[15]);
|
||||
Q[6] = (M32[4] ^ H[4]) - (M32[0] ^ H[0]) - (M32[3] ^ H[3]) - (M32[11] ^ H[11]) + (M32[13] ^ H[13]);
|
||||
Q[7] = (M32[1] ^ H[1]) - (M32[4] ^ H[4]) - (M32[5] ^ H[5]) - (M32[12] ^ H[12]) - (M32[14] ^ H[14]);
|
||||
Q[8] = (M32[2] ^ H[2]) - (M32[5] ^ H[5]) - (M32[6] ^ H[6]) + (M32[13] ^ H[13]) - (M32[15] ^ H[15]);
|
||||
Q[9] = (M32[0] ^ H[0]) - (M32[3] ^ H[3]) + (M32[6] ^ H[6]) - (M32[7] ^ H[7]) + (M32[14] ^ H[14]);
|
||||
Q[10] = (M32[8] ^ H[8]) - (M32[1] ^ H[1]) - (M32[4] ^ H[4]) - (M32[7] ^ H[7]) + (M32[15] ^ H[15]);
|
||||
Q[11] = (M32[8] ^ H[8]) - (M32[0] ^ H[0]) - (M32[2] ^ H[2]) - (M32[5] ^ H[5]) + (M32[9] ^ H[9]);
|
||||
Q[12] = (M32[1] ^ H[1]) + (M32[3] ^ H[3]) - (M32[6] ^ H[6]) - (M32[9] ^ H[9]) + (M32[10] ^ H[10]);
|
||||
Q[13] = (M32[2] ^ H[2]) + (M32[4] ^ H[4]) + (M32[7] ^ H[7]) + (M32[10] ^ H[10]) + (M32[11] ^ H[11]);
|
||||
Q[14] = (M32[3] ^ H[3]) - (M32[5] ^ H[5]) + (M32[8] ^ H[8]) - (M32[11] ^ H[11]) - (M32[12] ^ H[12]);
|
||||
Q[15] = (M32[12] ^ H[12]) - (M32[4] ^ H[4]) - (M32[6] ^ H[6]) - (M32[9] ^ H[9]) + (M32[13] ^ H[13]);
|
||||
|
||||
/* Diffuse the differences in every word in a bijective manner with ssi, and then add the values of the previous double pipe.*/
|
||||
Q[0] = ss0(Q[0]) + H[1];
|
||||
Q[1] = ss1(Q[1]) + H[2];
|
||||
Q[2] = ss2(Q[2]) + H[3];
|
||||
Q[3] = ss3(Q[3]) + H[4];
|
||||
Q[4] = ss4(Q[4]) + H[5];
|
||||
Q[5] = ss0(Q[5]) + H[6];
|
||||
Q[6] = ss1(Q[6]) + H[7];
|
||||
Q[7] = ss2(Q[7]) + H[8];
|
||||
Q[8] = ss3(Q[8]) + H[9];
|
||||
Q[9] = ss4(Q[9]) + H[10];
|
||||
Q[10] = ss0(Q[10]) + H[11];
|
||||
Q[11] = ss1(Q[11]) + H[12];
|
||||
Q[12] = ss2(Q[12]) + H[13];
|
||||
Q[13] = ss3(Q[13]) + H[14];
|
||||
Q[14] = ss4(Q[14]) + H[15];
|
||||
Q[15] = ss0(Q[15]) + H[0];
|
||||
|
||||
/* This is the Message expansion or f_1 in the documentation. */
|
||||
/* It has 16 rounds. */
|
||||
/* Blue Midnight Wish has two tunable security parameters. */
|
||||
/* The parameters are named EXPAND_1_ROUNDS and EXPAND_2_ROUNDS. */
|
||||
/* The following relation for these parameters should is satisfied: */
|
||||
/* EXPAND_1_ROUNDS + EXPAND_2_ROUNDS = 16 */
|
||||
|
||||
#pragma unroll
|
||||
for (i = 0; i<2; i++)
|
||||
Q[i + 16] = expand32_1(i + 16, M32, H, Q);
|
||||
|
||||
/* #pragma unroll
|
||||
for (i = 2; i<16; i++)
|
||||
Q[i + 16] = expand32_2(i + 16, M32, H, Q);
|
||||
*/
|
||||
uint32_t precalc = Q[18 - 16] + Q[18 - 14] + Q[18 - 12] + Q[18 - 10] + Q[18 - 8] + Q[18 - 6]; //+ Q[18 - 4]
|
||||
uint32_t precalc2 = Q[19 - 16] + Q[19 - 14] + Q[19 - 12] + Q[19 - 10] + Q[19 - 8] + Q[19 - 6];//+ Q[19 - 4]
|
||||
|
||||
#pragma unroll
|
||||
for (i = 2 + 16; i < 16 + 16; i += 2)
|
||||
{
|
||||
precalc = precalc + Q[i - 4];
|
||||
precalc2 = precalc2 + Q[i + 1 - 4];
|
||||
uint32_t p1 = ((i*(0x05555555ul) + SPH_ROTL32(M32[(i - 16) % 16], ((i - 16) % 16) + 1) + SPH_ROTL32(M32[(i - 13) % 16], ((i - 13) % 16) + 1) - SPH_ROTL32(M32[(i - 6) % 16], ((i - 6) % 16) + 1)) ^ H[(i - 16 + 7) % 16]);
|
||||
uint32_t p2 = (((i + 1)*(0x05555555ul) + SPH_ROTL32(M32[((i + 1) - 16) % 16], (((i + 1) - 16) % 16) + 1) + SPH_ROTL32(M32[((i + 1) - 13) % 16], (((i + 1) - 13) % 16) + 1) - SPH_ROTL32(M32[((i + 1) - 6) % 16], (((i + 1) - 6) % 16) + 1)) ^ H[((i + 1) - 16 + 7) % 16]);
|
||||
Q[i] = precalc + expand32_2(i, M32, H, Q) + p1;
|
||||
Q[i + 1] = precalc2 + expand32_2(i + 1, M32, H, Q) + p2;
|
||||
precalc = precalc - Q[i - 16];
|
||||
precalc2 = precalc2 - Q[i + 1 - 16];
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* Blue Midnight Wish has two temporary cummulative variables that accumulate via XORing */
|
||||
/* 16 new variables that are prooduced in the Message Expansion part. */
|
||||
XL32 = Q[16] ^ Q[17] ^ Q[18] ^ Q[19] ^ Q[20] ^ Q[21] ^ Q[22] ^ Q[23];
|
||||
XH32 = XL32^Q[24] ^ Q[25] ^ Q[26] ^ Q[27] ^ Q[28] ^ Q[29] ^ Q[30] ^ Q[31];
|
||||
|
||||
|
||||
M32[2] = (shr(XH32, 5) ^ shl(Q[18], 5) ^ M32[2]) + (XL32 ^ Q[26] ^ Q[2]);
|
||||
M32[3] = (shr(XH32, 1) ^ shl(Q[19], 5) ^ M32[3]) + (XL32 ^ Q[27] ^ Q[3]);
|
||||
M32[14] = SPH_ROTL32(M32[2], 15) + (XH32 ^ Q[30] ^ M32[14]) + (shr(XL32, 7) ^ Q[21] ^ Q[14]);
|
||||
M32[15] = SPH_ROTL32(M32[3], 16) + (XH32 ^ Q[31] ^ M32[15]) + (shr(XL32, 2) ^ Q[22] ^ Q[15]);
|
||||
|
||||
|
||||
M32[2] = (shr(XH32, 5) ^ shl(Q[18], 5) ^ M32[2]) + (XL32 ^ Q[26] ^ Q[2]);
|
||||
M32[3] = (shr(XH32, 1) ^ shl(Q[19], 5) ^ M32[3]) + (XL32 ^ Q[27] ^ Q[3]);
|
||||
M32[14] = SPH_ROTL32(M32[2], 15) + (XH32 ^ Q[30] ^ M32[14]) + (shr(XL32, 7) ^ Q[21] ^ Q[14]);
|
||||
M32[15] = SPH_ROTL32(M32[3], 16) + (XH32 ^ Q[31] ^ M32[15]) + (shr(XL32, 2) ^ Q[22] ^ Q[15]);
|
||||
}
|
||||
|
||||
#define TPB 512
|
||||
__global__ __launch_bounds__(TPB, 2)
|
||||
void bmw256_gpu_hash_32(uint32_t threads, uint32_t startNounce, uint64_t *g_hash, uint32_t *const __restrict__ nonceVector)
|
||||
void bmw256_gpu_hash_32(uint32_t threads, uint32_t startNounce, uint2 *g_hash, uint32_t *const __restrict__ nonceVector, uint32_t Target)
|
||||
{
|
||||
const uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
uint32_t message[16] = { 0 };
|
||||
uint2 message[8] = { 0 };
|
||||
|
||||
LOHI(message[0], message[1], __ldg(&g_hash[thread]));
|
||||
LOHI(message[2], message[3], __ldg(&g_hash[thread + 1 * threads]));
|
||||
LOHI(message[4], message[5], __ldg(&g_hash[thread + 2 * threads]));
|
||||
LOHI(message[6], message[7], __ldg(&g_hash[thread + 3 * threads]));
|
||||
message[0] = __ldg(&g_hash[thread + 0 * threads]);
|
||||
message[1] = __ldg(&g_hash[thread + 1 * threads]);
|
||||
message[2] = __ldg(&g_hash[thread + 2 * threads]);
|
||||
message[3] = __ldg(&g_hash[thread + 3 * threads]);
|
||||
//LOHI(message[2], message[3], __ldg(&g_hash[thread + 1 * threads]));
|
||||
//LOHI(message[4], message[5], __ldg(&g_hash[thread + 2 * threads]));
|
||||
//LOHI(message[6], message[7], __ldg(&g_hash[thread + 3 * threads]));
|
||||
|
||||
message[8]=0x80;
|
||||
message[14]=0x100;
|
||||
Compression256(message);
|
||||
Compression256_2(message);
|
||||
message[4].x = 0x80;
|
||||
message[7].x = 0x100;
|
||||
Compression256((uint32_t*)message);
|
||||
Compression256_2((uint32_t*)message);
|
||||
|
||||
if (((uint64_t*)message)[7] <= pTarget[3])
|
||||
if (message[7].y <= Target)
|
||||
{
|
||||
uint32_t tmp = atomicExch(&nonceVector[0], startNounce + thread);
|
||||
if (tmp != 0)
|
||||
@@ -247,7 +348,7 @@ void bmw256_gpu_hash_32(uint32_t threads, uint32_t startNounce, uint64_t *g_hash
|
||||
}
|
||||
|
||||
__host__
|
||||
void bmw256_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNounce, uint64_t *g_hash, uint32_t *resultnonces)
|
||||
void bmw256_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNounce, uint64_t *g_hash, uint32_t *resultnonces, uint32_t Target)
|
||||
{
|
||||
const uint32_t threadsperblock = TPB;
|
||||
dim3 grid((threads + threadsperblock - 1) / threadsperblock);
|
||||
@@ -255,13 +356,12 @@ void bmw256_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNounce, uint
|
||||
|
||||
cudaMemset(d_GNonce[thr_id], 0, 2 * sizeof(uint32_t));
|
||||
|
||||
bmw256_gpu_hash_32 << <grid, block >> >(threads, startNounce, g_hash, d_GNonce[thr_id]);
|
||||
bmw256_gpu_hash_32 << <grid, block >> >(threads, startNounce, (uint2*)g_hash, d_GNonce[thr_id], Target);
|
||||
cudaMemcpy(d_gnounce[thr_id], d_GNonce[thr_id], 2 * sizeof(uint32_t), cudaMemcpyDeviceToHost);
|
||||
resultnonces[0] = *(d_gnounce[thr_id]);
|
||||
resultnonces[1] = *(d_gnounce[thr_id] + 1);
|
||||
}
|
||||
|
||||
|
||||
__host__
|
||||
void bmw256_cpu_init(int thr_id, uint32_t threads)
|
||||
{
|
||||
@@ -276,8 +376,10 @@ void bmw256_cpu_free(int thr_id)
|
||||
cudaFreeHost(d_gnounce[thr_id]);
|
||||
}
|
||||
|
||||
/*
|
||||
__host__
|
||||
void bmw256_setTarget(const void *pTargetIn)
|
||||
{
|
||||
cudaMemcpyToSymbol(pTarget, pTargetIn, 32, 0, cudaMemcpyHostToDevice);
|
||||
}
|
||||
*/
|
||||
+267
-203
@@ -3,181 +3,249 @@
|
||||
#define CUBEHASH_ROUNDS 16 /* this is r for CubeHashr/b */
|
||||
#define CUBEHASH_BLOCKBYTES 32 /* this is b for CubeHashr/b */
|
||||
|
||||
#ifdef __INTELLISENSE__
|
||||
/* just for vstudio code colors */
|
||||
#define __CUDA_ARCH__ 520
|
||||
#endif
|
||||
|
||||
#if __CUDA_ARCH__ < 350
|
||||
#define LROT(x,bits) ((x << bits) | (x >> (32 - bits)))
|
||||
#else
|
||||
#define LROT(x, bits) __funnelshift_l(x, x, bits)
|
||||
#endif
|
||||
|
||||
#if __CUDA_ARCH__ < 500
|
||||
#define TPB 576
|
||||
#else
|
||||
#define TPB 1024
|
||||
#endif
|
||||
#define TPB35 576
|
||||
#define TPB50 1024
|
||||
|
||||
#define ROTATEUPWARDS7(a) LROT(a,7)
|
||||
#define ROTATEUPWARDS11(a) LROT(a,11)
|
||||
|
||||
//#define SWAP(a,b) { uint32_t u = a; a = b; b = u; }
|
||||
#define SWAP(a,b) { a ^= b; b ^= a; a ^= b; }
|
||||
|
||||
__device__ __forceinline__ void rrounds(uint32_t x[2][2][2][2][2])
|
||||
{
|
||||
int r;
|
||||
int j;
|
||||
int k;
|
||||
int l;
|
||||
int m;
|
||||
|
||||
#pragma unroll 2
|
||||
for (r = 0; r < CUBEHASH_ROUNDS; ++r) {
|
||||
|
||||
/* "add x_0jklm into x_1jklmn modulo 2^32" */
|
||||
#pragma unroll 2
|
||||
for (j = 0; j < 2; ++j)
|
||||
#pragma unroll 2
|
||||
for (k = 0; k < 2; ++k)
|
||||
#pragma unroll 2
|
||||
for (l = 0; l < 2; ++l)
|
||||
#pragma unroll 2
|
||||
for (m = 0; m < 2; ++m)
|
||||
x[1][j][k][l][m] += x[0][j][k][l][m];
|
||||
uint32_t x0[2][2][2][2];
|
||||
uint32_t x1[2][2][2][2];
|
||||
|
||||
for (r = 0; r < CUBEHASH_ROUNDS; r += 2) {
|
||||
/* "rotate x_0jklm upwards by 7 bits" */
|
||||
#pragma unroll 2
|
||||
for (j = 0; j < 2; ++j)
|
||||
#pragma unroll 2
|
||||
for (k = 0; k < 2; ++k)
|
||||
#pragma unroll 2
|
||||
for (l = 0; l < 2; ++l)
|
||||
#pragma unroll 2
|
||||
for (m = 0; m < 2; ++m)
|
||||
x[0][j][k][l][m] = ROTATEUPWARDS7(x[0][j][k][l][m]);
|
||||
x0[0][0][0][0] = ROTATEUPWARDS7(x[0][0][0][0][0]);
|
||||
x0[0][0][0][1] = ROTATEUPWARDS7(x[0][0][0][0][1]);
|
||||
x0[0][0][1][0] = ROTATEUPWARDS7(x[0][0][0][1][0]);
|
||||
x0[0][0][1][1] = ROTATEUPWARDS7(x[0][0][0][1][1]);
|
||||
x0[0][1][0][0] = ROTATEUPWARDS7(x[0][0][1][0][0]);
|
||||
x0[0][1][0][1] = ROTATEUPWARDS7(x[0][0][1][0][1]);
|
||||
x0[0][1][1][0] = ROTATEUPWARDS7(x[0][0][1][1][0]);
|
||||
x0[0][1][1][1] = ROTATEUPWARDS7(x[0][0][1][1][1]);
|
||||
x0[1][0][0][0] = ROTATEUPWARDS7(x[0][1][0][0][0]);
|
||||
x0[1][0][0][1] = ROTATEUPWARDS7(x[0][1][0][0][1]);
|
||||
x0[1][0][1][0] = ROTATEUPWARDS7(x[0][1][0][1][0]);
|
||||
x0[1][0][1][1] = ROTATEUPWARDS7(x[0][1][0][1][1]);
|
||||
x0[1][1][0][0] = ROTATEUPWARDS7(x[0][1][1][0][0]);
|
||||
x0[1][1][0][1] = ROTATEUPWARDS7(x[0][1][1][0][1]);
|
||||
x0[1][1][1][0] = ROTATEUPWARDS7(x[0][1][1][1][0]);
|
||||
x0[1][1][1][1] = ROTATEUPWARDS7(x[0][1][1][1][1]);
|
||||
|
||||
/* "swap x_00klm with x_01klm" */
|
||||
#pragma unroll 2
|
||||
for (k = 0; k < 2; ++k)
|
||||
#pragma unroll 2
|
||||
for (l = 0; l < 2; ++l)
|
||||
#pragma unroll 2
|
||||
for (m = 0; m < 2; ++m)
|
||||
SWAP(x[0][0][k][l][m], x[0][1][k][l][m])
|
||||
/* "add x_0jklm into x_1jklm modulo 2^32" */
|
||||
x1[0][0][0][0] = x[1][0][0][0][0] + x[0][0][0][0][0];
|
||||
x1[0][0][0][1] = x[1][0][0][0][1] + x[0][0][0][0][1];
|
||||
x1[0][0][1][0] = x[1][0][0][1][0] + x[0][0][0][1][0];
|
||||
x1[0][0][1][1] = x[1][0][0][1][1] + x[0][0][0][1][1];
|
||||
x1[0][1][0][0] = x[1][0][1][0][0] + x[0][0][1][0][0];
|
||||
x1[0][1][0][1] = x[1][0][1][0][1] + x[0][0][1][0][1];
|
||||
x1[0][1][1][0] = x[1][0][1][1][0] + x[0][0][1][1][0];
|
||||
x1[0][1][1][1] = x[1][0][1][1][1] + x[0][0][1][1][1];
|
||||
x1[1][0][0][0] = x[1][1][0][0][0] + x[0][1][0][0][0];
|
||||
x1[1][0][0][1] = x[1][1][0][0][1] + x[0][1][0][0][1];
|
||||
x1[1][0][1][0] = x[1][1][0][1][0] + x[0][1][0][1][0];
|
||||
x1[1][0][1][1] = x[1][1][0][1][1] + x[0][1][0][1][1];
|
||||
x1[1][1][0][0] = x[1][1][1][0][0] + x[0][1][1][0][0];
|
||||
x1[1][1][0][1] = x[1][1][1][0][1] + x[0][1][1][0][1];
|
||||
x1[1][1][1][0] = x[1][1][1][1][0] + x[0][1][1][1][0];
|
||||
x1[1][1][1][1] = x[1][1][1][1][1] + x[0][1][1][1][1];
|
||||
|
||||
/* "xor x_1jklm into x_0jklm" */
|
||||
#pragma unroll 2
|
||||
for (j = 0; j < 2; ++j)
|
||||
#pragma unroll 2
|
||||
for (k = 0; k < 2; ++k)
|
||||
#pragma unroll 2
|
||||
for (l = 0; l < 2; ++l)
|
||||
#pragma unroll 2
|
||||
for (m = 0; m < 2; ++m)
|
||||
x[0][j][k][l][m] ^= x[1][j][k][l][m];
|
||||
|
||||
/* "swap x_1jk0m with x_1jk1m" */
|
||||
#pragma unroll 2
|
||||
for (j = 0; j < 2; ++j)
|
||||
#pragma unroll 2
|
||||
for (k = 0; k < 2; ++k)
|
||||
#pragma unroll 2
|
||||
for (m = 0; m < 2; ++m)
|
||||
SWAP(x[1][j][k][0][m], x[1][j][k][1][m])
|
||||
|
||||
/* "add x_0jklm into x_1jklm modulo 2^32" */
|
||||
#pragma unroll 2
|
||||
for (j = 0; j < 2; ++j)
|
||||
#pragma unroll 2
|
||||
for (k = 0; k < 2; ++k)
|
||||
#pragma unroll 2
|
||||
for (l = 0; l < 2; ++l)
|
||||
#pragma unroll 2
|
||||
for (m = 0; m < 2; ++m)
|
||||
x[1][j][k][l][m] += x[0][j][k][l][m];
|
||||
/* "xor x_1~jklm into x_0jklm" */
|
||||
x[0][0][0][0][0] = x0[0][0][0][0] ^ x1[1][0][0][0];
|
||||
x[0][0][0][0][1] = x0[0][0][0][1] ^ x1[1][0][0][1];
|
||||
x[0][0][0][1][0] = x0[0][0][1][0] ^ x1[1][0][1][0];
|
||||
x[0][0][0][1][1] = x0[0][0][1][1] ^ x1[1][0][1][1];
|
||||
x[0][0][1][0][0] = x0[0][1][0][0] ^ x1[1][1][0][0];
|
||||
x[0][0][1][0][1] = x0[0][1][0][1] ^ x1[1][1][0][1];
|
||||
x[0][0][1][1][0] = x0[0][1][1][0] ^ x1[1][1][1][0];
|
||||
x[0][0][1][1][1] = x0[0][1][1][1] ^ x1[1][1][1][1];
|
||||
x[0][1][0][0][0] = x0[1][0][0][0] ^ x1[0][0][0][0];
|
||||
x[0][1][0][0][1] = x0[1][0][0][1] ^ x1[0][0][0][1];
|
||||
x[0][1][0][1][0] = x0[1][0][1][0] ^ x1[0][0][1][0];
|
||||
x[0][1][0][1][1] = x0[1][0][1][1] ^ x1[0][0][1][1];
|
||||
x[0][1][1][0][0] = x0[1][1][0][0] ^ x1[0][1][0][0];
|
||||
x[0][1][1][0][1] = x0[1][1][0][1] ^ x1[0][1][0][1];
|
||||
x[0][1][1][1][0] = x0[1][1][1][0] ^ x1[0][1][1][0];
|
||||
x[0][1][1][1][1] = x0[1][1][1][1] ^ x1[0][1][1][1];
|
||||
|
||||
/* "rotate x_0jklm upwards by 11 bits" */
|
||||
#pragma unroll 2
|
||||
for (j = 0; j < 2; ++j)
|
||||
#pragma unroll 2
|
||||
for (k = 0; k < 2; ++k)
|
||||
#pragma unroll 2
|
||||
for (l = 0; l < 2; ++l)
|
||||
#pragma unroll 2
|
||||
for (m = 0; m < 2; ++m)
|
||||
x[0][j][k][l][m] = ROTATEUPWARDS11(x[0][j][k][l][m]);
|
||||
x0[0][0][0][0] = ROTATEUPWARDS11(x[0][0][0][0][0]);
|
||||
x0[0][0][0][1] = ROTATEUPWARDS11(x[0][0][0][0][1]);
|
||||
x0[0][0][1][0] = ROTATEUPWARDS11(x[0][0][0][1][0]);
|
||||
x0[0][0][1][1] = ROTATEUPWARDS11(x[0][0][0][1][1]);
|
||||
x0[0][1][0][0] = ROTATEUPWARDS11(x[0][0][1][0][0]);
|
||||
x0[0][1][0][1] = ROTATEUPWARDS11(x[0][0][1][0][1]);
|
||||
x0[0][1][1][0] = ROTATEUPWARDS11(x[0][0][1][1][0]);
|
||||
x0[0][1][1][1] = ROTATEUPWARDS11(x[0][0][1][1][1]);
|
||||
x0[1][0][0][0] = ROTATEUPWARDS11(x[0][1][0][0][0]);
|
||||
x0[1][0][0][1] = ROTATEUPWARDS11(x[0][1][0][0][1]);
|
||||
x0[1][0][1][0] = ROTATEUPWARDS11(x[0][1][0][1][0]);
|
||||
x0[1][0][1][1] = ROTATEUPWARDS11(x[0][1][0][1][1]);
|
||||
x0[1][1][0][0] = ROTATEUPWARDS11(x[0][1][1][0][0]);
|
||||
x0[1][1][0][1] = ROTATEUPWARDS11(x[0][1][1][0][1]);
|
||||
x0[1][1][1][0] = ROTATEUPWARDS11(x[0][1][1][1][0]);
|
||||
x0[1][1][1][1] = ROTATEUPWARDS11(x[0][1][1][1][1]);
|
||||
|
||||
/* "swap x_0j0lm with x_0j1lm" */
|
||||
#pragma unroll 2
|
||||
for (j = 0; j < 2; ++j)
|
||||
#pragma unroll 2
|
||||
for (l = 0; l < 2; ++l)
|
||||
#pragma unroll 2
|
||||
for (m = 0; m < 2; ++m)
|
||||
SWAP(x[0][j][0][l][m], x[0][j][1][l][m])
|
||||
/* "add x_0jklm into x_1~jk~lm modulo 2^32" */
|
||||
x[1][1][0][1][0] = x1[1][0][1][0] + x[0][0][0][0][0];
|
||||
x[1][1][0][1][1] = x1[1][0][1][1] + x[0][0][0][0][1];
|
||||
x[1][1][0][0][0] = x1[1][0][0][0] + x[0][0][0][1][0];
|
||||
x[1][1][0][0][1] = x1[1][0][0][1] + x[0][0][0][1][1];
|
||||
x[1][1][1][1][0] = x1[1][1][1][0] + x[0][0][1][0][0];
|
||||
x[1][1][1][1][1] = x1[1][1][1][1] + x[0][0][1][0][1];
|
||||
x[1][1][1][0][0] = x1[1][1][0][0] + x[0][0][1][1][0];
|
||||
x[1][1][1][0][1] = x1[1][1][0][1] + x[0][0][1][1][1];
|
||||
x[1][0][0][1][0] = x1[0][0][1][0] + x[0][1][0][0][0];
|
||||
x[1][0][0][1][1] = x1[0][0][1][1] + x[0][1][0][0][1];
|
||||
x[1][0][0][0][0] = x1[0][0][0][0] + x[0][1][0][1][0];
|
||||
x[1][0][0][0][1] = x1[0][0][0][1] + x[0][1][0][1][1];
|
||||
x[1][0][1][1][0] = x1[0][1][1][0] + x[0][1][1][0][0];
|
||||
x[1][0][1][1][1] = x1[0][1][1][1] + x[0][1][1][0][1];
|
||||
x[1][0][1][0][0] = x1[0][1][0][0] + x[0][1][1][1][0];
|
||||
x[1][0][1][0][1] = x1[0][1][0][1] + x[0][1][1][1][1];
|
||||
|
||||
/* "xor x_1jklm into x_0jklm" */
|
||||
#pragma unroll 2
|
||||
for (j = 0; j < 2; ++j)
|
||||
#pragma unroll 2
|
||||
for (k = 0; k < 2; ++k)
|
||||
#pragma unroll 2
|
||||
for (l = 0; l < 2; ++l)
|
||||
#pragma unroll 2
|
||||
for (m = 0; m < 2; ++m)
|
||||
x[0][j][k][l][m] ^= x[1][j][k][l][m];
|
||||
/* "xor x_1~j~k~lm into x_0jklm" */
|
||||
x[0][0][0][0][0] = x0[0][0][0][0] ^ x[1][1][1][1][0];
|
||||
x[0][0][0][0][1] = x0[0][0][0][1] ^ x[1][1][1][1][1];
|
||||
x[0][0][0][1][0] = x0[0][0][1][0] ^ x[1][1][1][0][0];
|
||||
x[0][0][0][1][1] = x0[0][0][1][1] ^ x[1][1][1][0][1];
|
||||
x[0][0][1][0][0] = x0[0][1][0][0] ^ x[1][1][0][1][0];
|
||||
x[0][0][1][0][1] = x0[0][1][0][1] ^ x[1][1][0][1][1];
|
||||
x[0][0][1][1][0] = x0[0][1][1][0] ^ x[1][1][0][0][0];
|
||||
x[0][0][1][1][1] = x0[0][1][1][1] ^ x[1][1][0][0][1];
|
||||
x[0][1][0][0][0] = x0[1][0][0][0] ^ x[1][0][1][1][0];
|
||||
x[0][1][0][0][1] = x0[1][0][0][1] ^ x[1][0][1][1][1];
|
||||
x[0][1][0][1][0] = x0[1][0][1][0] ^ x[1][0][1][0][0];
|
||||
x[0][1][0][1][1] = x0[1][0][1][1] ^ x[1][0][1][0][1];
|
||||
x[0][1][1][0][0] = x0[1][1][0][0] ^ x[1][0][0][1][0];
|
||||
x[0][1][1][0][1] = x0[1][1][0][1] ^ x[1][0][0][1][1];
|
||||
x[0][1][1][1][0] = x0[1][1][1][0] ^ x[1][0][0][0][0];
|
||||
x[0][1][1][1][1] = x0[1][1][1][1] ^ x[1][0][0][0][1];
|
||||
|
||||
/* "swap x_1jkl0 with x_1jkl1" */
|
||||
#pragma unroll 2
|
||||
for (j = 0; j < 2; ++j)
|
||||
#pragma unroll 2
|
||||
for (k = 0; k < 2; ++k)
|
||||
#pragma unroll 2
|
||||
for (l = 0; l < 2; ++l)
|
||||
SWAP(x[1][j][k][l][0], x[1][j][k][l][1])
|
||||
/* "rotate x_0jklm upwards by 7 bits" */
|
||||
x0[0][0][0][0] = ROTATEUPWARDS7(x[0][0][0][0][0]);
|
||||
x0[0][0][0][1] = ROTATEUPWARDS7(x[0][0][0][0][1]);
|
||||
x0[0][0][1][0] = ROTATEUPWARDS7(x[0][0][0][1][0]);
|
||||
x0[0][0][1][1] = ROTATEUPWARDS7(x[0][0][0][1][1]);
|
||||
x0[0][1][0][0] = ROTATEUPWARDS7(x[0][0][1][0][0]);
|
||||
x0[0][1][0][1] = ROTATEUPWARDS7(x[0][0][1][0][1]);
|
||||
x0[0][1][1][0] = ROTATEUPWARDS7(x[0][0][1][1][0]);
|
||||
x0[0][1][1][1] = ROTATEUPWARDS7(x[0][0][1][1][1]);
|
||||
x0[1][0][0][0] = ROTATEUPWARDS7(x[0][1][0][0][0]);
|
||||
x0[1][0][0][1] = ROTATEUPWARDS7(x[0][1][0][0][1]);
|
||||
x0[1][0][1][0] = ROTATEUPWARDS7(x[0][1][0][1][0]);
|
||||
x0[1][0][1][1] = ROTATEUPWARDS7(x[0][1][0][1][1]);
|
||||
x0[1][1][0][0] = ROTATEUPWARDS7(x[0][1][1][0][0]);
|
||||
x0[1][1][0][1] = ROTATEUPWARDS7(x[0][1][1][0][1]);
|
||||
x0[1][1][1][0] = ROTATEUPWARDS7(x[0][1][1][1][0]);
|
||||
x0[1][1][1][1] = ROTATEUPWARDS7(x[0][1][1][1][1]);
|
||||
|
||||
/* "add x_0jklm into x_1~j~k~l~m modulo 2^32" */
|
||||
x1[1][1][1][1] = x[1][1][1][1][1] + x[0][0][0][0][0];
|
||||
x1[1][1][1][0] = x[1][1][1][1][0] + x[0][0][0][0][1];
|
||||
x1[1][1][0][1] = x[1][1][1][0][1] + x[0][0][0][1][0];
|
||||
x1[1][1][0][0] = x[1][1][1][0][0] + x[0][0][0][1][1];
|
||||
x1[1][0][1][1] = x[1][1][0][1][1] + x[0][0][1][0][0];
|
||||
x1[1][0][1][0] = x[1][1][0][1][0] + x[0][0][1][0][1];
|
||||
x1[1][0][0][1] = x[1][1][0][0][1] + x[0][0][1][1][0];
|
||||
x1[1][0][0][0] = x[1][1][0][0][0] + x[0][0][1][1][1];
|
||||
x1[0][1][1][1] = x[1][0][1][1][1] + x[0][1][0][0][0];
|
||||
x1[0][1][1][0] = x[1][0][1][1][0] + x[0][1][0][0][1];
|
||||
x1[0][1][0][1] = x[1][0][1][0][1] + x[0][1][0][1][0];
|
||||
x1[0][1][0][0] = x[1][0][1][0][0] + x[0][1][0][1][1];
|
||||
x1[0][0][1][1] = x[1][0][0][1][1] + x[0][1][1][0][0];
|
||||
x1[0][0][1][0] = x[1][0][0][1][0] + x[0][1][1][0][1];
|
||||
x1[0][0][0][1] = x[1][0][0][0][1] + x[0][1][1][1][0];
|
||||
x1[0][0][0][0] = x[1][0][0][0][0] + x[0][1][1][1][1];
|
||||
|
||||
/* "xor x_1j~k~l~m into x_0jklm" */
|
||||
x[0][0][0][0][0] = x0[0][0][0][0] ^ x1[0][1][1][1];
|
||||
x[0][0][0][0][1] = x0[0][0][0][1] ^ x1[0][1][1][0];
|
||||
x[0][0][0][1][0] = x0[0][0][1][0] ^ x1[0][1][0][1];
|
||||
x[0][0][0][1][1] = x0[0][0][1][1] ^ x1[0][1][0][0];
|
||||
x[0][0][1][0][0] = x0[0][1][0][0] ^ x1[0][0][1][1];
|
||||
x[0][0][1][0][1] = x0[0][1][0][1] ^ x1[0][0][1][0];
|
||||
x[0][0][1][1][0] = x0[0][1][1][0] ^ x1[0][0][0][1];
|
||||
x[0][0][1][1][1] = x0[0][1][1][1] ^ x1[0][0][0][0];
|
||||
x[0][1][0][0][0] = x0[1][0][0][0] ^ x1[1][1][1][1];
|
||||
x[0][1][0][0][1] = x0[1][0][0][1] ^ x1[1][1][1][0];
|
||||
x[0][1][0][1][0] = x0[1][0][1][0] ^ x1[1][1][0][1];
|
||||
x[0][1][0][1][1] = x0[1][0][1][1] ^ x1[1][1][0][0];
|
||||
x[0][1][1][0][0] = x0[1][1][0][0] ^ x1[1][0][1][1];
|
||||
x[0][1][1][0][1] = x0[1][1][0][1] ^ x1[1][0][1][0];
|
||||
x[0][1][1][1][0] = x0[1][1][1][0] ^ x1[1][0][0][1];
|
||||
x[0][1][1][1][1] = x0[1][1][1][1] ^ x1[1][0][0][0];
|
||||
|
||||
/* "rotate x_0jklm upwards by 11 bits" */
|
||||
x0[0][0][0][0] = ROTATEUPWARDS11(x[0][0][0][0][0]);
|
||||
x0[0][0][0][1] = ROTATEUPWARDS11(x[0][0][0][0][1]);
|
||||
x0[0][0][1][0] = ROTATEUPWARDS11(x[0][0][0][1][0]);
|
||||
x0[0][0][1][1] = ROTATEUPWARDS11(x[0][0][0][1][1]);
|
||||
x0[0][1][0][0] = ROTATEUPWARDS11(x[0][0][1][0][0]);
|
||||
x0[0][1][0][1] = ROTATEUPWARDS11(x[0][0][1][0][1]);
|
||||
x0[0][1][1][0] = ROTATEUPWARDS11(x[0][0][1][1][0]);
|
||||
x0[0][1][1][1] = ROTATEUPWARDS11(x[0][0][1][1][1]);
|
||||
x0[1][0][0][0] = ROTATEUPWARDS11(x[0][1][0][0][0]);
|
||||
x0[1][0][0][1] = ROTATEUPWARDS11(x[0][1][0][0][1]);
|
||||
x0[1][0][1][0] = ROTATEUPWARDS11(x[0][1][0][1][0]);
|
||||
x0[1][0][1][1] = ROTATEUPWARDS11(x[0][1][0][1][1]);
|
||||
x0[1][1][0][0] = ROTATEUPWARDS11(x[0][1][1][0][0]);
|
||||
x0[1][1][0][1] = ROTATEUPWARDS11(x[0][1][1][0][1]);
|
||||
x0[1][1][1][0] = ROTATEUPWARDS11(x[0][1][1][1][0]);
|
||||
x0[1][1][1][1] = ROTATEUPWARDS11(x[0][1][1][1][1]);
|
||||
|
||||
/* "add x_0jklm into x_1j~kl~m modulo 2^32" */
|
||||
x[1][0][1][0][1] = x1[0][1][0][1] + x[0][0][0][0][0];
|
||||
x[1][0][1][0][0] = x1[0][1][0][0] + x[0][0][0][0][1];
|
||||
x[1][0][1][1][1] = x1[0][1][1][1] + x[0][0][0][1][0];
|
||||
x[1][0][1][1][0] = x1[0][1][1][0] + x[0][0][0][1][1];
|
||||
x[1][0][0][0][1] = x1[0][0][0][1] + x[0][0][1][0][0];
|
||||
x[1][0][0][0][0] = x1[0][0][0][0] + x[0][0][1][0][1];
|
||||
x[1][0][0][1][1] = x1[0][0][1][1] + x[0][0][1][1][0];
|
||||
x[1][0][0][1][0] = x1[0][0][1][0] + x[0][0][1][1][1];
|
||||
x[1][1][1][0][1] = x1[1][1][0][1] + x[0][1][0][0][0];
|
||||
x[1][1][1][0][0] = x1[1][1][0][0] + x[0][1][0][0][1];
|
||||
x[1][1][1][1][1] = x1[1][1][1][1] + x[0][1][0][1][0];
|
||||
x[1][1][1][1][0] = x1[1][1][1][0] + x[0][1][0][1][1];
|
||||
x[1][1][0][0][1] = x1[1][0][0][1] + x[0][1][1][0][0];
|
||||
x[1][1][0][0][0] = x1[1][0][0][0] + x[0][1][1][0][1];
|
||||
x[1][1][0][1][1] = x1[1][0][1][1] + x[0][1][1][1][0];
|
||||
x[1][1][0][1][0] = x1[1][0][1][0] + x[0][1][1][1][1];
|
||||
|
||||
/* "xor x_1jkl~m into x_0jklm" */
|
||||
x[0][0][0][0][0] = x0[0][0][0][0] ^ x[1][0][0][0][1];
|
||||
x[0][0][0][0][1] = x0[0][0][0][1] ^ x[1][0][0][0][0];
|
||||
x[0][0][0][1][0] = x0[0][0][1][0] ^ x[1][0][0][1][1];
|
||||
x[0][0][0][1][1] = x0[0][0][1][1] ^ x[1][0][0][1][0];
|
||||
x[0][0][1][0][0] = x0[0][1][0][0] ^ x[1][0][1][0][1];
|
||||
x[0][0][1][0][1] = x0[0][1][0][1] ^ x[1][0][1][0][0];
|
||||
x[0][0][1][1][0] = x0[0][1][1][0] ^ x[1][0][1][1][1];
|
||||
x[0][0][1][1][1] = x0[0][1][1][1] ^ x[1][0][1][1][0];
|
||||
x[0][1][0][0][0] = x0[1][0][0][0] ^ x[1][1][0][0][1];
|
||||
x[0][1][0][0][1] = x0[1][0][0][1] ^ x[1][1][0][0][0];
|
||||
x[0][1][0][1][0] = x0[1][0][1][0] ^ x[1][1][0][1][1];
|
||||
x[0][1][0][1][1] = x0[1][0][1][1] ^ x[1][1][0][1][0];
|
||||
x[0][1][1][0][0] = x0[1][1][0][0] ^ x[1][1][1][0][1];
|
||||
x[0][1][1][0][1] = x0[1][1][0][1] ^ x[1][1][1][0][0];
|
||||
x[0][1][1][1][0] = x0[1][1][1][0] ^ x[1][1][1][1][1];
|
||||
x[0][1][1][1][1] = x0[1][1][1][1] ^ x[1][1][1][1][0];
|
||||
}
|
||||
}
|
||||
|
||||
__device__ __forceinline__ void block_tox(const uint32_t *in, uint32_t x[2][2][2][2][2])
|
||||
{
|
||||
x[0][0][0][0][0] ^= in[0];
|
||||
x[0][0][0][0][1] ^= in[1];
|
||||
x[0][0][0][1][0] ^= in[2];
|
||||
x[0][0][0][1][1] ^= in[3];
|
||||
x[0][0][1][0][0] ^= in[4];
|
||||
x[0][0][1][0][1] ^= in[5];
|
||||
x[0][0][1][1][0] ^= in[6];
|
||||
x[0][0][1][1][1] ^= in[7];
|
||||
}
|
||||
|
||||
__device__ __forceinline__ void hash_fromx(uint32_t *out, uint32_t x[2][2][2][2][2])
|
||||
{
|
||||
out[0] = x[0][0][0][0][0];
|
||||
out[1] = x[0][0][0][0][1];
|
||||
out[2] = x[0][0][0][1][0];
|
||||
out[3] = x[0][0][0][1][1];
|
||||
out[4] = x[0][0][1][0][0];
|
||||
out[5] = x[0][0][1][0][1];
|
||||
out[6] = x[0][0][1][1][0];
|
||||
out[7] = x[0][0][1][1][1];
|
||||
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
void Update32(uint32_t x[2][2][2][2][2], const uint32_t *data)
|
||||
{
|
||||
/* "xor the block into the first b bytes of the state" */
|
||||
/* "and then transform the state invertibly through r identical rounds" */
|
||||
block_tox(data, x);
|
||||
rrounds(x);
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
void Update32_const(uint32_t x[2][2][2][2][2])
|
||||
{
|
||||
x[0][0][0][0][0] ^= 0x80;
|
||||
rrounds(x);
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
void Final(uint32_t x[2][2][2][2][2], uint32_t *hashval)
|
||||
{
|
||||
@@ -185,27 +253,44 @@ void Final(uint32_t x[2][2][2][2][2], uint32_t *hashval)
|
||||
x[1][1][1][1][1] ^= 1U;
|
||||
|
||||
/* "the state is then transformed invertibly through 10r identical rounds" */
|
||||
#pragma unroll 2
|
||||
for (int i = 0; i < 10; ++i) rrounds(x);
|
||||
|
||||
/* "output the first h/8 bytes of the state" */
|
||||
hash_fromx(hashval, x);
|
||||
hashval[0] = x[0][0][0][0][0];
|
||||
hashval[1] = x[0][0][0][0][1];
|
||||
hashval[2] = x[0][0][0][1][0];
|
||||
hashval[3] = x[0][0][0][1][1];
|
||||
hashval[4] = x[0][0][1][0][0];
|
||||
hashval[5] = x[0][0][1][0][1];
|
||||
hashval[6] = x[0][0][1][1][0];
|
||||
hashval[7] = x[0][0][1][1][1];
|
||||
}
|
||||
|
||||
#if __CUDA_ARCH__ >= 500
|
||||
|
||||
__global__ __launch_bounds__(TPB, 1)
|
||||
__global__ __launch_bounds__(TPB50, 1)
|
||||
#else
|
||||
__global__ __launch_bounds__(TPB35, 1)
|
||||
#endif
|
||||
void cubehash256_gpu_hash_32(uint32_t threads, uint32_t startNounce, uint2 *g_hash)
|
||||
{
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
#if __CUDA_ARCH__ >= 500
|
||||
uint2 Hash[4];
|
||||
|
||||
Hash[0] = __ldg(&g_hash[thread]);
|
||||
Hash[1] = __ldg(&g_hash[thread + 1 * threads]);
|
||||
Hash[2] = __ldg(&g_hash[thread + 2 * threads]);
|
||||
Hash[3] = __ldg(&g_hash[thread + 3 * threads]);
|
||||
#else
|
||||
uint32_t Hash[8];
|
||||
|
||||
LOHI(Hash[0], Hash[1], __ldg(&((uint64_t*)g_hash)[thread]));
|
||||
LOHI(Hash[2], Hash[3], __ldg(&((uint64_t*)g_hash)[thread + 1 * threads]));
|
||||
LOHI(Hash[4], Hash[5], __ldg(&((uint64_t*)g_hash)[thread + 2 * threads]));
|
||||
LOHI(Hash[6], Hash[7], __ldg(&((uint64_t*)g_hash)[thread + 3 * threads]));
|
||||
#endif
|
||||
|
||||
uint32_t x[2][2][2][2][2] =
|
||||
{
|
||||
@@ -219,6 +304,7 @@ void cubehash256_gpu_hash_32(uint32_t threads, uint32_t startNounce, uint2 *g_ha
|
||||
0x15815AEB, 0x4AB6AAD6, 0x9CDAF8AF, 0xD6032C0A
|
||||
};
|
||||
|
||||
#if __CUDA_ARCH__ >= 500
|
||||
x[0][0][0][0][0] ^= Hash[0].x;
|
||||
x[0][0][0][0][1] ^= Hash[0].y;
|
||||
x[0][0][0][1][0] ^= Hash[1].x;
|
||||
@@ -227,48 +313,7 @@ void cubehash256_gpu_hash_32(uint32_t threads, uint32_t startNounce, uint2 *g_ha
|
||||
x[0][0][1][0][1] ^= Hash[2].y;
|
||||
x[0][0][1][1][0] ^= Hash[3].x;
|
||||
x[0][0][1][1][1] ^= Hash[3].y;
|
||||
|
||||
rrounds(x);
|
||||
x[0][0][0][0][0] ^= 0x80U;
|
||||
rrounds(x);
|
||||
|
||||
Final(x, (uint32_t*) Hash);
|
||||
|
||||
g_hash[thread] = Hash[0];
|
||||
g_hash[1 * threads + thread] = Hash[1];
|
||||
g_hash[2 * threads + thread] = Hash[2];
|
||||
g_hash[3 * threads + thread] = Hash[3];
|
||||
}
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
__global__ __launch_bounds__(TPB, 1)
|
||||
void cubehash256_gpu_hash_32(uint32_t threads, uint32_t startNounce, uint2 *d_hash)
|
||||
{
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
uint32_t Hash[8];
|
||||
uint64_t* g_hash = (uint64_t*) d_hash;
|
||||
|
||||
LOHI(Hash[0], Hash[1], __ldg(&g_hash[thread]));
|
||||
LOHI(Hash[2], Hash[3], __ldg(&g_hash[thread + 1 * threads]));
|
||||
LOHI(Hash[4], Hash[5], __ldg(&g_hash[thread + 2 * threads]));
|
||||
LOHI(Hash[6], Hash[7], __ldg(&g_hash[thread + 3 * threads]));
|
||||
|
||||
uint32_t x[2][2][2][2][2] =
|
||||
{
|
||||
0xEA2BD4B4, 0xCCD6F29F, 0x63117E71, 0x35481EAE,
|
||||
0x22512D5B, 0xE5D94E63, 0x7E624131, 0xF4CC12BE,
|
||||
0xC2D0B696, 0x42AF2070, 0xD0720C35, 0x3361DA8C,
|
||||
0x28CCECA4, 0x8EF8AD83, 0x4680AC00, 0x40E5FBAB,
|
||||
0xD89041C3, 0x6107FBD5, 0x6C859D41, 0xF0B26679,
|
||||
0x09392549, 0x5FA25603, 0x65C892FD, 0x93CB6285,
|
||||
0x2AF2B5AE, 0x9E4B4E60, 0x774ABFDD, 0x85254725,
|
||||
0x15815AEB, 0x4AB6AAD6, 0x9CDAF8AF, 0xD6032C0A
|
||||
};
|
||||
|
||||
x[0][0][0][0][0] ^= Hash[0];
|
||||
x[0][0][0][0][1] ^= Hash[1];
|
||||
x[0][0][0][1][0] ^= Hash[2];
|
||||
@@ -277,29 +322,48 @@ void cubehash256_gpu_hash_32(uint32_t threads, uint32_t startNounce, uint2 *d_ha
|
||||
x[0][0][1][0][1] ^= Hash[5];
|
||||
x[0][0][1][1][0] ^= Hash[6];
|
||||
x[0][0][1][1][1] ^= Hash[7];
|
||||
|
||||
#endif
|
||||
rrounds(x);
|
||||
x[0][0][0][0][0] ^= 0x80U;
|
||||
rrounds(x);
|
||||
|
||||
#if __CUDA_ARCH__ >= 500
|
||||
Final(x, (uint32_t*)Hash);
|
||||
|
||||
g_hash[thread] = Hash[0];
|
||||
g_hash[1 * threads + thread] = Hash[1];
|
||||
g_hash[2 * threads + thread] = Hash[2];
|
||||
g_hash[3 * threads + thread] = Hash[3];
|
||||
#else
|
||||
Final(x, Hash);
|
||||
|
||||
g_hash[thread] = ((uint64_t*)Hash)[0];
|
||||
g_hash[1 * threads + thread] = ((uint64_t*)Hash)[1];
|
||||
g_hash[2 * threads + thread] = ((uint64_t*)Hash)[2];
|
||||
g_hash[3 * threads + thread] = ((uint64_t*)Hash)[3];
|
||||
((uint64_t*)g_hash)[thread] = ((uint64_t*)Hash)[0];
|
||||
((uint64_t*)g_hash)[1 * threads + thread] = ((uint64_t*)Hash)[1];
|
||||
((uint64_t*)g_hash)[2 * threads + thread] = ((uint64_t*)Hash)[2];
|
||||
((uint64_t*)g_hash)[3 * threads + thread] = ((uint64_t*)Hash)[3];
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
__host__
|
||||
void cubehash256_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNounce, uint64_t *d_hash, int order)
|
||||
{
|
||||
uint32_t tpb = TPB;
|
||||
uint32_t tpb = TPB35;
|
||||
if (cuda_arch[thr_id] >= 500) tpb = TPB50;
|
||||
|
||||
dim3 grid((threads + tpb-1)/tpb);
|
||||
dim3 grid((threads + tpb - 1) / tpb);
|
||||
dim3 block(tpb);
|
||||
|
||||
cubehash256_gpu_hash_32 <<<grid, block>>> (threads, startNounce, (uint2*) d_hash);
|
||||
cubehash256_gpu_hash_32 << <grid, block >> > (threads, startNounce, (uint2*)d_hash);
|
||||
}
|
||||
__host__
|
||||
void cubehash256_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNounce, uint64_t *d_hash, int order, cudaStream_t stream)
|
||||
{
|
||||
uint32_t tpb = TPB35;
|
||||
if (cuda_arch[thr_id] >= 500) tpb = TPB50;
|
||||
|
||||
dim3 grid((threads + tpb - 1) / tpb);
|
||||
dim3 block(tpb);
|
||||
|
||||
cubehash256_gpu_hash_32 << <grid, block, 0, stream >> > (threads, startNounce, (uint2*)d_hash);
|
||||
}
|
||||
+22
-19
@@ -10,14 +10,15 @@
|
||||
|
||||
uint32_t *d_fugue256_hashoutput[MAX_GPUS];
|
||||
static uint32_t *d_resultNonce[MAX_GPUS];
|
||||
static unsigned int* d_textures[MAX_GPUS][8];
|
||||
|
||||
__constant__ uint32_t GPUstate[30]; // Single GPU
|
||||
__constant__ uint32_t pTarget[8]; // Single GPU
|
||||
|
||||
texture<unsigned int, 1, cudaReadModeElementType> mixTab0Tex;
|
||||
texture<unsigned int, 1, cudaReadModeElementType> mixTab1Tex;
|
||||
texture<unsigned int, 1, cudaReadModeElementType> mixTab2Tex;
|
||||
texture<unsigned int, 1, cudaReadModeElementType> mixTab3Tex;
|
||||
static texture<unsigned int, 1, cudaReadModeElementType> mixTab0Tex;
|
||||
static texture<unsigned int, 1, cudaReadModeElementType> mixTab1Tex;
|
||||
static texture<unsigned int, 1, cudaReadModeElementType> mixTab2Tex;
|
||||
static texture<unsigned int, 1, cudaReadModeElementType> mixTab3Tex;
|
||||
|
||||
#if USE_SHARED
|
||||
#define mixtab0(x) (*((uint32_t*)mixtabs + ( (x))))
|
||||
@@ -707,28 +708,29 @@ fugue256_gpu_hash(int thr_id, uint32_t threads, uint32_t startNounce, void *outp
|
||||
}
|
||||
}
|
||||
|
||||
#define texDef(texname, texmem, texsource, texsize) \
|
||||
#define texDef(id, texname, texmem, texsource, texsize) { \
|
||||
unsigned int *texmem; \
|
||||
cudaMalloc(&texmem, texsize); \
|
||||
d_textures[thr_id][id] = texmem; \
|
||||
cudaMemcpy(texmem, texsource, texsize, cudaMemcpyHostToDevice); \
|
||||
texname.normalized = 0; \
|
||||
texname.filterMode = cudaFilterModePoint; \
|
||||
texname.addressMode[0] = cudaAddressModeClamp; \
|
||||
{ cudaChannelFormatDesc channelDesc = cudaCreateChannelDesc<unsigned int>(); \
|
||||
cudaBindTexture(NULL, &texname, texmem, &channelDesc, texsize ); }
|
||||
|
||||
cudaBindTexture(NULL, &texname, texmem, &channelDesc, texsize ); \
|
||||
} \
|
||||
}
|
||||
|
||||
__host__
|
||||
void fugue256_cpu_init(int thr_id, uint32_t threads)
|
||||
{
|
||||
// Kopiere die Hash-Tabellen in den GPU-Speicher
|
||||
texDef(mixTab0Tex, mixTab0m, mixtab0_cpu, sizeof(uint32_t)*256);
|
||||
texDef(mixTab1Tex, mixTab1m, mixtab1_cpu, sizeof(uint32_t)*256);
|
||||
texDef(mixTab2Tex, mixTab2m, mixtab2_cpu, sizeof(uint32_t)*256);
|
||||
texDef(mixTab3Tex, mixTab3m, mixtab3_cpu, sizeof(uint32_t)*256);
|
||||
// Link the hash tables in the GPU
|
||||
texDef(0, mixTab0Tex, mixTab0m, mixtab0_cpu, sizeof(uint32_t)*256);
|
||||
texDef(1, mixTab1Tex, mixTab1m, mixtab1_cpu, sizeof(uint32_t)*256);
|
||||
texDef(2, mixTab2Tex, mixTab2m, mixtab2_cpu, sizeof(uint32_t)*256);
|
||||
texDef(3, mixTab3Tex, mixTab3m, mixtab3_cpu, sizeof(uint32_t)*256);
|
||||
|
||||
// Speicher für alle Ergebnisse belegen
|
||||
cudaMalloc(&d_fugue256_hashoutput[thr_id], 8 * sizeof(uint32_t) * threads);
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_fugue256_hashoutput[thr_id], (size_t) 32 * threads));
|
||||
cudaMalloc(&d_resultNonce[thr_id], sizeof(uint32_t));
|
||||
}
|
||||
|
||||
@@ -737,25 +739,26 @@ void fugue256_cpu_free(int thr_id)
|
||||
{
|
||||
cudaFree(d_fugue256_hashoutput[thr_id]);
|
||||
cudaFree(d_resultNonce[thr_id]);
|
||||
|
||||
for (int i=0; i<4; i++)
|
||||
cudaFree(d_textures[thr_id][i]);
|
||||
}
|
||||
|
||||
__host__
|
||||
void fugue256_cpu_setBlock(int thr_id, void *data, void *pTargetIn)
|
||||
{
|
||||
// CPU-Vorbereitungen treffen
|
||||
sph_fugue256_context ctx_fugue_const;
|
||||
sph_fugue256_init(&ctx_fugue_const);
|
||||
sph_fugue256 (&ctx_fugue_const, data, 80); // State speichern
|
||||
|
||||
sph_fugue256 (&ctx_fugue_const, data, 80);
|
||||
cudaMemcpyToSymbol(GPUstate, ctx_fugue_const.S, sizeof(uint32_t) * 30);
|
||||
|
||||
cudaMemcpyToSymbol(pTarget, pTargetIn, sizeof(uint32_t) * 8);
|
||||
cudaMemcpyToSymbol(pTarget, pTargetIn, 32);
|
||||
|
||||
cudaMemset(d_resultNonce[thr_id], 0xFF, sizeof(uint32_t));
|
||||
}
|
||||
|
||||
__host__
|
||||
void fugue256_cpu_hash(int thr_id, uint32_t threads, int startNounce, void *outputHashes, uint32_t *nounce)
|
||||
void fugue256_cpu_hash(int thr_id, uint32_t threads, uint32_t startNounce, void *outputHashes, uint32_t *nounce)
|
||||
{
|
||||
#if USE_SHARED
|
||||
const uint32_t threadsperblock = 256; // Alignment mit mixtab Grösse. NICHT ÄNDERN
|
||||
|
||||
+27
-20
@@ -7,6 +7,7 @@
|
||||
|
||||
static uint32_t *h_GNonces[MAX_GPUS];
|
||||
static uint32_t *d_GNonces[MAX_GPUS];
|
||||
static unsigned int* d_textures[MAX_GPUS][8];
|
||||
|
||||
__constant__ uint32_t pTarget[8];
|
||||
|
||||
@@ -66,14 +67,14 @@ __constant__ uint32_t pTarget[8];
|
||||
#define T3dn(x) tex1Dfetch(t3dn2, x)
|
||||
#endif
|
||||
|
||||
texture<unsigned int, 1, cudaReadModeElementType> t0up2;
|
||||
texture<unsigned int, 1, cudaReadModeElementType> t0dn2;
|
||||
texture<unsigned int, 1, cudaReadModeElementType> t1up2;
|
||||
texture<unsigned int, 1, cudaReadModeElementType> t1dn2;
|
||||
texture<unsigned int, 1, cudaReadModeElementType> t2up2;
|
||||
texture<unsigned int, 1, cudaReadModeElementType> t2dn2;
|
||||
texture<unsigned int, 1, cudaReadModeElementType> t3up2;
|
||||
texture<unsigned int, 1, cudaReadModeElementType> t3dn2;
|
||||
static texture<unsigned int, 1, cudaReadModeElementType> t0up2;
|
||||
static texture<unsigned int, 1, cudaReadModeElementType> t0dn2;
|
||||
static texture<unsigned int, 1, cudaReadModeElementType> t1up2;
|
||||
static texture<unsigned int, 1, cudaReadModeElementType> t1dn2;
|
||||
static texture<unsigned int, 1, cudaReadModeElementType> t2up2;
|
||||
static texture<unsigned int, 1, cudaReadModeElementType> t2dn2;
|
||||
static texture<unsigned int, 1, cudaReadModeElementType> t3up2;
|
||||
static texture<unsigned int, 1, cudaReadModeElementType> t3dn2;
|
||||
|
||||
#define RSTT(d0, d1, a, b0, b1, b2, b3, b4, b5, b6, b7) do { \
|
||||
t[d0] = T0up(B32_0(a[b0])) \
|
||||
@@ -175,7 +176,7 @@ void groestl256_perm_Q(uint32_t thread, uint32_t *a, char *mixtabs)
|
||||
}
|
||||
|
||||
__global__ __launch_bounds__(256,1)
|
||||
void groestl256_gpu_hash32(uint32_t threads, uint32_t startNounce, uint64_t *outputHash, uint32_t *resNonces)
|
||||
void groestl256_gpu_hash_32(uint32_t threads, uint32_t startNounce, uint64_t *outputHash, uint32_t *resNonces)
|
||||
{
|
||||
#if USE_SHARED
|
||||
extern __shared__ char mixtabs[];
|
||||
@@ -249,28 +250,31 @@ void groestl256_gpu_hash32(uint32_t threads, uint32_t startNounce, uint64_t *out
|
||||
}
|
||||
}
|
||||
|
||||
#define texDef(texname, texmem, texsource, texsize) \
|
||||
#define texDef(id, texname, texmem, texsource, texsize) { \
|
||||
unsigned int *texmem; \
|
||||
cudaMalloc(&texmem, texsize); \
|
||||
d_textures[thr_id][id] = texmem; \
|
||||
cudaMemcpy(texmem, texsource, texsize, cudaMemcpyHostToDevice); \
|
||||
texname.normalized = 0; \
|
||||
texname.filterMode = cudaFilterModePoint; \
|
||||
texname.addressMode[0] = cudaAddressModeClamp; \
|
||||
{ cudaChannelFormatDesc channelDesc = cudaCreateChannelDesc<unsigned int>(); \
|
||||
cudaBindTexture(NULL, &texname, texmem, &channelDesc, texsize ); } \
|
||||
cudaBindTexture(NULL, &texname, texmem, &channelDesc, texsize ); \
|
||||
} \
|
||||
}
|
||||
|
||||
__host__
|
||||
void groestl256_cpu_init(int thr_id, uint32_t threads)
|
||||
{
|
||||
// Texturen mit obigem Makro initialisieren
|
||||
texDef(t0up2, d_T0up, T0up_cpu, sizeof(uint32_t) * 256);
|
||||
texDef(t0dn2, d_T0dn, T0dn_cpu, sizeof(uint32_t) * 256);
|
||||
texDef(t1up2, d_T1up, T1up_cpu, sizeof(uint32_t) * 256);
|
||||
texDef(t1dn2, d_T1dn, T1dn_cpu, sizeof(uint32_t) * 256);
|
||||
texDef(t2up2, d_T2up, T2up_cpu, sizeof(uint32_t) * 256);
|
||||
texDef(t2dn2, d_T2dn, T2dn_cpu, sizeof(uint32_t) * 256);
|
||||
texDef(t3up2, d_T3up, T3up_cpu, sizeof(uint32_t) * 256);
|
||||
texDef(t3dn2, d_T3dn, T3dn_cpu, sizeof(uint32_t) * 256);
|
||||
texDef(0, t0up2, d_T0up, T0up_cpu, sizeof(uint32_t) * 256);
|
||||
texDef(1, t0dn2, d_T0dn, T0dn_cpu, sizeof(uint32_t) * 256);
|
||||
texDef(2, t1up2, d_T1up, T1up_cpu, sizeof(uint32_t) * 256);
|
||||
texDef(3, t1dn2, d_T1dn, T1dn_cpu, sizeof(uint32_t) * 256);
|
||||
texDef(4, t2up2, d_T2up, T2up_cpu, sizeof(uint32_t) * 256);
|
||||
texDef(5, t2dn2, d_T2dn, T2dn_cpu, sizeof(uint32_t) * 256);
|
||||
texDef(6, t3up2, d_T3up, T3up_cpu, sizeof(uint32_t) * 256);
|
||||
texDef(7, t3dn2, d_T3dn, T3dn_cpu, sizeof(uint32_t) * 256);
|
||||
|
||||
cudaMalloc(&d_GNonces[thr_id], 2*sizeof(uint32_t));
|
||||
cudaMallocHost(&h_GNonces[thr_id], 2*sizeof(uint32_t));
|
||||
@@ -279,6 +283,9 @@ void groestl256_cpu_init(int thr_id, uint32_t threads)
|
||||
__host__
|
||||
void groestl256_cpu_free(int thr_id)
|
||||
{
|
||||
for (int i=0; i<8; i++)
|
||||
cudaFree(d_textures[thr_id][i]);
|
||||
|
||||
cudaFree(d_GNonces[thr_id]);
|
||||
cudaFreeHost(h_GNonces[thr_id]);
|
||||
}
|
||||
@@ -299,7 +306,7 @@ uint32_t groestl256_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNoun
|
||||
#else
|
||||
size_t shared_size = 0;
|
||||
#endif
|
||||
groestl256_gpu_hash32<<<grid, block, shared_size>>>(threads, startNounce, d_outputHash, d_GNonces[thr_id]);
|
||||
groestl256_gpu_hash_32<<<grid, block, shared_size>>>(threads, startNounce, d_outputHash, d_GNonces[thr_id]);
|
||||
|
||||
MyStreamSynchronize(NULL, order, thr_id);
|
||||
|
||||
|
||||
+362
-84
@@ -13,40 +13,296 @@ void Round512v35(uint2 &p0, uint2 &p1, uint2 &p2, uint2 &p3, uint2 &p4, uint2 &p
|
||||
}
|
||||
|
||||
__forceinline__ __device__
|
||||
void Round_8_512v35(const uint2 *const __restrict__ ks, const uint2 *const __restrict__ ts,
|
||||
uint2 &p0, uint2 &p1, uint2 &p2, uint2 &p3, uint2 &p4, uint2 &p5, uint2 &p6, uint2 &p7, int R)
|
||||
void Round_8_512v35_1(const uint2 ks[9], const uint2 ts[3],
|
||||
uint2 &p0, uint2 &p1, uint2 &p2, uint2 &p3, uint2 &p4, uint2 &p5, uint2 &p6, uint2 &p7)
|
||||
{
|
||||
Round512v35(p0, p1, p2, p3, p4, p5, p6, p7, 46, 36, 19, 37);
|
||||
Round512v35(p2, p1, p4, p7, p6, p5, p0, p3, 33, 27, 14, 42);
|
||||
Round512v35(p4, p1, p6, p3, p0, p5, p2, p7, 17, 49, 36, 39);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 44, 9, 54, 56);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 44, 9, 54, 56);
|
||||
|
||||
p0 += ks[(R+0) % 9];
|
||||
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[1];
|
||||
p1 += ks[2];
|
||||
p2 += ks[3];
|
||||
p3 += ks[4];
|
||||
p4 += ks[5];
|
||||
p5 += ks[6] + ts[1];
|
||||
p6 += ks[7] + ts[2];
|
||||
p7 += ks[8] + make_uint2(1, 0);
|
||||
|
||||
Round512v35(p0, p1, p2, p3, p4, p5, p6, p7, 39, 30, 34, 24);
|
||||
Round512v35(p2, p1, p4, p7, p6, p5, p0, p3, 13, 50, 10, 17);
|
||||
Round512v35(p4, p1, p6, p3, p0, p5, p2, p7, 25, 29, 39, 43);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 8, 35, 56, 22);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 8, 35, 56, 22);
|
||||
|
||||
p0 += ks[(R+1) % 9];
|
||||
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[2];
|
||||
p1 += ks[3];
|
||||
p2 += ks[4];
|
||||
p3 += ks[5];
|
||||
p4 += ks[6];
|
||||
p5 += ks[7] + ts[2];
|
||||
p6 += ks[8] + ts[0];
|
||||
p7 += ks[0] + make_uint2(2, 0);
|
||||
}
|
||||
__forceinline__ __device__
|
||||
void Round_8_512v35_3(const uint2 ks[9], const uint2 ts[3],
|
||||
uint2 &p0, uint2 &p1, uint2 &p2, uint2 &p3, uint2 &p4, uint2 &p5, uint2 &p6, uint2 &p7)
|
||||
{
|
||||
Round512v35(p0, p1, p2, p3, p4, p5, p6, p7, 46, 36, 19, 37);
|
||||
Round512v35(p2, p1, p4, p7, p6, p5, p0, p3, 33, 27, 14, 42);
|
||||
Round512v35(p4, p1, p6, p3, p0, p5, p2, p7, 17, 49, 36, 39);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 44, 9, 54, 56);
|
||||
|
||||
p0 += ks[3];
|
||||
p1 += ks[4];
|
||||
p2 += ks[5];
|
||||
p3 += ks[6];
|
||||
p4 += ks[7];
|
||||
p5 += ks[8] + ts[0];
|
||||
p6 += ks[0] + ts[1];
|
||||
p7 += ks[1] + make_uint2(3, 0);
|
||||
|
||||
Round512v35(p0, p1, p2, p3, p4, p5, p6, p7, 39, 30, 34, 24);
|
||||
Round512v35(p2, p1, p4, p7, p6, p5, p0, p3, 13, 50, 10, 17);
|
||||
Round512v35(p4, p1, p6, p3, p0, p5, p2, p7, 25, 29, 39, 43);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 8, 35, 56, 22);
|
||||
|
||||
p0 += ks[4];
|
||||
p1 += ks[5];
|
||||
p2 += ks[6];
|
||||
p3 += ks[7];
|
||||
p4 += ks[8];
|
||||
p5 += ks[0] + ts[1];
|
||||
p6 += ks[1] + ts[2];
|
||||
p7 += ks[2] + make_uint2(4, 0);
|
||||
}
|
||||
__forceinline__ __device__
|
||||
void Round_8_512v35_5(const uint2 ks[9], const uint2 ts[3],
|
||||
uint2 &p0, uint2 &p1, uint2 &p2, uint2 &p3, uint2 &p4, uint2 &p5, uint2 &p6, uint2 &p7)
|
||||
{
|
||||
Round512v35(p0, p1, p2, p3, p4, p5, p6, p7, 46, 36, 19, 37);
|
||||
Round512v35(p2, p1, p4, p7, p6, p5, p0, p3, 33, 27, 14, 42);
|
||||
Round512v35(p4, p1, p6, p3, p0, p5, p2, p7, 17, 49, 36, 39);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 44, 9, 54, 56);
|
||||
|
||||
p0 += ks[5];
|
||||
p1 += ks[6];
|
||||
p2 += ks[7];
|
||||
p3 += ks[8];
|
||||
p4 += ks[0];
|
||||
p5 += ks[1] + ts[2];
|
||||
p6 += ks[2] + ts[0];
|
||||
p7 += ks[3] + make_uint2(5, 0);
|
||||
|
||||
Round512v35(p0, p1, p2, p3, p4, p5, p6, p7, 39, 30, 34, 24);
|
||||
Round512v35(p2, p1, p4, p7, p6, p5, p0, p3, 13, 50, 10, 17);
|
||||
Round512v35(p4, p1, p6, p3, p0, p5, p2, p7, 25, 29, 39, 43);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 8, 35, 56, 22);
|
||||
|
||||
p0 += ks[6];
|
||||
p1 += ks[7];
|
||||
p2 += ks[8];
|
||||
p3 += ks[0];
|
||||
p4 += ks[1];
|
||||
p5 += ks[2] + ts[0];
|
||||
p6 += ks[3] + ts[1];
|
||||
p7 += ks[4] + make_uint2(6, 0);
|
||||
}
|
||||
__forceinline__ __device__
|
||||
void Round_8_512v35_7(const uint2 ks[9], const uint2 ts[3],
|
||||
uint2 &p0, uint2 &p1, uint2 &p2, uint2 &p3, uint2 &p4, uint2 &p5, uint2 &p6, uint2 &p7)
|
||||
{
|
||||
Round512v35(p0, p1, p2, p3, p4, p5, p6, p7, 46, 36, 19, 37);
|
||||
Round512v35(p2, p1, p4, p7, p6, p5, p0, p3, 33, 27, 14, 42);
|
||||
Round512v35(p4, p1, p6, p3, p0, p5, p2, p7, 17, 49, 36, 39);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 44, 9, 54, 56);
|
||||
|
||||
p0 += ks[7];
|
||||
p1 += ks[8];
|
||||
p2 += ks[0];
|
||||
p3 += ks[1];
|
||||
p4 += ks[2];
|
||||
p5 += ks[3] + ts[1];
|
||||
p6 += ks[4] + ts[2];
|
||||
p7 += ks[5] + make_uint2(7, 0);
|
||||
|
||||
Round512v35(p0, p1, p2, p3, p4, p5, p6, p7, 39, 30, 34, 24);
|
||||
Round512v35(p2, p1, p4, p7, p6, p5, p0, p3, 13, 50, 10, 17);
|
||||
Round512v35(p4, p1, p6, p3, p0, p5, p2, p7, 25, 29, 39, 43);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 8, 35, 56, 22);
|
||||
|
||||
p0 += ks[8];
|
||||
p1 += ks[0];
|
||||
p2 += ks[1];
|
||||
p3 += ks[2];
|
||||
p4 += ks[3];
|
||||
p5 += ks[4] + ts[2];
|
||||
p6 += ks[5] + ts[0];
|
||||
p7 += ks[6] + make_uint2(8, 0);
|
||||
}
|
||||
__forceinline__ __device__
|
||||
void Round_8_512v35_9(const uint2 ks[9], const uint2 ts[3],
|
||||
uint2 &p0, uint2 &p1, uint2 &p2, uint2 &p3, uint2 &p4, uint2 &p5, uint2 &p6, uint2 &p7)
|
||||
{
|
||||
Round512v35(p0, p1, p2, p3, p4, p5, p6, p7, 46, 36, 19, 37);
|
||||
Round512v35(p2, p1, p4, p7, p6, p5, p0, p3, 33, 27, 14, 42);
|
||||
Round512v35(p4, p1, p6, p3, p0, p5, p2, p7, 17, 49, 36, 39);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 44, 9, 54, 56);
|
||||
|
||||
p0 += ks[0];
|
||||
p1 += ks[1];
|
||||
p2 += ks[2];
|
||||
p3 += ks[3];
|
||||
p4 += ks[4];
|
||||
p5 += ks[5] + ts[0];
|
||||
p6 += ks[6] + ts[1];
|
||||
p7 += ks[7] + make_uint2(9, 0);
|
||||
|
||||
Round512v35(p0, p1, p2, p3, p4, p5, p6, p7, 39, 30, 34, 24);
|
||||
Round512v35(p2, p1, p4, p7, p6, p5, p0, p3, 13, 50, 10, 17);
|
||||
Round512v35(p4, p1, p6, p3, p0, p5, p2, p7, 25, 29, 39, 43);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 8, 35, 56, 22);
|
||||
|
||||
p0 += ks[1];
|
||||
p1 += ks[2];
|
||||
p2 += ks[3];
|
||||
p3 += ks[4];
|
||||
p4 += ks[5];
|
||||
p5 += ks[6] + ts[1];
|
||||
p6 += ks[7] + ts[2];
|
||||
p7 += ks[8] + make_uint2(10, 0);
|
||||
}
|
||||
__forceinline__ __device__
|
||||
void Round_8_512v35_11(const uint2 ks[9], const uint2 ts[3],
|
||||
uint2 &p0, uint2 &p1, uint2 &p2, uint2 &p3, uint2 &p4, uint2 &p5, uint2 &p6, uint2 &p7)
|
||||
{
|
||||
Round512v35(p0, p1, p2, p3, p4, p5, p6, p7, 46, 36, 19, 37);
|
||||
Round512v35(p2, p1, p4, p7, p6, p5, p0, p3, 33, 27, 14, 42);
|
||||
Round512v35(p4, p1, p6, p3, p0, p5, p2, p7, 17, 49, 36, 39);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 44, 9, 54, 56);
|
||||
|
||||
p0 += ks[2];
|
||||
p1 += ks[3];
|
||||
p2 += ks[4];
|
||||
p3 += ks[5];
|
||||
p4 += ks[6];
|
||||
p5 += ks[7] + ts[2];
|
||||
p6 += ks[8] + ts[0];
|
||||
p7 += ks[0] + make_uint2(11, 0);
|
||||
|
||||
Round512v35(p0, p1, p2, p3, p4, p5, p6, p7, 39, 30, 34, 24);
|
||||
Round512v35(p2, p1, p4, p7, p6, p5, p0, p3, 13, 50, 10, 17);
|
||||
Round512v35(p4, p1, p6, p3, p0, p5, p2, p7, 25, 29, 39, 43);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 8, 35, 56, 22);
|
||||
|
||||
p0 += ks[3];
|
||||
p1 += ks[4];
|
||||
p2 += ks[5];
|
||||
p3 += ks[6];
|
||||
p4 += ks[7];
|
||||
p5 += ks[8] + ts[0];
|
||||
p6 += ks[0] + ts[1];
|
||||
p7 += ks[1] + make_uint2(12, 0);
|
||||
}
|
||||
__forceinline__ __device__
|
||||
void Round_8_512v35_13(const uint2 ks[9], const uint2 ts[3],
|
||||
uint2 &p0, uint2 &p1, uint2 &p2, uint2 &p3, uint2 &p4, uint2 &p5, uint2 &p6, uint2 &p7)
|
||||
{
|
||||
Round512v35(p0, p1, p2, p3, p4, p5, p6, p7, 46, 36, 19, 37);
|
||||
Round512v35(p2, p1, p4, p7, p6, p5, p0, p3, 33, 27, 14, 42);
|
||||
Round512v35(p4, p1, p6, p3, p0, p5, p2, p7, 17, 49, 36, 39);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 44, 9, 54, 56);
|
||||
|
||||
p0 += ks[4];
|
||||
p1 += ks[5];
|
||||
p2 += ks[6];
|
||||
p3 += ks[7];
|
||||
p4 += ks[8];
|
||||
p5 += ks[0] + ts[1];
|
||||
p6 += ks[1] + ts[2];
|
||||
p7 += ks[2] + make_uint2(13, 0);
|
||||
|
||||
Round512v35(p0, p1, p2, p3, p4, p5, p6, p7, 39, 30, 34, 24);
|
||||
Round512v35(p2, p1, p4, p7, p6, p5, p0, p3, 13, 50, 10, 17);
|
||||
Round512v35(p4, p1, p6, p3, p0, p5, p2, p7, 25, 29, 39, 43);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 8, 35, 56, 22);
|
||||
|
||||
p0 += ks[5];
|
||||
p1 += ks[6];
|
||||
p2 += ks[7];
|
||||
p3 += ks[8];
|
||||
p4 += ks[0];
|
||||
p5 += ks[1] + ts[2];
|
||||
p6 += ks[2] + ts[0];
|
||||
p7 += ks[3] + make_uint2(14, 0);
|
||||
}
|
||||
__forceinline__ __device__
|
||||
void Round_8_512v35_15(const uint2 ks[9], const uint2 ts[3],
|
||||
uint2 &p0, uint2 &p1, uint2 &p2, uint2 &p3, uint2 &p4, uint2 &p5, uint2 &p6, uint2 &p7)
|
||||
{
|
||||
Round512v35(p0, p1, p2, p3, p4, p5, p6, p7, 46, 36, 19, 37);
|
||||
Round512v35(p2, p1, p4, p7, p6, p5, p0, p3, 33, 27, 14, 42);
|
||||
Round512v35(p4, p1, p6, p3, p0, p5, p2, p7, 17, 49, 36, 39);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 44, 9, 54, 56);
|
||||
|
||||
p0 += ks[6];
|
||||
p1 += ks[7];
|
||||
p2 += ks[8];
|
||||
p3 += ks[0];
|
||||
p4 += ks[1];
|
||||
p5 += ks[2] + ts[0];
|
||||
p6 += ks[3] + ts[1];
|
||||
p7 += ks[4] + make_uint2(15, 0);
|
||||
|
||||
Round512v35(p0, p1, p2, p3, p4, p5, p6, p7, 39, 30, 34, 24);
|
||||
Round512v35(p2, p1, p4, p7, p6, p5, p0, p3, 13, 50, 10, 17);
|
||||
Round512v35(p4, p1, p6, p3, p0, p5, p2, p7, 25, 29, 39, 43);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 8, 35, 56, 22);
|
||||
|
||||
p0 += ks[7];
|
||||
p1 += ks[8];
|
||||
p2 += ks[0];
|
||||
p3 += ks[1];
|
||||
p4 += ks[2];
|
||||
p5 += ks[3] + ts[1];
|
||||
p6 += ks[4] + ts[2];
|
||||
p7 += ks[5] + make_uint2(16, 0);
|
||||
}
|
||||
__forceinline__ __device__
|
||||
void Round_8_512v35_17(const uint2 ks[9], const uint2 ts[3],
|
||||
uint2 &p0, uint2 &p1, uint2 &p2, uint2 &p3, uint2 &p4, uint2 &p5, uint2 &p6, uint2 &p7)
|
||||
{
|
||||
Round512v35(p0, p1, p2, p3, p4, p5, p6, p7, 46, 36, 19, 37);
|
||||
Round512v35(p2, p1, p4, p7, p6, p5, p0, p3, 33, 27, 14, 42);
|
||||
Round512v35(p4, p1, p6, p3, p0, p5, p2, p7, 17, 49, 36, 39);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 44, 9, 54, 56);
|
||||
|
||||
p0 += ks[8];
|
||||
p1 += ks[0];
|
||||
p2 += ks[1];
|
||||
p3 += ks[2];
|
||||
p4 += ks[3];
|
||||
p5 += ks[4] + ts[2];
|
||||
p6 += ks[5] + ts[0];
|
||||
p7 += ks[6] + make_uint2(17, 0);
|
||||
|
||||
Round512v35(p0, p1, p2, p3, p4, p5, p6, p7, 39, 30, 34, 24);
|
||||
Round512v35(p2, p1, p4, p7, p6, p5, p0, p3, 13, 50, 10, 17);
|
||||
Round512v35(p4, p1, p6, p3, p0, p5, p2, p7, 25, 29, 39, 43);
|
||||
Round512v35(p6, p1, p0, p7, p2, p5, p4, p3, 8, 35, 56, 22);
|
||||
|
||||
p0 += ks[0];
|
||||
p1 += ks[1];
|
||||
p2 += ks[2];
|
||||
p3 += ks[3];
|
||||
p4 += ks[4];
|
||||
p5 += ks[5] + ts[0];
|
||||
p6 += ks[6] + ts[1];
|
||||
p7 += ks[7] + make_uint2(18, 0);
|
||||
}
|
||||
|
||||
__forceinline__ __device__
|
||||
void Round_8_512v35_final(const uint2 *const __restrict__ ks, const uint2 *const __restrict__ ts,
|
||||
void Round_8_512v35_final(const uint2 ks[9], const uint2 ts[3],
|
||||
uint2 &p0, uint2 &p1, uint2 &p2, uint2 &p3, uint2 &p4, uint2 &p5, uint2 &p6, uint2 &p7)
|
||||
{
|
||||
Round512v35(p0, p1, p2, p3, p4, p5, p6, p7, 46, 36, 19, 37);
|
||||
@@ -74,84 +330,88 @@ void Round_8_512v35_final(const uint2 *const __restrict__ ks, const uint2 *const
|
||||
p3 += ks[3];
|
||||
}
|
||||
|
||||
__global__ __launch_bounds__(256,3)
|
||||
void skein256_gpu_hash_32(uint32_t threads, uint32_t startNounce, uint64_t *outputHash)
|
||||
__global__ __launch_bounds__(256, 4)
|
||||
void skein256_gpu_hash_32(uint32_t threads, uint32_t startNounce, uint2 *outputHash)
|
||||
{
|
||||
const uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
const uint2 skein_ks_parity = { 0xA9FC1A22, 0x1BD11BDA };
|
||||
|
||||
const uint2 h2[9] = {
|
||||
{ 0x2FDB3E13, 0xCCD044A1 },
|
||||
{ 0x1A79A9EB, 0xE8359030 },
|
||||
{ 0x4F816E6F, 0x55AEA061 },
|
||||
{ 0xAE9B94DB, 0x2A2767A4 },
|
||||
{ 0x74DD7683, 0xEC06025E },
|
||||
{ 0xC4746251, 0xE7A436CD },
|
||||
{ 0x393AD185, 0xC36FBAF9 },
|
||||
{ 0x33EDFC13, 0x3EEDBA18 },
|
||||
{ 0xC73A4E2A, 0xB69D3CFC }
|
||||
};
|
||||
const uint2 t12[2][3] = {
|
||||
{ { 0x20, 0 },
|
||||
{ 0, 0xf0000000 },
|
||||
{ 0x20, 0xf0000000 } },
|
||||
{ { 0x08, 0 },
|
||||
{ 0, 0xff000000 },
|
||||
{ 0x08, 0xff000000 } }
|
||||
};
|
||||
|
||||
if (thread < threads)
|
||||
{
|
||||
const uint2 skein_ks_parity = { 0xA9FC1A22, 0x1BD11BDA };
|
||||
const uint2 t12[6] = {
|
||||
{ 0x20, 0 },
|
||||
{ 0, 0xf0000000 },
|
||||
{ 0x20, 0xf0000000 },
|
||||
{ 0x08, 0 },
|
||||
{ 0, 0xff000000 },
|
||||
{ 0x08, 0xff000000 }
|
||||
};
|
||||
|
||||
uint2 h[9] = {
|
||||
{ 0x2FDB3E13, 0xCCD044A1 },
|
||||
{ 0x1A79A9EB, 0xE8359030 },
|
||||
{ 0x4F816E6F, 0x55AEA061 },
|
||||
{ 0xAE9B94DB, 0x2A2767A4 },
|
||||
{ 0x74DD7683, 0xEC06025E },
|
||||
{ 0xC4746251, 0xE7A436CD },
|
||||
{ 0x393AD185, 0xC36FBAF9 },
|
||||
{ 0x33EDFC13, 0x3EEDBA18 },
|
||||
{ 0xC73A4E2A, 0xB69D3CFC }
|
||||
};
|
||||
uint2 dt0,dt1,dt2,dt3;
|
||||
uint2 p0, p1, p2, p3, p4, p5, p6, p7;
|
||||
|
||||
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]);
|
||||
dt0 = __ldg(&outputHash[0 * threads + thread]);
|
||||
dt1 = __ldg(&outputHash[1 * threads + thread]);
|
||||
dt2 = __ldg(&outputHash[2 * threads + thread]);
|
||||
dt3 = __ldg(&outputHash[3 * threads + thread]);
|
||||
|
||||
p0 = h[0] + dt0;
|
||||
p1 = h[1] + dt1;
|
||||
p2 = h[2] + dt2;
|
||||
p3 = h[3] + dt3;
|
||||
p4 = h[4];
|
||||
p5 = h[5] + t12[0];
|
||||
p6 = h[6] + t12[1];
|
||||
p7 = h[7];
|
||||
p0 = h2[0] + dt0;
|
||||
p1 = h2[1] + dt1;
|
||||
p2 = h2[2] + dt2;
|
||||
p3 = h2[3] + dt3;
|
||||
p4 = h2[4];
|
||||
p5 = h2[5] + t12[0][0];
|
||||
p6 = h2[6] + t12[0][1];
|
||||
p7 = h2[7];
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 1; i<19; i+=2) {
|
||||
Round_8_512v35(h,t12,p0,p1,p2,p3,p4,p5,p6,p7,i);
|
||||
}
|
||||
// forced unroll required
|
||||
Round_8_512v35_1(h2, t12[0], p0, p1, p2, p3, p4, p5, p6, p7);
|
||||
Round_8_512v35_3(h2, t12[0], p0, p1, p2, p3, p4, p5, p6, p7);
|
||||
Round_8_512v35_5(h2, t12[0], p0, p1, p2, p3, p4, p5, p6, p7);
|
||||
Round_8_512v35_7(h2, t12[0], p0, p1, p2, p3, p4, p5, p6, p7);
|
||||
Round_8_512v35_9(h2, t12[0], p0, p1, p2, p3, p4, p5, p6, p7);
|
||||
Round_8_512v35_11(h2, t12[0], p0, p1, p2, p3, p4, p5, p6, p7);
|
||||
Round_8_512v35_13(h2, t12[0], p0, p1, p2, p3, p4, p5, p6, p7);
|
||||
Round_8_512v35_15(h2, t12[0], p0, p1, p2, p3, p4, p5, p6, p7);
|
||||
Round_8_512v35_17(h2, t12[0], p0, p1, p2, p3, p4, p5, p6, p7);
|
||||
|
||||
p0 ^= dt0;
|
||||
p1 ^= dt1;
|
||||
p2 ^= dt2;
|
||||
p3 ^= dt3;
|
||||
|
||||
h[0] = p0;
|
||||
h[1] = p1;
|
||||
h[2] = p2;
|
||||
h[3] = p3;
|
||||
h[4] = p4;
|
||||
h[5] = p5;
|
||||
h[6] = p6;
|
||||
h[7] = p7;
|
||||
h[8] = skein_ks_parity ^ h[0] ^ h[1] ^ h[2] ^ h[3] ^ h[4] ^ h[5] ^ h[6] ^ h[7];
|
||||
const uint2 h[9] = { p0, p1, p2, p3, p4, p5, p6, p7, skein_ks_parity ^ h[0] ^ h[1] ^ h[2] ^ h[3] ^ h[4] ^ h[5] ^ h[6] ^ h[7] };
|
||||
|
||||
const uint2 *t = t12+3;
|
||||
p5 += t12[3]; //p5 already equal h[5]
|
||||
p6 += t12[4];
|
||||
p5 += t12[1][0]; //p5 already equal h[5]
|
||||
p6 += t12[1][1];
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 1; i<17; i+=2) {
|
||||
Round_8_512v35(h, t, p0, p1, p2, p3, p4, p5, p6, p7, i);
|
||||
}
|
||||
Round_8_512v35_final(h, t, p0, p1, p2, p3, p4, p5, p6, p7);
|
||||
outputHash[thread] = devectorize(p0);
|
||||
outputHash[threads+thread] = devectorize(p1);
|
||||
outputHash[2*threads+thread] = devectorize(p2);
|
||||
outputHash[3*threads+thread] = devectorize(p3);
|
||||
// forced unroll
|
||||
Round_8_512v35_1(h, t12[1], p0, p1, p2, p3, p4, p5, p6, p7);
|
||||
Round_8_512v35_3(h, t12[1], p0, p1, p2, p3, p4, p5, p6, p7);
|
||||
Round_8_512v35_5(h, t12[1], p0, p1, p2, p3, p4, p5, p6, p7);
|
||||
Round_8_512v35_7(h, t12[1], p0, p1, p2, p3, p4, p5, p6, p7);
|
||||
Round_8_512v35_9(h, t12[1], p0, p1, p2, p3, p4, p5, p6, p7);
|
||||
Round_8_512v35_11(h, t12[1], p0, p1, p2, p3, p4, p5, p6, p7);
|
||||
Round_8_512v35_13(h, t12[1], p0, p1, p2, p3, p4, p5, p6, p7);
|
||||
Round_8_512v35_15(h, t12[1], p0, p1, p2, p3, p4, p5, p6, p7);
|
||||
Round_8_512v35_final(h, t12[1], p0, p1, p2, p3, p4, p5, p6, p7);
|
||||
|
||||
outputHash[0 * threads + thread] = p0;
|
||||
outputHash[1 * threads + thread] = p1;
|
||||
outputHash[2 * threads + thread] = p2;
|
||||
outputHash[3 * threads + thread] = p3;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -285,16 +545,34 @@ __host__
|
||||
void skein256_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNounce, uint64_t *d_outputHash, int order)
|
||||
{
|
||||
const uint32_t threadsperblock = 256;
|
||||
int dev_id = device_map[thr_id];
|
||||
|
||||
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);
|
||||
if (device_sm[dev_id] > 300 && cuda_arch[dev_id] > 300)
|
||||
skein256_gpu_hash_32 << <grid, block >> >(threads, startNounce, (uint2*)d_outputHash);
|
||||
else
|
||||
skein256_gpu_hash_32_v30<<<grid, block>>>(threads, startNounce, d_outputHash);
|
||||
skein256_gpu_hash_32_v30 << <grid, block >> >(threads, startNounce, d_outputHash);
|
||||
|
||||
MyStreamSynchronize(NULL, order, thr_id);
|
||||
//MyStreamSynchronize(NULL, order, thr_id);
|
||||
}
|
||||
|
||||
__host__
|
||||
void skein256_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNounce, uint64_t *d_outputHash, int order, cudaStream_t stream)
|
||||
{
|
||||
const uint32_t threadsperblock = 256;
|
||||
int dev_id = device_map[thr_id];
|
||||
|
||||
dim3 grid((threads + threadsperblock - 1) / threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
|
||||
// only 1kH/s perf change between kernels on a 960...
|
||||
if (device_sm[dev_id] > 300 && cuda_arch[dev_id] > 300)
|
||||
skein256_gpu_hash_32 << <grid, block, 0, stream >> >(threads, startNounce, (uint2*)d_outputHash);
|
||||
else
|
||||
skein256_gpu_hash_32_v30 << <grid, block,0, stream >> >(threads, startNounce, d_outputHash);
|
||||
|
||||
//MyStreamSynchronize(NULL, order, thr_id);
|
||||
}
|
||||
@@ -0,0 +1,469 @@
|
||||
/**
|
||||
* Blake-256 Decred 180-Bytes input Cuda Kernel (Tested on SM 5/5.2)
|
||||
*
|
||||
* Tanguy Pruvot - Feb 2016
|
||||
*
|
||||
* Revised for optimisation by pallas @ bitcointalk - Apr 2016
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include <memory.h>
|
||||
|
||||
#include <miner.h>
|
||||
|
||||
extern "C" {
|
||||
#include <sph/sph_blake.h>
|
||||
}
|
||||
|
||||
/* threads per block */
|
||||
#define TPB 512
|
||||
/* nonces per round */
|
||||
#define NPR 128
|
||||
|
||||
/* hash by cpu with blake 256 */
|
||||
extern "C" void decred_hash(void *output, const void *input)
|
||||
{
|
||||
sph_blake256_context ctx;
|
||||
|
||||
sph_blake256_set_rounds(14);
|
||||
|
||||
sph_blake256_init(&ctx);
|
||||
sph_blake256(&ctx, input, 180);
|
||||
sph_blake256_close(&ctx, output);
|
||||
}
|
||||
|
||||
#include <cuda_helper.h>
|
||||
|
||||
#ifdef __INTELLISENSE__
|
||||
#define __byte_perm(x, y, b) x
|
||||
#endif
|
||||
|
||||
__constant__ uint32_t _ALIGN(4) d_data[24];
|
||||
|
||||
/* 16 adapters max */
|
||||
static uint32_t *d_resNonce[MAX_GPUS];
|
||||
static uint32_t *h_resNonce[MAX_GPUS];
|
||||
|
||||
/* max count of found nonces in one call */
|
||||
#define NBN 2
|
||||
#if NBN > 1
|
||||
static uint32_t extra_results[NBN] = { UINT32_MAX };
|
||||
#endif
|
||||
|
||||
|
||||
/* ############################################################################################################################### */
|
||||
|
||||
#define GSPREC(a,b,c,d,x,y) { \
|
||||
v[a] += (m[x] ^ c_u256[y]) + v[b]; \
|
||||
v[d] = __byte_perm(v[d] ^ v[a], 0, 0x1032); \
|
||||
v[c] += v[d]; \
|
||||
v[b] = SPH_ROTR32(v[b] ^ v[c], 12); \
|
||||
v[a] += (m[y] ^ c_u256[x]) + v[b]; \
|
||||
v[d] = __byte_perm(v[d] ^ v[a], 0, 0x0321); \
|
||||
v[c] += v[d]; \
|
||||
v[b] = SPH_ROTR32(v[b] ^ v[c], 7); \
|
||||
}
|
||||
|
||||
|
||||
#define GSPREC4(a0,b0,c0,d0,x0,y0,a1,b1,c1,d1,x1,y1,a2,b2,c2,d2,x2,y2,a3,b3,c3,d3,x3,y3) { \
|
||||
v[a0] += (m[x0] ^ c_u256[y0]) + v[b0]; \
|
||||
v[a1] += (m[x1] ^ c_u256[y1]) + v[b1]; \
|
||||
v[a2] += (m[x2] ^ c_u256[y2]) + v[b2]; \
|
||||
v[a3] += (m[x3] ^ c_u256[y3]) + v[b3]; \
|
||||
v[d0] = __byte_perm(v[d0] ^ v[a0], 0, 0x1032); \
|
||||
v[d1] = __byte_perm(v[d1] ^ v[a1], 0, 0x1032); \
|
||||
v[d2] = __byte_perm(v[d2] ^ v[a2], 0, 0x1032); \
|
||||
v[d3] = __byte_perm(v[d3] ^ v[a3], 0, 0x1032); \
|
||||
v[c0] += v[d0]; \
|
||||
v[c1] += v[d1]; \
|
||||
v[c2] += v[d2]; \
|
||||
v[c3] += v[d3]; \
|
||||
v[b0] = SPH_ROTR32(v[b0] ^ v[c0], 12); \
|
||||
v[b1] = SPH_ROTR32(v[b1] ^ v[c1], 12); \
|
||||
v[b2] = SPH_ROTR32(v[b2] ^ v[c2], 12); \
|
||||
v[b3] = SPH_ROTR32(v[b3] ^ v[c3], 12); \
|
||||
v[a0] += (m[y0] ^ c_u256[x0]) + v[b0]; \
|
||||
v[a1] += (m[y1] ^ c_u256[x1]) + v[b1]; \
|
||||
v[a2] += (m[y2] ^ c_u256[x2]) + v[b2]; \
|
||||
v[a3] += (m[y3] ^ c_u256[x3]) + v[b3]; \
|
||||
v[d0] = __byte_perm(v[d0] ^ v[a0], 0, 0x0321); \
|
||||
v[d1] = __byte_perm(v[d1] ^ v[a1], 0, 0x0321); \
|
||||
v[d2] = __byte_perm(v[d2] ^ v[a2], 0, 0x0321); \
|
||||
v[d3] = __byte_perm(v[d3] ^ v[a3], 0, 0x0321); \
|
||||
v[c0] += v[d0]; \
|
||||
v[c1] += v[d1]; \
|
||||
v[c2] += v[d2]; \
|
||||
v[c3] += v[d3]; \
|
||||
v[b0] = SPH_ROTR32(v[b0] ^ v[c0], 7); \
|
||||
v[b1] = SPH_ROTR32(v[b1] ^ v[c1], 7); \
|
||||
v[b2] = SPH_ROTR32(v[b2] ^ v[c2], 7); \
|
||||
v[b3] = SPH_ROTR32(v[b3] ^ v[c3], 7); \
|
||||
}
|
||||
|
||||
|
||||
static const __constant__ uint32_t c_u256[16] = {
|
||||
0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344,
|
||||
0xA4093822, 0x299F31D0, 0x082EFA98, 0xEC4E6C89,
|
||||
0x452821E6, 0x38D01377, 0xBE5466CF, 0x34E90C6C,
|
||||
0xC0AC29B7, 0xC97C50DD, 0x3F84D5B5, 0xB5470917
|
||||
};
|
||||
|
||||
|
||||
__device__ __forceinline__
|
||||
uint32_t blake256_compress_14(uint32_t *m, uint32_t *v_init, uint32_t d_data6, uint32_t d_data7)
|
||||
{
|
||||
uint32_t v[16];
|
||||
|
||||
#pragma unroll
|
||||
for (uint32_t i = 0; i < 16; i++) v[i] = v_init[i];
|
||||
// these two are not modified:
|
||||
v[ 9] = 0x85A308D3;
|
||||
v[13] = 0x299F31D0 ^ (180U*8U);
|
||||
|
||||
// round 1 with nonce
|
||||
GSPREC(1, 5, 0x9, 0xD, 2, 3);
|
||||
GSPREC(0, 5, 0xA, 0xF, 8, 9);
|
||||
GSPREC(1, 6, 0xB, 0xC, 10, 11);
|
||||
GSPREC(2, 7, 0x8, 0xD, 12, 13);
|
||||
GSPREC(3, 4, 0x9, 0xE, 14, 15);
|
||||
// round 2
|
||||
GSPREC4(0, 4, 0x8, 0xC, 14, 10, 1, 5, 0x9, 0xD, 4, 8, 2, 6, 0xA, 0xE, 9, 15, 3, 7, 0xB, 0xF, 13, 6);
|
||||
GSPREC4(0, 5, 0xA, 0xF, 1, 12, 1, 6, 0xB, 0xC, 0, 2, 2, 7, 0x8, 0xD, 11, 7, 3, 4, 0x9, 0xE, 5, 3);
|
||||
// round 3
|
||||
GSPREC4(0, 4, 0x8, 0xC, 11, 8, 1, 5, 0x9, 0xD, 12, 0, 2, 6, 0xA, 0xE, 5, 2, 3, 7, 0xB, 0xF, 15, 13);
|
||||
GSPREC4(0, 5, 0xA, 0xF, 10, 14, 1, 6, 0xB, 0xC, 3, 6, 2, 7, 0x8, 0xD, 7, 1, 3, 4, 0x9, 0xE, 9, 4);
|
||||
// round 4
|
||||
GSPREC4(0, 4, 0x8, 0xC, 7, 9, 1, 5, 0x9, 0xD, 3, 1, 2, 6, 0xA, 0xE, 13, 12, 3, 7, 0xB, 0xF, 11, 14);
|
||||
GSPREC4(0, 5, 0xA, 0xF, 2, 6, 1, 6, 0xB, 0xC, 5, 10, 2, 7, 0x8, 0xD, 4, 0, 3, 4, 0x9, 0xE, 15, 8);
|
||||
// round 5
|
||||
GSPREC4(0, 4, 0x8, 0xC, 9, 0, 1, 5, 0x9, 0xD, 5, 7, 2, 6, 0xA, 0xE, 2, 4, 3, 7, 0xB, 0xF, 10, 15);
|
||||
GSPREC4(0, 5, 0xA, 0xF, 14, 1, 1, 6, 0xB, 0xC, 11, 12, 2, 7, 0x8, 0xD, 6, 8, 3, 4, 0x9, 0xE, 3, 13);
|
||||
// round 6
|
||||
GSPREC4(0, 4, 0x8, 0xC, 2, 12, 1, 5, 0x9, 0xD, 6, 10, 2, 6, 0xA, 0xE, 0, 11, 3, 7, 0xB, 0xF, 8, 3);
|
||||
GSPREC4(0, 5, 0xA, 0xF, 4, 13, 1, 6, 0xB, 0xC, 7, 5, 2, 7, 0x8, 0xD, 15,14, 3, 4, 0x9, 0xE, 1, 9);
|
||||
// round 7
|
||||
GSPREC4(0, 4, 0x8, 0xC, 12, 5, 1, 5, 0x9, 0xD, 1, 15, 2, 6, 0xA, 0xE, 14,13, 3, 7, 0xB, 0xF, 4, 10);
|
||||
GSPREC4(0, 5, 0xA, 0xF, 0, 7, 1, 6, 0xB, 0xC, 6, 3, 2, 7, 0x8, 0xD, 9, 2, 3, 4, 0x9, 0xE, 8, 11);
|
||||
#ifdef FULL_4WAY
|
||||
// round 8
|
||||
GSPREC4(0, 4, 0x8, 0xC, 13,11, 1, 5, 0x9, 0xD, 7, 14, 2, 6, 0xA, 0xE, 12, 1, 3, 7, 0xB, 0xF, 3, 9);
|
||||
GSPREC4(0, 5, 0xA, 0xF, 5, 0, 1, 6, 0xB, 0xC, 15, 4, 2, 7, 0x8, 0xD, 8, 6, 3, 4, 0x9, 0xE, 2, 10);
|
||||
// round 9
|
||||
GSPREC4(0, 4, 0x8, 0xC, 6, 15, 1, 5, 0x9, 0xD, 14, 9, 2, 6, 0xA, 0xE, 11, 3, 3, 7, 0xB, 0xF, 0, 8);
|
||||
GSPREC4(0, 5, 0xA, 0xF, 12, 2, 1, 6, 0xB, 0xC, 13, 7, 2, 7, 0x8, 0xD, 1, 4, 3, 4, 0x9, 0xE, 10, 5);
|
||||
// round 10
|
||||
GSPREC4(0, 4, 0x8, 0xC, 10, 2, 1, 5, 0x9, 0xD, 8, 4, 2, 6, 0xA, 0xE, 7, 6, 3, 7, 0xB, 0xF, 1, 5);
|
||||
GSPREC4(0, 5, 0xA, 0xF, 15,11, 1, 6, 0xB, 0xC, 9, 14, 2, 7, 0x8, 0xD, 3, 12, 3, 4, 0x9, 0xE, 13, 0);
|
||||
// round 11
|
||||
GSPREC4(0, 4, 0x8, 0xC, 0, 1, 1, 5, 0x9, 0xD, 2, 3, 2, 6, 0xA, 0xE, 4, 5, 3, 7, 0xB, 0xF, 6, 7);
|
||||
GSPREC4(0, 5, 0xA, 0xF, 8, 9, 1, 6, 0xB, 0xC, 10,11, 2, 7, 0x8, 0xD, 12,13, 3, 4, 0x9, 0xE, 14,15);
|
||||
// round 12
|
||||
GSPREC4(0, 4, 0x8, 0xC, 14,10, 1, 5, 0x9, 0xD, 4, 8, 2, 6, 0xA, 0xE, 9, 15, 3, 7, 0xB, 0xF, 13, 6);
|
||||
GSPREC4(0, 5, 0xA, 0xF, 1, 12, 1, 6, 0xB, 0xC, 0, 2, 2, 7, 0x8, 0xD, 11, 7, 3, 4, 0x9, 0xE, 5, 3);
|
||||
// round 13
|
||||
GSPREC4(0, 4, 0x8, 0xC, 11, 8, 1, 5, 0x9, 0xD, 12, 0, 2, 6, 0xA, 0xE, 5, 2, 3, 7, 0xB, 0xF, 15,13);
|
||||
GSPREC4(0, 5, 0xA, 0xF, 10,14, 1, 6, 0xB, 0xC, 3, 6, 2, 7, 0x8, 0xD, 7, 1, 3, 4, 0x9, 0xE, 9, 4);
|
||||
#else
|
||||
// round 8
|
||||
GSPREC(0, 4, 0x8, 0xC, 13,11);
|
||||
GSPREC(1, 5, 0x9, 0xD, 7, 14);
|
||||
GSPREC(2, 6, 0xA, 0xE, 12, 1);
|
||||
GSPREC(3, 7, 0xB, 0xF, 3, 9);
|
||||
GSPREC(0, 5, 0xA, 0xF, 5, 0);
|
||||
GSPREC(1, 6, 0xB, 0xC, 15, 4);
|
||||
GSPREC(2, 7, 0x8, 0xD, 8, 6);
|
||||
GSPREC(3, 4, 0x9, 0xE, 2, 10);
|
||||
// round 9
|
||||
GSPREC(0, 4, 0x8, 0xC, 6, 15);
|
||||
GSPREC(1, 5, 0x9, 0xD, 14, 9);
|
||||
GSPREC(2, 6, 0xA, 0xE, 11, 3);
|
||||
GSPREC(3, 7, 0xB, 0xF, 0, 8);
|
||||
GSPREC(0, 5, 0xA, 0xF, 12, 2);
|
||||
GSPREC(1, 6, 0xB, 0xC, 13, 7);
|
||||
GSPREC(2, 7, 0x8, 0xD, 1, 4);
|
||||
GSPREC(3, 4, 0x9, 0xE, 10, 5);
|
||||
// round 10
|
||||
GSPREC(0, 4, 0x8, 0xC, 10, 2);
|
||||
GSPREC(1, 5, 0x9, 0xD, 8, 4);
|
||||
GSPREC(2, 6, 0xA, 0xE, 7, 6);
|
||||
GSPREC(3, 7, 0xB, 0xF, 1, 5);
|
||||
GSPREC(0, 5, 0xA, 0xF, 15,11);
|
||||
GSPREC(1, 6, 0xB, 0xC, 9, 14);
|
||||
GSPREC(2, 7, 0x8, 0xD, 3, 12);
|
||||
GSPREC(3, 4, 0x9, 0xE, 13, 0);
|
||||
// round 11
|
||||
GSPREC(0, 4, 0x8, 0xC, 0, 1);
|
||||
GSPREC(1, 5, 0x9, 0xD, 2, 3);
|
||||
GSPREC(2, 6, 0xA, 0xE, 4, 5);
|
||||
GSPREC(3, 7, 0xB, 0xF, 6, 7);
|
||||
GSPREC(0, 5, 0xA, 0xF, 8, 9);
|
||||
GSPREC(1, 6, 0xB, 0xC, 10,11);
|
||||
GSPREC(2, 7, 0x8, 0xD, 12,13);
|
||||
GSPREC(3, 4, 0x9, 0xE, 14,15);
|
||||
// round 12
|
||||
GSPREC(0, 4, 0x8, 0xC, 14,10);
|
||||
GSPREC(1, 5, 0x9, 0xD, 4, 8);
|
||||
GSPREC(2, 6, 0xA, 0xE, 9, 15);
|
||||
GSPREC(3, 7, 0xB, 0xF, 13, 6);
|
||||
GSPREC(0, 5, 0xA, 0xF, 1, 12);
|
||||
GSPREC(1, 6, 0xB, 0xC, 0, 2);
|
||||
GSPREC(2, 7, 0x8, 0xD, 11, 7);
|
||||
GSPREC(3, 4, 0x9, 0xE, 5, 3);
|
||||
// round 13
|
||||
GSPREC(0, 4, 0x8, 0xC, 11, 8);
|
||||
GSPREC(1, 5, 0x9, 0xD, 12, 0);
|
||||
GSPREC(2, 6, 0xA, 0xE, 5, 2);
|
||||
GSPREC(3, 7, 0xB, 0xF, 15,13);
|
||||
GSPREC(0, 5, 0xA, 0xF, 10,14);
|
||||
GSPREC(1, 6, 0xB, 0xC, 3, 6);
|
||||
GSPREC(2, 7, 0x8, 0xD, 7, 1);
|
||||
GSPREC(3, 4, 0x9, 0xE, 9, 4);
|
||||
#endif
|
||||
// round 14
|
||||
GSPREC(0, 4, 0x8, 0xC, 7, 9);
|
||||
GSPREC(1, 5, 0x9, 0xD, 3, 1);
|
||||
GSPREC(2, 6, 0xA, 0xE, 13,12);
|
||||
GSPREC(3, 7, 0xB, 0xF, 11,14);
|
||||
GSPREC(0, 5, 0xA, 0xF, 2, 6);
|
||||
GSPREC(2, 7, 0x8, 0xD, 4, 0);
|
||||
|
||||
if ((d_data7 ^ v[7] ^ v[15]) == 0) {
|
||||
GSPREC(1, 6, 0xB, 0xC, 5, 10);
|
||||
GSPREC(3, 4, 0x9, 0xE, 15, 8);
|
||||
return (d_data6 ^ v[6] ^ v[14]);
|
||||
}
|
||||
return UINT32_MAX;
|
||||
}
|
||||
|
||||
|
||||
/* ############################################################################################################################### */
|
||||
|
||||
// ------ Close: Last 52/64 bytes ------
|
||||
__global__
|
||||
void blake256_gpu_hash_nonce(const uint32_t threads, const uint32_t startNonce, uint32_t *resNonce, const uint64_t highTarget)
|
||||
{
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
// if (thread < threads)
|
||||
{
|
||||
const uint32_t nonce = startNonce + thread * NPR;
|
||||
uint32_t m[16], v[16], temp;
|
||||
const uint32_t d_data6 = d_data[6], d_data7 = d_data[7];
|
||||
|
||||
#pragma unroll
|
||||
for(int i = 0; i < 8; i++) v[i] = d_data[i];
|
||||
|
||||
#pragma unroll
|
||||
for (uint32_t i = 0; i < 16; i++) m[i] = d_data[i+8U];
|
||||
|
||||
v[ 8] = 0x243F6A88;
|
||||
v[ 9] = 0x85A308D3;
|
||||
v[10] = 0x13198A2E;
|
||||
v[11] = 0x03707344;
|
||||
|
||||
v[12] = 0xA4093822 ^ (180U*8U);
|
||||
v[13] = 0x299F31D0 ^ (180U*8U);
|
||||
v[14] = 0x082EFA98;
|
||||
v[15] = 0xEC4E6C89;
|
||||
|
||||
// round 1 without nonce
|
||||
GSPREC(0, 4, 0x8, 0xC, 0, 1);
|
||||
GSPREC(2, 6, 0xA, 0xE, 4, 5);
|
||||
GSPREC(3, 7, 0xB, 0xF, 6, 7);
|
||||
|
||||
for (m[3] = nonce; m[3] < nonce + NPR; m[3]++) {
|
||||
temp = blake256_compress_14(m, v, d_data6, d_data7);
|
||||
|
||||
if (temp != UINT32_MAX && cuda_swab32(temp) <= highTarget) {
|
||||
#if NBN == 2
|
||||
if (resNonce[0] != UINT32_MAX) resNonce[1] = m[3];
|
||||
else resNonce[0] = m[3];
|
||||
#else
|
||||
resNonce[0] = m[3];
|
||||
#endif
|
||||
// from alexis78:
|
||||
// return statement allows CUDA7.5 to :
|
||||
// 1. Store the values fetched from constant memory in registers.
|
||||
// 2. Perform more precomputations on the outside of the for loop.
|
||||
// 3. Stop the continuous fetches from the constant memory while iterating
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
__host__
|
||||
static uint32_t decred_cpu_hash_nonce(const int thr_id, const uint32_t threads, const uint32_t startNonce, const uint64_t highTarget)
|
||||
{
|
||||
uint32_t result = UINT32_MAX;
|
||||
const uint32_t real_threads = threads / NPR;
|
||||
|
||||
dim3 grid((real_threads + TPB-1)/TPB);
|
||||
dim3 block(TPB);
|
||||
|
||||
/* Check error on Ctrl+C or kill to prevent segfaults on exit */
|
||||
if (cudaMemset(d_resNonce[thr_id], 0xff, NBN*sizeof(uint32_t)) != cudaSuccess)
|
||||
return result;
|
||||
|
||||
blake256_gpu_hash_nonce <<<grid, block>>> (real_threads, startNonce, d_resNonce[thr_id], highTarget);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
if (cudaSuccess == cudaMemcpy(h_resNonce[thr_id], d_resNonce[thr_id], NBN*sizeof(uint32_t), cudaMemcpyDeviceToHost)) {
|
||||
result = h_resNonce[thr_id][0];
|
||||
#if NBN > 1
|
||||
for (int n=0; n < (NBN-1); n++)
|
||||
extra_results[n] = h_resNonce[thr_id][n+1];
|
||||
#endif
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
__host__
|
||||
static void decred_midstate_128(uint32_t *output, const uint32_t *input)
|
||||
{
|
||||
sph_blake256_context ctx;
|
||||
|
||||
sph_blake256_set_rounds(14);
|
||||
|
||||
sph_blake256_init(&ctx);
|
||||
sph_blake256(&ctx, input, 128);
|
||||
|
||||
memcpy(output, (void*)ctx.H, 32);
|
||||
}
|
||||
|
||||
|
||||
__host__
|
||||
void decred_cpu_setBlock_52(uint32_t *penddata, const uint32_t *midstate, const uint32_t *ptarget)
|
||||
{
|
||||
uint32_t _ALIGN(64) data[24];
|
||||
memcpy(data, midstate, 32);
|
||||
// pre swab32
|
||||
for (int i=0; i<13; i++)
|
||||
data[8+i] = swab32(penddata[i]);
|
||||
data[21] = 0x80000001;
|
||||
data[22] = 0;
|
||||
data[23] = 0x000005a0;
|
||||
CUDA_SAFE_CALL(cudaMemcpyToSymbol(d_data, data, 32 + 64, 0, cudaMemcpyHostToDevice));
|
||||
}
|
||||
|
||||
|
||||
/* ############################################################################################################################### */
|
||||
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
|
||||
// nonce position is different in decred
|
||||
#define DCR_NONCE_OFT32 35
|
||||
|
||||
extern "C" int scanhash_decred(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
|
||||
{
|
||||
uint32_t _ALIGN(64) endiandata[48];
|
||||
uint32_t _ALIGN(64) midstate[8];
|
||||
|
||||
uint32_t *pdata = work->data;
|
||||
uint32_t *ptarget = work->target;
|
||||
uint32_t *pnonce = &pdata[DCR_NONCE_OFT32];
|
||||
|
||||
const uint32_t first_nonce = *pnonce;
|
||||
uint64_t targetHigh = ((uint64_t*)ptarget)[3];
|
||||
|
||||
int dev_id = device_map[thr_id];
|
||||
int intensity = (device_sm[dev_id] > 500 && !is_windows()) ? 29 : 25;
|
||||
if (device_sm[dev_id] < 350) intensity = 22;
|
||||
|
||||
uint32_t throughput = cuda_default_throughput(thr_id, 1U << intensity);
|
||||
if (init[thr_id]) throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
int rc = 0;
|
||||
|
||||
if (opt_benchmark) {
|
||||
targetHigh = 0x1ULL << 32;
|
||||
ptarget[6] = swab32(0xff);
|
||||
}
|
||||
|
||||
if (!init[thr_id])
|
||||
{
|
||||
cudaSetDevice(dev_id);
|
||||
if (opt_cudaschedule == -1 && gpu_threads == 1) {
|
||||
cudaDeviceReset();
|
||||
// reduce cpu usage (linux)
|
||||
cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);
|
||||
cudaDeviceSetCacheConfig(cudaFuncCachePreferL1);
|
||||
CUDA_LOG_ERROR();
|
||||
}
|
||||
|
||||
CUDA_CALL_OR_RET_X(cudaMalloc(&d_resNonce[thr_id], NBN * sizeof(uint32_t)), -1);
|
||||
CUDA_CALL_OR_RET_X(cudaMallocHost(&h_resNonce[thr_id], NBN * sizeof(uint32_t)), -1);
|
||||
init[thr_id] = true;
|
||||
}
|
||||
|
||||
memcpy(endiandata, pdata, 180);
|
||||
decred_midstate_128(midstate, endiandata);
|
||||
decred_cpu_setBlock_52(&pdata[32], midstate, ptarget);
|
||||
|
||||
do {
|
||||
// GPU HASH
|
||||
uint32_t foundNonce = decred_cpu_hash_nonce(thr_id, throughput, (*pnonce), targetHigh);
|
||||
|
||||
if (foundNonce != UINT32_MAX)
|
||||
{
|
||||
uint32_t vhashcpu[8];
|
||||
uint32_t Htarg = ptarget[6];
|
||||
|
||||
be32enc(&endiandata[DCR_NONCE_OFT32], foundNonce);
|
||||
decred_hash(vhashcpu, endiandata);
|
||||
|
||||
if (vhashcpu[6] <= Htarg && fulltest(vhashcpu, ptarget))
|
||||
{
|
||||
rc = 1;
|
||||
work_set_target_ratio(work, vhashcpu);
|
||||
*hashes_done = (*pnonce) - first_nonce + throughput;
|
||||
work->nonces[0] = swab32(foundNonce);
|
||||
#if NBN > 1
|
||||
if (extra_results[0] != UINT32_MAX) {
|
||||
be32enc(&endiandata[DCR_NONCE_OFT32], extra_results[0]);
|
||||
decred_hash(vhashcpu, endiandata);
|
||||
if (vhashcpu[6] <= Htarg && fulltest(vhashcpu, ptarget)) {
|
||||
work->nonces[1] = swab32(extra_results[0]);
|
||||
if (bn_hash_target_ratio(vhashcpu, ptarget) > work->shareratio) {
|
||||
work_set_target_ratio(work, vhashcpu);
|
||||
xchg(work->nonces[1], work->nonces[0]);
|
||||
}
|
||||
rc = 2;
|
||||
}
|
||||
extra_results[0] = UINT32_MAX;
|
||||
}
|
||||
#endif
|
||||
*pnonce = work->nonces[0];
|
||||
return rc;
|
||||
}
|
||||
else if (opt_debug) {
|
||||
applog_hash(ptarget);
|
||||
applog_compare_hash(vhashcpu, ptarget);
|
||||
gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", foundNonce);
|
||||
}
|
||||
}
|
||||
|
||||
*pnonce += throughput;
|
||||
|
||||
} while (!work_restart[thr_id].restart && max_nonce > (uint64_t)throughput + (*pnonce));
|
||||
|
||||
*hashes_done = (*pnonce) - first_nonce;
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
||||
// cleanup
|
||||
extern "C" void free_decred(int thr_id)
|
||||
{
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
|
||||
cudaFreeHost(h_resNonce[thr_id]);
|
||||
cudaFree(d_resNonce[thr_id]);
|
||||
|
||||
init[thr_id] = false;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
+12
-10
@@ -42,11 +42,11 @@ extern "C" int scanhash_keccak256(int thr_id, struct work* work, uint32_t max_no
|
||||
uint32_t *pdata = work->data;
|
||||
uint32_t *ptarget = work->target;
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1U << 21); // 256*256*8*4
|
||||
throughput = min(throughput, max_nonce - first_nonce);
|
||||
uint32_t throughput = cuda_default_throughput(thr_id, 1U << 21); // 256*256*8*4
|
||||
if (init[thr_id]) throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0x0005;
|
||||
ptarget[7] = 0x000f;
|
||||
|
||||
if (!init[thr_id]) {
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
@@ -68,23 +68,24 @@ extern "C" int scanhash_keccak256(int thr_id, struct work* work, uint32_t max_no
|
||||
*hashes_done = pdata[19] - first_nonce + throughput;
|
||||
|
||||
uint32_t foundNonce = keccak256_cpu_hash_80(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
|
||||
if (foundNonce != UINT32_MAX)
|
||||
if (foundNonce != UINT32_MAX && bench_algo < 0)
|
||||
{
|
||||
uint32_t _ALIGN(64) vhash64[8];
|
||||
be32enc(&endiandata[19], foundNonce);
|
||||
keccak256_hash(vhash64, endiandata);
|
||||
|
||||
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
|
||||
bn_store_hash_target_ratio(vhash64, ptarget, work);
|
||||
work_set_target_ratio(work, vhash64);
|
||||
pdata[19] = foundNonce;
|
||||
return 1;
|
||||
}
|
||||
else {
|
||||
applog(LOG_WARNING, "GPU #%d: result for nounce %08x does not validate on CPU!", device_map[thr_id], foundNonce);
|
||||
gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", foundNonce);
|
||||
}
|
||||
}
|
||||
|
||||
if ((uint64_t) pdata[19] + throughput > max_nonce) {
|
||||
if ((uint64_t) throughput + pdata[19] >= max_nonce) {
|
||||
pdata[19] = max_nonce;
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -92,6 +93,7 @@ extern "C" int scanhash_keccak256(int thr_id, struct work* work, uint32_t max_no
|
||||
|
||||
} while (!work_restart[thr_id].restart);
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -101,12 +103,12 @@ extern "C" void free_keccak256(int thr_id)
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
cudaFree(d_hash[thr_id]);
|
||||
|
||||
keccak256_cpu_free(thr_id);
|
||||
init[thr_id] = false;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
init[thr_id] = false;
|
||||
}
|
||||
@@ -0,0 +1,475 @@
|
||||
/**
|
||||
* Optimized Blake-256 8-rounds Cuda Kernel (Tested on SM >3.0)
|
||||
* Based upon Blake-256 implementation of Tanguy Pruvot - Nov. 2014
|
||||
*
|
||||
* Provos Alexis - Jan. 2016
|
||||
*
|
||||
* Fixed CUDA 7.5 flaw
|
||||
* minor code changes
|
||||
* code cleanup
|
||||
* increased nonces per thread
|
||||
* removed SSE2 midstate computation
|
||||
* Provos Alexis - Mar 2016
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include <memory.h>
|
||||
|
||||
#include "miner.h"
|
||||
|
||||
extern "C" {
|
||||
#include "sph/sph_blake.h"
|
||||
}
|
||||
|
||||
#include "cuda_helper.h"
|
||||
|
||||
#ifdef __INTELLISENSE__
|
||||
#define __byte_perm(x, y, b) x
|
||||
#endif
|
||||
|
||||
/* threads per block and nonces per thread */
|
||||
#define TPB 768
|
||||
#define NPT 384
|
||||
#define NBN 2
|
||||
|
||||
__constant__ uint32_t _ALIGN(16) d_data[21];
|
||||
|
||||
/* 16 gpu threads max */
|
||||
static uint32_t *d_resNonce[MAX_GPUS];
|
||||
static uint32_t *h_resNonce[MAX_GPUS];
|
||||
static cudaStream_t streams[MAX_GPUS];
|
||||
|
||||
/* hash by cpu with blake 256 */
|
||||
extern "C" void vanillahash(void *output, const void *input, int8_t blakerounds){
|
||||
uchar hash[64];
|
||||
sph_blake256_context ctx;
|
||||
|
||||
sph_blake256_set_rounds(blakerounds);
|
||||
|
||||
sph_blake256_init(&ctx);
|
||||
sph_blake256(&ctx, input, 80);
|
||||
sph_blake256_close(&ctx, hash);
|
||||
|
||||
memcpy(output, hash, 32);
|
||||
}
|
||||
#define GS4(a,b,c,d,x,y,a1,b1,c1,d1,x1,y1,a2,b2,c2,d2,x2,y2,a3,b3,c3,d3,x3,y3) { \
|
||||
v[ a]+= (m[ x] ^ z[ y]) + v[ b]; \
|
||||
v[a1]+= (m[x1] ^ z[y1]) + v[b1]; \
|
||||
v[a2]+= (m[x2] ^ z[y2]) + v[b2]; \
|
||||
v[a3]+= (m[x3] ^ z[y3]) + v[b3]; \
|
||||
\
|
||||
v[ d] = __byte_perm(v[ d] ^ v[ a], 0, 0x1032); \
|
||||
v[d1] = __byte_perm(v[d1] ^ v[a1], 0, 0x1032); \
|
||||
v[d2] = __byte_perm(v[d2] ^ v[a2], 0, 0x1032); \
|
||||
v[d3] = __byte_perm(v[d3] ^ v[a3], 0, 0x1032); \
|
||||
\
|
||||
v[ c]+= v[ d]; \
|
||||
v[c1]+= v[d1]; \
|
||||
v[c2]+= v[d2]; \
|
||||
v[c3]+= v[d3]; \
|
||||
\
|
||||
v[ b] = ROTR32(v[ b] ^ v[ c], 12); \
|
||||
v[b1] = ROTR32(v[b1] ^ v[c1], 12); \
|
||||
v[b2] = ROTR32(v[b2] ^ v[c2], 12); \
|
||||
v[b3] = ROTR32(v[b3] ^ v[c3], 12); \
|
||||
\
|
||||
v[ a]+= (m[ y] ^ z[ x]) + v[ b]; \
|
||||
v[a1]+= (m[y1] ^ z[x1]) + v[b1]; \
|
||||
v[a2]+= (m[y2] ^ z[x2]) + v[b2]; \
|
||||
v[a3]+= (m[y3] ^ z[x3]) + v[b3]; \
|
||||
\
|
||||
v[ d] = __byte_perm(v[ d] ^ v[ a], 0, 0x0321); \
|
||||
v[d1] = __byte_perm(v[d1] ^ v[a1], 0, 0x0321); \
|
||||
v[d2] = __byte_perm(v[d2] ^ v[a2], 0, 0x0321); \
|
||||
v[d3] = __byte_perm(v[d3] ^ v[a3], 0, 0x0321); \
|
||||
\
|
||||
v[ c]+= v[ d]; \
|
||||
v[c1]+= v[d1]; \
|
||||
v[c2]+= v[d2]; \
|
||||
v[c3]+= v[d3]; \
|
||||
\
|
||||
v[ b] = ROTR32(v[ b] ^ v[ c], 7); \
|
||||
v[b1] = ROTR32(v[b1] ^ v[c1], 7); \
|
||||
v[b2] = ROTR32(v[b2] ^ v[c2], 7); \
|
||||
v[b3] = ROTR32(v[b3] ^ v[c3], 7); \
|
||||
}
|
||||
|
||||
#define GS3(a,b,c,d,x,y,a1,b1,c1,d1,x1,y1,a2,b2,c2,d2,x2,y2) { \
|
||||
v[ a]+= (m[ x] ^ z[ y]) + v[ b]; \
|
||||
v[a1]+= (m[x1] ^ z[y1]) + v[b1]; \
|
||||
v[a2]+= (m[x2] ^ z[y2]) + v[b2]; \
|
||||
\
|
||||
v[ d] = __byte_perm(v[ d] ^ v[ a], 0, 0x1032); \
|
||||
v[d1] = __byte_perm(v[d1] ^ v[a1], 0, 0x1032); \
|
||||
v[d2] = __byte_perm(v[d2] ^ v[a2], 0, 0x1032); \
|
||||
\
|
||||
v[ c]+= v[ d]; \
|
||||
v[c1]+= v[d1]; \
|
||||
v[c2]+= v[d2]; \
|
||||
\
|
||||
v[ b] = ROTR32(v[ b] ^ v[ c], 12); \
|
||||
v[b1] = ROTR32(v[b1] ^ v[c1], 12); \
|
||||
v[b2] = ROTR32(v[b2] ^ v[c2], 12); \
|
||||
\
|
||||
v[ a]+= (m[ y] ^ z[ x]) + v[ b]; \
|
||||
v[a1]+= (m[y1] ^ z[x1]) + v[b1]; \
|
||||
v[a2]+= (m[y2] ^ z[x2]) + v[b2]; \
|
||||
\
|
||||
v[ d] = __byte_perm(v[ d] ^ v[ a], 0, 0x0321); \
|
||||
v[d1] = __byte_perm(v[d1] ^ v[a1], 0, 0x0321); \
|
||||
v[d2] = __byte_perm(v[d2] ^ v[a2], 0, 0x0321); \
|
||||
\
|
||||
v[ c]+= v[ d]; \
|
||||
v[c1]+= v[d1]; \
|
||||
v[c2]+= v[d2]; \
|
||||
\
|
||||
v[ b] = ROTR32(v[ b] ^ v[ c], 7); \
|
||||
v[b1] = ROTR32(v[b1] ^ v[c1], 7); \
|
||||
v[b2] = ROTR32(v[b2] ^ v[c2], 7); \
|
||||
}
|
||||
|
||||
#define GS2(a,b,c,d,x,y,a1,b1,c1,d1,x1,y1) { \
|
||||
v[ a]+= (m[ x] ^ z[ y]) + v[ b]; \
|
||||
v[a1]+= (m[x1] ^ z[y1]) + v[b1]; \
|
||||
\
|
||||
v[ d] = __byte_perm(v[ d] ^ v[ a], 0, 0x1032); \
|
||||
v[d1] = __byte_perm(v[d1] ^ v[a1], 0, 0x1032); \
|
||||
\
|
||||
v[ c]+= v[ d]; \
|
||||
v[c1]+= v[d1]; \
|
||||
\
|
||||
v[ b] = ROTR32(v[ b] ^ v[ c], 12); \
|
||||
v[b1] = ROTR32(v[b1] ^ v[c1], 12); \
|
||||
\
|
||||
v[ a]+= (m[ y] ^ z[ x]) + v[ b]; \
|
||||
v[a1]+= (m[y1] ^ z[x1]) + v[b1]; \
|
||||
\
|
||||
v[ d] = __byte_perm(v[ d] ^ v[ a], 0, 0x0321); \
|
||||
v[d1] = __byte_perm(v[d1] ^ v[a1], 0, 0x0321); \
|
||||
\
|
||||
v[ c]+= v[ d]; \
|
||||
v[c1]+= v[d1]; \
|
||||
\
|
||||
v[ b] = ROTR32(v[ b] ^ v[ c], 7); \
|
||||
v[b1] = ROTR32(v[b1] ^ v[c1], 7); \
|
||||
}
|
||||
|
||||
#define GS(a,b,c,d,x,y) { \
|
||||
v[a] += (m[x] ^ z[y]) + v[b]; \
|
||||
v[d] = __byte_perm(v[d] ^ v[a],0, 0x1032); \
|
||||
v[c] += v[d]; \
|
||||
v[b] = ROTR32(v[b] ^ v[c], 12); \
|
||||
v[a] += (m[y] ^ z[x]) + v[b]; \
|
||||
v[d] = __byte_perm(v[d] ^ v[a],0, 0x0321); \
|
||||
v[c] += v[d]; \
|
||||
v[b] = ROTR32(v[b] ^ v[c], 7); \
|
||||
}
|
||||
|
||||
__global__ __launch_bounds__(TPB,1)
|
||||
void vanilla_gpu_hash_16_8(const uint32_t threads, const uint32_t startNonce, uint32_t *resNonce,const uint64_t highTarget){
|
||||
uint32_t _ALIGN(16) v[16];
|
||||
uint32_t _ALIGN(16) tmp[16];
|
||||
|
||||
const size_t thread = blockDim.x * blockIdx.x + threadIdx.x;
|
||||
const uint64_t step = gridDim.x * blockDim.x;
|
||||
const uint64_t maxNonce = startNonce + threads;
|
||||
|
||||
const int8_t r[][16] = {
|
||||
{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },{ 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
|
||||
{ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },{ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
|
||||
{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },{ 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
|
||||
{ 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 }
|
||||
};
|
||||
const uint32_t z[16] = {
|
||||
0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344, 0xA4093822, 0x299F31D0, 0x082EFA98, 0xEC4E6C89,
|
||||
0x452821E6, 0x38D01377, 0xBE5466CF, 0x34E90C6C, 0xC0AC29B7, 0xC97C50DD, 0x3F84D5B5, 0xB5470917
|
||||
};
|
||||
|
||||
//PREFETCH
|
||||
#pragma unroll
|
||||
for(int i=0;i<16;i++){
|
||||
tmp[ i] = d_data[ i];
|
||||
}
|
||||
|
||||
uint32_t m[16] = {
|
||||
d_data[16], d_data[17], d_data[18], 0,
|
||||
0x80000000UL, 0, 0, 0,
|
||||
0, 0, 0, 0,
|
||||
0, 1, 0, 640
|
||||
};
|
||||
|
||||
const uint32_t h7 = d_data[19];
|
||||
const uint32_t h6 = d_data[20];
|
||||
//END OF PREFETCH
|
||||
uint64_t m3 = startNonce + thread;
|
||||
loopstart:
|
||||
if(m3>=maxNonce)return;
|
||||
m[3] = m3;
|
||||
|
||||
#pragma unroll
|
||||
for(int i=0;i<16;i++)
|
||||
v[ i] = tmp[ i];
|
||||
|
||||
v[ 1]+= m[3] ^ z[2];
|
||||
v[13] = __byte_perm(v[13] ^ v[1],0, 0x0321);
|
||||
v[ 9]+= v[13];
|
||||
v[ 5] = ROTR32(v[5] ^ v[9], 7);
|
||||
v[ 0]+= v[5];
|
||||
v[15] = __byte_perm(v[15] ^ v[0],0, 0x1032);
|
||||
|
||||
v[10]+= v[15];
|
||||
v[ 5] = ROTR32(v[5] ^ v[10], 12);
|
||||
v[ 0]+= z[8] + v[5];
|
||||
v[15] = __byte_perm(v[15] ^ v[0],0, 0x0321);
|
||||
v[10]+= v[15];
|
||||
v[ 5] = ROTR32(v[5] ^ v[10], 7);
|
||||
|
||||
GS3( 1, 6,11,12,10,11, 2, 7, 8,13,12,13, 3, 4, 9,14,14,15);
|
||||
|
||||
#pragma unroll
|
||||
for(int i=0;i<6;i++){
|
||||
GS4(0, 4, 8,12,r[i][ 0],r[i][ 1], 1, 5, 9,13,r[i][ 2],r[i][ 3], 2, 6,10,14,r[i][ 4],r[i][ 5], 3, 7,11,15,r[i][ 6],r[i][ 7]);
|
||||
GS4(0, 5,10,15,r[i][ 8],r[i][ 9], 1, 6,11,12,r[i][10],r[i][11], 2, 7, 8,13,r[i][12],r[i][13], 3, 4, 9,14,r[i][14],r[i][15]);
|
||||
}
|
||||
GS4(0, 4, 8,12,r[6][ 0],r[6][ 1], 1, 5, 9,13,r[6][ 2],r[6][ 3], 2, 6,10,14,r[6][ 4],r[6][ 5], 3, 7,11,15,r[6][ 6],r[6][ 7]);
|
||||
|
||||
v[ 0] += (m[ 5] ^ z[0]) + v[5];
|
||||
v[ 2] += (m[ 8] ^ z[6]) + v[7];
|
||||
v[13] = __byte_perm(v[13] ^ v[2],0, 0x1032);
|
||||
v[15] = __byte_perm(v[15] ^ v[0],0, 0x1032);
|
||||
|
||||
v[ 8] += v[13];
|
||||
v[10] += v[15];
|
||||
|
||||
v[ 5] = ROTR32(v[ 5] ^ v[10], 12);
|
||||
v[ 7] = ROTR32(v[ 7] ^ v[ 8], 12);
|
||||
|
||||
v[ 0] += (m[ 0] ^ z[5]) + v[5];
|
||||
v[ 2] += (m[ 6] ^ z[8]) + v[7];
|
||||
|
||||
v[15] = __byte_perm(v[15] ^ v[ 0],0, 0x0321);
|
||||
v[13] = __byte_perm(v[13] ^ v[ 2],0, 0x0321);
|
||||
|
||||
v[8] += v[13];
|
||||
v[7] = ROTR32(v[7] ^ v[8], 7);
|
||||
|
||||
// only compute h6 & 7
|
||||
if((v[15]^h7)==v[7]){
|
||||
v[ 1] += (m[15] ^ z[ 4]) + v[6];
|
||||
v[ 3] += (m[2] ^ z[10]) + v[4];
|
||||
v[12] = __byte_perm(v[12] ^ v[ 1],0, 0x1032);
|
||||
v[14] = __byte_perm(v[14] ^ v[3],0, 0x1032);
|
||||
v[11] += v[12];
|
||||
v[ 9] += v[14];
|
||||
v[ 6] = ROTR32(v[ 6] ^ v[11], 12);
|
||||
|
||||
v[ 1] += (m[ 4] ^ z[15]) + v[ 6];
|
||||
v[ 3] += (m[10] ^ z[ 2]) + ROTR32(v[ 4] ^ v[ 9],12);
|
||||
v[12] = __byte_perm(v[12] ^ v[ 1],0, 0x0321);
|
||||
v[14] = __byte_perm(v[14] ^ v[ 3],0, 0x0321);
|
||||
|
||||
v[11] += v[12];
|
||||
v[ 6] = ROTR32(v[ 6] ^ v[11], 7);
|
||||
|
||||
if(cuda_swab32(h6^v[6]^v[14]) <= highTarget) {
|
||||
#if NBN == 2
|
||||
/* keep the smallest nonce, + extra one if found */
|
||||
if (m[3] < resNonce[0]){
|
||||
resNonce[1] = resNonce[0];
|
||||
resNonce[0] = m[3];
|
||||
}
|
||||
else
|
||||
resNonce[1] = m[3];
|
||||
#else
|
||||
resNonce[0] = m[3];
|
||||
#endif
|
||||
return; //<-- this may cause a problem on extranonce if the extranonce is on position current_nonce + X * step where X=[1,2,3..,N]
|
||||
}
|
||||
}
|
||||
m3+=step;
|
||||
goto loopstart;
|
||||
}
|
||||
|
||||
__host__
|
||||
void vanilla_cpu_setBlock_16(const int thr_id,const uint32_t* endiandata, uint32_t *penddata){
|
||||
|
||||
const uint32_t _ALIGN(64) z[16] = {
|
||||
SPH_C32(0x243F6A88), SPH_C32(0x85A308D3), SPH_C32(0x13198A2E), SPH_C32(0x03707344),
|
||||
SPH_C32(0xA4093822), SPH_C32(0x299F31D0), SPH_C32(0x082EFA98), SPH_C32(0xEC4E6C89),
|
||||
SPH_C32(0x452821E6), SPH_C32(0x38D01377), SPH_C32(0xBE5466CF), SPH_C32(0x34E90C6C),
|
||||
SPH_C32(0xC0AC29B7), SPH_C32(0xC97C50DD), SPH_C32(0x3F84D5B5), SPH_C32(0xB5470917)
|
||||
};
|
||||
uint32_t _ALIGN(64) h[22];
|
||||
|
||||
sph_blake256_context ctx;
|
||||
|
||||
sph_blake256_set_rounds(8);
|
||||
|
||||
sph_blake256_init(&ctx);
|
||||
sph_blake256(&ctx, endiandata, 64);
|
||||
|
||||
h[ 0] = ctx.H[0]; h[ 1] = ctx.H[1];
|
||||
h[ 2] = ctx.H[2]; h[21] = ctx.H[3];
|
||||
h[ 4] = ctx.H[4]; h[20] = ctx.H[5];
|
||||
h[19] = ctx.H[6]; h[16] = ctx.H[7];
|
||||
|
||||
uint32_t tmp = h[20];
|
||||
h[20] = h[19];
|
||||
h[19] = h[16];
|
||||
h[16] = penddata[ 0];
|
||||
h[17] = penddata[ 1];
|
||||
h[18] = penddata[ 2];
|
||||
h[12] = z[ 4] ^ 640;
|
||||
h[ 8] = z[ 0];
|
||||
|
||||
h[ 0] += (h[16] ^ z[ 1]) + h[ 4];
|
||||
h[12] = SPH_ROTR32(h[12] ^ h[0],16);
|
||||
h[ 8] += h[12];
|
||||
h[ 4] = SPH_ROTR32(h[ 4] ^ h[ 8], 12);
|
||||
h[ 0] += (h[17] ^ z[ 0]) + h[ 4];
|
||||
h[12] = SPH_ROTR32(h[12] ^ h[0],8);
|
||||
h[ 8] += h[12];
|
||||
h[ 4] = SPH_ROTR32(h[ 4] ^ h[ 8], 7);
|
||||
|
||||
h[1] += (h[18] ^ z[ 3]) + tmp;
|
||||
|
||||
h[13] = SPH_ROTR32(z[ 5] ^ 640 ^ h[1],16);
|
||||
h[ 5] = ROTR32(tmp ^ (z[ 1] + h[13]), 12);
|
||||
|
||||
h[ 1] += h[ 5];
|
||||
h[ 2] += (0x80000000UL ^ z[ 5]) + h[20];
|
||||
|
||||
h[14] = SPH_ROTR32(z[ 6] ^ h[2], 16);
|
||||
h[ 6] = z[ 2] + h[14];
|
||||
h[ 6] = SPH_ROTR32(h[20] ^ h[ 6], 12);
|
||||
|
||||
h[21] += z[ 7] + h[19];
|
||||
h[ 0] += z[ 9];
|
||||
|
||||
h[ 2] += z[ 4] + h[ 6];
|
||||
|
||||
h[ 9] = z[ 1] + h[13];
|
||||
h[10] = z[ 2] + h[14];
|
||||
|
||||
h[14] = SPH_ROTR32(h[14] ^ h[2],8); //0x0321
|
||||
h[10]+=h[14];
|
||||
|
||||
h[ 6] = SPH_ROTR32(h[ 6] ^ h[10],7);
|
||||
h[15] = SPH_ROTR32(z[ 7] ^ h[21],16);
|
||||
|
||||
h[11] = z[ 3] + h[15];
|
||||
h[ 7] = SPH_ROTR32(h[19] ^ h[11], 12);
|
||||
h[ 3] = h[21] + h[ 7] + z[ 6];
|
||||
|
||||
h[15] = SPH_ROTR32(h[15] ^ h[ 3],8);
|
||||
h[11]+= h[15];
|
||||
h[ 7] = ROTR32(h[ 7] ^ h[11],7);
|
||||
|
||||
cudaMemcpyToSymbolAsync(d_data, h, 21*sizeof(uint32_t), 0, cudaMemcpyHostToDevice, streams[thr_id]);
|
||||
}
|
||||
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
|
||||
extern "C" int scanhash_vanilla(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done, const int8_t blakerounds)
|
||||
{
|
||||
uint32_t *pdata = work->data;
|
||||
uint32_t *ptarget = work->target;
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
const uint32_t targetHigh = ptarget[6];
|
||||
int dev_id = device_map[thr_id];
|
||||
|
||||
if (!init[thr_id]) {
|
||||
cudaSetDevice(dev_id);
|
||||
if (opt_cudaschedule == -1 && gpu_threads == 1) {
|
||||
cudaDeviceReset();
|
||||
// reduce cpu usage (linux)
|
||||
cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);
|
||||
cudaDeviceSetCacheConfig(cudaFuncCachePreferL1);
|
||||
CUDA_LOG_ERROR();
|
||||
}
|
||||
CUDA_CALL_OR_RET_X(cudaMalloc(&d_resNonce[thr_id], NBN * sizeof(uint32_t)), -1);
|
||||
CUDA_CALL_OR_RET_X(cudaMallocHost(&h_resNonce[thr_id], NBN * sizeof(uint32_t)), -1);
|
||||
cudaStreamCreate(&streams[thr_id]);
|
||||
init[thr_id] = true;
|
||||
}
|
||||
|
||||
uint32_t _ALIGN(64) endiandata[20];
|
||||
|
||||
for (int k = 0; k < 16; k++)
|
||||
be32enc(&endiandata[k], pdata[k]);
|
||||
|
||||
cudaMemsetAsync(d_resNonce[thr_id], 0xff, sizeof(uint32_t),streams[thr_id]);
|
||||
|
||||
vanilla_cpu_setBlock_16(thr_id,endiandata,&pdata[16]);
|
||||
|
||||
int intensity = (device_sm[dev_id] > 500 && !is_windows()) ? 30 : 24;
|
||||
if (device_sm[dev_id] < 350) intensity = 22;
|
||||
uint32_t throughput = cuda_default_throughput(thr_id, 1U << intensity);
|
||||
if (init[thr_id]) throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
const dim3 grid((throughput + (NPT*TPB)-1)/(NPT*TPB));
|
||||
const dim3 block(TPB);
|
||||
int rc = 0;
|
||||
|
||||
do {
|
||||
vanilla_gpu_hash_16_8<<<grid,block, 0, streams[thr_id]>>>(throughput, pdata[19], d_resNonce[thr_id], targetHigh);
|
||||
cudaMemcpyAsync(h_resNonce[thr_id], d_resNonce[thr_id], NBN*sizeof(uint32_t), cudaMemcpyDeviceToHost,streams[thr_id]);
|
||||
cudaStreamSynchronize(streams[thr_id]);
|
||||
|
||||
if (h_resNonce[thr_id][0] != UINT32_MAX){
|
||||
uint32_t vhashcpu[8];
|
||||
uint32_t Htarg = (uint32_t)targetHigh;
|
||||
|
||||
for (int k=0; k < 19; k++)
|
||||
be32enc(&endiandata[k], pdata[k]);
|
||||
|
||||
be32enc(&endiandata[19], h_resNonce[thr_id][0]);
|
||||
vanillahash(vhashcpu, endiandata, blakerounds);
|
||||
|
||||
if (vhashcpu[6] <= Htarg && fulltest(vhashcpu, ptarget)) {
|
||||
rc = 1;
|
||||
work_set_target_ratio(work, vhashcpu);
|
||||
*hashes_done = pdata[19] - first_nonce + throughput;
|
||||
pdata[19] = h_resNonce[thr_id][0];
|
||||
#if NBN > 1
|
||||
if (h_resNonce[thr_id][1] != UINT32_MAX) {
|
||||
be32enc(&endiandata[19], h_resNonce[thr_id][1]);
|
||||
vanillahash(vhashcpu, endiandata, blakerounds);
|
||||
pdata[21] = h_resNonce[thr_id][1];
|
||||
if (bn_hash_target_ratio(vhashcpu, ptarget) > work->shareratio) {
|
||||
work_set_target_ratio(work, vhashcpu);
|
||||
xchg(pdata[19], pdata[21]);
|
||||
}
|
||||
rc = 2;
|
||||
}
|
||||
#endif
|
||||
return rc;
|
||||
}
|
||||
else {
|
||||
gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", h_resNonce[thr_id][0]);
|
||||
}
|
||||
}
|
||||
|
||||
pdata[19] += throughput;
|
||||
} while (!work_restart[thr_id].restart && ((uint64_t)max_nonce > ((uint64_t)(pdata[19]) + (uint64_t)throughput)));
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
MyStreamSynchronize(NULL, 0, dev_id);
|
||||
return rc;
|
||||
}
|
||||
|
||||
// cleanup
|
||||
extern "C" void free_vanilla(int thr_id)
|
||||
{
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaThreadSynchronize();
|
||||
|
||||
cudaFreeHost(h_resNonce[thr_id]);
|
||||
cudaFree(d_resNonce[thr_id]);
|
||||
|
||||
init[thr_id] = false;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
@@ -33,8 +33,9 @@ __device__ cuda_compactTestFunction_t d_JackpotTrueFunction = JackpotTrueTest, d
|
||||
|
||||
cuda_compactTestFunction_t h_JackpotTrueFunction[MAX_GPUS], h_JackpotFalseFunction[MAX_GPUS];
|
||||
|
||||
// Setup-Funktionen
|
||||
__host__ void jackpot_compactTest_cpu_init(int thr_id, uint32_t threads)
|
||||
// Setup-Function
|
||||
__host__
|
||||
void jackpot_compactTest_cpu_init(int thr_id, uint32_t threads)
|
||||
{
|
||||
cudaMemcpyFromSymbol(&h_JackpotTrueFunction[thr_id], d_JackpotTrueFunction, sizeof(cuda_compactTestFunction_t));
|
||||
cudaMemcpyFromSymbol(&h_JackpotFalseFunction[thr_id], d_JackpotFalseFunction, sizeof(cuda_compactTestFunction_t));
|
||||
@@ -51,6 +52,18 @@ __host__ void jackpot_compactTest_cpu_init(int thr_id, uint32_t threads)
|
||||
cudaMalloc(&d_partSum[1][thr_id], sizeof(uint32_t) * s1); // BLOCKSIZE (Threads/Block)
|
||||
}
|
||||
|
||||
__host__
|
||||
void jackpot_compactTest_cpu_free(int thr_id)
|
||||
{
|
||||
cudaFree(d_tempBranch1Nonces[thr_id]);
|
||||
cudaFree(d_numValid[thr_id]);
|
||||
|
||||
cudaFree(d_partSum[0][thr_id]);
|
||||
cudaFree(d_partSum[1][thr_id]);
|
||||
|
||||
cudaFreeHost(h_numValid[thr_id]);
|
||||
}
|
||||
|
||||
#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ < 300
|
||||
/**
|
||||
* __shfl_up() calculates a source lane ID by subtracting delta from the caller's lane ID, and clamping to the range 0..width-1
|
||||
|
||||
+94
-80
@@ -9,80 +9,70 @@ extern "C"
|
||||
|
||||
#include "miner.h"
|
||||
#include "cuda_helper.h"
|
||||
#include "quark/cuda_quark.h"
|
||||
|
||||
static uint32_t *d_hash[MAX_GPUS];
|
||||
static uint32_t *d_hash[MAX_GPUS] = { 0 };
|
||||
|
||||
// Speicher zur Generierung der Noncevektoren für die bedingten Hashes
|
||||
static uint32_t *d_jackpotNonces[MAX_GPUS] = { 0 };
|
||||
static uint32_t *d_branch1Nonces[MAX_GPUS] = { 0 };
|
||||
static uint32_t *d_branch2Nonces[MAX_GPUS] = { 0 };
|
||||
static uint32_t *d_branch3Nonces[MAX_GPUS] = { 0 };
|
||||
|
||||
extern void jackpot_keccak512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void jackpot_keccak512_cpu_setBlock(void *pdata, size_t inlen);
|
||||
extern void jackpot_keccak512_cpu_hash(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_hash, int order);
|
||||
|
||||
extern void quark_blake512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_blake512_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_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 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 jackpot_compactTest_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void jackpot_compactTest_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *inpHashes, uint32_t *d_validNonceTable,
|
||||
uint32_t *d_nonces1, uint32_t *nrm1,
|
||||
uint32_t *d_nonces2, uint32_t *nrm2,
|
||||
int order);
|
||||
extern void jackpot_compactTest_cpu_free(int thr_id);
|
||||
extern void jackpot_compactTest_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *inpHashes, uint32_t *d_validNonceTable,
|
||||
uint32_t *d_nonces1, uint32_t *nrm1, uint32_t *d_nonces2, uint32_t *nrm2, int order);
|
||||
|
||||
extern uint32_t cuda_check_hash_branch(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_inputHash, int order);
|
||||
|
||||
// Speicher zur Generierung der Noncevektoren für die bedingten Hashes
|
||||
static uint32_t *d_jackpotNonces[MAX_GPUS];
|
||||
static uint32_t *d_branch1Nonces[MAX_GPUS];
|
||||
static uint32_t *d_branch2Nonces[MAX_GPUS];
|
||||
static uint32_t *d_branch3Nonces[MAX_GPUS];
|
||||
|
||||
// Original jackpothash Funktion aus einem miner Quelltext
|
||||
extern "C" unsigned int jackpothash(void *state, const void *input)
|
||||
{
|
||||
sph_blake512_context ctx_blake;
|
||||
sph_groestl512_context ctx_groestl;
|
||||
sph_jh512_context ctx_jh;
|
||||
sph_keccak512_context ctx_keccak;
|
||||
sph_skein512_context ctx_skein;
|
||||
uint32_t hash[16];
|
||||
unsigned int rnd;
|
||||
|
||||
uint32_t hash[16];
|
||||
sph_blake512_context ctx_blake;
|
||||
sph_groestl512_context ctx_groestl;
|
||||
sph_jh512_context ctx_jh;
|
||||
sph_keccak512_context ctx_keccak;
|
||||
sph_skein512_context ctx_skein;
|
||||
|
||||
sph_keccak512_init(&ctx_keccak);
|
||||
sph_keccak512 (&ctx_keccak, input, 80);
|
||||
sph_keccak512_close(&ctx_keccak, hash);
|
||||
sph_keccak512_init(&ctx_keccak);
|
||||
sph_keccak512 (&ctx_keccak, input, 80);
|
||||
sph_keccak512_close(&ctx_keccak, hash);
|
||||
|
||||
unsigned int round;
|
||||
for (round = 0; round < 3; round++) {
|
||||
if (hash[0] & 0x01) {
|
||||
sph_groestl512_init(&ctx_groestl);
|
||||
sph_groestl512 (&ctx_groestl, (&hash), 64);
|
||||
sph_groestl512_close(&ctx_groestl, (&hash));
|
||||
}
|
||||
else {
|
||||
sph_skein512_init(&ctx_skein);
|
||||
sph_skein512 (&ctx_skein, (&hash), 64);
|
||||
sph_skein512_close(&ctx_skein, (&hash));
|
||||
}
|
||||
if (hash[0] & 0x01) {
|
||||
sph_blake512_init(&ctx_blake);
|
||||
sph_blake512 (&ctx_blake, (&hash), 64);
|
||||
sph_blake512_close(&ctx_blake, (&hash));
|
||||
}
|
||||
else {
|
||||
sph_jh512_init(&ctx_jh);
|
||||
sph_jh512 (&ctx_jh, (&hash), 64);
|
||||
sph_jh512_close(&ctx_jh, (&hash));
|
||||
}
|
||||
}
|
||||
memcpy(state, hash, 32);
|
||||
for (rnd = 0; rnd < 3; rnd++)
|
||||
{
|
||||
if (hash[0] & 0x01) {
|
||||
sph_groestl512_init(&ctx_groestl);
|
||||
sph_groestl512 (&ctx_groestl, (&hash), 64);
|
||||
sph_groestl512_close(&ctx_groestl, (&hash));
|
||||
}
|
||||
else {
|
||||
sph_skein512_init(&ctx_skein);
|
||||
sph_skein512 (&ctx_skein, (&hash), 64);
|
||||
sph_skein512_close(&ctx_skein, (&hash));
|
||||
}
|
||||
|
||||
return round;
|
||||
if (hash[0] & 0x01) {
|
||||
sph_blake512_init(&ctx_blake);
|
||||
sph_blake512 (&ctx_blake, (&hash), 64);
|
||||
sph_blake512_close(&ctx_blake, (&hash));
|
||||
}
|
||||
else {
|
||||
sph_jh512_init(&ctx_jh);
|
||||
sph_jh512 (&ctx_jh, (&hash), 64);
|
||||
sph_jh512_close(&ctx_jh, (&hash));
|
||||
}
|
||||
}
|
||||
memcpy(state, hash, 32);
|
||||
|
||||
return rnd;
|
||||
}
|
||||
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
@@ -93,18 +83,30 @@ extern "C" int scanhash_jackpot(int thr_id, struct work *work, uint32_t max_nonc
|
||||
uint32_t *pdata = work->data;
|
||||
uint32_t *ptarget = work->target;
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
int dev_id = device_map[thr_id];
|
||||
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1U << 20);
|
||||
throughput = min(throughput, max_nonce - first_nonce);
|
||||
uint32_t throughput = cuda_default_throughput(thr_id, 1U << 20);
|
||||
if (init[thr_id]) throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0x000f;
|
||||
ptarget[7] = 0x000f;
|
||||
|
||||
if (!init[thr_id])
|
||||
{
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaSetDevice(dev_id);
|
||||
if (opt_cudaschedule == -1 && gpu_threads == 1) {
|
||||
cudaDeviceReset();
|
||||
// reduce cpu usage
|
||||
cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);
|
||||
CUDA_LOG_ERROR();
|
||||
}
|
||||
cuda_get_arch(thr_id);
|
||||
if (device_sm[dev_id] < 300 || cuda_arch[dev_id] < 300) {
|
||||
gpulog(LOG_ERR, thr_id, "Sorry, This algo is not supported by this GPU arch (SM 3.0 required)");
|
||||
proper_exit(EXIT_CODE_CUDA_ERROR);
|
||||
}
|
||||
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hash[thr_id], 16 * sizeof(uint32_t) * throughput));
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hash[thr_id], (size_t) 64 * throughput));
|
||||
|
||||
jackpot_keccak512_cpu_init(thr_id, throughput);
|
||||
jackpot_compactTest_cpu_init(thr_id, throughput);
|
||||
@@ -115,11 +117,11 @@ extern "C" int scanhash_jackpot(int thr_id, struct work *work, uint32_t max_nonc
|
||||
|
||||
cuda_check_cpu_init(thr_id, throughput);
|
||||
|
||||
cudaMalloc(&d_branch1Nonces[thr_id], sizeof(uint32_t)*throughput*2);
|
||||
cudaMalloc(&d_branch2Nonces[thr_id], sizeof(uint32_t)*throughput*2);
|
||||
cudaMalloc(&d_branch3Nonces[thr_id], sizeof(uint32_t)*throughput*2);
|
||||
cudaMalloc(&d_branch1Nonces[thr_id], (size_t) sizeof(uint32_t)*throughput*2);
|
||||
cudaMalloc(&d_branch2Nonces[thr_id], (size_t) sizeof(uint32_t)*throughput*2);
|
||||
cudaMalloc(&d_branch3Nonces[thr_id], (size_t) sizeof(uint32_t)*throughput*2);
|
||||
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_jackpotNonces[thr_id], sizeof(uint32_t)*throughput*2));
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_jackpotNonces[thr_id], (size_t) sizeof(uint32_t)*throughput*2));
|
||||
|
||||
init[thr_id] = true;
|
||||
}
|
||||
@@ -209,37 +211,40 @@ extern "C" int scanhash_jackpot(int thr_id, struct work *work, uint32_t max_nonc
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce + throughput;
|
||||
|
||||
CUDA_LOG_ERROR();
|
||||
|
||||
uint32_t foundNonce = cuda_check_hash_branch(thr_id, nrm3, pdata[19], d_branch3Nonces[thr_id], d_hash[thr_id], order++);
|
||||
if (foundNonce != 0xffffffff)
|
||||
|
||||
if (foundNonce != UINT32_MAX)
|
||||
{
|
||||
uint32_t vhash64[8];
|
||||
be32enc(&endiandata[19], foundNonce);
|
||||
|
||||
// diese jackpothash Funktion gibt die Zahl der Runden zurück
|
||||
// jackpothash function gibt die Zahl der Runden zurück
|
||||
jackpothash(vhash64, endiandata);
|
||||
|
||||
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
|
||||
int res = 1;
|
||||
work_set_target_ratio(work, vhash64);
|
||||
#if 0
|
||||
uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1);
|
||||
bn_store_hash_target_ratio(vhash64, ptarget, work);
|
||||
if (secNonce != 0) {
|
||||
be32enc(&endiandata[19], secNonce);
|
||||
nist5hash(vhash64, endiandata);
|
||||
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio)
|
||||
bn_store_hash_target_ratio(vhash64, ptarget, work);
|
||||
work_set_target_ratio(work, vhash64);
|
||||
pdata[21] = secNonce;
|
||||
res++;
|
||||
}
|
||||
#endif
|
||||
pdata[19] = foundNonce;
|
||||
return res;
|
||||
} else {
|
||||
applog(LOG_WARNING, "GPU #%d: result for nonce %08x does not validate on CPU!",
|
||||
device_map[thr_id], foundNonce);
|
||||
gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", foundNonce);
|
||||
}
|
||||
}
|
||||
|
||||
if ((uint64_t) pdata[19] + throughput > max_nonce) {
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
if ((uint64_t) throughput + pdata[19] >= max_nonce) {
|
||||
pdata[19] = max_nonce;
|
||||
break;
|
||||
}
|
||||
@@ -248,6 +253,10 @@ extern "C" int scanhash_jackpot(int thr_id, struct work *work, uint32_t max_nonc
|
||||
|
||||
} while (!work_restart[thr_id].restart);
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
|
||||
CUDA_LOG_ERROR();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -257,18 +266,23 @@ extern "C" void free_jackpot(int thr_id)
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
|
||||
cudaFree(d_hash[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
cudaFree(d_branch1Nonces[thr_id]);
|
||||
cudaFree(d_branch2Nonces[thr_id]);
|
||||
cudaFree(d_branch3Nonces[thr_id]);
|
||||
|
||||
cudaFree(d_jackpotNonces[thr_id]);
|
||||
|
||||
quark_blake512_cpu_free(thr_id);
|
||||
quark_groestl512_cpu_free(thr_id);
|
||||
jackpot_compactTest_cpu_free(thr_id);
|
||||
|
||||
cudaFree(d_hash[thr_id]);
|
||||
|
||||
cuda_check_cpu_free(thr_id);
|
||||
init[thr_id] = false;
|
||||
CUDA_LOG_ERROR();
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
|
||||
init[thr_id] = false;
|
||||
}
|
||||
+14
-14
@@ -19,7 +19,7 @@ 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 pools.cpp util.cpp bench.cpp bignum.cpp \
|
||||
api.cpp hashlog.cpp nvml.cpp stats.cpp sysinfos.cpp cuda.cpp \
|
||||
heavy/heavy.cu \
|
||||
heavy/cuda_blake512.cu heavy/cuda_blake512.h \
|
||||
@@ -33,10 +33,11 @@ ccminer_SOURCES = elist.h miner.h compat.h \
|
||||
myriadgroestl.cpp cuda_myriadgroestl.cu \
|
||||
lyra2/Lyra2.c lyra2/Sponge.c \
|
||||
lyra2/lyra2RE.cu lyra2/cuda_lyra2.cu \
|
||||
lyra2/lyra2REv2.cu lyra2/cuda_lyra2v2.cu \
|
||||
lyra2/lyra2REv2.cu lyra2/cuda_lyra2v2.cu \
|
||||
Algo256/cuda_bmw256.cu Algo256/cuda_cubehash256.cu \
|
||||
Algo256/cuda_blake256.cu Algo256/cuda_groestl256.cu Algo256/cuda_keccak256.cu Algo256/cuda_skein256.cu \
|
||||
Algo256/blake256.cu Algo256/keccak256.cu \
|
||||
Algo256/blake256.cu Algo256/decred.cu Algo256/vanilla.cu Algo256/keccak256.cu \
|
||||
Algo256/blake2s.cu sph/blake2s.c \
|
||||
Algo256/bmw.cu Algo256/cuda_bmw.cu \
|
||||
JHA/jackpotcoin.cu JHA/cuda_jha_keccak512.cu \
|
||||
JHA/cuda_jha_compactionTest.cu cuda_checkhash.cu \
|
||||
@@ -47,7 +48,7 @@ ccminer_SOURCES = elist.h miner.h compat.h \
|
||||
cuda_nist5.cu pentablake.cu skein.cu cuda_skeincoin.cu skein2.cpp zr5.cu \
|
||||
sph/bmw.c sph/blake.c sph/groestl.c sph/jh.c sph/keccak.c sph/skein.c \
|
||||
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/hamsi.c sph/hamsi_helper.c sph/streebog.c \
|
||||
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 \
|
||||
x11/x11.cu x11/fresh.cu x11/cuda_x11_luffa512.cu x11/cuda_x11_cubehash512.cu \
|
||||
@@ -55,10 +56,9 @@ ccminer_SOURCES = elist.h miner.h compat.h \
|
||||
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 \
|
||||
spreadx11/spreadx11.cu spreadx11/cuda_blake.cu spreadx11/cuda_spreadx11_sign.cu spreadx11/cuda_sha256.cu
|
||||
x15/whirlpool.cu \
|
||||
x17/x17.cu x17/cuda_x17_haval256.cu x17/cuda_x17_sha512.cu \
|
||||
x11/c11.cu x11/s3.cu x11/sib.cu x11/cuda_streebog.cu
|
||||
|
||||
# scrypt
|
||||
ccminer_SOURCES += scrypt.cpp scrypt-jane.cpp \
|
||||
@@ -77,12 +77,12 @@ 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)
|
||||
|
||||
nvcc_ARCH = -gencode=arch=compute_50,code=\"sm_50,compute_50\"
|
||||
|
||||
#nvcc_ARCH += -gencode=arch=compute_52,code=\"sm_52,compute_52\"
|
||||
nvcc_ARCH += -gencode=arch=compute_52,code=\"sm_52,compute_52\"
|
||||
#nvcc_ARCH += -gencode=arch=compute_35,code=\"sm_35,compute_35\"
|
||||
#nvcc_ARCH += -gencode=arch=compute_30,code=\"sm_30,compute_30\"
|
||||
#nvcc_ARCH += -gencode=arch=compute_20,code=\"sm_21,compute_20\"
|
||||
@@ -113,6 +113,9 @@ x11/cuda_x11_luffa512.o: x11/cuda_x11_luffa512.cu
|
||||
x11/cuda_x11_luffa512_Cubehash.o: x11/cuda_x11_luffa512_Cubehash.cu
|
||||
$(NVCC) $(nvcc_FLAGS) --maxrregcount=76 -o $@ -c $<
|
||||
|
||||
x11/cuda_x11_simd512.o: x11/cuda_x11_simd512.cu
|
||||
$(NVCC) $(nvcc_FLAGS) -Xcompiler -Wno-unused-variable -o $@ -c $<
|
||||
|
||||
x13/cuda_x13_hamsi512.o: x13/cuda_x13_hamsi512.cu
|
||||
$(NVCC) $(nvcc_FLAGS) --maxrregcount=72 -o $@ -c $<
|
||||
|
||||
@@ -155,6 +158,3 @@ scrypt/titan_kernel.o: scrypt/titan_kernel.cu
|
||||
skein.o: skein.cu
|
||||
$(NVCC) $(nvcc_FLAGS) --maxrregcount=64 -o $@ -c $<
|
||||
|
||||
skein2.o: skein2.cu
|
||||
$(NVCC) $(nvcc_FLAGS) --maxrregcount=64 -o $@ -c $<
|
||||
|
||||
@@ -8,12 +8,14 @@ Fork by tpruvot@github with X14,X15,X17,Blake256,BlakeCoin,Lyra2RE,Skein,ZR5 and
|
||||
BTC donation address: 1AJdfCpLWPNoAMDfHF1wD5y8VgKSSTHxPo
|
||||
[](https://tip4commit.com/github/tpruvot/ccminer)
|
||||
|
||||
A part of the recent algos were originally wrote by [djm34](https://github.com/djm34).
|
||||
A part of the recent algos were originally written by [djm34](https://github.com/djm34).
|
||||
|
||||
This variant was tested and built on Linux (ubuntu server 14.04) and VStudio 2013 on Windows 7.
|
||||
|
||||
Note that the x86 releases are generally faster than x64 ones on Windows.
|
||||
|
||||
The recommended CUDA Toolkit version is [6.5.19](http://developer.download.nvidia.com/compute/cuda/6_5/rel/installers/cuda_6.5.19_windows_general_64.exe), but some light algos could be faster with the version 7.5 (like blake and skein).
|
||||
|
||||
About source code dependencies
|
||||
------------------------------
|
||||
|
||||
|
||||
+48
-4
@@ -1,5 +1,5 @@
|
||||
|
||||
ccMiner release 1.6.6 (Aug 2015) "Lyra2REv2, BMW And Vanilla"
|
||||
ccMiner release 1.7.6 (May 2016) "DCR vote & pool device stats"
|
||||
---------------------------------------------------------------
|
||||
|
||||
***************************************************************
|
||||
@@ -24,6 +24,7 @@ cbuchner v1.2:
|
||||
|
||||
This is a CUDA accelerated mining application which handle :
|
||||
|
||||
Decred (Blake256 14-rounds - 180 bytes)
|
||||
HeavyCoin & MjollnirCoin
|
||||
FugueCoin
|
||||
GroestlCoin & Myriad-Groestl
|
||||
@@ -43,8 +44,10 @@ Pentablake (Blake 512 x5)
|
||||
Neoscrypt (FeatherCoin)
|
||||
Scrypt and Scrypt:N
|
||||
Scrypt-Jane (Chacha)
|
||||
Sibcoin (sib)
|
||||
Skein (Skein + SHA)
|
||||
Woodcoin (Double Skein)
|
||||
Vanilla (Blake256 8-rounds - double sha256)
|
||||
Vertcoin Lyra2RE
|
||||
Ziftrcoin (ZR5)
|
||||
|
||||
@@ -65,10 +68,12 @@ This code is based on the pooler cpuminer and inherits
|
||||
its command line interface and options.
|
||||
|
||||
-a, --algo=ALGO specify the algorithm to use
|
||||
blake use to mine Saffroncoin (Blake 256)
|
||||
blake use to mine Saffroncoin (Blake256)
|
||||
blakecoin use to mine Old Blake 256
|
||||
blake2s use to mine Nevacoin (Blake2-S 256)
|
||||
bmw use to mine Midnight
|
||||
c11/flax use to mine Chaincoin and Flax
|
||||
decred use to mine Decred 180 bytes Blake256-14
|
||||
deep use to mine Deepcoin
|
||||
dmd-gr use to mine Diamond-Groestl
|
||||
fresh use to mine Freshcoin
|
||||
@@ -90,13 +95,16 @@ its command line interface and options.
|
||||
scrypt:N use to mine Scrypt-N (:10 for 2048 iterations)
|
||||
scrypt-jane use to mine Chacha coins like Cache and Ultracoin
|
||||
s3 use to mine 1coin
|
||||
sib use to mine Sibcoin
|
||||
skein use to mine Skeincoin
|
||||
skein2 use to mine Woodcoin
|
||||
x11 use to mine DarkCoin
|
||||
x14 use to mine X14Coin
|
||||
x15 use to mine Halcyon
|
||||
x17 use to mine X17
|
||||
whirlpoolx use to mine Vanilla
|
||||
x17 use to mine X17
|
||||
vanilla use to mine Vanilla (Blake256)
|
||||
whirlpool use to mine Joincoin
|
||||
zr5 use to mine ZiftrCoin
|
||||
|
||||
-d, --devices gives a comma separated list of CUDA device IDs
|
||||
@@ -121,6 +129,7 @@ its command line interface and options.
|
||||
-r, --retries=N number of times to retry if a network call fails
|
||||
(default: retry indefinitely)
|
||||
-R, --retry-pause=N time to pause between retries, in seconds (default: 15)
|
||||
--shares-limit maximum shares to mine before exiting the program.
|
||||
--time-limit maximum time [s] to mine before exiting the program.
|
||||
-T, --timeout=N network timeout, in seconds (default: 300)
|
||||
-s, --scantime=N upper bound on time spent scanning current work when
|
||||
@@ -163,6 +172,9 @@ Scrypt specific options:
|
||||
-L, --lookup-gap Divides the per-hash memory requirement by this factor
|
||||
by storing only every N'th value in the scratchpad.
|
||||
Default is 1.
|
||||
--texture-cache comma separated list of flags (0/1/2) specifying
|
||||
which of the CUDA devices shall use the texture
|
||||
cache for mining. Kepler devices may profit.
|
||||
--no-autotune disable auto-tuning of kernel launch parameters
|
||||
|
||||
|
||||
@@ -227,7 +239,39 @@ features.
|
||||
|
||||
>>> RELEASE HISTORY <<<
|
||||
|
||||
Under Dev... v1.7
|
||||
May 18th 2016 v1.7.6
|
||||
Decred vote support
|
||||
X17 cleanup and improvement
|
||||
Add mining.ping stratum method and handle unknown methods
|
||||
Implement a pool stats/benchmark mode (-p stats on yiimp)
|
||||
Add --shares-limit parameter, can be used for benchmarks
|
||||
|
||||
Mar. 13th 2016 v1.7.5
|
||||
Blake2S Algo (NEVA/OXEN)
|
||||
|
||||
Feb. 28th 2016 v1.7.4 (1.7.3 was a preview, not official)
|
||||
Decred simplified stratum (getwork over stratum)
|
||||
Vanilla kernel by MrMad
|
||||
Drop/Disable WhirlpoolX
|
||||
|
||||
Feb. 11th 2016 v1.7.2
|
||||
Decred Algo (longpoll only)
|
||||
Blake256 improvements/cleanup
|
||||
|
||||
Jan. 26th 2016 v1.7.1
|
||||
Implement sib algo (X11 + Russian Streebog-512/GOST)
|
||||
Whirlpool speed x2 with the midstate precompute
|
||||
Small bug fixes about device ids mapping (and vendor names)
|
||||
Add Vanilla algo (Blake256 8-rounds - double sha256)
|
||||
|
||||
Nov. 06th 2015 v1.7
|
||||
Improve old devices compatibility (x11, lyra2v2, quark, qubit...)
|
||||
Add windows support for SM 2.1 and drop SM 3.5 (x86)
|
||||
Improve lyra2 (v1/v2) cuda implementations
|
||||
Improve most common algos on SM5+ with sp blake kernel
|
||||
Restore whirlpool algo (and whirlcoin variant)
|
||||
Prepare algo/pool switch ability, trivial method
|
||||
Add --benchmark alone to run a benchmark for all algos
|
||||
Add --cuda-schedule parameter
|
||||
Add --show-diff parameter, which display shares diff,
|
||||
and is able to detect real solved blocks on pools.
|
||||
|
||||
@@ -0,0 +1,135 @@
|
||||
#ifndef ALGOS_H
|
||||
#define ALGOS_H
|
||||
|
||||
#include <string.h>
|
||||
#include "compat.h"
|
||||
|
||||
enum sha_algos {
|
||||
ALGO_BLAKECOIN = 0,
|
||||
ALGO_BLAKE,
|
||||
ALGO_BLAKE2S,
|
||||
ALGO_BMW,
|
||||
ALGO_C11,
|
||||
ALGO_DEEP,
|
||||
ALGO_DECRED,
|
||||
ALGO_DMD_GR,
|
||||
ALGO_FRESH,
|
||||
ALGO_FUGUE256, /* Fugue256 */
|
||||
ALGO_GROESTL,
|
||||
ALGO_HEAVY, /* Heavycoin hash */
|
||||
ALGO_KECCAK,
|
||||
ALGO_JACKPOT,
|
||||
ALGO_LUFFA,
|
||||
ALGO_LYRA2,
|
||||
ALGO_LYRA2v2,
|
||||
ALGO_MJOLLNIR, /* Hefty hash */
|
||||
ALGO_MYR_GR,
|
||||
ALGO_NEOSCRYPT,
|
||||
ALGO_NIST5,
|
||||
ALGO_PENTABLAKE,
|
||||
ALGO_QUARK,
|
||||
ALGO_QUBIT,
|
||||
ALGO_SCRYPT,
|
||||
ALGO_SCRYPT_JANE,
|
||||
ALGO_SIB,
|
||||
ALGO_SKEIN,
|
||||
ALGO_SKEIN2,
|
||||
ALGO_S3,
|
||||
ALGO_X11,
|
||||
ALGO_X13,
|
||||
ALGO_X14,
|
||||
ALGO_X15,
|
||||
ALGO_X17,
|
||||
ALGO_VANILLA,
|
||||
ALGO_WHIRLCOIN,
|
||||
ALGO_WHIRLPOOL,
|
||||
ALGO_WHIRLPOOLX,
|
||||
ALGO_ZR5,
|
||||
ALGO_AUTO,
|
||||
ALGO_COUNT
|
||||
};
|
||||
|
||||
extern volatile enum sha_algos opt_algo;
|
||||
|
||||
static const char *algo_names[] = {
|
||||
"blakecoin",
|
||||
"blake",
|
||||
"blake2s",
|
||||
"bmw",
|
||||
"c11",
|
||||
"deep",
|
||||
"decred",
|
||||
"dmd-gr",
|
||||
"fresh",
|
||||
"fugue256",
|
||||
"groestl",
|
||||
"heavy",
|
||||
"keccak",
|
||||
"jackpot",
|
||||
"luffa",
|
||||
"lyra2",
|
||||
"lyra2v2",
|
||||
"mjollnir",
|
||||
"myr-gr",
|
||||
"neoscrypt",
|
||||
"nist5",
|
||||
"penta",
|
||||
"quark",
|
||||
"qubit",
|
||||
"scrypt",
|
||||
"scrypt-jane",
|
||||
"sib",
|
||||
"skein",
|
||||
"skein2",
|
||||
"s3",
|
||||
"x11",
|
||||
"x13",
|
||||
"x14",
|
||||
"x15",
|
||||
"x17",
|
||||
"vanilla",
|
||||
"whirlcoin",
|
||||
"whirlpool",
|
||||
"whirlpoolx",
|
||||
"zr5",
|
||||
"auto", /* reserved for multi algo */
|
||||
""
|
||||
};
|
||||
|
||||
// string to int/enum
|
||||
static inline int algo_to_int(char* arg)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < ALGO_COUNT; i++) {
|
||||
if (algo_names[i] && !strcasecmp(arg, algo_names[i])) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
if (i == ALGO_COUNT) {
|
||||
// some aliases...
|
||||
if (!strcasecmp("all", arg))
|
||||
i = ALGO_AUTO;
|
||||
else if (!strcasecmp("flax", arg))
|
||||
i = ALGO_C11;
|
||||
else if (!strcasecmp("diamond", arg))
|
||||
i = ALGO_DMD_GR;
|
||||
else if (!strcasecmp("doom", arg))
|
||||
i = ALGO_LUFFA;
|
||||
else if (!strcasecmp("lyra2re", arg))
|
||||
i = ALGO_LYRA2;
|
||||
else if (!strcasecmp("lyra2rev2", arg))
|
||||
i = ALGO_LYRA2v2;
|
||||
else if (!strcasecmp("whirl", arg))
|
||||
i = ALGO_WHIRLPOOL;
|
||||
else if (!strcasecmp("ziftr", arg))
|
||||
i = ALGO_ZR5;
|
||||
else
|
||||
i = -1;
|
||||
}
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -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.8"
|
||||
|
||||
#ifdef WIN32
|
||||
# define _WINSOCK_DEPRECATED_NO_WARNINGS
|
||||
@@ -33,6 +33,7 @@
|
||||
|
||||
#include "miner.h"
|
||||
#include "nvml.h"
|
||||
#include "algos.h"
|
||||
|
||||
#ifndef WIN32
|
||||
# include <errno.h>
|
||||
@@ -100,9 +101,6 @@ extern struct stratum_ctx stratum;
|
||||
extern int num_cpus;
|
||||
extern float cpu_temp(int);
|
||||
extern uint32_t cpu_clock(int);
|
||||
// cuda.cpp
|
||||
int cuda_num_devices();
|
||||
int cuda_gpu_clocks(struct cgpu_info *gpu);
|
||||
|
||||
char driver_version[32] = { 0 };
|
||||
|
||||
@@ -124,7 +122,7 @@ 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);
|
||||
cgpu->gpu_power = gpu_power(cgpu); // mWatts
|
||||
#endif
|
||||
cuda_gpu_clocks(cgpu);
|
||||
|
||||
@@ -166,14 +164,16 @@ static char *getthreads(char *params)
|
||||
*/
|
||||
static char *getsummary(char *params)
|
||||
{
|
||||
char algo[64]; *algo = '\0';
|
||||
char algo[64] = { 0 };
|
||||
time_t ts = time(NULL);
|
||||
double accps, uptime = difftime(ts, startup);
|
||||
uint32_t wait_time = 0, accepted_count = 0, rejected_count = 0;
|
||||
uint32_t wait_time = 0, solved_count = 0;
|
||||
uint32_t 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;
|
||||
solved_count += pools[p].solved_count;
|
||||
}
|
||||
accps = (60.0 * accepted_count) / (uptime ? uptime : 1.0);
|
||||
|
||||
@@ -181,12 +181,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;"
|
||||
"ALGO=%s;GPUS=%d;KHS=%.2f;SOLV=%d;ACC=%d;REJ=%d;"
|
||||
"ACCMN=%.3f;DIFF=%.6f;NETKHS=%.0f;"
|
||||
"POOLS=%u;WAIT=%u;UPTIME=%.0f;TS=%u|",
|
||||
PACKAGE_NAME, PACKAGE_VERSION, APIVERSION,
|
||||
algo, active_gpus, (double)global_hashrate / 1000.,
|
||||
accepted_count, rejected_count,
|
||||
solved_count, accepted_count, rejected_count,
|
||||
accps, net_diff > 1e-6 ? net_diff : stratum_diff, (double)net_hashrate / 1000.,
|
||||
num_pools, wait_time, uptime, (uint32_t) ts);
|
||||
return buffer;
|
||||
@@ -199,9 +199,12 @@ static char *getpoolnfo(char *params)
|
||||
{
|
||||
char *s = buffer;
|
||||
char jobid[128] = { 0 };
|
||||
char nonce[128] = { 0 };
|
||||
char extra[96] = { 0 };
|
||||
int pooln = params ? atoi(params) % num_pools : cur_pooln;
|
||||
struct pool_infos *p = &pools[pooln];
|
||||
uint32_t last_share = 0;
|
||||
if (p->last_share_time)
|
||||
last_share = (uint32_t) (time(NULL) - p->last_share_time);
|
||||
|
||||
*s = '\0';
|
||||
|
||||
@@ -209,17 +212,25 @@ static char *getpoolnfo(char *params)
|
||||
strncpy(jobid, stratum.job.job_id, sizeof(stratum.job.job_id));
|
||||
if (stratum.job.xnonce2) {
|
||||
/* used temporary to be sure all is ok */
|
||||
sprintf(nonce, "0x");
|
||||
cbin2hex(&nonce[2], (const char*) stratum.job.xnonce2, stratum.xnonce2_size);
|
||||
sprintf(extra, "0x");
|
||||
if (p->algo == ALGO_DECRED) {
|
||||
char compat[32] = { 0 };
|
||||
cbin2hex(&extra[2], (const char*) stratum.xnonce1, min(36, stratum.xnonce2_size));
|
||||
cbin2hex(compat, (const char*) stratum.job.xnonce2, 4);
|
||||
memcpy(&extra[2], compat, 8); // compat extranonce
|
||||
} else {
|
||||
cbin2hex(&extra[2], (const char*) stratum.job.xnonce2, stratum.xnonce2_size);
|
||||
}
|
||||
}
|
||||
|
||||
snprintf(s, MYBUFSIZ, "URL=%s;USER=%s;ACC=%d;REJ=%d;H=%u;JOB=%s;DIFF=%.6f;"
|
||||
"N2SZ=%d;N2=%s;PING=%u;DISCO=%u;WAIT=%u;UPTIME=%u|",
|
||||
snprintf(s, MYBUFSIZ, "POOL=%s;ALGO=%s;URL=%s;USER=%s;SOLV=%d;ACC=%d;REJ=%d;STALE=%u;H=%u;JOB=%s;DIFF=%.6f;"
|
||||
"BEST=%.6f;N2SZ=%d;N2=%s;PING=%u;DISCO=%u;WAIT=%u;UPTIME=%u;LAST=%u|",
|
||||
strlen(p->name) ? p->name : p->short_url, algo_names[p->algo],
|
||||
p->url, p->type & POOL_STRATUM ? p->user : "",
|
||||
p->accepted_count, p->rejected_count,
|
||||
stratum.job.height, jobid, stratum_diff,
|
||||
(int) stratum.xnonce2_size, nonce, stratum.answer_msec,
|
||||
p->disconnects, p->wait_time, p->work_time);
|
||||
p->solved_count, p->accepted_count, p->rejected_count, p->stales_count,
|
||||
stratum.job.height, jobid, stratum_diff, p->best_share,
|
||||
(int) stratum.xnonce2_size, extra, stratum.answer_msec,
|
||||
p->disconnects, p->wait_time, p->work_time, last_share);
|
||||
|
||||
return s;
|
||||
}
|
||||
@@ -405,13 +416,13 @@ static char *remote_switchpool(char *params)
|
||||
return buffer;
|
||||
if (!params || strlen(params) == 0) {
|
||||
// rotate pool test
|
||||
ret = pool_switch_next();
|
||||
ret = pool_switch_next(-1);
|
||||
} else {
|
||||
int n = atoi(params);
|
||||
if (n == cur_pooln)
|
||||
ret = true;
|
||||
else if (n < num_pools)
|
||||
ret = pool_switch(n);
|
||||
ret = pool_switch(-1, n);
|
||||
}
|
||||
sprintf(buffer, "%s|", ret ? "ok" : "fail");
|
||||
return buffer;
|
||||
@@ -429,7 +440,7 @@ static char *remote_seturl(char *params)
|
||||
return buffer;
|
||||
if (!params || strlen(params) == 0) {
|
||||
// rotate pool test
|
||||
ret = pool_switch_next();
|
||||
ret = pool_switch_next(-1);
|
||||
} else {
|
||||
ret = pool_switch_url(params);
|
||||
}
|
||||
@@ -991,7 +1002,7 @@ void *api_thread(void *userdata)
|
||||
/* to be able to report the default value set in each algo */
|
||||
void api_set_throughput(int thr_id, uint32_t throughput)
|
||||
{
|
||||
if (&thr_info[thr_id]) {
|
||||
if (thr_id < MAX_GPUS && thr_info) {
|
||||
struct cgpu_info *cgpu = &thr_info[thr_id].gpu;
|
||||
uint32_t ws = throughput;
|
||||
uint8_t i = 0;
|
||||
@@ -1004,4 +1015,7 @@ void api_set_throughput(int thr_id, uint32_t throughput)
|
||||
cgpu->intensity += ((float) (throughput-(1U << i)) / (1U << i));
|
||||
}
|
||||
}
|
||||
// to display in bench results
|
||||
if (opt_benchmark)
|
||||
bench_set_throughput(thr_id, throughput);
|
||||
}
|
||||
+8
-4
@@ -1,5 +1,5 @@
|
||||
<?php
|
||||
/* ccminer API sample UI (API 1.5) */
|
||||
/* ccminer API sample UI (API 1.7) */
|
||||
|
||||
$host = 'http://localhost/api/'; // 'http://'.$_SERVER['SERVER_NAME'].'/api/';
|
||||
$configs = array(
|
||||
@@ -28,7 +28,7 @@ function ignoreField($key)
|
||||
{
|
||||
$ignored = array(
|
||||
'API','VER','GPU','BUS','POOLS',
|
||||
'CARD','GPUS','CPU','TS',
|
||||
'CARD','GPUS','CPU','TS','URL',
|
||||
);
|
||||
return in_array($key, $ignored);
|
||||
}
|
||||
@@ -46,6 +46,10 @@ function translateField($key)
|
||||
$intl['ACC'] = 'Accepted shares';
|
||||
$intl['ACCMN'] = 'Accepted / mn';
|
||||
$intl['REJ'] = 'Rejected';
|
||||
$intl['SOLV'] = 'Solved';
|
||||
$intl['BEST'] = 'Best share';
|
||||
$intl['STALE'] = 'Stale shares';
|
||||
$intl['LAST'] = 'Last share';
|
||||
$intl['DIFF'] = 'Difficulty';
|
||||
$intl['NETKHS'] = 'Net Rate';
|
||||
$intl['UPTIME'] = 'Miner up time';
|
||||
@@ -53,10 +57,10 @@ function translateField($key)
|
||||
$intl['THR'] = 'Throughput';
|
||||
$intl['WAIT'] = 'Wait time';
|
||||
|
||||
|
||||
$intl['H'] = 'Bloc height';
|
||||
$intl['I'] = 'Intensity';
|
||||
$intl['HWF'] = 'Failures';
|
||||
$intl['POOL'] = 'Pool';
|
||||
$intl['POOLS'] = 'Pools';
|
||||
|
||||
$intl['TEMP'] = 'T°c';
|
||||
@@ -231,7 +235,7 @@ div#footer {
|
||||
#header h1 { padding: 12px; font-size: 20px; }
|
||||
#footer p { margin: 12px 24px; }
|
||||
|
||||
table.stats { width: 280px; margin: 4px 16px; display: inline-block; }
|
||||
table.stats { width: 280px; margin: 4px 16px; display: inline-block; vertical-align: top; }
|
||||
th.machine { color: darkcyan; padding: 16px 0px 0px 0px; text-align: left; border-bottom: 1px solid gray; }
|
||||
th.gpu { color: white; padding: 3px 3px; font: bolder; text-align: left; background: rgba(65, 65, 65, 0.85); }
|
||||
td.key { width: 99px; max-width: 180px; }
|
||||
|
||||
@@ -0,0 +1,202 @@
|
||||
/**
|
||||
* Made to benchmark and test algo switch
|
||||
*
|
||||
* 2015 - tpruvot@github
|
||||
*/
|
||||
|
||||
#include <unistd.h>
|
||||
|
||||
#include "miner.h"
|
||||
#include "algos.h"
|
||||
|
||||
int bench_algo = -1;
|
||||
|
||||
static double algo_hashrates[MAX_GPUS][ALGO_COUNT] = { 0 };
|
||||
static uint32_t algo_throughput[MAX_GPUS][ALGO_COUNT] = { 0 };
|
||||
static int algo_mem_used[MAX_GPUS][ALGO_COUNT] = { 0 };
|
||||
static int device_mem_free[MAX_GPUS] = { 0 };
|
||||
|
||||
static pthread_barrier_t miner_barr;
|
||||
static pthread_barrier_t algo_barr;
|
||||
static pthread_mutex_t bench_lock = PTHREAD_MUTEX_INITIALIZER;
|
||||
|
||||
extern double thr_hashrates[MAX_GPUS];
|
||||
|
||||
void bench_init(int threads)
|
||||
{
|
||||
bench_algo = opt_algo = (enum sha_algos) 0; /* first */
|
||||
applog(LOG_BLUE, "Starting benchmark mode with %s", algo_names[opt_algo]);
|
||||
pthread_barrier_init(&miner_barr, NULL, threads);
|
||||
pthread_barrier_init(&algo_barr, NULL, threads);
|
||||
// required for usage of first algo.
|
||||
for (int n=0; n < opt_n_threads; n++) {
|
||||
device_mem_free[n] = cuda_available_memory(n);
|
||||
}
|
||||
}
|
||||
|
||||
void bench_free()
|
||||
{
|
||||
pthread_barrier_destroy(&miner_barr);
|
||||
pthread_barrier_destroy(&algo_barr);
|
||||
}
|
||||
|
||||
// required to switch algos
|
||||
void algo_free_all(int thr_id)
|
||||
{
|
||||
// only initialized algos will be freed
|
||||
free_blake256(thr_id);
|
||||
free_blake2s(thr_id);
|
||||
free_bmw(thr_id);
|
||||
free_c11(thr_id);
|
||||
free_decred(thr_id);
|
||||
free_deep(thr_id);
|
||||
free_keccak256(thr_id);
|
||||
free_fresh(thr_id);
|
||||
free_fugue256(thr_id);
|
||||
free_groestlcoin(thr_id);
|
||||
free_heavy(thr_id);
|
||||
free_jackpot(thr_id);
|
||||
free_luffa(thr_id);
|
||||
free_lyra2(thr_id);
|
||||
free_lyra2v2(thr_id);
|
||||
free_myriad(thr_id);
|
||||
free_neoscrypt(thr_id);
|
||||
free_nist5(thr_id);
|
||||
free_pentablake(thr_id);
|
||||
free_quark(thr_id);
|
||||
free_qubit(thr_id);
|
||||
free_skeincoin(thr_id);
|
||||
free_skein2(thr_id);
|
||||
free_sib(thr_id);
|
||||
free_s3(thr_id);
|
||||
free_vanilla(thr_id);
|
||||
free_whirl(thr_id);
|
||||
free_x11(thr_id);
|
||||
free_x13(thr_id);
|
||||
free_x14(thr_id);
|
||||
free_x15(thr_id);
|
||||
free_x17(thr_id);
|
||||
free_zr5(thr_id);
|
||||
//free_sha256d(thr_id);
|
||||
free_scrypt(thr_id);
|
||||
free_scrypt_jane(thr_id);
|
||||
}
|
||||
|
||||
// benchmark all algos (called once per mining thread)
|
||||
bool bench_algo_switch_next(int thr_id)
|
||||
{
|
||||
int algo = (int) opt_algo;
|
||||
int prev_algo = algo;
|
||||
int dev_id = device_map[thr_id % MAX_GPUS];
|
||||
int mfree, mused;
|
||||
// doesnt seems enough to prevent device slow down
|
||||
// after some algo switchs
|
||||
bool need_reset = (gpu_threads == 1);
|
||||
|
||||
algo++;
|
||||
|
||||
// skip some duplicated algos
|
||||
if (algo == ALGO_C11) algo++; // same as x11
|
||||
if (algo == ALGO_DMD_GR) algo++; // same as groestl
|
||||
if (algo == ALGO_MJOLLNIR) algo++; // same as heavy
|
||||
if (algo == ALGO_WHIRLCOIN) algo++; // same as whirlpool
|
||||
|
||||
if (device_sm[dev_id] && device_sm[dev_id] < 300) {
|
||||
// incompatible SM 2.1 kernels...
|
||||
if (algo == ALGO_GROESTL) algo++;
|
||||
if (algo == ALGO_MYR_GR) algo++;
|
||||
if (algo == ALGO_JACKPOT) algo++; // compact shuffle
|
||||
if (algo == ALGO_NEOSCRYPT) algo++;
|
||||
if (algo == ALGO_WHIRLPOOLX) algo++;
|
||||
}
|
||||
// and unwanted ones...
|
||||
if (algo == ALGO_SCRYPT) algo++;
|
||||
if (algo == ALGO_SCRYPT_JANE) algo++;
|
||||
|
||||
// free current algo memory and track mem usage
|
||||
mused = cuda_available_memory(thr_id);
|
||||
algo_free_all(thr_id);
|
||||
CUDA_LOG_ERROR();
|
||||
|
||||
// device can take some time to free
|
||||
mfree = cuda_available_memory(thr_id);
|
||||
if (device_mem_free[thr_id] > mfree) {
|
||||
sleep(1);
|
||||
mfree = cuda_available_memory(thr_id);
|
||||
}
|
||||
|
||||
// we need to wait completion on all cards before the switch
|
||||
if (opt_n_threads > 1) {
|
||||
pthread_barrier_wait(&miner_barr);
|
||||
}
|
||||
|
||||
char rate[32] = { 0 };
|
||||
double hashrate = stats_get_speed(thr_id, thr_hashrates[thr_id]);
|
||||
format_hashrate(hashrate, rate);
|
||||
gpulog(LOG_NOTICE, thr_id, "%s hashrate = %s", algo_names[prev_algo], rate);
|
||||
|
||||
// ensure memory leak is still real after the barrier
|
||||
if (device_mem_free[thr_id] > mfree) {
|
||||
mfree = cuda_available_memory(thr_id);
|
||||
}
|
||||
|
||||
// check if there is memory leak
|
||||
if (device_mem_free[thr_id] - mfree > 1) {
|
||||
gpulog(LOG_WARNING, thr_id, "possible %d MB memory leak in %s! %d MB free",
|
||||
(device_mem_free[thr_id] - mfree), algo_names[prev_algo], mfree);
|
||||
cuda_reset_device(thr_id, NULL); // force to free the leak
|
||||
need_reset = false;
|
||||
mfree = cuda_available_memory(thr_id);
|
||||
}
|
||||
// store used memory per algo
|
||||
algo_mem_used[thr_id][opt_algo] = device_mem_free[thr_id] - mused;
|
||||
device_mem_free[thr_id] = mfree;
|
||||
|
||||
// store to dump a table per gpu later
|
||||
algo_hashrates[thr_id][prev_algo] = hashrate;
|
||||
|
||||
// wait the other threads to display logs correctly
|
||||
if (opt_n_threads > 1) {
|
||||
pthread_barrier_wait(&algo_barr);
|
||||
}
|
||||
|
||||
if (algo == ALGO_AUTO)
|
||||
return false; // all algos done
|
||||
|
||||
// mutex primary used for the stats purge
|
||||
pthread_mutex_lock(&bench_lock);
|
||||
stats_purge_all();
|
||||
|
||||
opt_algo = (enum sha_algos) algo;
|
||||
global_hashrate = 0;
|
||||
thr_hashrates[thr_id] = 0; // reset for minmax64
|
||||
pthread_mutex_unlock(&bench_lock);
|
||||
|
||||
if (need_reset)
|
||||
cuda_reset_device(thr_id, NULL);
|
||||
|
||||
if (thr_id == 0)
|
||||
applog(LOG_BLUE, "Benchmark algo %s...", algo_names[algo]);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void bench_set_throughput(int thr_id, uint32_t throughput)
|
||||
{
|
||||
algo_throughput[thr_id][opt_algo] = throughput;
|
||||
}
|
||||
|
||||
void bench_display_results()
|
||||
{
|
||||
for (int n=0; n < opt_n_threads; n++)
|
||||
{
|
||||
int dev_id = device_map[n];
|
||||
applog(LOG_BLUE, "Benchmark results for GPU #%d - %s:", dev_id, device_name[dev_id]);
|
||||
for (int i=0; i < ALGO_COUNT-1; i++) {
|
||||
double rate = algo_hashrates[n][i];
|
||||
if (rate == 0.0) continue;
|
||||
applog(LOG_INFO, "%12s : %12.1f kH/s, %5d MB, %8u thr.", algo_names[i],
|
||||
rate / 1024., algo_mem_used[n][i], algo_throughput[n][i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
+7
-1
@@ -77,4 +77,10 @@ extern "C" void bn_store_hash_target_ratio(uint32_t* hash, uint32_t* target, str
|
||||
work->shareratio = bn_hash_target_ratio(hash, target);
|
||||
work->sharediff = work->targetdiff * work->shareratio;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extern "C" void work_set_target_ratio(struct work* work, uint32_t* hash)
|
||||
{
|
||||
bn_store_hash_target_ratio(hash, work->target, work);
|
||||
}
|
||||
|
||||
+15
-15
@@ -117,17 +117,17 @@ public:
|
||||
|
||||
unsigned long getulong() const
|
||||
{
|
||||
return BN_get_word(this);
|
||||
return (unsigned long) BN_get_word(this);
|
||||
}
|
||||
|
||||
unsigned int getuint() const
|
||||
{
|
||||
return BN_get_word(this);
|
||||
return (unsigned int) BN_get_word(this);
|
||||
}
|
||||
|
||||
int getint() const
|
||||
{
|
||||
unsigned long n = BN_get_word(this);
|
||||
unsigned long n = (unsigned long) 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
|
||||
@@ -141,7 +141,7 @@ public:
|
||||
bool fNegative;
|
||||
uint64 n;
|
||||
|
||||
if (sn < (int64)0)
|
||||
if (sn < 0LL)
|
||||
{
|
||||
// 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,
|
||||
@@ -171,12 +171,12 @@ public:
|
||||
}
|
||||
*p++ = c;
|
||||
}
|
||||
unsigned int nSize = p - (pch + 4);
|
||||
unsigned int nSize = (unsigned int) (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);
|
||||
BN_mpi2bn(pch, (int) (p - pch), this);
|
||||
}
|
||||
|
||||
void setuint64(uint64 n)
|
||||
@@ -198,12 +198,12 @@ public:
|
||||
}
|
||||
*p++ = c;
|
||||
}
|
||||
unsigned int nSize = p - (pch + 4);
|
||||
unsigned int nSize = (unsigned int) (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);
|
||||
BN_mpi2bn(pch, (int) (p - pch), this);
|
||||
}
|
||||
|
||||
void setuint256(uint256 n)
|
||||
@@ -226,12 +226,12 @@ public:
|
||||
}
|
||||
*p++ = c;
|
||||
}
|
||||
unsigned int nSize = p - (pch + 4);
|
||||
unsigned int nSize = (unsigned int) (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);
|
||||
BN_mpi2bn(pch, (int) (p - pch), this);
|
||||
}
|
||||
|
||||
uint256 getuint256() const
|
||||
@@ -244,7 +244,7 @@ public:
|
||||
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--)
|
||||
for (unsigned int i = 0, j = (unsigned int) vch.size()-1; i < sizeof(n) && j >= 4; i++, j--)
|
||||
((unsigned char*)&n)[i] = vch[j];
|
||||
return n;
|
||||
}
|
||||
@@ -252,7 +252,7 @@ public:
|
||||
void setvch(const std::vector<unsigned char>& vch)
|
||||
{
|
||||
std::vector<unsigned char> vch2(vch.size() + 4);
|
||||
unsigned int nSize = vch.size();
|
||||
unsigned int nSize = (unsigned int) vch.size();
|
||||
// BIGNUM's byte stream format expects 4 bytes of
|
||||
// big endian size data info at the front
|
||||
vch2[0] = (nSize >> 24) & 0xff;
|
||||
@@ -261,7 +261,7 @@ public:
|
||||
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);
|
||||
BN_mpi2bn(&vch2[0], (int) vch2.size(), this);
|
||||
}
|
||||
|
||||
std::vector<unsigned char> getvch() const
|
||||
@@ -322,12 +322,12 @@ public:
|
||||
unsigned int nSize = BN_num_bytes(this);
|
||||
unsigned int nCompact = 0;
|
||||
if (nSize <= 3)
|
||||
nCompact = BN_get_word(this) << 8*(3-nSize);
|
||||
nCompact = (unsigned int) BN_get_word(this) << 8*(3-nSize);
|
||||
else
|
||||
{
|
||||
CBigNum bn;
|
||||
BN_rshift(&bn, this, 8*(nSize-3));
|
||||
nCompact = BN_get_word(&bn);
|
||||
nCompact = (unsigned int) 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.
|
||||
|
||||
+1085
-435
File diff suppressed because it is too large.
Load diff
+40
-31
@@ -42,7 +42,7 @@
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
|
||||
<ImportGroup Label="ExtensionSettings">
|
||||
<Import Project="$(VCTargetsPath)\BuildCustomizations\CUDA 6.5.props" />
|
||||
<Import Project="$(VCTargetsPath)\BuildCustomizations\CUDA 7.5.props" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
@@ -80,10 +80,10 @@
|
||||
<CudaCompile>
|
||||
<CInterleavedPTX>false</CInterleavedPTX>
|
||||
<GenerateLineInfo>true</GenerateLineInfo>
|
||||
<MaxRegCount>80</MaxRegCount>
|
||||
<MaxRegCount>255</MaxRegCount>
|
||||
<PtxAsOptionV>true</PtxAsOptionV>
|
||||
<Keep>true</Keep>
|
||||
<CodeGeneration>compute_50,sm_50</CodeGeneration>
|
||||
<CodeGeneration>compute_50,sm_50;compute_52,sm_52;compute_35,sm_35;compute_30,sm_30;compute_20,sm_20</CodeGeneration>
|
||||
<Include>$(NVTOOLSEXT_PATH)\include;..\..\..\Common\C99</Include>
|
||||
</CudaCompile>
|
||||
</ItemDefinitionGroup>
|
||||
@@ -112,15 +112,16 @@
|
||||
<CudaCompile>
|
||||
<CInterleavedPTX>false</CInterleavedPTX>
|
||||
<GenerateLineInfo>true</GenerateLineInfo>
|
||||
<MaxRegCount>80</MaxRegCount>
|
||||
<MaxRegCount>255</MaxRegCount>
|
||||
<PtxAsOptionV>true</PtxAsOptionV>
|
||||
<Keep>true</Keep>
|
||||
<CodeGeneration>compute_50,sm_50</CodeGeneration>
|
||||
<CodeGeneration>compute_50,sm_50;compute_52,sm_52;compute_35,sm_35;compute_30,sm_30;compute_20,sm_20</CodeGeneration>
|
||||
<Include>$(NVTOOLSEXT_PATH)\include;..\..\..\Common\C99</Include>
|
||||
<TargetMachinePlatform>64</TargetMachinePlatform>
|
||||
</CudaCompile>
|
||||
<CudaLink>
|
||||
<PerformDeviceLink>false</PerformDeviceLink>
|
||||
<Optimization>O3</Optimization>
|
||||
</CudaLink>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
@@ -155,16 +156,16 @@
|
||||
</Link>
|
||||
<CudaCompile>
|
||||
<CInterleavedPTX>false</CInterleavedPTX>
|
||||
<MaxRegCount>80</MaxRegCount>
|
||||
<MaxRegCount>255</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_50,sm_50;compute_52,sm_52;compute_35,sm_35;compute_30,sm_30;compute_20,sm_20</CodeGeneration>
|
||||
<AdditionalOptions>--ptxas-options="-O2" %(AdditionalOptions)</AdditionalOptions>
|
||||
<Optimization>O2</Optimization>
|
||||
<Optimization>O3</Optimization>
|
||||
</CudaCompile>
|
||||
<CudaLink>
|
||||
<GPUDebugInfo>false</GPUDebugInfo>
|
||||
<Optimization>O3</Optimization>
|
||||
<Optimization>O2</Optimization>
|
||||
</CudaLink>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
|
||||
@@ -198,10 +199,10 @@
|
||||
</Link>
|
||||
<CudaCompile>
|
||||
<CInterleavedPTX>false</CInterleavedPTX>
|
||||
<MaxRegCount>80</MaxRegCount>
|
||||
<MaxRegCount>255</MaxRegCount>
|
||||
<PtxAsOptionV>true</PtxAsOptionV>
|
||||
<Keep>true</Keep>
|
||||
<CodeGeneration>compute_35,sm_35;compute_50,sm_50;compute_52,sm_52</CodeGeneration>
|
||||
<CodeGeneration>compute_50,sm_50;compute_52,sm_52;compute_35,sm_35;compute_30,sm_30;compute_20,sm_20</CodeGeneration>
|
||||
<Include>$(NVTOOLSEXT_PATH)\include;..\..\..\Common\C99</Include>
|
||||
<Optimization>O3</Optimization>
|
||||
<TargetMachinePlatform>64</TargetMachinePlatform>
|
||||
@@ -231,6 +232,7 @@
|
||||
</ClCompile>
|
||||
<ClCompile Include="pools.cpp" />
|
||||
<ClCompile Include="util.cpp" />
|
||||
<ClCompile Include="bench.cpp" />
|
||||
<ClCompile Include="bignum.cpp" />
|
||||
<ClInclude Include="bignum.hpp" />
|
||||
<ClCompile Include="fuguecoin.cpp" />
|
||||
@@ -245,10 +247,13 @@
|
||||
<ClCompile Include="myriadgroestl.cpp" />
|
||||
<ClCompile Include="lyra2\Lyra2.c" />
|
||||
<ClCompile Include="lyra2\Sponge.c" />
|
||||
<ClInclude Include="lyra2\cuda_lyra2_sm2.cuh" />
|
||||
<ClInclude Include="lyra2\cuda_lyra2_sm5.cuh" />
|
||||
<ClInclude Include="neoscrypt\neoscrypt.h" />
|
||||
<ClCompile Include="neoscrypt\neoscrypt.cpp" />
|
||||
<ClCompile Include="neoscrypt\neoscrypt-cpu.c" />
|
||||
<ClInclude Include="neoscrypt\cuda_vectors.h" />
|
||||
<ClInclude Include="x11\cuda_x11_simd512_sm2.cuh" />
|
||||
<CudaCompile Include="Algo256\bmw.cu" />
|
||||
<CudaCompile Include="Algo256\cuda_bmw.cu">
|
||||
<MaxRegCount>76</MaxRegCount>
|
||||
@@ -259,6 +264,7 @@
|
||||
<ClCompile Include="skein2.cpp" />
|
||||
<ClCompile Include="sph\aes_helper.c" />
|
||||
<ClCompile Include="sph\blake.c" />
|
||||
<ClCompile Include="sph\blake2s.c" />
|
||||
<ClCompile Include="sph\bmw.c" />
|
||||
<ClCompile Include="sph\cubehash.c" />
|
||||
<ClCompile Include="sph\echo.c" />
|
||||
@@ -280,6 +286,7 @@
|
||||
<ClCompile Include="sph\shavite.c" />
|
||||
<ClCompile Include="sph\simd.c" />
|
||||
<ClCompile Include="sph\skein.c" />
|
||||
<ClCompile Include="sph\streebog.c" />
|
||||
<ClCompile Include="sph\hamsi.c" />
|
||||
<ClCompile Include="sph\hamsi_helper.c" />
|
||||
<ClCompile Include="sph\whirlpool.c" />
|
||||
@@ -305,12 +312,16 @@
|
||||
<ClInclude Include="cpuminer-config.h" />
|
||||
<ClInclude Include="cuda_groestlcoin.h" />
|
||||
<ClInclude Include="cuda_helper.h" />
|
||||
<ClInclude Include="cuda_vector.h" />
|
||||
<ClInclude Include="cuda_vector_uint2x4.h" />
|
||||
<ClInclude Include="elist.h" />
|
||||
<ClInclude Include="heavy\heavy.h" />
|
||||
<ClInclude Include="hefty1.h" />
|
||||
<ClInclude Include="algos.h" />
|
||||
<ClInclude Include="miner.h" />
|
||||
<ClInclude Include="nvml.h" />
|
||||
<ClInclude Include="quark\cuda_bmw512_sm3.cuh" />
|
||||
<ClInclude Include="quark\cuda_quark_blake512_sp.cuh" />
|
||||
<ClInclude Include="quark\cuda_skein512_sp.cuh" />
|
||||
<ClInclude Include="res\resource.h" />
|
||||
<ClInclude Include="scrypt\salsa_kernel.h" />
|
||||
<ClInclude Include="sph\sph_blake.h" />
|
||||
@@ -328,6 +339,7 @@
|
||||
<ClInclude Include="sph\sph_shavite.h" />
|
||||
<ClInclude Include="sph\sph_simd.h" />
|
||||
<ClInclude Include="sph\sph_skein.h" />
|
||||
<ClInclude Include="sph\sph_streebog.h" />
|
||||
<ClInclude Include="sph\sph_hamsi.h" />
|
||||
<ClInclude Include="sph\sph_types.h" />
|
||||
<ClInclude Include="sph\sph_whirlpool.h" />
|
||||
@@ -336,8 +348,8 @@
|
||||
<ClInclude Include="lyra2\Sponge.h" />
|
||||
<ClInclude Include="quark\groestl_transf_quad.h" />
|
||||
<ClInclude Include="quark\groestl_functions_quad.h" />
|
||||
<ClInclude Include="spreadx11\bignum_fp.h" />
|
||||
<ClInclude Include="spreadx11\spreadx11.h" />
|
||||
<ClInclude Include="quark\cuda_quark.h" />
|
||||
<ClInclude Include="x11\cuda_x11.h" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<CudaCompile Include="cuda.cpp" />
|
||||
@@ -398,6 +410,11 @@
|
||||
<AdditionalOptions Condition="'$(Configuration)'=='Release'">--ptxas-options="-dlcm=cg" %(AdditionalOptions)</AdditionalOptions>
|
||||
<FastMath>true</FastMath>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="Algo256\blake2s.cu" />
|
||||
<CudaCompile Include="Algo256\decred.cu">
|
||||
<MaxRegCount>128</MaxRegCount>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="Algo256\vanilla.cu" />
|
||||
<CudaCompile Include="Algo256\keccak256.cu" />
|
||||
<CudaCompile Include="Algo256\cuda_blake256.cu" />
|
||||
<CudaCompile Include="Algo256\cuda_bmw256.cu" />
|
||||
@@ -456,13 +473,7 @@
|
||||
<CudaCompile Include="cuda_skeincoin.cu">
|
||||
<MaxRegCount>48</MaxRegCount>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="spreadx11\spreadx11.cu" />
|
||||
<CudaCompile Include="spreadx11\cuda_blake.cu" />
|
||||
<CudaCompile Include="spreadx11\cuda_spreadx11_sign.cu" />
|
||||
<CudaCompile Include="spreadx11\cuda_sha256.cu" />
|
||||
<CudaCompile Include="x11\cuda_x11_aes.cu">
|
||||
<ExcludedFromBuild>true</ExcludedFromBuild>
|
||||
</CudaCompile>
|
||||
<ClInclude Include="x11\cuda_x11_aes.cuh" />
|
||||
<CudaCompile Include="x11\cuda_x11_cubehash512.cu" />
|
||||
<CudaCompile Include="x11\cuda_x11_echo.cu">
|
||||
</CudaCompile>
|
||||
@@ -473,17 +484,16 @@
|
||||
<CudaCompile Include="x11\cuda_x11_shavite512.cu">
|
||||
<MaxRegCount>128</MaxRegCount>
|
||||
</CudaCompile>
|
||||
<ClInclude Include="x11\cuda_x11_simd512_func.cuh" />
|
||||
<CudaCompile Include="x11\cuda_x11_simd512.cu">
|
||||
<MaxRegCount>64</MaxRegCount>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x11\cuda_streebog.cu" />
|
||||
<CudaCompile Include="x11\c11.cu" />
|
||||
<CudaCompile Include="x11\fresh.cu" />
|
||||
<CudaCompile Include="x11\sib.cu" />
|
||||
<CudaCompile Include="x11\s3.cu" />
|
||||
<CudaCompile Include="x11\simd_functions.cu">
|
||||
<ExcludedFromBuild>true</ExcludedFromBuild>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x11\x11.cu">
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x11\x11.cu" />
|
||||
<CudaCompile Include="x13\cuda_x13_hamsi512.cu">
|
||||
<MaxRegCount>72</MaxRegCount>
|
||||
</CudaCompile>
|
||||
@@ -496,11 +506,10 @@
|
||||
<CudaCompile Include="x15\cuda_x14_shabal512.cu" />
|
||||
<CudaCompile Include="x15\cuda_x15_whirlpool.cu" />
|
||||
<CudaCompile Include="x15\x15.cu" />
|
||||
<CudaCompile Include="x15\cuda_whirlpoolx.cu" />
|
||||
<CudaCompile Include="x15\whirlpoolx.cu" />
|
||||
<CudaCompile Include="x15\whirlpool.cu" />
|
||||
<CudaCompile Include="x17\x17.cu">
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x17\cuda_x17_haval512.cu">
|
||||
<CudaCompile Include="x17\cuda_x17_haval256.cu">
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x17\cuda_x17_sha512.cu">
|
||||
<MaxRegCount>80</MaxRegCount>
|
||||
@@ -517,7 +526,7 @@
|
||||
</ItemGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||
<ImportGroup Label="ExtensionTargets">
|
||||
<Import Project="$(VCTargetsPath)\BuildCustomizations\CUDA 6.5.targets" />
|
||||
<Import Project="$(VCTargetsPath)\BuildCustomizations\CUDA 7.5.targets" />
|
||||
</ImportGroup>
|
||||
<!-- Copy the required dlls -->
|
||||
<Target Name="AfterBuild">
|
||||
@@ -526,4 +535,4 @@
|
||||
<Target Name="AfterClean">
|
||||
<Delete Files="@(FilesToCopy->'$(OutDir)%(Filename)%(Extension)')" TreatErrorsAsWarnings="true" />
|
||||
</Target>
|
||||
</Project>
|
||||
</Project>
|
||||
+79
-25
@@ -79,6 +79,9 @@
|
||||
<Filter Include="Source Files\neoscrypt">
|
||||
<UniqueIdentifier>{2037fd0d-e7a2-4da8-956c-150aec726a99}</UniqueIdentifier>
|
||||
</Filter>
|
||||
<Filter Include="Source Files\CUDA\lyra2">
|
||||
<UniqueIdentifier>{1613763f-895c-4321-b58b-6f5849868956}</UniqueIdentifier>
|
||||
</Filter>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="compat\jansson\dump.c">
|
||||
@@ -183,6 +186,9 @@
|
||||
<ClCompile Include="sph\sha2big.c">
|
||||
<Filter>Source Files\sph</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="sph\streebog.c">
|
||||
<Filter>Source Files\sph</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="compat\winansi.c">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
@@ -246,11 +252,20 @@
|
||||
<ClCompile Include="hefty1.c">
|
||||
<Filter>Source Files\CUDA\heavy</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="bench.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="bignum.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="sph\blake2s.c">
|
||||
<Filter>Source Files\sph</Filter>
|
||||
</ClCompile>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="algos.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="compat.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
@@ -284,6 +299,12 @@
|
||||
<ClInclude Include="cuda_groestlcoin.h">
|
||||
<Filter>Header Files\CUDA</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="quark\cuda_quark.h">
|
||||
<Filter>Header Files\CUDA</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="x11\cuda_x11.h">
|
||||
<Filter>Header Files\CUDA</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="sph\sph_blake.h">
|
||||
<Filter>Header Files\sph</Filter>
|
||||
</ClInclude>
|
||||
@@ -329,7 +350,7 @@
|
||||
<ClInclude Include="cuda_helper.h">
|
||||
<Filter>Header Files\CUDA</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="cuda_vector.h">
|
||||
<ClInclude Include="cuda_vector_uint2x4.h">
|
||||
<Filter>Header Files\CUDA</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="sph\sph_hamsi.h">
|
||||
@@ -338,6 +359,9 @@
|
||||
<ClInclude Include="sph\sph_shabal.h">
|
||||
<Filter>Header Files\sph</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="sph\sph_streebog.h">
|
||||
<Filter>Header Files\sph</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="sph\sph_whirlpool.h">
|
||||
<Filter>Header Files\sph</Filter>
|
||||
</ClInclude>
|
||||
@@ -413,6 +437,24 @@
|
||||
<ClInclude Include="bignum.hpp">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="lyra2\cuda_lyra2_sm2.cuh">
|
||||
<Filter>Source Files\CUDA\lyra2</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="quark\cuda_quark_blake512_sp.cuh">
|
||||
<Filter>Source Files\CUDA\quark</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="quark\cuda_skein512_sp.cuh">
|
||||
<Filter>Source Files\CUDA\quark</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="quark\cuda_bmw512_sm3.cuh">
|
||||
<Filter>Source Files\CUDA\quark</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="x11\cuda_x11_simd512_sm2.cuh">
|
||||
<Filter>Source Files\CUDA\x11</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="lyra2\cuda_lyra2_sm5.cuh">
|
||||
<Filter>Source Files\CUDA\lyra2</Filter>
|
||||
</ClInclude>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<CudaCompile Include="cuda.cpp">
|
||||
@@ -493,9 +535,9 @@
|
||||
<CudaCompile Include="cuda_nist5.cu">
|
||||
<Filter>Source Files\CUDA</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x11\cuda_x11_aes.cu">
|
||||
<ClInclude Include="x11\cuda_x11_aes.cuh">
|
||||
<Filter>Source Files\CUDA\x11</Filter>
|
||||
</CudaCompile>
|
||||
</ClInclude>
|
||||
<CudaCompile Include="x11\cuda_x11_cubehash512.cu">
|
||||
<Filter>Source Files\CUDA\x11</Filter>
|
||||
</CudaCompile>
|
||||
@@ -514,6 +556,9 @@
|
||||
<CudaCompile Include="x11\cuda_x11_simd512.cu">
|
||||
<Filter>Source Files\CUDA\x11</Filter>
|
||||
</CudaCompile>
|
||||
<ClInclude Include="x11\cuda_x11_simd512_func.cuh">
|
||||
<Filter>Source Files\CUDA\x11</Filter>
|
||||
</ClInclude>
|
||||
<CudaCompile Include="x11\c11.cu">
|
||||
<Filter>Source Files\CUDA\x11</Filter>
|
||||
</CudaCompile>
|
||||
@@ -523,9 +568,6 @@
|
||||
<CudaCompile Include="x11\x11.cu">
|
||||
<Filter>Source Files\CUDA\x11</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x11\simd_functions.cu">
|
||||
<Filter>Source Files\CUDA\x11</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x13\cuda_x13_fugue512.cu">
|
||||
<Filter>Source Files\CUDA\x13</Filter>
|
||||
</CudaCompile>
|
||||
@@ -550,13 +592,10 @@
|
||||
<CudaCompile Include="x15\cuda_x15_whirlpool.cu">
|
||||
<Filter>Source Files\CUDA\x15</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x15\cuda_whirlpoolx.cu">
|
||||
<CudaCompile Include="x15\whirlpool.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">
|
||||
<CudaCompile Include="x17\cuda_x17_haval256.cu">
|
||||
<Filter>Source Files\CUDA\x17</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x17\cuda_x17_sha512.cu">
|
||||
@@ -568,11 +607,23 @@
|
||||
<CudaCompile Include="pentablake.cu">
|
||||
<Filter>Source Files\CUDA</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x11\sib.cu">
|
||||
<Filter>Source Files\CUDA\x11</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x11\cuda_streebog.cu">
|
||||
<Filter>Source Files\CUDA\x11</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="x11\s3.cu">
|
||||
<Filter>Source Files\CUDA\x11</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="Algo256\blake256.cu">
|
||||
<Filter>Source Files\CUDA</Filter>
|
||||
<Filter>Source Files\CUDA\Algo256</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="Algo256\decred.cu">
|
||||
<Filter>Source Files\CUDA\Algo256</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="Algo256\vanilla.cu">
|
||||
<Filter>Source Files\CUDA\Algo256</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="Algo256\keccak256.cu">
|
||||
<Filter>Source Files\CUDA</Filter>
|
||||
@@ -598,18 +649,6 @@
|
||||
<CudaCompile Include="Algo256\cuda_skein256.cu">
|
||||
<Filter>Source Files\CUDA\Algo256</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="lyra2\cuda_lyra2.cu">
|
||||
<Filter>Source Files\CUDA</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="lyra2\lyra2RE.cu">
|
||||
<Filter>Source Files\CUDA</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="lyra2\cuda_lyra2v2.cu">
|
||||
<Filter>Source Files\CUDA</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="lyra2\lyra2REv2.cu">
|
||||
<Filter>Source Files\CUDA</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="zr5.cu">
|
||||
<Filter>Source Files\CUDA</Filter>
|
||||
</CudaCompile>
|
||||
@@ -658,6 +697,21 @@
|
||||
<CudaCompile Include="Algo256\cuda_bmw.cu">
|
||||
<Filter>Source Files\CUDA\Algo256</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="lyra2\cuda_lyra2.cu">
|
||||
<Filter>Source Files\CUDA\lyra2</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="lyra2\cuda_lyra2v2.cu">
|
||||
<Filter>Source Files\CUDA\lyra2</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="lyra2\lyra2RE.cu">
|
||||
<Filter>Source Files\CUDA\lyra2</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="lyra2\lyra2REv2.cu">
|
||||
<Filter>Source Files\CUDA\lyra2</Filter>
|
||||
</CudaCompile>
|
||||
<CudaCompile Include="Algo256\blake2s.cu">
|
||||
<Filter>Source Files\CUDA\Algo256</Filter>
|
||||
</CudaCompile>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<Image Include="res\ccminer.ico">
|
||||
@@ -674,4 +728,4 @@
|
||||
<Filter>Ressources</Filter>
|
||||
</Text>
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
</Project>
|
||||
+1
-7
@@ -1,4 +1,4 @@
|
||||
AC_INIT([ccminer], [1.7-dev])
|
||||
AC_INIT([ccminer], [1.7.6-r10], [], [ccminer], [http://github.com/tpruvot/ccminer])
|
||||
|
||||
AC_PREREQ([2.59c])
|
||||
AC_CANONICAL_SYSTEM
|
||||
@@ -76,12 +76,6 @@ 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
-1
@@ -1,4 +1,5 @@
|
||||
# possible additional CUDA_CFLAGS
|
||||
#-gencode=arch=compute_52,code=\"sm_52,compute_52\"
|
||||
#-gencode=arch=compute_50,code=\"sm_50,compute_50\"
|
||||
#-gencode=arch=compute_35,code=\"sm_35,compute_35\"
|
||||
#-gencode=arch=compute_30,code=\"sm_30,compute_30\"
|
||||
@@ -7,5 +8,6 @@
|
||||
|
||||
extracflags="-march=native -D_REENTRANT -falign-functions=16 -falign-jumps=16 -falign-labels=16"
|
||||
|
||||
CUDA_CFLAGS="-O3 -lineno -Xcompiler -Wall" ./configure CXXFLAGS="-O3 $extracflags" --with-cuda=/usr/local/cuda --with-nvml=libnvidia-ml.so
|
||||
CUDA_CFLAGS="-O3 -lineno -Xcompiler -Wall -D_FORCE_INLINES" \
|
||||
./configure CXXFLAGS="-O3 $extracflags" --with-cuda=/usr/local/cuda --with-nvml=libnvidia-ml.so
|
||||
|
||||
+4
-4
@@ -126,7 +126,7 @@
|
||||
#define LIBCURL_PROTOCOL_HTTP 1
|
||||
|
||||
/* Defined if libcurl supports HTTPS */
|
||||
/* #undef LIBCURL_PROTOCOL_HTTPS */
|
||||
#define LIBCURL_PROTOCOL_HTTPS 1
|
||||
|
||||
/* Defined if libcurl supports IMAP */
|
||||
/* #undef LIBCURL_PROTOCOL_IMAP */
|
||||
@@ -162,7 +162,7 @@
|
||||
#define PACKAGE_NAME "ccminer"
|
||||
|
||||
/* Define to the full name and version of this package. */
|
||||
#define PACKAGE_STRING "ccminer 1.7-dev"
|
||||
#define PACKAGE_STRING "ccminer 1.7.6"
|
||||
|
||||
/* Define to the one symbol short name of this package. */
|
||||
#define PACKAGE_TARNAME "ccminer"
|
||||
@@ -171,7 +171,7 @@
|
||||
#define PACKAGE_URL "http://github.com/tpruvot/ccminer"
|
||||
|
||||
/* Define to the version of this package. */
|
||||
#define PACKAGE_VERSION "1.7-dev"
|
||||
#define PACKAGE_VERSION "1.7.6"
|
||||
|
||||
/* 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 +185,7 @@
|
||||
#define STDC_HEADERS 1
|
||||
|
||||
/* Version number of package */
|
||||
#define VERSION "1.7-dev"
|
||||
#define VERSION "1.7.6"
|
||||
|
||||
/* Define curl_free() as free() if our version of curl lacks curl_free. */
|
||||
/* #undef curl_free */
|
||||
|
||||
@@ -4,10 +4,6 @@
|
||||
#include <unistd.h>
|
||||
#include <map>
|
||||
|
||||
#ifndef _WIN32
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
// include thrust
|
||||
#ifndef __cplusplus
|
||||
#include <thrust/version.h>
|
||||
@@ -23,6 +19,11 @@
|
||||
|
||||
#include "cuda_runtime.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
/* miner.h functions are declared in C type, not C++ */
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// CUDA Devices on the System
|
||||
int cuda_num_devices()
|
||||
{
|
||||
@@ -51,6 +52,11 @@ int cuda_num_devices()
|
||||
return GPU_N;
|
||||
}
|
||||
|
||||
int cuda_version()
|
||||
{
|
||||
return (int) CUDART_VERSION;
|
||||
}
|
||||
|
||||
void cuda_devicenames()
|
||||
{
|
||||
cudaError_t err;
|
||||
@@ -62,29 +68,31 @@ void cuda_devicenames()
|
||||
exit(1);
|
||||
}
|
||||
|
||||
GPU_N = min(MAX_GPUS, GPU_N);
|
||||
if (opt_n_threads)
|
||||
GPU_N = min(MAX_GPUS, opt_n_threads);
|
||||
for (int i=0; i < GPU_N; i++)
|
||||
{
|
||||
char vendorname[32] = { 0 };
|
||||
int dev_id = device_map[i];
|
||||
cudaDeviceProp props;
|
||||
cudaGetDeviceProperties(&props, device_map[i]);
|
||||
cudaGetDeviceProperties(&props, dev_id);
|
||||
|
||||
device_sm[i] = (props.major * 100 + props.minor * 10);
|
||||
device_sm[dev_id] = (props.major * 100 + props.minor * 10);
|
||||
|
||||
if (device_name[i]) {
|
||||
free(device_name[i]);
|
||||
device_name[i] = NULL;
|
||||
if (device_name[dev_id]) {
|
||||
free(device_name[dev_id]);
|
||||
device_name[dev_id] = 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);
|
||||
device_name[dev_id] = (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]);
|
||||
sprintf(device_name[dev_id], "%s %s", vendorname, &props.name[8]);
|
||||
else
|
||||
sprintf(device_name[i], "%s %s", vendorname, props.name);
|
||||
sprintf(device_name[dev_id], "%s %s", vendorname, props.name);
|
||||
} else
|
||||
#endif
|
||||
device_name[i] = strdup(props.name);
|
||||
device_name[dev_id] = strdup(props.name);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -93,11 +101,11 @@ void cuda_print_devices()
|
||||
int ngpus = cuda_num_devices();
|
||||
cuda_devicenames();
|
||||
for (int n=0; n < ngpus; n++) {
|
||||
int m = device_map[n];
|
||||
int dev_id = device_map[n % MAX_GPUS];
|
||||
cudaDeviceProp props;
|
||||
cudaGetDeviceProperties(&props, m);
|
||||
cudaGetDeviceProperties(&props, dev_id);
|
||||
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]);
|
||||
fprintf(stderr, "GPU #%d: SM %d.%d %s\n", dev_id, props.major, props.minor, device_name[dev_id]);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -143,19 +151,92 @@ int cuda_finddevice(char *name)
|
||||
return -1;
|
||||
}
|
||||
|
||||
uint32_t device_intensity(int thr_id, const char *func, uint32_t defcount)
|
||||
// since 1.7
|
||||
uint32_t cuda_default_throughput(int thr_id, uint32_t defcount)
|
||||
{
|
||||
//int dev_id = device_map[thr_id % MAX_GPUS];
|
||||
uint32_t throughput = gpus_intensity[thr_id] ? gpus_intensity[thr_id] : defcount;
|
||||
api_set_throughput(thr_id, throughput);
|
||||
if (gpu_threads > 1 && throughput == defcount) throughput /= (gpu_threads-1);
|
||||
if (api_thr_id != -1) api_set_throughput(thr_id, throughput);
|
||||
//gpulog(LOG_INFO, thr_id, "throughput %u", throughput);
|
||||
return throughput;
|
||||
}
|
||||
|
||||
// if we use 2 threads on the same gpu, we need to reinit the threads
|
||||
void cuda_reset_device(int thr_id, bool *init)
|
||||
{
|
||||
int dev_id = device_map[thr_id % MAX_GPUS];
|
||||
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;
|
||||
}
|
||||
}
|
||||
// force exit from algo's scan loops/function
|
||||
restart_threads();
|
||||
cudaDeviceSynchronize();
|
||||
while (cudaStreamQuery(NULL) == cudaErrorNotReady)
|
||||
usleep(1000);
|
||||
}
|
||||
cudaDeviceReset();
|
||||
if (opt_cudaschedule >= 0) {
|
||||
cudaSetDeviceFlags((unsigned)(opt_cudaschedule & cudaDeviceScheduleMask));
|
||||
} else {
|
||||
cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);
|
||||
}
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
|
||||
// return free memory in megabytes
|
||||
int cuda_available_memory(int thr_id)
|
||||
{
|
||||
int dev_id = device_map[thr_id % MAX_GPUS];
|
||||
size_t mtotal, mfree = 0;
|
||||
cudaSetDevice(dev_id);
|
||||
cudaMemGetInfo(&mfree, &mtotal);
|
||||
return (int) (mfree / (1024 * 1024));
|
||||
}
|
||||
|
||||
// Check (and reset) last cuda error, and report it in logs
|
||||
void cuda_log_lasterror(int thr_id, const char* func, int line)
|
||||
{
|
||||
cudaError_t err = cudaGetLastError();
|
||||
if (err != cudaSuccess && !opt_quiet)
|
||||
gpulog(LOG_WARNING, thr_id, "%s:%d %s", func, line, cudaGetErrorString(err));
|
||||
}
|
||||
|
||||
// Clear any cuda error in non-cuda unit (.c/.cpp)
|
||||
void cuda_clear_lasterror()
|
||||
{
|
||||
cudaGetLastError();
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
int cuda_gpu_clocks(struct cgpu_info *gpu)
|
||||
{
|
||||
cudaDeviceProp props;
|
||||
if (cudaGetDeviceProperties(&props, gpu->gpu_id) == cudaSuccess) {
|
||||
gpu->gpu_clock = props.clockRate;
|
||||
gpu->gpu_memclock = props.memoryClockRate;
|
||||
gpu->gpu_mem = props.totalGlobalMem;
|
||||
return 0;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Zeitsynchronisations-Routine von cudaminer mit CPU sleep
|
||||
// Note: if you disable all of these calls, CPU usage will hit 100%
|
||||
typedef struct { double value[8]; } tsumarray;
|
||||
cudaError_t MyStreamSynchronize(cudaStream_t stream, int situation, int thr_id)
|
||||
{
|
||||
cudaError_t result = cudaSuccess;
|
||||
if (abort_flag)
|
||||
return result;
|
||||
if (situation >= 0)
|
||||
{
|
||||
static std::map<int, tsumarray> tsum;
|
||||
@@ -181,45 +262,10 @@ cudaError_t MyStreamSynchronize(cudaStream_t stream, int situation, int thr_id)
|
||||
return result;
|
||||
}
|
||||
|
||||
int cuda_gpu_clocks(struct cgpu_info *gpu)
|
||||
{
|
||||
cudaDeviceProp props;
|
||||
if (cudaGetDeviceProperties(&props, gpu->gpu_id) == cudaSuccess) {
|
||||
gpu->gpu_clock = props.clockRate;
|
||||
gpu->gpu_memclock = props.memoryClockRate;
|
||||
gpu->gpu_mem = props.totalGlobalMem;
|
||||
return 0;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
// if we use 2 threads on the same gpu, we need to reinit the threads
|
||||
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;
|
||||
}
|
||||
}
|
||||
// force exit from algo's scan loops/function
|
||||
restart_threads();
|
||||
cudaDeviceSynchronize();
|
||||
while (cudaStreamQuery(NULL) == cudaErrorNotReady)
|
||||
usleep(1000);
|
||||
}
|
||||
cudaDeviceReset();
|
||||
if (opt_cudaschedule >= 0)
|
||||
cudaSetDeviceFlags((unsigned)(opt_cudaschedule & cudaDeviceScheduleMask));
|
||||
}
|
||||
|
||||
void cudaReportHardwareFailure(int thr_id, cudaError_t err, const char* func)
|
||||
{
|
||||
struct cgpu_info *gpu = &thr_info[thr_id].gpu;
|
||||
gpu->hw_errors++;
|
||||
applog(LOG_ERR, "GPU #%d: %s %s", device_map[thr_id], func, cudaGetErrorString(err));
|
||||
gpulog(LOG_ERR, thr_id, "%s %s", func, cudaGetErrorString(err));
|
||||
sleep(1);
|
||||
}
|
||||
+19
-6
@@ -11,23 +11,27 @@
|
||||
__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;
|
||||
static uint32_t* h_resNonces[MAX_GPUS] = { NULL };
|
||||
static uint32_t* d_resNonces[MAX_GPUS] = { NULL };
|
||||
static __thread 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));
|
||||
CUDA_SAFE_CALL(cudaMallocHost(&h_resNonces[thr_id], 32));
|
||||
init_done = true;
|
||||
}
|
||||
|
||||
__host__
|
||||
void cuda_check_cpu_free(int thr_id)
|
||||
{
|
||||
if (!init_done) return;
|
||||
cudaFree(d_resNonces[thr_id]);
|
||||
cudaFreeHost(h_resNonces[thr_id]);
|
||||
d_resNonces[thr_id] = NULL;
|
||||
h_resNonces[thr_id] = NULL;
|
||||
init_done = false;
|
||||
}
|
||||
|
||||
// Target Difficulty
|
||||
@@ -121,6 +125,9 @@ 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 (bench_algo >= 0) // dont interrupt the global benchmark
|
||||
return UINT32_MAX;
|
||||
|
||||
if (!init_done) {
|
||||
applog(LOG_ERR, "missing call to cuda_check_cpu_init");
|
||||
return UINT32_MAX;
|
||||
@@ -143,6 +150,9 @@ uint32_t cuda_check_hash_32(int thr_id, uint32_t threads, uint32_t startNounce,
|
||||
dim3 grid((threads + threadsperblock - 1) / threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
|
||||
if (bench_algo >= 0) // dont interrupt the global benchmark
|
||||
return UINT32_MAX;
|
||||
|
||||
if (!init_done) {
|
||||
applog(LOG_ERR, "missing call to cuda_check_cpu_init");
|
||||
return UINT32_MAX;
|
||||
@@ -192,7 +202,7 @@ uint32_t cuda_check_hash_suppl(int thr_id, uint32_t threads, uint32_t startNounc
|
||||
cuda_checkhash_64_suppl <<<grid, block>>> (startNounce, d_inputHash, d_resNonces[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
cudaMemcpy(h_resNonces[thr_id], d_resNonces[thr_id], 8*sizeof(uint32_t), cudaMemcpyDeviceToHost);
|
||||
cudaMemcpy(h_resNonces[thr_id], d_resNonces[thr_id], 32, cudaMemcpyDeviceToHost);
|
||||
rescnt = h_resNonces[thr_id][0];
|
||||
if (rescnt > numNonce) {
|
||||
if (numNonce <= rescnt) {
|
||||
@@ -237,9 +247,12 @@ uint32_t cuda_check_hash_branch(int thr_id, uint32_t threads, uint32_t startNoun
|
||||
|
||||
uint32_t result = UINT32_MAX;
|
||||
|
||||
if (bench_algo >= 0) // dont interrupt the global benchmark
|
||||
return result;
|
||||
|
||||
if (!init_done) {
|
||||
applog(LOG_ERR, "missing call to cuda_check_cpu_init");
|
||||
return UINT32_MAX;
|
||||
return result;
|
||||
}
|
||||
|
||||
cudaMemset(d_resNonces[thr_id], 0xff, sizeof(uint32_t));
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
/**
|
||||
* Helper to trace gpu computed data with --cputest
|
||||
*
|
||||
* Sample usage in an algo scan cuda unit :
|
||||
*
|
||||
* #define _DEBUG
|
||||
* #define _DEBUG_PREFIX "x11-"
|
||||
* #include "cuda_debug.cuh"
|
||||
*
|
||||
* TRACE64("luffa", d_hash);
|
||||
* or
|
||||
* TRACE("luffa")
|
||||
*
|
||||
* Dont forget to link the scan function in util.cpp (do_gpu_tests)
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
//#include "cuda_helper.h"
|
||||
|
||||
#ifndef _DEBUG_PREFIX
|
||||
#define _DEBUG_PREFIX ""
|
||||
#endif
|
||||
|
||||
#ifdef _DEBUG
|
||||
#define TRACE64(algo, d_buf) { \
|
||||
if (max_nonce == 1 && pdata[19] <= 1 && !opt_benchmark) { \
|
||||
uint32_t oft = 0; \
|
||||
uint32_t* debugbuf = NULL; \
|
||||
cudaMallocHost(&debugbuf, 16*sizeof(uint32_t)); \
|
||||
cudaMemcpy(debugbuf, d_buf[thr_id] + oft, 16*sizeof(uint32_t), cudaMemcpyDeviceToHost); \
|
||||
printf(_DEBUG_PREFIX "%s %08x %08x %08x %08x %08x %08x %08x %08x %08x %08x %08x %08x %08x %08x %08x %08x\n", \
|
||||
algo, \
|
||||
swab32(debugbuf[0]), swab32(debugbuf[1]), swab32(debugbuf[2]), swab32(debugbuf[3]), \
|
||||
swab32(debugbuf[4]), swab32(debugbuf[5]), swab32(debugbuf[6]), swab32(debugbuf[7]), \
|
||||
swab32(debugbuf[8]), swab32(debugbuf[9]), swab32(debugbuf[10]),swab32(debugbuf[11]), \
|
||||
swab32(debugbuf[12]),swab32(debugbuf[13]),swab32(debugbuf[14]),swab32(debugbuf[15])); \
|
||||
cudaFreeHost(debugbuf); \
|
||||
} \
|
||||
}
|
||||
#else
|
||||
#define TRACE64(algo, d_buf) {}
|
||||
#endif
|
||||
|
||||
// simplified default
|
||||
#define TRACE(algo) TRACE64(algo, d_hash)
|
||||
|
||||
+3
-3
@@ -1,7 +1,7 @@
|
||||
#ifndef _CUDA_FUGUE512_H
|
||||
#define _CUDA_FUGUE512_H
|
||||
#ifndef _CUDA_FUGUE256_H
|
||||
#define _CUDA_FUGUE256_H
|
||||
|
||||
void fugue256_cpu_hash(int thr_id, uint32_t threads, int startNounce, void *outputHashes, uint32_t *nounce);
|
||||
void fugue256_cpu_hash(int thr_id, uint32_t threads, uint32_t startNounce, void *outputHashes, uint32_t *nounce);
|
||||
void fugue256_cpu_setBlock(int thr_id, void *data, void *pTargetIn);
|
||||
void fugue256_cpu_init(int thr_id, uint32_t threads);
|
||||
void fugue256_cpu_free(int thr_id);
|
||||
|
||||
+2
-2
@@ -99,7 +99,7 @@ void groestlcoin_cpu_init(int thr_id, uint32_t threads)
|
||||
// to check if the binary supports SM3+
|
||||
cuda_get_arch(thr_id);
|
||||
|
||||
cudaMalloc(&d_resultNonce[thr_id], sizeof(uint32_t));
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_resultNonce[thr_id], sizeof(uint32_t)));
|
||||
}
|
||||
|
||||
__host__
|
||||
@@ -153,7 +153,7 @@ void groestlcoin_cpu_hash(int thr_id, uint32_t threads, uint32_t startNounce, vo
|
||||
|
||||
int dev_id = device_map[thr_id];
|
||||
if (device_sm[dev_id] < 300 || cuda_arch[dev_id] < 300) {
|
||||
printf("Sorry, This algo is not supported by this GPU arch (SM 3.0 required)");
|
||||
gpulog(LOG_ERR, thr_id, "Sorry, This algo is not supported by this GPU arch (SM 3.0 required)");
|
||||
proper_exit(EXIT_CODE_CUDA_ERROR);
|
||||
}
|
||||
|
||||
|
||||
+73
-81
@@ -11,6 +11,7 @@
|
||||
#define __launch_bounds__(max_tpb, min_blocks)
|
||||
#endif
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#ifndef UINT32_MAX
|
||||
@@ -29,7 +30,6 @@ extern int cuda_arch[MAX_GPUS];
|
||||
|
||||
// common functions
|
||||
extern int cuda_get_arch(int thr_id);
|
||||
extern void cuda_reset_device(int thr_id, bool *init);
|
||||
extern void cuda_check_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void cuda_check_cpu_free(int thr_id);
|
||||
extern void cuda_check_cpu_setTarget(const void *ptarget);
|
||||
@@ -96,7 +96,6 @@ __device__ __forceinline__ uint64_t REPLACE_LODWORD(const uint64_t &x, const uin
|
||||
return (x & 0xFFFFFFFF00000000ULL) | ((uint64_t)y);
|
||||
}
|
||||
|
||||
// Endian Drehung für 32 Bit Typen
|
||||
#ifdef __CUDA_ARCH__
|
||||
__device__ __forceinline__ uint32_t cuda_swab32(uint32_t x)
|
||||
{
|
||||
@@ -133,8 +132,16 @@ __device__ __forceinline__ uint64_t cuda_swab64(uint64_t x)
|
||||
{
|
||||
// Input: 77665544 33221100
|
||||
// Output: 00112233 44556677
|
||||
uint64_t result = __byte_perm((uint32_t) x, 0, 0x0123);
|
||||
return (result << 32) | __byte_perm(_HIDWORD(x), 0, 0x0123);
|
||||
uint64_t result;
|
||||
//result = __byte_perm((uint32_t) x, 0, 0x0123);
|
||||
//return (result << 32) + __byte_perm(_HIDWORD(x), 0, 0x0123);
|
||||
asm("{ .reg .b32 x, y; // swab64\n\t"
|
||||
"mov.b64 {x,y}, %1;\n\t"
|
||||
"prmt.b32 x, x, 0, 0x0123;\n\t"
|
||||
"prmt.b32 y, y, 0, 0x0123;\n\t"
|
||||
"mov.b64 %0, {y,x};\n\t"
|
||||
"}\n" : "=l"(result): "l"(x));
|
||||
return result;
|
||||
}
|
||||
#else
|
||||
/* host */
|
||||
@@ -198,7 +205,7 @@ __device__ __forceinline__
|
||||
uint64_t xor1(uint64_t a, uint64_t b)
|
||||
{
|
||||
uint64_t result;
|
||||
asm("xor.b64 %0, %1, %2;" : "=l"(result) : "l"(a), "l"(b));
|
||||
asm("xor.b64 %0, %1, %2; // xor1" : "=l"(result) : "l"(a), "l"(b));
|
||||
return result;
|
||||
}
|
||||
#else
|
||||
@@ -211,7 +218,7 @@ __device__ __forceinline__
|
||||
uint64_t xor3(uint64_t a, uint64_t b, uint64_t c)
|
||||
{
|
||||
uint64_t result;
|
||||
asm("xor.b64 %0, %2, %3;\n\t"
|
||||
asm("xor.b64 %0, %2, %3; // xor3\n\t"
|
||||
"xor.b64 %0, %0, %1;\n\t"
|
||||
/* output : input registers */
|
||||
: "=l"(result) : "l"(a), "l"(b), "l"(c));
|
||||
@@ -246,49 +253,31 @@ uint64_t xandx(uint64_t a, uint64_t b, uint64_t c)
|
||||
{
|
||||
#ifdef __CUDA_ARCH__
|
||||
uint64_t result;
|
||||
asm("{\n\t"
|
||||
asm("{ // xandx \n\t"
|
||||
".reg .u64 n;\n\t"
|
||||
"xor.b64 %0, %2, %3;\n\t"
|
||||
"and.b64 n, %0, %1;\n\t"
|
||||
"xor.b64 %0, n, %3;"
|
||||
"}\n"
|
||||
: "=l"(result) : "l"(a), "l"(b), "l"(c));
|
||||
"xor.b64 %0, n, %3;\n\t"
|
||||
"}\n" : "=l"(result) : "l"(a), "l"(b), "l"(c));
|
||||
return result;
|
||||
#else
|
||||
return ((b^c) & a) ^ c;
|
||||
#endif
|
||||
}
|
||||
|
||||
// device asm for x17
|
||||
__device__ __forceinline__
|
||||
uint64_t sph_t64(uint64_t x)
|
||||
{
|
||||
#ifdef __CUDA_ARCH__
|
||||
uint64_t result;
|
||||
asm("{\n\t"
|
||||
"and.b64 %0,%1,0xFFFFFFFFFFFFFFFF;\n\t"
|
||||
"}\n"
|
||||
: "=l"(result) : "l"(x));
|
||||
return result;
|
||||
#else
|
||||
return x;
|
||||
#endif
|
||||
}
|
||||
|
||||
// device asm for x17
|
||||
__device__ __forceinline__
|
||||
uint64_t andor(uint64_t a, uint64_t b, uint64_t c)
|
||||
{
|
||||
#ifdef __CUDA_ARCH__
|
||||
uint64_t result;
|
||||
asm("{\n\t"
|
||||
asm("{ // andor\n\t"
|
||||
".reg .u64 m,n;\n\t"
|
||||
"and.b64 m, %1, %2;\n\t"
|
||||
" or.b64 n, %1, %2;\n\t"
|
||||
"and.b64 %0, n, %3;\n\t"
|
||||
" or.b64 %0, %0, m ;\n\t"
|
||||
"}\n"
|
||||
: "=l"(result) : "l"(a), "l"(b), "l"(c));
|
||||
" or.b64 %0, %0, m;\n\t"
|
||||
"}\n" : "=l"(result) : "l"(a), "l"(b), "l"(c));
|
||||
return result;
|
||||
#else
|
||||
return ((a | b) & c) | (a & b);
|
||||
@@ -302,7 +291,6 @@ uint64_t shr_t64(uint64_t x, uint32_t n)
|
||||
#ifdef __CUDA_ARCH__
|
||||
uint64_t result;
|
||||
asm("shr.b64 %0,%1,%2;\n\t"
|
||||
"and.b64 %0,%0,0xFFFFFFFFFFFFFFFF;\n\t" /* useful ? */
|
||||
: "=l"(result) : "l"(x), "r"(n));
|
||||
return result;
|
||||
#else
|
||||
@@ -316,7 +304,6 @@ uint64_t shl_t64(uint64_t x, uint32_t n)
|
||||
#ifdef __CUDA_ARCH__
|
||||
uint64_t result;
|
||||
asm("shl.b64 %0,%1,%2;\n\t"
|
||||
"and.b64 %0,%0,0xFFFFFFFFFFFFFFFF;\n\t" /* useful ? */
|
||||
: "=l"(result) : "l"(x), "r"(n));
|
||||
return result;
|
||||
#else
|
||||
@@ -370,15 +357,14 @@ __device__ __forceinline__
|
||||
uint64_t ROTR64(const uint64_t x, const int offset)
|
||||
{
|
||||
uint64_t result;
|
||||
asm("{\n\t"
|
||||
asm("{ // ROTR64 \n\t"
|
||||
".reg .b64 lhs;\n\t"
|
||||
".reg .u32 roff;\n\t"
|
||||
"shr.b64 lhs, %1, %2;\n\t"
|
||||
"sub.u32 roff, 64, %2;\n\t"
|
||||
"shl.b64 %0, %1, roff;\n\t"
|
||||
"add.u64 %0, %0, lhs;\n\t"
|
||||
"}\n"
|
||||
: "=l"(result) : "l"(x), "r"(offset));
|
||||
"}\n" : "=l"(result) : "l"(x), "r"(offset));
|
||||
return result;
|
||||
}
|
||||
#else
|
||||
@@ -405,15 +391,14 @@ __device__ __forceinline__
|
||||
uint64_t ROTL64(const uint64_t x, const int offset)
|
||||
{
|
||||
uint64_t result;
|
||||
asm("{\n\t"
|
||||
asm("{ // ROTL64 \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));
|
||||
"}\n" : "=l"(result) : "l"(x), "r"(offset));
|
||||
return result;
|
||||
}
|
||||
#elif __CUDA_ARCH__ >= 320 && USE_ROT_ASM_OPT == 3
|
||||
@@ -421,7 +406,7 @@ __device__
|
||||
uint64_t ROTL64(const uint64_t x, const int offset)
|
||||
{
|
||||
uint64_t res;
|
||||
asm("{\n\t"
|
||||
asm("{ // ROTL64 \n\t"
|
||||
".reg .u32 tl,th,vl,vh;\n\t"
|
||||
".reg .pred p;\n\t"
|
||||
"mov.b64 {tl,th}, %1;\n\t"
|
||||
@@ -430,8 +415,7 @@ uint64_t ROTL64(const uint64_t x, const int offset)
|
||||
"setp.lt.u32 p, %2, 32;\n\t"
|
||||
"@!p mov.b64 %0, {vl,vh};\n\t"
|
||||
"@p mov.b64 %0, {vh,vl};\n\t"
|
||||
"}"
|
||||
: "=l"(res) : "l"(x) , "r"(offset)
|
||||
"}\n" : "=l"(res) : "l"(x) , "r"(offset)
|
||||
);
|
||||
return res;
|
||||
}
|
||||
@@ -486,6 +470,15 @@ static __host__ __device__ __forceinline__ uint64_t devectorize(uint2 v) {
|
||||
#endif
|
||||
}
|
||||
|
||||
static __device__ __forceinline__ uint2 eorswap32(uint2 u, uint2 v)
|
||||
{
|
||||
uint2 result;
|
||||
result.y = u.x ^ v.x;
|
||||
result.x = u.y ^ v.y;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* uint2 direct ops by c++ operator definitions
|
||||
*/
|
||||
@@ -498,11 +491,10 @@ static __device__ __forceinline__ void operator^= (uint2 &a, uint2 b) { a = a ^
|
||||
static __device__ __forceinline__ uint2 operator+ (uint2 a, uint2 b) {
|
||||
#ifdef __CUDA_ARCH__
|
||||
uint2 result;
|
||||
asm("{\n\t"
|
||||
"add.cc.u32 %0,%2,%4; \n\t"
|
||||
"addc.u32 %1,%3,%5; \n\t"
|
||||
"}\n\t"
|
||||
: "=r"(result.x), "=r"(result.y) : "r"(a.x), "r"(a.y), "r"(b.x), "r"(b.y));
|
||||
asm("{ // uint2 a+b \n\t"
|
||||
"add.cc.u32 %0, %2, %4; \n\t"
|
||||
"addc.u32 %1, %3, %5; \n\t"
|
||||
"}\n" : "=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));
|
||||
@@ -514,11 +506,10 @@ static __device__ __forceinline__ void operator+= (uint2 &a, uint2 b) { a = a +
|
||||
static __device__ __forceinline__ uint2 operator- (uint2 a, uint2 b) {
|
||||
#if defined(__CUDA_ARCH__) && CUDA_VERSION < 7000
|
||||
uint2 result;
|
||||
asm("{\n\t"
|
||||
"sub.cc.u32 %0,%2,%4; \n\t"
|
||||
"subc.u32 %1,%3,%5; \n\t"
|
||||
"}\n\t"
|
||||
: "=r"(result.x), "=r"(result.y) : "r"(a.x), "r"(a.y), "r"(b.x), "r"(b.y));
|
||||
asm("{ // uint2 a-b \n\t"
|
||||
"sub.cc.u32 %0, %2, %4; \n\t"
|
||||
"subc.u32 %1, %3, %5; \n\t"
|
||||
"}\n" : "=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));
|
||||
@@ -534,13 +525,12 @@ static __device__ __forceinline__ uint2 operator* (uint2 a, uint2 b)
|
||||
{
|
||||
#ifdef __CUDA_ARCH__
|
||||
uint2 result;
|
||||
asm("{\n\t"
|
||||
"mul.lo.u32 %0,%2,%4; \n\t"
|
||||
"mul.hi.u32 %1,%2,%4; \n\t"
|
||||
"mad.lo.cc.u32 %1,%3,%4,%1; \n\t"
|
||||
"madc.lo.u32 %1,%3,%5,%1; \n\t"
|
||||
"}\n\t"
|
||||
: "=r"(result.x), "=r"(result.y) : "r"(a.x), "r"(a.y), "r"(b.x), "r"(b.y));
|
||||
asm("{ // uint2 a*b \n\t"
|
||||
"mul.lo.u32 %0, %2, %4; \n\t"
|
||||
"mul.hi.u32 %1, %2, %4; \n\t"
|
||||
"mad.lo.cc.u32 %1, %3, %4, %1; \n\t"
|
||||
"madc.lo.u32 %1, %3, %5, %1; \n\t"
|
||||
"}\n" : "=r"(result.x), "=r"(result.y) : "r"(a.x), "r"(a.y), "r"(b.x), "r"(b.y));
|
||||
return result;
|
||||
#else
|
||||
// incorrect but unused host equiv
|
||||
@@ -579,11 +569,9 @@ uint2 ROR2(const uint2 a, const int offset)
|
||||
return result;
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
uint2 ROL2(const uint2 a, const int offset)
|
||||
{
|
||||
#if __CUDA_ARCH__ >= 350
|
||||
__inline__ __device__ uint2 ROL2(const uint2 a, const int offset) {
|
||||
uint2 result;
|
||||
#if __CUDA_ARCH__ > 300
|
||||
if (offset >= 32) {
|
||||
asm("shf.l.wrap.b32 %0, %1, %2, %3;" : "=r"(result.x) : "r"(a.x), "r"(a.y), "r"(offset));
|
||||
asm("shf.l.wrap.b32 %0, %1, %2, %3;" : "=r"(result.y) : "r"(a.y), "r"(a.x), "r"(offset));
|
||||
@@ -592,14 +580,20 @@ uint2 ROL2(const uint2 a, const int offset)
|
||||
asm("shf.l.wrap.b32 %0, %1, %2, %3;" : "=r"(result.x) : "r"(a.y), "r"(a.x), "r"(offset));
|
||||
asm("shf.l.wrap.b32 %0, %1, %2, %3;" : "=r"(result.y) : "r"(a.x), "r"(a.y), "r"(offset));
|
||||
}
|
||||
#else
|
||||
if (!offset)
|
||||
result = a;
|
||||
else
|
||||
result = ROR2(a, 64 - offset);
|
||||
#endif
|
||||
return result;
|
||||
}
|
||||
#else
|
||||
__inline__ __device__ uint2 ROL2(const uint2 v, const int n)
|
||||
{
|
||||
uint2 result;
|
||||
if (!n)
|
||||
result = v;
|
||||
else
|
||||
result = ROR2(v, 64 - n);
|
||||
|
||||
return result;
|
||||
}
|
||||
#endif
|
||||
|
||||
__device__ __forceinline__
|
||||
uint2 SWAPUINT2(uint2 value)
|
||||
@@ -633,9 +627,9 @@ __device__ __inline__ uint2 ROR24(const uint2 a)
|
||||
return result;
|
||||
}
|
||||
#else
|
||||
#define ROL8(u) ((u) << 8)
|
||||
#define ROR16(u) ((u) >> 16)
|
||||
#define ROR24(u) ((u) >> 24)
|
||||
#define ROL8(u) ROL2(u, 8)
|
||||
#define ROR16(u) ROR2(u,16)
|
||||
#define ROR24(u) ROR2(u,24)
|
||||
#endif
|
||||
|
||||
/* uint2 for bmw512 - to double check later */
|
||||
@@ -646,17 +640,15 @@ static uint2 SHL2(uint2 a, int offset)
|
||||
#if __CUDA_ARCH__ > 300
|
||||
uint2 result;
|
||||
if (offset < 32) {
|
||||
asm("{\n\t"
|
||||
"shf.l.clamp.b32 %1,%2,%3,%4; \n\t"
|
||||
"shl.b32 %0,%2,%4; \n\t"
|
||||
"}\n\t"
|
||||
: "=r"(result.x), "=r"(result.y) : "r"(a.x), "r"(a.y), "r"(offset));
|
||||
asm("{ // SHL2 (l) \n\t"
|
||||
"shf.l.clamp.b32 %1, %2, %3, %4; \n\t"
|
||||
"shl.b32 %0, %2, %4; \n\t"
|
||||
"}\n" : "=r"(result.x), "=r"(result.y) : "r"(a.x), "r"(a.y), "r"(offset));
|
||||
} else {
|
||||
asm("{\n\t"
|
||||
"shf.l.clamp.b32 %1,%2,%3,%4; \n\t"
|
||||
"shl.b32 %0,%2,%4; \n\t"
|
||||
"}\n\t"
|
||||
: "=r"(result.x), "=r"(result.y) : "r"(a.y), "r"(a.x), "r"(offset));
|
||||
asm("{ // SHL2 (h) \n\t"
|
||||
"shf.l.clamp.b32 %1, %2, %3, %4; \n\t"
|
||||
"shl.b32 %0, %2, %4; \n\t"
|
||||
"}\n" : "=r"(result.x), "=r"(result.y) : "r"(a.y), "r"(a.x), "r"(offset));
|
||||
}
|
||||
return result;
|
||||
#else
|
||||
|
||||
+18
-25
@@ -10,26 +10,10 @@ extern "C"
|
||||
#include "miner.h"
|
||||
|
||||
#include "cuda_helper.h"
|
||||
#include "quark/cuda_quark.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_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_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 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_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);
|
||||
|
||||
|
||||
// Original nist5hash Funktion aus einem miner Quelltext
|
||||
extern "C" void nist5hash(void *state, const void *input)
|
||||
{
|
||||
@@ -74,14 +58,15 @@ extern "C" int scanhash_nist5(int thr_id, struct work *work, uint32_t max_nonce,
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
int res = 0;
|
||||
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1 << 20); // 256*256*16
|
||||
throughput = min(throughput, (max_nonce - first_nonce));
|
||||
uint32_t throughput = cuda_default_throughput(thr_id, 1 << 20); // 256*256*16
|
||||
if (init[thr_id]) throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0x00FF;
|
||||
|
||||
if (!init[thr_id])
|
||||
{
|
||||
cudaDeviceSynchronize();
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
|
||||
// Constants copy/init (no device alloc in these algos)
|
||||
@@ -133,12 +118,12 @@ extern "C" int scanhash_nist5(int thr_id, struct work *work, uint32_t max_nonce,
|
||||
if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) {
|
||||
res = 1;
|
||||
uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1);
|
||||
bn_store_hash_target_ratio(vhash64, ptarget, work);
|
||||
work_set_target_ratio(work, vhash64);
|
||||
if (secNonce != 0) {
|
||||
be32enc(&endiandata[19], secNonce);
|
||||
nist5hash(vhash64, endiandata);
|
||||
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio)
|
||||
bn_store_hash_target_ratio(vhash64, ptarget, work);
|
||||
work_set_target_ratio(work, vhash64);
|
||||
pdata[21] = secNonce;
|
||||
res++;
|
||||
}
|
||||
@@ -146,15 +131,21 @@ extern "C" int scanhash_nist5(int thr_id, struct work *work, uint32_t max_nonce,
|
||||
goto out;
|
||||
}
|
||||
else {
|
||||
applog(LOG_WARNING, "GPU #%d: result for nonce %08x does not validate on CPU!", device_map[thr_id], foundNonce);
|
||||
gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", foundNonce);
|
||||
}
|
||||
}
|
||||
|
||||
if ((uint64_t) throughput + pdata[19] >= max_nonce) {
|
||||
pdata[19] = max_nonce;
|
||||
break;
|
||||
}
|
||||
|
||||
pdata[19] += throughput;
|
||||
|
||||
} while (pdata[19] < max_nonce && !work_restart[thr_id].restart);
|
||||
} while (!work_restart[thr_id].restart);
|
||||
|
||||
out:
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
#ifdef USE_STREAMS
|
||||
for (int i = 0; i < 5; i++)
|
||||
cudaStreamDestroy(stream[i]);
|
||||
@@ -169,12 +160,14 @@ extern "C" void free_nist5(int thr_id)
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
cudaFree(d_hash[thr_id]);
|
||||
|
||||
quark_blake512_cpu_free(thr_id);
|
||||
quark_groestl512_cpu_free(thr_id);
|
||||
cuda_check_cpu_free(thr_id);
|
||||
init[thr_id] = false;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
}
|
||||
+6
-1
@@ -708,6 +708,12 @@ __host__
|
||||
void skeincoin_init(int thr_id)
|
||||
{
|
||||
cuda_get_arch(thr_id);
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_found[thr_id], 2 * sizeof(uint32_t)));
|
||||
}
|
||||
|
||||
__host__
|
||||
void skeincoin_free(int thr_id) {
|
||||
cudaFree(d_found[thr_id]);
|
||||
}
|
||||
|
||||
__host__
|
||||
@@ -716,7 +722,6 @@ void skeincoin_setBlock_80(int thr_id, void *pdata)
|
||||
uint64_t message[16];
|
||||
memcpy(&message[0], pdata, 80);
|
||||
|
||||
CUDA_SAFE_CALL(cudaMalloc(&(d_found[thr_id]), 2 * sizeof(uint32_t)));
|
||||
cudaMemcpyToSymbol(c_message16, &message[8], 16, 0, cudaMemcpyHostToDevice);
|
||||
|
||||
precalc(message);
|
||||
|
||||
-248
@@ -1,248 +0,0 @@
|
||||
#ifndef CUDA_VECTOR_H
|
||||
#define CUDA_VECTOR_H
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
#if (defined(_MSC_VER) && defined(_WIN64)) || defined(__LP64__)
|
||||
#define __LDG_PTR "l"
|
||||
#else
|
||||
#define __LDG_PTR "r"
|
||||
#endif
|
||||
|
||||
#include "cuda_helper.h"
|
||||
|
||||
//typedef __device_builtin__ struct ulong16 ulong16;
|
||||
|
||||
typedef struct __align__(32) uint8
|
||||
{
|
||||
unsigned int s0, s1, s2, s3, s4, s5, s6, s7;
|
||||
} uint8;
|
||||
|
||||
typedef struct __align__(64) uint16
|
||||
{
|
||||
union {
|
||||
struct {unsigned int s0, s1, s2, s3, s4, s5, s6, s7;};
|
||||
uint8 lo;
|
||||
};
|
||||
union {
|
||||
struct {unsigned int s8, s9, sa, sb, sc, sd, se, sf;};
|
||||
uint8 hi;
|
||||
};
|
||||
} uint16;
|
||||
|
||||
|
||||
static __inline__ __host__ __device__ uint16 make_uint16(
|
||||
unsigned int s0, unsigned int s1, unsigned int s2, unsigned int s3, unsigned int s4, unsigned int s5, unsigned int s6, unsigned int s7,
|
||||
unsigned int s8, unsigned int s9, unsigned int sa, unsigned int sb, unsigned int sc, unsigned int sd, unsigned int se, unsigned int sf)
|
||||
{
|
||||
uint16 t; t.s0 = s0; t.s1 = s1; t.s2 = s2; t.s3 = s3; t.s4 = s4; t.s5 = s5; t.s6 = s6; t.s7 = s7;
|
||||
t.s8 = s8; t.s9 = s9; t.sa = sa; t.sb = sb; t.sc = sc; t.sd = sd; t.se = se; t.sf = sf;
|
||||
return t;
|
||||
}
|
||||
|
||||
static __inline__ __host__ __device__ uint16 make_uint16(const uint8 &a, const uint8 &b)
|
||||
{
|
||||
uint16 t; t.lo=a; t.hi=b; return t;
|
||||
}
|
||||
|
||||
static __inline__ __host__ __device__ uint8 make_uint8(
|
||||
unsigned int s0, unsigned int s1, unsigned int s2, unsigned int s3, unsigned int s4, unsigned int s5, unsigned int s6, unsigned int s7)
|
||||
{
|
||||
uint8 t; t.s0 = s0; t.s1 = s1; t.s2 = s2; t.s3 = s3; t.s4 = s4; t.s5 = s5; t.s6 = s6; t.s7 = s7;
|
||||
return t;
|
||||
}
|
||||
|
||||
|
||||
static __forceinline__ __device__ uchar4 operator^ (uchar4 a, uchar4 b) { return make_uchar4(a.x ^ b.x, a.y ^ b.y, a.z ^ b.z, a.w ^ b.w); }
|
||||
static __forceinline__ __device__ uchar4 operator+ (uchar4 a, uchar4 b) { return make_uchar4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w); }
|
||||
|
||||
|
||||
static __forceinline__ __device__ uint4 operator^ (uint4 a, uint4 b) { return make_uint4(a.x ^ b.x, a.y ^ b.y, a.z ^ b.z, a.w ^ b.w); }
|
||||
static __forceinline__ __device__ uint4 operator+ (uint4 a, uint4 b) { return make_uint4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w); }
|
||||
|
||||
|
||||
static __forceinline__ __device__ ulonglong4 operator^ (ulonglong4 a, ulonglong4 b) { return make_ulonglong4(a.x ^ b.x, a.y ^ b.y, a.z ^ b.z, a.w ^ b.w); }
|
||||
static __forceinline__ __device__ ulonglong4 operator+ (ulonglong4 a, ulonglong4 b) { return make_ulonglong4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w); }
|
||||
static __forceinline__ __device__ ulonglong2 operator^ (ulonglong2 a, ulonglong2 b) { return make_ulonglong2(a.x ^ b.x, a.y ^ b.y); }
|
||||
|
||||
|
||||
static __forceinline__ __device__ __host__ uint8 operator^ (const uint8 &a, const uint8 &b) { return make_uint8(a.s0 ^ b.s0, a.s1 ^ b.s1, a.s2 ^ b.s2, a.s3 ^ b.s3, a.s4 ^ b.s4, a.s5 ^ b.s5, a.s6 ^ b.s6, a.s7 ^ b.s7); }
|
||||
|
||||
static __forceinline__ __device__ __host__ uint8 operator+ (const uint8 &a, const uint8 &b) { return make_uint8(a.s0 + b.s0, a.s1 + b.s1, a.s2 + b.s2, a.s3 + b.s3, a.s4 + b.s4, a.s5 + b.s5, a.s6 + b.s6, a.s7 + b.s7); }
|
||||
|
||||
static __forceinline__ __device__ __host__ uint16 operator^ (const uint16 &a, const uint16 &b) {
|
||||
return make_uint16(a.s0 ^ b.s0, a.s1 ^ b.s1, a.s2 ^ b.s2, a.s3 ^ b.s3, a.s4 ^ b.s4, a.s5 ^ b.s5, a.s6 ^ b.s6, a.s7 ^ b.s7,
|
||||
a.s8 ^ b.s8, a.s9 ^ b.s9, a.sa ^ b.sa, a.sb ^ b.sb, a.sc ^ b.sc, a.sd ^ b.sd, a.se ^ b.se, a.sf ^ b.sf);
|
||||
}
|
||||
|
||||
static __forceinline__ __device__ __host__ uint16 operator+ (const uint16 &a, const uint16 &b) {
|
||||
return make_uint16(a.s0 + b.s0, a.s1 + b.s1, a.s2 + b.s2, a.s3 + b.s3, a.s4 + b.s4, a.s5 + b.s5, a.s6 + b.s6, a.s7 + b.s7,
|
||||
a.s8 + b.s8, a.s9 + b.s9, a.sa + b.sa, a.sb + b.sb, a.sc + b.sc, a.sd + b.sd, a.se + b.se, a.sf + b.sf);
|
||||
}
|
||||
|
||||
static __forceinline__ __device__ void operator^= (uint4 &a, uint4 b) { a = a ^ b; }
|
||||
static __forceinline__ __device__ void operator^= (uchar4 &a, uchar4 b) { a = a ^ b; }
|
||||
static __forceinline__ __device__ __host__ void operator^= (uint8 &a, const uint8 &b) { a = a ^ b; }
|
||||
static __forceinline__ __device__ __host__ void operator^= (uint16 &a, const uint16 &b) { a = a ^ b; }
|
||||
|
||||
|
||||
static __forceinline__ __device__ void operator^= (ulonglong4 &a, const ulonglong4 &b) { a = a ^ b; }
|
||||
static __forceinline__ __device__ void operator^= (ulonglong2 &a, const ulonglong2 &b) { a = a ^ b; }
|
||||
|
||||
static __forceinline__ __device__ void operator+= (uint4 &a, uint4 b) { a = a + b; }
|
||||
static __forceinline__ __device__ void operator+= (uchar4 &a, uchar4 b) { a = a + b; }
|
||||
static __forceinline__ __device__ __host__ void operator+= (uint8 &a, const uint8 &b) { a = a + b; }
|
||||
static __forceinline__ __device__ __host__ void operator+= (uint16 &a, const uint16 &b) { a = a + b; }
|
||||
|
||||
#if __CUDA_ARCH__ < 320
|
||||
|
||||
#define rotateL ROTL32
|
||||
#define rotateR ROTR32
|
||||
|
||||
#else
|
||||
|
||||
static __forceinline__ __device__ uint32_t rotateL(uint32_t vec4, uint32_t shift)
|
||||
{
|
||||
uint32_t ret;
|
||||
asm("shf.l.wrap.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(vec4), "r"(vec4), "r"(shift));
|
||||
return ret;
|
||||
}
|
||||
|
||||
static __forceinline__ __device__ uint32_t rotateR(uint32_t vec4, uint32_t shift)
|
||||
{
|
||||
uint32_t ret;
|
||||
asm("shf.r.wrap.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(vec4), "r"(vec4), "r"(shift));
|
||||
return ret;
|
||||
}
|
||||
|
||||
static __device__ __inline__ uint8 __ldg8(const uint8_t *ptr)
|
||||
{
|
||||
uint8 test;
|
||||
asm volatile ("ld.global.nc.v4.u32 {%0,%1,%2,%3},[%4];" : "=r"(test.s0), "=r"(test.s1), "=r"(test.s2), "=r"(test.s3) : __LDG_PTR(ptr));
|
||||
asm volatile ("ld.global.nc.v4.u32 {%0,%1,%2,%3},[%4+16];" : "=r"(test.s4), "=r"(test.s5), "=r"(test.s6), "=r"(test.s7) : __LDG_PTR(ptr));
|
||||
return (test);
|
||||
}
|
||||
|
||||
static __device__ __inline__ uint32_t __ldgtoint(const uint8_t *ptr)
|
||||
{
|
||||
uint32_t test;
|
||||
asm volatile ("ld.global.nc.u32 {%0},[%1];" : "=r"(test) : __LDG_PTR(ptr));
|
||||
return (test);
|
||||
}
|
||||
|
||||
static __device__ __inline__ uint32_t __ldgtoint64(const uint8_t *ptr)
|
||||
{
|
||||
uint64_t test;
|
||||
asm volatile ("ld.global.nc.u64 {%0},[%1];" : "=l"(test) : __LDG_PTR(ptr));
|
||||
return (test);
|
||||
}
|
||||
|
||||
|
||||
static __device__ __inline__ uint32_t __ldgtoint_unaligned(const uint8_t *ptr)
|
||||
{
|
||||
uint32_t test;
|
||||
asm volatile ("{\n\t"
|
||||
".reg .u8 a,b,c,d; \n\t"
|
||||
"ld.global.nc.u8 a,[%1]; \n\t"
|
||||
"ld.global.nc.u8 b,[%1+1]; \n\t"
|
||||
"ld.global.nc.u8 c,[%1+2]; \n\t"
|
||||
"ld.global.nc.u8 d,[%1+3]; \n\t"
|
||||
"mov.b32 %0,{a,b,c,d}; }\n\t"
|
||||
: "=r"(test) : __LDG_PTR(ptr));
|
||||
return (test);
|
||||
}
|
||||
|
||||
static __device__ __inline__ uint64_t __ldgtoint64_unaligned(const uint8_t *ptr)
|
||||
{
|
||||
uint64_t test;
|
||||
asm volatile ("{\n\t"
|
||||
".reg .u8 a,b,c,d,e,f,g,h; \n\t"
|
||||
".reg .u32 i,j; \n\t"
|
||||
"ld.global.nc.u8 a,[%1]; \n\t"
|
||||
"ld.global.nc.u8 b,[%1+1]; \n\t"
|
||||
"ld.global.nc.u8 c,[%1+2]; \n\t"
|
||||
"ld.global.nc.u8 d,[%1+3]; \n\t"
|
||||
"ld.global.nc.u8 e,[%1+4]; \n\t"
|
||||
"ld.global.nc.u8 f,[%1+5]; \n\t"
|
||||
"ld.global.nc.u8 g,[%1+6]; \n\t"
|
||||
"ld.global.nc.u8 h,[%1+7]; \n\t"
|
||||
"mov.b32 i,{a,b,c,d}; \n\t"
|
||||
"mov.b32 j,{e,f,g,h}; \n\t"
|
||||
"mov.b64 %0,{i,j}; }\n\t"
|
||||
: "=l"(test) : __LDG_PTR(ptr));
|
||||
return (test);
|
||||
}
|
||||
|
||||
|
||||
static __device__ __inline__ uint64_t __ldgtoint64_trunc(const uint8_t *ptr)
|
||||
{
|
||||
uint32_t zero = 0;
|
||||
uint64_t test;
|
||||
asm volatile ("{\n\t"
|
||||
".reg .u8 a,b,c,d; \n\t"
|
||||
".reg .u32 i; \n\t"
|
||||
"ld.global.nc.u8 a,[%1]; \n\t"
|
||||
"ld.global.nc.u8 b,[%1+1]; \n\t"
|
||||
"ld.global.nc.u8 c,[%1+2]; \n\t"
|
||||
"ld.global.nc.u8 d,[%1+3]; \n\t"
|
||||
"mov.b32 i,{a,b,c,d}; \n\t"
|
||||
"mov.b64 %0,{i,%1}; }\n\t"
|
||||
: "=l"(test) : __LDG_PTR(ptr), "r"(zero));
|
||||
return (test);
|
||||
}
|
||||
|
||||
|
||||
|
||||
static __device__ __inline__ uint32_t __ldgtoint_unaligned2(const uint8_t *ptr)
|
||||
{
|
||||
uint32_t test;
|
||||
asm("{\n\t"
|
||||
".reg .u8 e,b,c,d; \n\t"
|
||||
"ld.global.nc.u8 e,[%1]; \n\t"
|
||||
"ld.global.nc.u8 b,[%1+1]; \n\t"
|
||||
"ld.global.nc.u8 c,[%1+2]; \n\t"
|
||||
"ld.global.nc.u8 d,[%1+3]; \n\t"
|
||||
"mov.b32 %0,{e,b,c,d}; }\n\t"
|
||||
: "=r"(test) : __LDG_PTR(ptr));
|
||||
return (test);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
static __forceinline__ __device__ uint8 swapvec(const uint8 *buf)
|
||||
{
|
||||
uint8 vec;
|
||||
vec.s0 = cuda_swab32(buf[0].s0);
|
||||
vec.s1 = cuda_swab32(buf[0].s1);
|
||||
vec.s2 = cuda_swab32(buf[0].s2);
|
||||
vec.s3 = cuda_swab32(buf[0].s3);
|
||||
vec.s4 = cuda_swab32(buf[0].s4);
|
||||
vec.s5 = cuda_swab32(buf[0].s5);
|
||||
vec.s6 = cuda_swab32(buf[0].s6);
|
||||
vec.s7 = cuda_swab32(buf[0].s7);
|
||||
return vec;
|
||||
}
|
||||
|
||||
static __forceinline__ __device__ uint16 swapvec(const uint16 *buf)
|
||||
{
|
||||
uint16 vec;
|
||||
vec.s0 = cuda_swab32(buf[0].s0);
|
||||
vec.s1 = cuda_swab32(buf[0].s1);
|
||||
vec.s2 = cuda_swab32(buf[0].s2);
|
||||
vec.s3 = cuda_swab32(buf[0].s3);
|
||||
vec.s4 = cuda_swab32(buf[0].s4);
|
||||
vec.s5 = cuda_swab32(buf[0].s5);
|
||||
vec.s6 = cuda_swab32(buf[0].s6);
|
||||
vec.s7 = cuda_swab32(buf[0].s7);
|
||||
vec.s8 = cuda_swab32(buf[0].s8);
|
||||
vec.s9 = cuda_swab32(buf[0].s9);
|
||||
vec.sa = cuda_swab32(buf[0].sa);
|
||||
vec.sb = cuda_swab32(buf[0].sb);
|
||||
vec.sc = cuda_swab32(buf[0].sc);
|
||||
vec.sd = cuda_swab32(buf[0].sd);
|
||||
vec.se = cuda_swab32(buf[0].se);
|
||||
vec.sf = cuda_swab32(buf[0].sf);
|
||||
return vec;
|
||||
}
|
||||
#endif // #ifndef CUDA_VECTOR_H
|
||||
@@ -0,0 +1,62 @@
|
||||
#ifndef CUDA_VECTOR_UINT2x4_H
|
||||
#define CUDA_VECTOR_UINT2x4_H
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
#if (defined(_MSC_VER) && defined(_WIN64)) || defined(__LP64__)
|
||||
#define __LDG_PTR "l"
|
||||
#else
|
||||
#define __LDG_PTR "r"
|
||||
#endif
|
||||
|
||||
#include "cuda_helper.h"
|
||||
|
||||
typedef struct __align__(16) uint2x4 {
|
||||
uint2 x, y, z, w;
|
||||
} uint2x4;
|
||||
|
||||
|
||||
static __inline__ __device__ uint2x4 make_uint2x4(uint2 s0, uint2 s1, uint2 s2, uint2 s3)
|
||||
{
|
||||
uint2x4 t;
|
||||
t.x = s0; t.y = s1; t.z = s2; t.w = s3;
|
||||
return t;
|
||||
}
|
||||
|
||||
static __forceinline__ __device__ uint2x4 operator^ (const uint2x4 &a, const uint2x4 &b) {
|
||||
return make_uint2x4(a.x ^ b.x, a.y ^ b.y, a.z ^ b.z, a.w ^ b.w);
|
||||
}
|
||||
|
||||
static __forceinline__ __device__ uint2x4 operator+ (const uint2x4 &a, const uint2x4 &b) {
|
||||
return make_uint2x4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
|
||||
}
|
||||
|
||||
/////////////////////////
|
||||
|
||||
static __forceinline__ __device__ void operator^= (uint2x4 &a, const uint2x4 &b) { a = a ^ b; }
|
||||
static __forceinline__ __device__ void operator+= (uint2x4 &a, const uint2x4 &b) { a = a + b; }
|
||||
|
||||
#if __CUDA_ARCH__ >= 320
|
||||
|
||||
static __device__ __inline__ uint2x4 __ldg4(const uint2x4 *ptr)
|
||||
{
|
||||
uint2x4 ret;
|
||||
asm("ld.global.nc.v4.u32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x.x), "=r"(ret.x.y), "=r"(ret.y.x), "=r"(ret.y.y) : __LDG_PTR(ptr));
|
||||
asm("ld.global.nc.v4.u32 {%0,%1,%2,%3}, [%4+16];" : "=r"(ret.z.x), "=r"(ret.z.y), "=r"(ret.w.x), "=r"(ret.w.y) : __LDG_PTR(ptr));
|
||||
return ret;
|
||||
}
|
||||
|
||||
static __device__ __inline__ void ldg4(const uint2x4 *ptr, uint2x4 *ret)
|
||||
{
|
||||
asm("ld.global.nc.v4.u32 {%0,%1,%2,%3}, [%4];" : "=r"(ret[0].x.x), "=r"(ret[0].x.y), "=r"(ret[0].y.x), "=r"(ret[0].y.y) : __LDG_PTR(ptr));
|
||||
asm("ld.global.nc.v4.u32 {%0,%1,%2,%3}, [%4+16];" : "=r"(ret[0].z.x), "=r"(ret[0].z.y), "=r"(ret[0].w.x), "=r"(ret[0].w.y) : __LDG_PTR(ptr));
|
||||
asm("ld.global.nc.v4.u32 {%0,%1,%2,%3}, [%4+32];" : "=r"(ret[1].x.x), "=r"(ret[1].x.y), "=r"(ret[1].y.x), "=r"(ret[1].y.y) : __LDG_PTR(ptr));
|
||||
asm("ld.global.nc.v4.u32 {%0,%1,%2,%3}, [%4+48];" : "=r"(ret[1].z.x), "=r"(ret[1].z.y), "=r"(ret[1].w.x), "=r"(ret[1].w.y) : __LDG_PTR(ptr));
|
||||
asm("ld.global.nc.v4.u32 {%0,%1,%2,%3}, [%4+64];" : "=r"(ret[2].x.x), "=r"(ret[2].x.y), "=r"(ret[2].y.x), "=r"(ret[2].y.y) : __LDG_PTR(ptr));
|
||||
asm("ld.global.nc.v4.u32 {%0,%1,%2,%3}, [%4+80];" : "=r"(ret[2].z.x), "=r"(ret[2].z.y), "=r"(ret[2].w.x), "=r"(ret[2].w.y) : __LDG_PTR(ptr));
|
||||
}
|
||||
#elif !defined(__ldg4)
|
||||
#define __ldg4(x) (*(x))
|
||||
#define ldg4(ptr, ret) { *(ret) = (*(ptr)); }
|
||||
#endif
|
||||
|
||||
#endif // H
|
||||
+12
-21
@@ -8,14 +8,6 @@
|
||||
|
||||
#include "cuda_fugue256.h"
|
||||
|
||||
extern "C" void my_fugue256_init(void *cc);
|
||||
extern "C" void my_fugue256(void *cc, const void *data, size_t len);
|
||||
extern "C" void my_fugue256_close(void *cc, void *dst);
|
||||
extern "C" void my_fugue256_addbits_and_close(void *cc, unsigned ub, unsigned n, void *dst);
|
||||
|
||||
// vorbereitete Kontexte nach den ersten 80 Bytes
|
||||
// sph_fugue256_context ctx_fugue_const[MAX_GPUS];
|
||||
|
||||
#define SWAP32(x) \
|
||||
((((x) << 24) & 0xff000000u) | (((x) << 8) & 0x00ff0000u) | \
|
||||
(((x) >> 8) & 0x0000ff00u) | (((x) >> 24) & 0x000000ffu))
|
||||
@@ -38,11 +30,11 @@ int scanhash_fugue256(int thr_id, struct work* work, uint32_t max_nonce, unsigne
|
||||
uint32_t *ptarget = work->target;
|
||||
uint32_t start_nonce = pdata[19]++;
|
||||
int intensity = (device_sm[device_map[thr_id]] > 500) ? 22 : 19;
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1 << intensity); // 256*256*8
|
||||
throughput = min(throughput, max_nonce - start_nonce);
|
||||
uint32_t throughput = cuda_default_throughput(thr_id, 1U << intensity);
|
||||
if (init[thr_id]) throughput = min(throughput, max_nonce - start_nonce);
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0xf;
|
||||
ptarget[7] = 0xf;
|
||||
|
||||
// init
|
||||
if(!init[thr_id])
|
||||
@@ -57,7 +49,6 @@ int scanhash_fugue256(int thr_id, struct work* work, uint32_t max_nonce, unsigne
|
||||
for (int kk=0; kk < 20; kk++)
|
||||
be32enc(&endiandata[kk], pdata[kk]);
|
||||
|
||||
// Context mit dem Endian gedrehten Blockheader vorbereiten (Nonce wird später ersetzt)
|
||||
fugue256_cpu_setBlock(thr_id, endiandata, (void*)ptarget);
|
||||
|
||||
do {
|
||||
@@ -65,7 +56,9 @@ int scanhash_fugue256(int thr_id, struct work* work, uint32_t max_nonce, unsigne
|
||||
uint32_t foundNounce = UINT32_MAX;
|
||||
fugue256_cpu_hash(thr_id, throughput, pdata[19], NULL, &foundNounce);
|
||||
|
||||
if (foundNounce < UINT32_MAX)
|
||||
*hashes_done = pdata[19] - start_nonce + throughput;
|
||||
|
||||
if (foundNounce < UINT32_MAX && bench_algo < 0)
|
||||
{
|
||||
uint32_t vhash[8];
|
||||
sph_fugue256_context ctx_fugue;
|
||||
@@ -77,17 +70,15 @@ int scanhash_fugue256(int thr_id, struct work* work, uint32_t max_nonce, unsigne
|
||||
|
||||
if (vhash[7] <= ptarget[7] && fulltest(vhash, ptarget))
|
||||
{
|
||||
bn_store_hash_target_ratio(vhash, ptarget, work);
|
||||
work_set_target_ratio(work, vhash);
|
||||
pdata[19] = foundNounce;
|
||||
*hashes_done = foundNounce - start_nonce + 1;
|
||||
return 1;
|
||||
} else {
|
||||
applog(LOG_WARNING, "GPU #%d: result for nonce %08x does not validate on CPU!",
|
||||
device_map[thr_id], foundNounce);
|
||||
gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", foundNounce);
|
||||
}
|
||||
}
|
||||
|
||||
if ((uint64_t) pdata[19] + throughput > (uint64_t) max_nonce) {
|
||||
if ((uint64_t) throughput + pdata[19] >= max_nonce) {
|
||||
pdata[19] = max_nonce;
|
||||
break;
|
||||
}
|
||||
@@ -96,7 +87,7 @@ int scanhash_fugue256(int thr_id, struct work* work, uint32_t max_nonce, unsigne
|
||||
|
||||
} while (!work_restart[thr_id].restart);
|
||||
|
||||
*hashes_done = pdata[19] - start_nonce + 1;
|
||||
*hashes_done = pdata[19] - start_nonce;
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -106,11 +97,11 @@ void free_fugue256(int thr_id)
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
fugue256_cpu_free(thr_id);
|
||||
|
||||
init[thr_id] = false;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
}
|
||||
+20
-13
@@ -33,17 +33,24 @@ int scanhash_groestlcoin(int thr_id, struct work *work, uint32_t max_nonce, unsi
|
||||
uint32_t *pdata = work->data;
|
||||
uint32_t *ptarget = work->target;
|
||||
uint32_t start_nonce = pdata[19];
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1 << 19); // 256*256*8
|
||||
throughput = min(throughput, max_nonce - start_nonce);
|
||||
uint32_t throughput = cuda_default_throughput(thr_id, 1 << 19); // 256*256*8
|
||||
if (init[thr_id]) throughput = min(throughput, max_nonce - start_nonce);
|
||||
|
||||
uint32_t *outputHash = (uint32_t*)malloc(throughput * 64);
|
||||
uint32_t *outputHash = (uint32_t*)malloc((size_t) 64* throughput);
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0x000000ff;
|
||||
ptarget[7] = 0x001f;
|
||||
|
||||
if (!init[thr_id])
|
||||
{
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
if (opt_cudaschedule == -1 && gpu_threads == 1) {
|
||||
cudaDeviceReset();
|
||||
// reduce cpu usage
|
||||
cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);
|
||||
CUDA_LOG_ERROR();
|
||||
}
|
||||
CUDA_LOG_ERROR();
|
||||
groestlcoin_cpu_init(thr_id, throughput);
|
||||
init[thr_id] = true;
|
||||
}
|
||||
@@ -61,31 +68,31 @@ int scanhash_groestlcoin(int thr_id, struct work *work, uint32_t max_nonce, unsi
|
||||
// GPU hash
|
||||
groestlcoin_cpu_hash(thr_id, throughput, pdata[19], outputHash, &foundNounce);
|
||||
|
||||
if (foundNounce < UINT32_MAX)
|
||||
if (foundNounce < UINT32_MAX && bench_algo < 0)
|
||||
{
|
||||
uint32_t _ALIGN(64) vhash[8];
|
||||
endiandata[19] = swab32(foundNounce);
|
||||
groestlhash(vhash, endiandata);
|
||||
|
||||
if (vhash[7] <= ptarget[7] && fulltest(vhash, ptarget)) {
|
||||
bn_store_hash_target_ratio(vhash, ptarget, work);
|
||||
work_set_target_ratio(work, vhash);
|
||||
pdata[19] = foundNounce;
|
||||
free(outputHash);
|
||||
return true;
|
||||
} else {
|
||||
applog(LOG_WARNING, "GPU #%d: result for nonce %08x does not validate on CPU!",
|
||||
device_map[thr_id], foundNounce);
|
||||
gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", foundNounce);
|
||||
}
|
||||
}
|
||||
|
||||
if ((uint64_t) pdata[19] + throughput > max_nonce) {
|
||||
*hashes_done = pdata[19] - start_nonce + 1;
|
||||
if ((uint64_t) throughput + pdata[19] >= max_nonce) {
|
||||
pdata[19] = max_nonce;
|
||||
break;
|
||||
}
|
||||
pdata[19] += throughput;
|
||||
|
||||
} while (pdata[19] < max_nonce && !work_restart[thr_id].restart);
|
||||
} while (!work_restart[thr_id].restart);
|
||||
|
||||
*hashes_done = pdata[19] - start_nonce;
|
||||
|
||||
free(outputHash);
|
||||
return 0;
|
||||
@@ -97,10 +104,10 @@ void free_groestlcoin(int thr_id)
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
groestlcoin_cpu_free(thr_id);
|
||||
init[thr_id] = false;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
}
|
||||
+12
-4
@@ -191,8 +191,9 @@ template <int BLOCKSIZE> __global__ void blake512_gpu_hash(uint32_t threads, uin
|
||||
|
||||
// ---------------------------- END CUDA blake512 functions ------------------------------------
|
||||
|
||||
// Setup-Funktionen
|
||||
__host__ void blake512_cpu_init(int thr_id, uint32_t threads)
|
||||
// Setup Function
|
||||
__host__
|
||||
void blake512_cpu_init(int thr_id, uint32_t threads)
|
||||
{
|
||||
// Kopiere die Hash-Tabellen in den GPU-Speicher
|
||||
cudaMemcpyToSymbol( c_sigma,
|
||||
@@ -211,12 +212,19 @@ __host__ void blake512_cpu_init(int thr_id, uint32_t threads)
|
||||
0, cudaMemcpyHostToDevice);
|
||||
|
||||
// Speicher für alle Ergebnisse belegen
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hash5output[thr_id], 16 * sizeof(uint32_t) * threads));
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hash5output[thr_id], (size_t) 64 * threads));
|
||||
}
|
||||
|
||||
__host__
|
||||
void blake512_cpu_free(int thr_id)
|
||||
{
|
||||
cudaFree(d_hash5output[thr_id]);
|
||||
}
|
||||
|
||||
static int BLOCKSIZE = 84;
|
||||
|
||||
__host__ void blake512_cpu_setBlock(void *pdata, int len)
|
||||
__host__
|
||||
void blake512_cpu_setBlock(void *pdata, int len)
|
||||
// data muss 84-Byte haben!
|
||||
// heftyHash hat 32-Byte
|
||||
{
|
||||
|
||||
@@ -124,7 +124,13 @@ __host__
|
||||
void combine_cpu_init(int thr_id, uint32_t threads)
|
||||
{
|
||||
// Speicher für alle Ergebnisse belegen
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hashoutput[thr_id], 8 * sizeof(uint32_t) * threads));
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hashoutput[thr_id], (size_t) 32 * threads));
|
||||
}
|
||||
|
||||
__host__
|
||||
void combine_cpu_free(int thr_id)
|
||||
{
|
||||
cudaFree(d_hashoutput[thr_id]);
|
||||
}
|
||||
|
||||
__host__
|
||||
|
||||
+29
-14
@@ -9,6 +9,7 @@
|
||||
// globaler Speicher für alle HeftyHashes aller Threads
|
||||
extern uint32_t *heavy_heftyHashes[MAX_GPUS];
|
||||
extern uint32_t *heavy_nonceVector[MAX_GPUS];
|
||||
static unsigned int *d_textures[MAX_GPUS][8];
|
||||
|
||||
// globaler Speicher für unsere Ergebnisse
|
||||
uint32_t *d_hash4output[MAX_GPUS];
|
||||
@@ -730,36 +731,50 @@ template <int BLOCKSIZE> __global__ void groestl512_gpu_hash(uint32_t threads, u
|
||||
}
|
||||
}
|
||||
|
||||
#define texDef(texname, texmem, texsource, texsize) \
|
||||
#define texDef(id, texname, texmem, texsource, texsize) { \
|
||||
unsigned int *texmem; \
|
||||
cudaMalloc(&texmem, texsize); \
|
||||
d_textures[thr_id][id] = texmem; \
|
||||
cudaMemcpy(texmem, texsource, texsize, cudaMemcpyHostToDevice); \
|
||||
texname.normalized = 0; \
|
||||
texname.filterMode = cudaFilterModePoint; \
|
||||
texname.addressMode[0] = cudaAddressModeClamp; \
|
||||
{ cudaChannelFormatDesc channelDesc = cudaCreateChannelDesc<unsigned int>(); \
|
||||
cudaBindTexture(NULL, &texname, texmem, &channelDesc, texsize ); } \
|
||||
cudaBindTexture(NULL, &texname, texmem, &channelDesc, texsize ); \
|
||||
} \
|
||||
}
|
||||
|
||||
// Setup-Funktionen
|
||||
__host__ void groestl512_cpu_init(int thr_id, uint32_t threads)
|
||||
// Setup Function
|
||||
__host__
|
||||
void groestl512_cpu_init(int thr_id, uint32_t threads)
|
||||
{
|
||||
// Texturen mit obigem Makro initialisieren
|
||||
texDef(t0up, d_T0up, T0up_cpu, sizeof(uint32_t)*256);
|
||||
texDef(t0dn, d_T0dn, T0dn_cpu, sizeof(uint32_t)*256);
|
||||
texDef(t1up, d_T1up, T1up_cpu, sizeof(uint32_t)*256);
|
||||
texDef(t1dn, d_T1dn, T1dn_cpu, sizeof(uint32_t)*256);
|
||||
texDef(t2up, d_T2up, T2up_cpu, sizeof(uint32_t)*256);
|
||||
texDef(t2dn, d_T2dn, T2dn_cpu, sizeof(uint32_t)*256);
|
||||
texDef(t3up, d_T3up, T3up_cpu, sizeof(uint32_t)*256);
|
||||
texDef(t3dn, d_T3dn, T3dn_cpu, sizeof(uint32_t)*256);
|
||||
texDef(0, t0up, d_T0up, T0up_cpu, sizeof(uint32_t)*256);
|
||||
texDef(1, t0dn, d_T0dn, T0dn_cpu, sizeof(uint32_t)*256);
|
||||
texDef(2, t1up, d_T1up, T1up_cpu, sizeof(uint32_t)*256);
|
||||
texDef(3, t1dn, d_T1dn, T1dn_cpu, sizeof(uint32_t)*256);
|
||||
texDef(4, t2up, d_T2up, T2up_cpu, sizeof(uint32_t)*256);
|
||||
texDef(5, t2dn, d_T2dn, T2dn_cpu, sizeof(uint32_t)*256);
|
||||
texDef(6, t3up, d_T3up, T3up_cpu, sizeof(uint32_t)*256);
|
||||
texDef(7, t3dn, d_T3dn, T3dn_cpu, sizeof(uint32_t)*256);
|
||||
|
||||
// Speicher für alle Ergebnisse belegen
|
||||
cudaMalloc(&d_hash4output[thr_id], 16 * sizeof(uint32_t) * threads);
|
||||
cudaMalloc(&d_hash4output[thr_id], (size_t) 64 * threads);
|
||||
}
|
||||
|
||||
__host__
|
||||
void groestl512_cpu_free(int thr_id)
|
||||
{
|
||||
for (int i=0; i <8; i++)
|
||||
cudaFree(d_textures[thr_id][i]);
|
||||
|
||||
cudaFree(d_hash4output[thr_id]);
|
||||
}
|
||||
|
||||
static int BLOCKSIZE = 84;
|
||||
|
||||
__host__ void groestl512_cpu_setBlock(void *data, int len)
|
||||
__host__
|
||||
void groestl512_cpu_setBlock(void *data, int len)
|
||||
// data muss 80/84-Byte haben!
|
||||
// heftyHash hat 32-Byte
|
||||
{
|
||||
|
||||
+15
-8
@@ -31,7 +31,8 @@ uint32_t hefty_cpu_hashTable[] = {
|
||||
0x510e527fUL,
|
||||
0x9b05688cUL,
|
||||
0x1f83d9abUL,
|
||||
0x5be0cd19UL };
|
||||
0x5be0cd19UL
|
||||
};
|
||||
|
||||
uint32_t hefty_cpu_constantTable[] = {
|
||||
0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL,
|
||||
@@ -268,29 +269,29 @@ void hefty_gpu_hash(uint32_t threads, uint32_t startNounce, uint32_t *outputHash
|
||||
|
||||
// Progress W2 (Bytes 64...127) then W3 (Bytes 128...191) ...
|
||||
|
||||
#pragma unroll 3
|
||||
|
||||
for(int k=0;k<3;k++)
|
||||
{
|
||||
#pragma unroll 2
|
||||
|
||||
for(int j=0;j<2;j++)
|
||||
W2[j] = s1(W1[14+j]) + W1[9+j] + s0(W1[1+j]) + W1[j];
|
||||
#pragma unroll 5
|
||||
|
||||
for(int j=2;j<7;j++)
|
||||
W2[j] = s1(W2[j-2]) + W1[9+j] + s0(W1[1+j]) + W1[j];
|
||||
|
||||
#pragma unroll 8
|
||||
|
||||
for(int j=7;j<15;j++)
|
||||
W2[j] = s1(W2[j-2]) + W2[j-7] + s0(W1[1+j]) + W1[j];
|
||||
|
||||
W2[15] = s1(W2[13]) + W2[8] + s0(W2[0]) + W1[15];
|
||||
|
||||
#pragma unroll 16
|
||||
|
||||
for(int j=0;j<16;j++)
|
||||
{
|
||||
Absorb(sponge, regs[3] + regs[7]);
|
||||
hefty_gpu_round(regs, W2[j], heftyLookUp(j + ((k+1)<<4)), sponge);
|
||||
}
|
||||
#pragma unroll 16
|
||||
|
||||
for(int j=0;j<16;j++)
|
||||
W1[j] = W2[j];
|
||||
}
|
||||
@@ -316,7 +317,13 @@ void hefty_cpu_init(int thr_id, uint32_t threads)
|
||||
sizeof(uint32_t) * 64 );
|
||||
|
||||
// Speicher für alle Hefty1 hashes belegen
|
||||
CUDA_SAFE_CALL(cudaMalloc(&heavy_heftyHashes[thr_id], 8 * sizeof(uint32_t) * threads));
|
||||
CUDA_SAFE_CALL(cudaMalloc(&heavy_heftyHashes[thr_id], (size_t) 32 * threads));
|
||||
}
|
||||
|
||||
__host__
|
||||
void hefty_cpu_free(int thr_id)
|
||||
{
|
||||
cudaFree(heavy_heftyHashes[thr_id]);
|
||||
}
|
||||
|
||||
__host__
|
||||
|
||||
@@ -185,7 +185,7 @@ template <int BLOCKSIZE> __global__ void keccak512_gpu_hash(uint32_t threads, ui
|
||||
|
||||
// ---------------------------- END CUDA keccak512 functions ------------------------------------
|
||||
|
||||
__host__
|
||||
__host__
|
||||
void keccak512_cpu_init(int thr_id, uint32_t threads)
|
||||
{
|
||||
// Kopiere die Hash-Tabellen in den GPU-Speicher
|
||||
@@ -195,7 +195,13 @@ void keccak512_cpu_init(int thr_id, uint32_t threads)
|
||||
0, cudaMemcpyHostToDevice);
|
||||
|
||||
// Speicher für alle Ergebnisse belegen
|
||||
cudaMalloc(&d_hash3output[thr_id], 16 * sizeof(uint32_t) * threads);
|
||||
cudaMalloc(&d_hash3output[thr_id], (size_t) 64 * threads);
|
||||
}
|
||||
|
||||
__host__
|
||||
void keccak512_cpu_free(int thr_id)
|
||||
{
|
||||
cudaFree(d_hash3output[thr_id]);
|
||||
}
|
||||
|
||||
// ----------------BEGIN keccak512 CPU version from scrypt-jane code --------------------
|
||||
|
||||
+10
-3
@@ -160,8 +160,9 @@ template <int BLOCKSIZE> __global__ void sha256_gpu_hash(uint32_t threads, uint3
|
||||
}
|
||||
}
|
||||
|
||||
// Setup-Funktionen
|
||||
__host__ void sha256_cpu_init(int thr_id, uint32_t threads)
|
||||
// Setup Function
|
||||
__host__
|
||||
void sha256_cpu_init(int thr_id, uint32_t threads)
|
||||
{
|
||||
// Kopiere die Hash-Tabellen in den GPU-Speicher
|
||||
cudaMemcpyToSymbol( sha256_gpu_constantTable,
|
||||
@@ -169,7 +170,13 @@ __host__ void sha256_cpu_init(int thr_id, uint32_t threads)
|
||||
sizeof(uint32_t) * 64 );
|
||||
|
||||
// Speicher für alle Ergebnisse belegen
|
||||
cudaMalloc(&d_hash2output[thr_id], 8 * sizeof(uint32_t) * threads);
|
||||
cudaMalloc(&d_hash2output[thr_id], (size_t) 8 * sizeof(uint32_t) * threads);
|
||||
}
|
||||
|
||||
__host__
|
||||
void sha256_cpu_free(int thr_id)
|
||||
{
|
||||
cudaFree(d_hash2output[thr_id]);
|
||||
}
|
||||
|
||||
static int BLOCKSIZE = 84;
|
||||
|
||||
+278
-248
@@ -1,9 +1,20 @@
|
||||
#include <stdio.h>
|
||||
#include <openssl/sha.h>
|
||||
#include <cuda.h>
|
||||
#include <map>
|
||||
// include thrust
|
||||
|
||||
// include thrust if possible
|
||||
#if defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ >= 2 && CUDA_VERSION < 7000
|
||||
#warning "Heavy: incompatible GCC version!"
|
||||
#define USE_THRUST 0
|
||||
#else
|
||||
#define USE_THRUST 1
|
||||
#endif
|
||||
|
||||
#if USE_THRUST
|
||||
#include <thrust/remove.h>
|
||||
#include <thrust/device_vector.h>
|
||||
#endif
|
||||
|
||||
#include "miner.h"
|
||||
|
||||
@@ -32,99 +43,99 @@ extern uint32_t *heavy_heftyHashes[MAX_GPUS];
|
||||
/* Combines top 64-bits from each hash into a single hash */
|
||||
static void combine_hashes(uint32_t *out, const uint32_t *hash1, const uint32_t *hash2, const uint32_t *hash3, const uint32_t *hash4)
|
||||
{
|
||||
const uint32_t *hash[4] = { hash1, hash2, hash3, hash4 };
|
||||
int bits;
|
||||
unsigned int i;
|
||||
uint32_t mask;
|
||||
unsigned int k;
|
||||
const uint32_t *hash[4] = { hash1, hash2, hash3, hash4 };
|
||||
int bits;
|
||||
unsigned int i;
|
||||
uint32_t mask;
|
||||
unsigned int k;
|
||||
|
||||
/* Transpose first 64 bits of each hash into out */
|
||||
memset(out, 0, 32);
|
||||
bits = 0;
|
||||
for (i = 7; i >= 6; i--) {
|
||||
for (mask = 0x80000000; mask; mask >>= 1) {
|
||||
for (k = 0; k < 4; k++) {
|
||||
out[(255 - bits)/32] <<= 1;
|
||||
if ((hash[k][i] & mask) != 0)
|
||||
out[(255 - bits)/32] |= 1;
|
||||
bits++;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* Transpose first 64 bits of each hash into out */
|
||||
memset(out, 0, 32);
|
||||
bits = 0;
|
||||
for (i = 7; i >= 6; i--) {
|
||||
for (mask = 0x80000000; mask; mask >>= 1) {
|
||||
for (k = 0; k < 4; k++) {
|
||||
out[(255 - bits)/32] <<= 1;
|
||||
if ((hash[k][i] & mask) != 0)
|
||||
out[(255 - bits)/32] |= 1;
|
||||
bits++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#include <intrin.h>
|
||||
static uint32_t __inline bitsset( uint32_t x )
|
||||
{
|
||||
DWORD r = 0;
|
||||
_BitScanReverse(&r, x);
|
||||
return r;
|
||||
DWORD r = 0;
|
||||
_BitScanReverse(&r, x);
|
||||
return r;
|
||||
}
|
||||
#else
|
||||
static uint32_t bitsset( uint32_t x )
|
||||
{
|
||||
return 31-__builtin_clz(x);
|
||||
return 31-__builtin_clz(x);
|
||||
}
|
||||
#endif
|
||||
|
||||
// Finde das high bit in einem Multiword-Integer.
|
||||
static int findhighbit(const uint32_t *ptarget, int words)
|
||||
{
|
||||
int i;
|
||||
int highbit = 0;
|
||||
for (i=words-1; i >= 0; --i)
|
||||
{
|
||||
if (ptarget[i] != 0) {
|
||||
highbit = i*32 + bitsset(ptarget[i])+1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return highbit;
|
||||
int i;
|
||||
int highbit = 0;
|
||||
for (i=words-1; i >= 0; --i)
|
||||
{
|
||||
if (ptarget[i] != 0) {
|
||||
highbit = i*32 + bitsset(ptarget[i])+1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return highbit;
|
||||
}
|
||||
|
||||
// Generiere ein Multiword-Integer das die Zahl
|
||||
// (2 << highbit) - 1 repräsentiert.
|
||||
static void genmask(uint32_t *ptarget, int words, int highbit)
|
||||
{
|
||||
int i;
|
||||
for (i=words-1; i >= 0; --i)
|
||||
{
|
||||
if ((i+1)*32 <= highbit)
|
||||
ptarget[i] = UINT32_MAX;
|
||||
else if (i*32 > highbit)
|
||||
ptarget[i] = 0x00000000;
|
||||
else
|
||||
ptarget[i] = (1 << (highbit-i*32)) - 1;
|
||||
}
|
||||
int i;
|
||||
for (i=words-1; i >= 0; --i)
|
||||
{
|
||||
if ((i+1)*32 <= highbit)
|
||||
ptarget[i] = UINT32_MAX;
|
||||
else if (i*32 > highbit)
|
||||
ptarget[i] = 0x00000000;
|
||||
else
|
||||
ptarget[i] = (1 << (highbit-i*32)) - 1;
|
||||
}
|
||||
}
|
||||
|
||||
struct check_nonce_for_remove
|
||||
{
|
||||
check_nonce_for_remove(uint64_t target, uint32_t *hashes, uint32_t hashlen, uint32_t startNonce) :
|
||||
m_target(target),
|
||||
m_hashes(hashes),
|
||||
m_hashlen(hashlen),
|
||||
m_startNonce(startNonce) { }
|
||||
check_nonce_for_remove(uint64_t target, uint32_t *hashes, uint32_t hashlen, uint32_t startNonce) :
|
||||
m_target(target),
|
||||
m_hashes(hashes),
|
||||
m_hashlen(hashlen),
|
||||
m_startNonce(startNonce) { }
|
||||
|
||||
uint64_t m_target;
|
||||
uint32_t *m_hashes;
|
||||
uint32_t m_hashlen;
|
||||
uint32_t m_startNonce;
|
||||
uint64_t m_target;
|
||||
uint32_t *m_hashes;
|
||||
uint32_t m_hashlen;
|
||||
uint32_t m_startNonce;
|
||||
|
||||
__device__
|
||||
bool operator()(const uint32_t x)
|
||||
{
|
||||
// Position im Hash Buffer
|
||||
uint32_t hashIndex = x - m_startNonce;
|
||||
// Wert des Hashes (als uint64_t) auslesen.
|
||||
// Steht im 6. und 7. Wort des Hashes (jeder dieser Hashes hat 512 Bits)
|
||||
uint64_t hashValue = *((uint64_t*)(&m_hashes[m_hashlen*hashIndex + 6]));
|
||||
bool res = (hashValue & m_target) != hashValue;
|
||||
//printf("ndx=%x val=%08x target=%lx\n", hashIndex, hashValue, m_target);
|
||||
// gegen das Target prüfen. Es dürfen nur Bits aus dem Target gesetzt sein.
|
||||
return res;
|
||||
}
|
||||
__device__
|
||||
bool operator()(const uint32_t x)
|
||||
{
|
||||
// Position im Hash Buffer
|
||||
uint32_t hashIndex = x - m_startNonce;
|
||||
// Wert des Hashes (als uint64_t) auslesen.
|
||||
// Steht im 6. und 7. Wort des Hashes (jeder dieser Hashes hat 512 Bits)
|
||||
uint64_t hashValue = *((uint64_t*)(&m_hashes[m_hashlen*hashIndex + 6]));
|
||||
bool res = (hashValue & m_target) != hashValue;
|
||||
//printf("ndx=%x val=%08x target=%lx\n", hashIndex, hashValue, m_target);
|
||||
// gegen das Target prüfen. Es dürfen nur Bits aus dem Target gesetzt sein.
|
||||
return res;
|
||||
}
|
||||
};
|
||||
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
@@ -132,239 +143,258 @@ static bool init[MAX_GPUS] = { 0 };
|
||||
__host__
|
||||
int scanhash_heavy(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done, uint32_t maxvote, int blocklen)
|
||||
{
|
||||
uint32_t *pdata = work->data;
|
||||
uint32_t *ptarget = work->target;
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
// CUDA will process thousands of threads.
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, (1U << 19) - 256);
|
||||
throughput = min(throughput, max_nonce - first_nonce);
|
||||
uint32_t *pdata = work->data;
|
||||
uint32_t *ptarget = work->target;
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
// CUDA will process thousands of threads.
|
||||
uint32_t throughput = cuda_default_throughput(thr_id, (1U << 19) - 256);
|
||||
if (init[thr_id]) throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
int rc = 0;
|
||||
uint32_t *hash = NULL;
|
||||
uint32_t *cpu_nonceVector = NULL;
|
||||
CUDA_SAFE_CALL(cudaMallocHost(&hash, throughput*8*sizeof(uint32_t)));
|
||||
CUDA_SAFE_CALL(cudaMallocHost(&cpu_nonceVector, throughput*sizeof(uint32_t)));
|
||||
int rc = 0;
|
||||
uint32_t *hash = NULL;
|
||||
uint32_t *cpu_nonceVector = NULL;
|
||||
|
||||
int nrmCalls[6];
|
||||
memset(nrmCalls, 0, sizeof(int) * 6);
|
||||
int nrmCalls[6];
|
||||
memset(nrmCalls, 0, sizeof(int) * 6);
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0x00ff;
|
||||
if (opt_benchmark)
|
||||
ptarget[7] = 0x000f;
|
||||
|
||||
// für jeden Hash ein individuelles Target erstellen basierend
|
||||
// auf dem höchsten Bit, das in ptarget gesetzt ist.
|
||||
int highbit = findhighbit(ptarget, 8);
|
||||
uint32_t target2[2], target3[2], target4[2], target5[2];
|
||||
genmask(target2, 2, highbit/4+(((highbit%4)>3)?1:0) ); // SHA256
|
||||
genmask(target3, 2, highbit/4+(((highbit%4)>2)?1:0) ); // keccak512
|
||||
genmask(target4, 2, highbit/4+(((highbit%4)>1)?1:0) ); // groestl512
|
||||
genmask(target5, 2, highbit/4+(((highbit%4)>0)?1:0) ); // blake512
|
||||
// für jeden Hash ein individuelles Target erstellen basierend
|
||||
// auf dem höchsten Bit, das in ptarget gesetzt ist.
|
||||
int highbit = findhighbit(ptarget, 8);
|
||||
uint32_t target2[2], target3[2], target4[2], target5[2];
|
||||
genmask(target2, 2, highbit/4+(((highbit%4)>3)?1:0) ); // SHA256
|
||||
genmask(target3, 2, highbit/4+(((highbit%4)>2)?1:0) ); // keccak512
|
||||
genmask(target4, 2, highbit/4+(((highbit%4)>1)?1:0) ); // groestl512
|
||||
genmask(target5, 2, highbit/4+(((highbit%4)>0)?1:0) ); // blake512
|
||||
|
||||
if (!init[thr_id])
|
||||
{
|
||||
hefty_cpu_init(thr_id, throughput);
|
||||
sha256_cpu_init(thr_id, throughput);
|
||||
keccak512_cpu_init(thr_id, throughput);
|
||||
groestl512_cpu_init(thr_id, throughput);
|
||||
blake512_cpu_init(thr_id, throughput);
|
||||
combine_cpu_init(thr_id, throughput);
|
||||
if (!init[thr_id])
|
||||
{
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
if (opt_cudaschedule == -1 && gpu_threads == 1) {
|
||||
cudaDeviceReset();
|
||||
// reduce cpu usage
|
||||
cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);
|
||||
CUDA_LOG_ERROR();
|
||||
}
|
||||
|
||||
CUDA_SAFE_CALL(cudaMalloc(&heavy_nonceVector[thr_id], sizeof(uint32_t) * throughput));
|
||||
hefty_cpu_init(thr_id, throughput);
|
||||
sha256_cpu_init(thr_id, throughput);
|
||||
keccak512_cpu_init(thr_id, throughput);
|
||||
groestl512_cpu_init(thr_id, throughput);
|
||||
blake512_cpu_init(thr_id, throughput);
|
||||
combine_cpu_init(thr_id, throughput);
|
||||
|
||||
init[thr_id] = true;
|
||||
}
|
||||
CUDA_SAFE_CALL(cudaMalloc(&heavy_nonceVector[thr_id], sizeof(uint32_t) * throughput));
|
||||
|
||||
if (blocklen == HEAVYCOIN_BLKHDR_SZ)
|
||||
{
|
||||
uint16_t *ext = (uint16_t *)&pdata[20];
|
||||
init[thr_id] = true;
|
||||
}
|
||||
|
||||
if (opt_vote > maxvote) {
|
||||
applog(LOG_WARNING, "Your block reward vote (%hu) exceeds "
|
||||
"the maxvote reported by the pool (%hu).",
|
||||
opt_vote, maxvote);
|
||||
}
|
||||
// weird but require at least one cudaSetDevice first
|
||||
CUDA_SAFE_CALL(cudaMallocHost(&hash, (size_t) 32 * throughput));
|
||||
CUDA_SAFE_CALL(cudaMallocHost(&cpu_nonceVector, sizeof(uint32_t) * throughput));
|
||||
|
||||
if (opt_trust_pool && opt_vote > maxvote) {
|
||||
applog(LOG_WARNING, "Capping block reward vote to maxvote reported by pool.");
|
||||
ext[0] = maxvote;
|
||||
}
|
||||
else
|
||||
ext[0] = opt_vote;
|
||||
}
|
||||
if (blocklen == HEAVYCOIN_BLKHDR_SZ)
|
||||
{
|
||||
uint16_t *ext = (uint16_t*) &pdata[20];
|
||||
|
||||
// Setze die Blockdaten
|
||||
hefty_cpu_setBlock(thr_id, throughput, pdata, blocklen);
|
||||
sha256_cpu_setBlock(pdata, blocklen);
|
||||
keccak512_cpu_setBlock(pdata, blocklen);
|
||||
groestl512_cpu_setBlock(pdata, blocklen);
|
||||
blake512_cpu_setBlock(pdata, blocklen);
|
||||
if (opt_vote > maxvote && !opt_benchmark) {
|
||||
applog(LOG_WARNING, "Your block reward vote (%hu) exceeds the maxvote reported by the pool (%hu).",
|
||||
opt_vote, maxvote);
|
||||
}
|
||||
|
||||
do {
|
||||
if (opt_trust_pool && opt_vote > maxvote) {
|
||||
applog(LOG_WARNING, "Capping block reward vote to maxvote reported by pool.");
|
||||
ext[0] = maxvote;
|
||||
}
|
||||
else
|
||||
ext[0] = opt_vote;
|
||||
}
|
||||
|
||||
////// Compaction init
|
||||
thrust::device_ptr<uint32_t> devNoncePtr(heavy_nonceVector[thr_id]);
|
||||
thrust::device_ptr<uint32_t> devNoncePtrEnd((heavy_nonceVector[thr_id]) + throughput);
|
||||
uint32_t actualNumberOfValuesInNonceVectorGPU = throughput;
|
||||
uint64_t *t;
|
||||
// Setze die Blockdaten
|
||||
hefty_cpu_setBlock(thr_id, throughput, pdata, blocklen);
|
||||
sha256_cpu_setBlock(pdata, blocklen);
|
||||
keccak512_cpu_setBlock(pdata, blocklen);
|
||||
groestl512_cpu_setBlock(pdata, blocklen);
|
||||
blake512_cpu_setBlock(pdata, blocklen);
|
||||
|
||||
hefty_cpu_hash(thr_id, throughput, pdata[19]);
|
||||
//cudaThreadSynchronize();
|
||||
sha256_cpu_hash(thr_id, throughput, pdata[19]);
|
||||
//cudaThreadSynchronize();
|
||||
do {
|
||||
uint32_t actualNumberOfValuesInNonceVectorGPU = throughput;
|
||||
|
||||
// Hier ist die längste CPU Wartephase. Deshalb ein strategisches MyStreamSynchronize() hier.
|
||||
MyStreamSynchronize(NULL, 1, thr_id);
|
||||
////// Compaction init
|
||||
|
||||
////// Compaction
|
||||
t = (uint64_t*) target2;
|
||||
devNoncePtrEnd = thrust::remove_if(devNoncePtr, devNoncePtrEnd, check_nonce_for_remove(*t, d_hash2output[thr_id], 8, pdata[19]));
|
||||
actualNumberOfValuesInNonceVectorGPU = (uint32_t)(devNoncePtrEnd - devNoncePtr);
|
||||
if(actualNumberOfValuesInNonceVectorGPU == 0)
|
||||
goto emptyNonceVector;
|
||||
hefty_cpu_hash(thr_id, throughput, pdata[19]);
|
||||
sha256_cpu_hash(thr_id, throughput, pdata[19]);
|
||||
|
||||
keccak512_cpu_hash(thr_id, actualNumberOfValuesInNonceVectorGPU, pdata[19]);
|
||||
//cudaThreadSynchronize();
|
||||
// Hier ist die längste CPU Wartephase. Deshalb ein strategisches MyStreamSynchronize() hier.
|
||||
MyStreamSynchronize(NULL, 1, thr_id);
|
||||
|
||||
////// Compaction
|
||||
t = (uint64_t*) target3;
|
||||
devNoncePtrEnd = thrust::remove_if(devNoncePtr, devNoncePtrEnd, check_nonce_for_remove(*t, d_hash3output[thr_id], 16, pdata[19]));
|
||||
actualNumberOfValuesInNonceVectorGPU = (uint32_t)(devNoncePtrEnd - devNoncePtr);
|
||||
if(actualNumberOfValuesInNonceVectorGPU == 0)
|
||||
goto emptyNonceVector;
|
||||
#if USE_THRUST
|
||||
thrust::device_ptr<uint32_t> devNoncePtr(heavy_nonceVector[thr_id]);
|
||||
thrust::device_ptr<uint32_t> devNoncePtrEnd((heavy_nonceVector[thr_id]) + throughput);
|
||||
|
||||
blake512_cpu_hash(thr_id, actualNumberOfValuesInNonceVectorGPU, pdata[19]);
|
||||
//cudaThreadSynchronize();
|
||||
////// Compaction
|
||||
uint64_t *t = (uint64_t*) target2;
|
||||
devNoncePtrEnd = thrust::remove_if(devNoncePtr, devNoncePtrEnd, check_nonce_for_remove(*t, d_hash2output[thr_id], 8, pdata[19]));
|
||||
actualNumberOfValuesInNonceVectorGPU = (uint32_t)(devNoncePtrEnd - devNoncePtr);
|
||||
if(actualNumberOfValuesInNonceVectorGPU == 0)
|
||||
goto emptyNonceVector;
|
||||
|
||||
////// Compaction
|
||||
t = (uint64_t*) target5;
|
||||
devNoncePtrEnd = thrust::remove_if(devNoncePtr, devNoncePtrEnd, check_nonce_for_remove(*t, d_hash5output[thr_id], 16, pdata[19]));
|
||||
actualNumberOfValuesInNonceVectorGPU = (uint32_t)(devNoncePtrEnd - devNoncePtr);
|
||||
if(actualNumberOfValuesInNonceVectorGPU == 0)
|
||||
goto emptyNonceVector;
|
||||
keccak512_cpu_hash(thr_id, actualNumberOfValuesInNonceVectorGPU, pdata[19]);
|
||||
|
||||
groestl512_cpu_hash(thr_id, actualNumberOfValuesInNonceVectorGPU, pdata[19]);
|
||||
//cudaThreadSynchronize();
|
||||
////// Compaction
|
||||
t = (uint64_t*) target3;
|
||||
devNoncePtrEnd = thrust::remove_if(devNoncePtr, devNoncePtrEnd, check_nonce_for_remove(*t, d_hash3output[thr_id], 16, pdata[19]));
|
||||
actualNumberOfValuesInNonceVectorGPU = (uint32_t)(devNoncePtrEnd - devNoncePtr);
|
||||
if(actualNumberOfValuesInNonceVectorGPU == 0)
|
||||
goto emptyNonceVector;
|
||||
|
||||
////// Compaction
|
||||
t = (uint64_t*) target4;
|
||||
devNoncePtrEnd = thrust::remove_if(devNoncePtr, devNoncePtrEnd, check_nonce_for_remove(*t, d_hash4output[thr_id], 16, pdata[19]));
|
||||
actualNumberOfValuesInNonceVectorGPU = (uint32_t)(devNoncePtrEnd - devNoncePtr);
|
||||
if(actualNumberOfValuesInNonceVectorGPU == 0)
|
||||
goto emptyNonceVector;
|
||||
blake512_cpu_hash(thr_id, actualNumberOfValuesInNonceVectorGPU, pdata[19]);
|
||||
|
||||
// combine
|
||||
combine_cpu_hash(thr_id, actualNumberOfValuesInNonceVectorGPU, pdata[19], hash);
|
||||
////// Compaction
|
||||
t = (uint64_t*) target5;
|
||||
devNoncePtrEnd = thrust::remove_if(devNoncePtr, devNoncePtrEnd, check_nonce_for_remove(*t, d_hash5output[thr_id], 16, pdata[19]));
|
||||
actualNumberOfValuesInNonceVectorGPU = (uint32_t)(devNoncePtrEnd - devNoncePtr);
|
||||
if(actualNumberOfValuesInNonceVectorGPU == 0)
|
||||
goto emptyNonceVector;
|
||||
|
||||
if (opt_tracegpu) {
|
||||
applog(LOG_BLUE, "heavy GPU hash:");
|
||||
applog_hash((uchar*)hash);
|
||||
}
|
||||
groestl512_cpu_hash(thr_id, actualNumberOfValuesInNonceVectorGPU, pdata[19]);
|
||||
|
||||
// Ergebnisse kopieren
|
||||
if(actualNumberOfValuesInNonceVectorGPU > 0)
|
||||
{
|
||||
size_t size = sizeof(uint32_t) * actualNumberOfValuesInNonceVectorGPU;
|
||||
CUDA_SAFE_CALL(cudaMemcpy(cpu_nonceVector, heavy_nonceVector[thr_id], size, cudaMemcpyDeviceToHost));
|
||||
cudaThreadSynchronize();
|
||||
////// Compaction
|
||||
t = (uint64_t*) target4;
|
||||
devNoncePtrEnd = thrust::remove_if(devNoncePtr, devNoncePtrEnd, check_nonce_for_remove(*t, d_hash4output[thr_id], 16, pdata[19]));
|
||||
actualNumberOfValuesInNonceVectorGPU = (uint32_t)(devNoncePtrEnd - devNoncePtr);
|
||||
#else
|
||||
// todo (nvlabs cub ?)
|
||||
actualNumberOfValuesInNonceVectorGPU = 0;
|
||||
#endif
|
||||
if(actualNumberOfValuesInNonceVectorGPU == 0)
|
||||
goto emptyNonceVector;
|
||||
|
||||
for (uint32_t i=0; i < actualNumberOfValuesInNonceVectorGPU; i++)
|
||||
{
|
||||
uint32_t nonce = cpu_nonceVector[i];
|
||||
uint32_t *foundhash = &hash[8*i];
|
||||
if (foundhash[7] <= ptarget[7] && fulltest(foundhash, ptarget)) {
|
||||
uint32_t vhash[8];
|
||||
pdata[19] += nonce - pdata[19];
|
||||
heavycoin_hash((uchar*)vhash, (uchar*)pdata, blocklen);
|
||||
if (memcmp(vhash, foundhash, 8*sizeof(uint32_t))) {
|
||||
applog(LOG_ERR, "hash for nonce %08x does not validate on CPU!\n", nonce);
|
||||
} else {
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
bn_store_hash_target_ratio(vhash, ptarget, work);
|
||||
rc = 1;
|
||||
goto exit;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// combine
|
||||
combine_cpu_hash(thr_id, actualNumberOfValuesInNonceVectorGPU, pdata[19], hash);
|
||||
|
||||
if (opt_tracegpu) {
|
||||
applog(LOG_BLUE, "heavy GPU hash:");
|
||||
applog_hash((uchar*)hash);
|
||||
}
|
||||
|
||||
// Ergebnisse kopieren
|
||||
if(actualNumberOfValuesInNonceVectorGPU > 0)
|
||||
{
|
||||
size_t size = sizeof(uint32_t) * actualNumberOfValuesInNonceVectorGPU;
|
||||
cudaMemcpy(cpu_nonceVector, heavy_nonceVector[thr_id], size, cudaMemcpyDeviceToHost);
|
||||
|
||||
for (uint32_t i=0; i < actualNumberOfValuesInNonceVectorGPU; i++)
|
||||
{
|
||||
uint32_t nonce = cpu_nonceVector[i];
|
||||
uint32_t *foundhash = &hash[8*i];
|
||||
if (foundhash[7] <= ptarget[7] && fulltest(foundhash, ptarget)) {
|
||||
uint32_t vhash[8];
|
||||
pdata[19] += nonce - pdata[19];
|
||||
heavycoin_hash((uchar*)vhash, (uchar*)pdata, blocklen);
|
||||
if (memcmp(vhash, foundhash, 32)) {
|
||||
gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", nonce);
|
||||
} else {
|
||||
work_set_target_ratio(work, vhash);
|
||||
rc = 1;
|
||||
goto exit;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
emptyNonceVector:
|
||||
if ((uint64_t) throughput + pdata[19] >= max_nonce) {
|
||||
pdata[19] = max_nonce;
|
||||
break;
|
||||
}
|
||||
pdata[19] += throughput;
|
||||
|
||||
pdata[19] += throughput;
|
||||
|
||||
} while (pdata[19] < max_nonce && !work_restart[thr_id].restart);
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
} while (!work_restart[thr_id].restart);
|
||||
|
||||
exit:
|
||||
cudaFreeHost(cpu_nonceVector);
|
||||
cudaFreeHost(hash);
|
||||
return rc;
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
|
||||
cudaFreeHost(cpu_nonceVector);
|
||||
cudaFreeHost(hash);
|
||||
CUDA_LOG_ERROR();
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
// cleanup
|
||||
extern "C" void free_heavy(int thr_id)
|
||||
{
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
cudaFree(heavy_nonceVector[thr_id]);
|
||||
cudaFree(heavy_nonceVector[thr_id]);
|
||||
|
||||
// todo: free sub algos vectors
|
||||
blake512_cpu_free(thr_id);
|
||||
groestl512_cpu_free(thr_id);
|
||||
hefty_cpu_free(thr_id);
|
||||
keccak512_cpu_free(thr_id);
|
||||
sha256_cpu_free(thr_id);
|
||||
combine_cpu_free(thr_id);
|
||||
|
||||
init[thr_id] = false;
|
||||
init[thr_id] = false;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
|
||||
__host__
|
||||
void heavycoin_hash(uchar* output, const uchar* input, int len)
|
||||
{
|
||||
unsigned char hash1[32];
|
||||
unsigned char hash2[32];
|
||||
uint32_t hash3[16];
|
||||
uint32_t hash4[16];
|
||||
uint32_t hash5[16];
|
||||
uint32_t *final;
|
||||
SHA256_CTX ctx;
|
||||
sph_keccak512_context keccakCtx;
|
||||
sph_groestl512_context groestlCtx;
|
||||
sph_blake512_context blakeCtx;
|
||||
unsigned char hash1[32];
|
||||
unsigned char hash2[32];
|
||||
uint32_t hash3[16];
|
||||
uint32_t hash4[16];
|
||||
uint32_t hash5[16];
|
||||
uint32_t *final;
|
||||
SHA256_CTX ctx;
|
||||
sph_keccak512_context keccakCtx;
|
||||
sph_groestl512_context groestlCtx;
|
||||
sph_blake512_context blakeCtx;
|
||||
|
||||
HEFTY1(input, len, hash1);
|
||||
HEFTY1(input, len, hash1);
|
||||
|
||||
/* HEFTY1 is new, so take an extra security measure to eliminate
|
||||
* the possiblity of collisions:
|
||||
*
|
||||
* Hash(x) = SHA256(x + HEFTY1(x))
|
||||
*
|
||||
* N.B. '+' is concatenation.
|
||||
*/
|
||||
SHA256_Init(&ctx);
|
||||
SHA256_Update(&ctx, input, len);
|
||||
SHA256_Update(&ctx, hash1, sizeof(hash1));
|
||||
SHA256_Final(hash2, &ctx);
|
||||
/* HEFTY1 is new, so take an extra security measure to eliminate
|
||||
* the possiblity of collisions:
|
||||
*
|
||||
* Hash(x) = SHA256(x + HEFTY1(x))
|
||||
*
|
||||
* N.B. '+' is concatenation.
|
||||
*/
|
||||
SHA256_Init(&ctx);
|
||||
SHA256_Update(&ctx, input, len);
|
||||
SHA256_Update(&ctx, hash1, sizeof(hash1));
|
||||
SHA256_Final(hash2, &ctx);
|
||||
|
||||
/* Additional security: Do not rely on a single cryptographic hash
|
||||
* function. Instead, combine the outputs of 4 of the most secure
|
||||
* cryptographic hash functions-- SHA256, KECCAK512, GROESTL512
|
||||
* and BLAKE512.
|
||||
*/
|
||||
/* Additional security: Do not rely on a single cryptographic hash
|
||||
* function. Instead, combine the outputs of 4 of the most secure
|
||||
* cryptographic hash functions-- SHA256, KECCAK512, GROESTL512
|
||||
* and BLAKE512.
|
||||
*/
|
||||
|
||||
sph_keccak512_init(&keccakCtx);
|
||||
sph_keccak512(&keccakCtx, input, len);
|
||||
sph_keccak512(&keccakCtx, hash1, sizeof(hash1));
|
||||
sph_keccak512_close(&keccakCtx, (void *)&hash3);
|
||||
sph_keccak512_init(&keccakCtx);
|
||||
sph_keccak512(&keccakCtx, input, len);
|
||||
sph_keccak512(&keccakCtx, hash1, sizeof(hash1));
|
||||
sph_keccak512_close(&keccakCtx, (void *)&hash3);
|
||||
|
||||
sph_groestl512_init(&groestlCtx);
|
||||
sph_groestl512(&groestlCtx, input, len);
|
||||
sph_groestl512(&groestlCtx, hash1, sizeof(hash1));
|
||||
sph_groestl512_close(&groestlCtx, (void *)&hash4);
|
||||
sph_groestl512_init(&groestlCtx);
|
||||
sph_groestl512(&groestlCtx, input, len);
|
||||
sph_groestl512(&groestlCtx, hash1, sizeof(hash1));
|
||||
sph_groestl512_close(&groestlCtx, (void *)&hash4);
|
||||
|
||||
sph_blake512_init(&blakeCtx);
|
||||
sph_blake512(&blakeCtx, input, len);
|
||||
sph_blake512(&blakeCtx, (unsigned char *)&hash1, sizeof(hash1));
|
||||
sph_blake512_close(&blakeCtx, (void *)&hash5);
|
||||
sph_blake512_init(&blakeCtx);
|
||||
sph_blake512(&blakeCtx, input, len);
|
||||
sph_blake512(&blakeCtx, (unsigned char *)&hash1, sizeof(hash1));
|
||||
sph_blake512_close(&blakeCtx, (void *)&hash5);
|
||||
|
||||
final = (uint32_t *)output;
|
||||
combine_hashes(final, (uint32_t *)hash2, hash3, hash4, hash5);
|
||||
final = (uint32_t *)output;
|
||||
combine_hashes(final, (uint32_t *)hash2, hash3, hash4, hash5);
|
||||
}
|
||||
@@ -4,27 +4,33 @@
|
||||
void blake512_cpu_init(int thr_id, uint32_t threads);
|
||||
void blake512_cpu_setBlock(void *pdata, int len);
|
||||
void blake512_cpu_hash(int thr_id, uint32_t threads, uint32_t startNounce);
|
||||
void blake512_cpu_free(int thr_id);
|
||||
|
||||
void groestl512_cpu_init(int thr_id, uint32_t threads);
|
||||
void groestl512_cpu_copyHeftyHash(int thr_id, uint32_t threads, void *heftyHashes, int copy);
|
||||
void groestl512_cpu_setBlock(void *data, int len);
|
||||
void groestl512_cpu_hash(int thr_id, uint32_t threads, uint32_t startNounce);
|
||||
void groestl512_cpu_free(int thr_id);
|
||||
|
||||
void hefty_cpu_hash(int thr_id, uint32_t threads, int startNounce);
|
||||
void hefty_cpu_setBlock(int thr_id, uint32_t threads, void *data, int len);
|
||||
void hefty_cpu_init(int thr_id, uint32_t threads);
|
||||
void hefty_cpu_free(int thr_id);
|
||||
|
||||
void keccak512_cpu_init(int thr_id, uint32_t threads);
|
||||
void keccak512_cpu_setBlock(void *data, int len);
|
||||
void keccak512_cpu_copyHeftyHash(int thr_id, uint32_t threads, void *heftyHashes, int copy);
|
||||
void keccak512_cpu_hash(int thr_id, uint32_t threads, uint32_t startNounce);
|
||||
void keccak512_cpu_free(int thr_id);
|
||||
|
||||
void sha256_cpu_init(int thr_id, uint32_t threads);
|
||||
void sha256_cpu_setBlock(void *data, int len);
|
||||
void sha256_cpu_hash(int thr_id, uint32_t threads, int startNounce);
|
||||
void sha256_cpu_copyHeftyHash(int thr_id, uint32_t threads, void *heftyHashes, int copy);
|
||||
void sha256_cpu_free(int thr_id);
|
||||
|
||||
void combine_cpu_init(int thr_id, uint32_t threads);
|
||||
void combine_cpu_hash(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *hash);
|
||||
void combine_cpu_free(int thr_id);
|
||||
|
||||
#endif
|
||||
+543
-180
@@ -1,223 +1,586 @@
|
||||
/**
|
||||
* Lyra2 (v1) cuda implementation based on djm34 work - SM 5/5.2
|
||||
* tpruvot@github 2015
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <memory.h>
|
||||
|
||||
#include "cuda_helper.h"
|
||||
#define TPB52 32
|
||||
|
||||
#define TPB 160
|
||||
#include "cuda_lyra2_sm2.cuh"
|
||||
#include "cuda_lyra2_sm5.cuh"
|
||||
|
||||
static __constant__ uint2 blake2b_IV[8] = {
|
||||
{ 0xf3bcc908, 0x6a09e667 },
|
||||
{ 0x84caa73b, 0xbb67ae85 },
|
||||
{ 0xfe94f82b, 0x3c6ef372 },
|
||||
{ 0x5f1d36f1, 0xa54ff53a },
|
||||
{ 0xade682d1, 0x510e527f },
|
||||
{ 0x2b3e6c1f, 0x9b05688c },
|
||||
{ 0xfb41bd6b, 0x1f83d9ab },
|
||||
{ 0x137e2179, 0x5be0cd19 }
|
||||
};
|
||||
#ifdef __INTELLISENSE__
|
||||
/* just for vstudio code colors */
|
||||
#define __CUDA_ARCH__ 520
|
||||
#endif
|
||||
|
||||
#define reduceDuplexRow(rowIn, rowInOut, rowOut) { \
|
||||
for (int i = 0; i < 8; i++) { \
|
||||
for (int j = 0; j < 12; j++) \
|
||||
state[j] ^= Matrix[12 * i + j][rowIn] + Matrix[12 * i + j][rowInOut]; \
|
||||
round_lyra(state); \
|
||||
for (int j = 0; j < 12; j++) \
|
||||
Matrix[j + 12 * i][rowOut] ^= state[j]; \
|
||||
Matrix[0 + 12 * i][rowInOut] ^= state[11]; \
|
||||
Matrix[1 + 12 * i][rowInOut] ^= state[0]; \
|
||||
Matrix[2 + 12 * i][rowInOut] ^= state[1]; \
|
||||
Matrix[3 + 12 * i][rowInOut] ^= state[2]; \
|
||||
Matrix[4 + 12 * i][rowInOut] ^= state[3]; \
|
||||
Matrix[5 + 12 * i][rowInOut] ^= state[4]; \
|
||||
Matrix[6 + 12 * i][rowInOut] ^= state[5]; \
|
||||
Matrix[7 + 12 * i][rowInOut] ^= state[6]; \
|
||||
Matrix[8 + 12 * i][rowInOut] ^= state[7]; \
|
||||
Matrix[9 + 12 * i][rowInOut] ^= state[8]; \
|
||||
Matrix[10+ 12 * i][rowInOut] ^= state[9]; \
|
||||
Matrix[11+ 12 * i][rowInOut] ^= state[10]; \
|
||||
} \
|
||||
}
|
||||
#if !defined(__CUDA_ARCH__) || __CUDA_ARCH__ > 500
|
||||
|
||||
#define absorbblock(in) { \
|
||||
state[0] ^= Matrix[0][in]; \
|
||||
state[1] ^= Matrix[1][in]; \
|
||||
state[2] ^= Matrix[2][in]; \
|
||||
state[3] ^= Matrix[3][in]; \
|
||||
state[4] ^= Matrix[4][in]; \
|
||||
state[5] ^= Matrix[5][in]; \
|
||||
state[6] ^= Matrix[6][in]; \
|
||||
state[7] ^= Matrix[7][in]; \
|
||||
state[8] ^= Matrix[8][in]; \
|
||||
state[9] ^= Matrix[9][in]; \
|
||||
state[10] ^= Matrix[10][in]; \
|
||||
state[11] ^= Matrix[11][in]; \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
}
|
||||
#include "cuda_lyra2_vectors.h"
|
||||
|
||||
#ifdef __INTELLISENSE__
|
||||
/* just for vstudio code colors */
|
||||
__device__ uint32_t __shfl(uint32_t a, uint32_t b, uint32_t c);
|
||||
#endif
|
||||
|
||||
#define Nrow 8
|
||||
#define Ncol 8
|
||||
#define memshift 3
|
||||
|
||||
#define BUF_COUNT 0
|
||||
|
||||
__device__ uint2 *DMatrix;
|
||||
|
||||
__device__ __forceinline__ void LD4S(uint2 res[3], const int row, const int col, const int thread, const int threads)
|
||||
{
|
||||
#if BUF_COUNT != 8
|
||||
extern __shared__ uint2 shared_mem[];
|
||||
const int s0 = (Ncol * (row - BUF_COUNT) + col) * memshift;
|
||||
#endif
|
||||
#if BUF_COUNT != 0
|
||||
const int d0 = (memshift *(Ncol * row + col) * threads + thread)*blockDim.x + threadIdx.x;
|
||||
#endif
|
||||
|
||||
#if BUF_COUNT == 8
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
res[j] = *(DMatrix + d0 + j * threads * blockDim.x);
|
||||
#elif BUF_COUNT == 0
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
res[j] = shared_mem[((s0 + j) * blockDim.y + threadIdx.y) * blockDim.x + threadIdx.x];
|
||||
#else
|
||||
if (row < BUF_COUNT)
|
||||
{
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
res[j] = *(DMatrix + d0 + j * threads * blockDim.x);
|
||||
}
|
||||
else
|
||||
{
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
res[j] = shared_mem[((s0 + j) * blockDim.y + threadIdx.y) * blockDim.x + threadIdx.x];
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
__device__ __forceinline__ void ST4S(const int row, const int col, const uint2 data[3], const int thread, const int threads)
|
||||
{
|
||||
#if BUF_COUNT != 8
|
||||
extern __shared__ uint2 shared_mem[];
|
||||
const int s0 = (Ncol * (row - BUF_COUNT) + col) * memshift;
|
||||
#endif
|
||||
#if BUF_COUNT != 0
|
||||
const int d0 = (memshift *(Ncol * row + col) * threads + thread)*blockDim.x + threadIdx.x;
|
||||
#endif
|
||||
|
||||
#if BUF_COUNT == 8
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
*(DMatrix + d0 + j * threads * blockDim.x) = data[j];
|
||||
#elif BUF_COUNT == 0
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
shared_mem[((s0 + j) * blockDim.y + threadIdx.y) * blockDim.x + threadIdx.x] = data[j];
|
||||
#else
|
||||
if (row < BUF_COUNT)
|
||||
{
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
*(DMatrix + d0 + j * threads * blockDim.x) = data[j];
|
||||
}
|
||||
else
|
||||
{
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
shared_mem[((s0 + j) * blockDim.y + threadIdx.y) * blockDim.x + threadIdx.x] = data[j];
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#if __CUDA_ARCH__ >= 300
|
||||
__device__ __forceinline__ uint32_t WarpShuffle(uint32_t a, uint32_t b, uint32_t c)
|
||||
{
|
||||
return __shfl(a, b, c);
|
||||
}
|
||||
|
||||
__device__ __forceinline__ uint2 WarpShuffle(uint2 a, uint32_t b, uint32_t c)
|
||||
{
|
||||
return make_uint2(__shfl(a.x, b, c), __shfl(a.y, b, c));
|
||||
}
|
||||
|
||||
__device__ __forceinline__ void WarpShuffle3(uint2 &a1, uint2 &a2, uint2 &a3, uint32_t b1, uint32_t b2, uint32_t b3, uint32_t c)
|
||||
{
|
||||
a1 = WarpShuffle(a1, b1, c);
|
||||
a2 = WarpShuffle(a2, b2, c);
|
||||
a3 = WarpShuffle(a3, b3, c);
|
||||
}
|
||||
|
||||
#else
|
||||
__device__ __forceinline__ uint32_t WarpShuffle(uint32_t a, uint32_t b, uint32_t c)
|
||||
{
|
||||
extern __shared__ uint2 shared_mem[];
|
||||
|
||||
const uint32_t thread = blockDim.x * threadIdx.y + threadIdx.x;
|
||||
uint32_t *_ptr = (uint32_t*)shared_mem;
|
||||
|
||||
__threadfence_block();
|
||||
uint32_t buf = _ptr[thread];
|
||||
|
||||
_ptr[thread] = a;
|
||||
__threadfence_block();
|
||||
uint32_t result = _ptr[(thread&~(c - 1)) + (b&(c - 1))];
|
||||
|
||||
__threadfence_block();
|
||||
_ptr[thread] = buf;
|
||||
|
||||
__threadfence_block();
|
||||
return result;
|
||||
}
|
||||
|
||||
__device__ __forceinline__ uint2 WarpShuffle(uint2 a, uint32_t b, uint32_t c)
|
||||
{
|
||||
extern __shared__ uint2 shared_mem[];
|
||||
|
||||
const uint32_t thread = blockDim.x * threadIdx.y + threadIdx.x;
|
||||
|
||||
__threadfence_block();
|
||||
uint2 buf = shared_mem[thread];
|
||||
|
||||
shared_mem[thread] = a;
|
||||
__threadfence_block();
|
||||
uint2 result = shared_mem[(thread&~(c - 1)) + (b&(c - 1))];
|
||||
|
||||
__threadfence_block();
|
||||
shared_mem[thread] = buf;
|
||||
|
||||
__threadfence_block();
|
||||
return result;
|
||||
}
|
||||
|
||||
__device__ __forceinline__ void WarpShuffle3(uint2 &a1, uint2 &a2, uint2 &a3, uint32_t b1, uint32_t b2, uint32_t b3, uint32_t c)
|
||||
{
|
||||
extern __shared__ uint2 shared_mem[];
|
||||
|
||||
const uint32_t thread = blockDim.x * threadIdx.y + threadIdx.x;
|
||||
|
||||
__threadfence_block();
|
||||
uint2 buf = shared_mem[thread];
|
||||
|
||||
shared_mem[thread] = a1;
|
||||
__threadfence_block();
|
||||
a1 = shared_mem[(thread&~(c - 1)) + (b1&(c - 1))];
|
||||
__threadfence_block();
|
||||
shared_mem[thread] = a2;
|
||||
__threadfence_block();
|
||||
a2 = shared_mem[(thread&~(c - 1)) + (b2&(c - 1))];
|
||||
__threadfence_block();
|
||||
shared_mem[thread] = a3;
|
||||
__threadfence_block();
|
||||
a3 = shared_mem[(thread&~(c - 1)) + (b3&(c - 1))];
|
||||
|
||||
__threadfence_block();
|
||||
shared_mem[thread] = buf;
|
||||
__threadfence_block();
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
static __device__ __forceinline__
|
||||
void Gfunc(uint2 & a, uint2 &b, uint2 &c, uint2 &d)
|
||||
void Gfunc(uint2 &a, uint2 &b, uint2 &c, uint2 &d)
|
||||
{
|
||||
a += b; d ^= a; d = SWAPUINT2(d);
|
||||
c += d; b ^= c; b = ROR2(b, 24);
|
||||
a += b; d ^= a; d = ROR2(d, 16);
|
||||
a += b; d = eorswap32(a, d);
|
||||
c += d; b ^= c; b = ROR24(b);
|
||||
a += b; d ^= a; d = ROR16(d);
|
||||
c += d; b ^= c; b = ROR2(b, 63);
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
static void round_lyra(uint2 *s)
|
||||
__device__ __forceinline__ void round_lyra(uint2 s[4])
|
||||
{
|
||||
Gfunc(s[0], s[4], s[8], s[12]);
|
||||
Gfunc(s[1], s[5], s[9], s[13]);
|
||||
Gfunc(s[2], s[6], s[10], s[14]);
|
||||
Gfunc(s[3], s[7], s[11], s[15]);
|
||||
Gfunc(s[0], s[5], s[10], s[15]);
|
||||
Gfunc(s[1], s[6], s[11], s[12]);
|
||||
Gfunc(s[2], s[7], s[8], s[13]);
|
||||
Gfunc(s[3], s[4], s[9], s[14]);
|
||||
Gfunc(s[0], s[1], s[2], s[3]);
|
||||
WarpShuffle3(s[1], s[2], s[3], threadIdx.x + 1, threadIdx.x + 2, threadIdx.x + 3, 4);
|
||||
Gfunc(s[0], s[1], s[2], s[3]);
|
||||
WarpShuffle3(s[1], s[2], s[3], threadIdx.x + 3, threadIdx.x + 2, threadIdx.x + 1, 4);
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
void reduceDuplexRowSetup(const int rowIn, const int rowInOut, const int rowOut, uint2 state[16], uint2 Matrix[96][8])
|
||||
static __device__ __forceinline__
|
||||
void round_lyra(uint2x4* s)
|
||||
{
|
||||
Gfunc(s[0].x, s[1].x, s[2].x, s[3].x);
|
||||
Gfunc(s[0].y, s[1].y, s[2].y, s[3].y);
|
||||
Gfunc(s[0].z, s[1].z, s[2].z, s[3].z);
|
||||
Gfunc(s[0].w, s[1].w, s[2].w, s[3].w);
|
||||
Gfunc(s[0].x, s[1].y, s[2].z, s[3].w);
|
||||
Gfunc(s[0].y, s[1].z, s[2].w, s[3].x);
|
||||
Gfunc(s[0].z, s[1].w, s[2].x, s[3].y);
|
||||
Gfunc(s[0].w, s[1].x, s[2].y, s[3].z);
|
||||
}
|
||||
|
||||
static __device__ __forceinline__
|
||||
void reduceDuplex(uint2 state[4], uint32_t thread, const uint32_t threads)
|
||||
{
|
||||
uint2 state1[3];
|
||||
|
||||
#if __CUDA_ARCH__ > 500
|
||||
#pragma unroll
|
||||
#pragma unroll
|
||||
#endif
|
||||
for (int i = 0; i < 8; i++)
|
||||
for (int i = 0; i < Nrow; i++)
|
||||
{
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 12; j++)
|
||||
state[j] ^= Matrix[12 * i + j][rowIn] + Matrix[12 * i + j][rowInOut];
|
||||
ST4S(0, Ncol - i - 1, state, thread, threads);
|
||||
|
||||
round_lyra(state);
|
||||
}
|
||||
|
||||
#pragma unroll 4
|
||||
for (int i = 0; i < Nrow; i++)
|
||||
{
|
||||
LD4S(state1, 0, i, thread, threads);
|
||||
for (int j = 0; j < 3; j++)
|
||||
state[j] ^= state1[j];
|
||||
|
||||
round_lyra(state);
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 12; j++)
|
||||
Matrix[j + 84 - 12 * i][rowOut] = Matrix[12 * i + j][rowIn] ^ state[j];
|
||||
|
||||
Matrix[0 + 12 * i][rowInOut] ^= state[11];
|
||||
Matrix[1 + 12 * i][rowInOut] ^= state[0];
|
||||
Matrix[2 + 12 * i][rowInOut] ^= state[1];
|
||||
Matrix[3 + 12 * i][rowInOut] ^= state[2];
|
||||
Matrix[4 + 12 * i][rowInOut] ^= state[3];
|
||||
Matrix[5 + 12 * i][rowInOut] ^= state[4];
|
||||
Matrix[6 + 12 * i][rowInOut] ^= state[5];
|
||||
Matrix[7 + 12 * i][rowInOut] ^= state[6];
|
||||
Matrix[8 + 12 * i][rowInOut] ^= state[7];
|
||||
Matrix[9 + 12 * i][rowInOut] ^= state[8];
|
||||
Matrix[10 + 12 * i][rowInOut] ^= state[9];
|
||||
Matrix[11 + 12 * i][rowInOut] ^= state[10];
|
||||
for (int j = 0; j < 3; j++)
|
||||
state1[j] ^= state[j];
|
||||
ST4S(1, Ncol - i - 1, state1, thread, threads);
|
||||
}
|
||||
}
|
||||
|
||||
__global__ __launch_bounds__(TPB, 1)
|
||||
void lyra2_gpu_hash_32(uint32_t threads, uint32_t startNounce, uint64_t *outputHash)
|
||||
static __device__ __forceinline__
|
||||
void reduceDuplexRowSetup(const int rowIn, const int rowInOut, const int rowOut, uint2 state[4], uint32_t thread, const uint32_t threads)
|
||||
{
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
uint2 state1[3], state2[3];
|
||||
|
||||
#pragma unroll 1
|
||||
for (int i = 0; i < Nrow; i++)
|
||||
{
|
||||
LD4S(state1, rowIn, i, thread, threads);
|
||||
LD4S(state2, rowInOut, i, thread, threads);
|
||||
for (int j = 0; j < 3; j++)
|
||||
state[j] ^= state1[j] + state2[j];
|
||||
|
||||
round_lyra(state);
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state1[j] ^= state[j];
|
||||
|
||||
ST4S(rowOut, Ncol - i - 1, state1, thread, threads);
|
||||
|
||||
//一個手前のスレッドからデータを貰う(同時に一個先のスレッドにデータを送る)
|
||||
uint2 Data0 = state[0];
|
||||
uint2 Data1 = state[1];
|
||||
uint2 Data2 = state[2];
|
||||
WarpShuffle3(Data0, Data1, Data2, threadIdx.x - 1, threadIdx.x - 1, threadIdx.x - 1, 4);
|
||||
|
||||
if (threadIdx.x == 0)
|
||||
{
|
||||
state2[0] ^= Data2;
|
||||
state2[1] ^= Data0;
|
||||
state2[2] ^= Data1;
|
||||
}
|
||||
else
|
||||
{
|
||||
state2[0] ^= Data0;
|
||||
state2[1] ^= Data1;
|
||||
state2[2] ^= Data2;
|
||||
}
|
||||
|
||||
ST4S(rowInOut, i, state2, thread, threads);
|
||||
}
|
||||
}
|
||||
|
||||
static __device__ __forceinline__
|
||||
void reduceDuplexRowt(const int rowIn, const int rowInOut, const int rowOut, uint2 state[4], const uint32_t thread, const uint32_t threads)
|
||||
{
|
||||
for (int i = 0; i < Nrow; i++)
|
||||
{
|
||||
uint2 state1[3], state2[3];
|
||||
|
||||
LD4S(state1, rowIn, i, thread, threads);
|
||||
LD4S(state2, rowInOut, i, thread, threads);
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state[j] ^= state1[j] + state2[j];
|
||||
|
||||
round_lyra(state);
|
||||
|
||||
//一個手前のスレッドからデータを貰う(同時に一個先のスレッドにデータを送る)
|
||||
uint2 Data0 = state[0];
|
||||
uint2 Data1 = state[1];
|
||||
uint2 Data2 = state[2];
|
||||
WarpShuffle3(Data0, Data1, Data2, threadIdx.x - 1, threadIdx.x - 1, threadIdx.x - 1, 4);
|
||||
|
||||
if (threadIdx.x == 0)
|
||||
{
|
||||
state2[0] ^= Data2;
|
||||
state2[1] ^= Data0;
|
||||
state2[2] ^= Data1;
|
||||
}
|
||||
else
|
||||
{
|
||||
state2[0] ^= Data0;
|
||||
state2[1] ^= Data1;
|
||||
state2[2] ^= Data2;
|
||||
}
|
||||
|
||||
ST4S(rowInOut, i, state2, thread, threads);
|
||||
|
||||
LD4S(state1, rowOut, i, thread, threads);
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state1[j] ^= state[j];
|
||||
|
||||
ST4S(rowOut, i, state1, thread, threads);
|
||||
}
|
||||
}
|
||||
|
||||
static __device__ __forceinline__
|
||||
void reduceDuplexRowt_8(const int rowInOut, uint2* state, const uint32_t thread, const uint32_t threads)
|
||||
{
|
||||
|
||||
uint2 state1[3], state2[3], last[3];
|
||||
|
||||
LD4S(state1, 2, 0, thread, threads);
|
||||
LD4S(last, rowInOut, 0, thread, threads);
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state[j] ^= state1[j] + last[j];
|
||||
|
||||
round_lyra(state);
|
||||
|
||||
//一個手前のスレッドからデータを貰う(同時に一個先のスレッドにデータを送る)
|
||||
uint2 Data0 = state[0];
|
||||
uint2 Data1 = state[1];
|
||||
uint2 Data2 = state[2];
|
||||
WarpShuffle3(Data0, Data1, Data2, threadIdx.x - 1, threadIdx.x - 1, threadIdx.x - 1, 4);
|
||||
|
||||
if (threadIdx.x == 0)
|
||||
{
|
||||
last[0] ^= Data2;
|
||||
last[1] ^= Data0;
|
||||
last[2] ^= Data1;
|
||||
}
|
||||
else
|
||||
{
|
||||
last[0] ^= Data0;
|
||||
last[1] ^= Data1;
|
||||
last[2] ^= Data2;
|
||||
}
|
||||
|
||||
if (rowInOut == 5)
|
||||
{
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
last[j] ^= state[j];
|
||||
}
|
||||
|
||||
for (int i = 1; i < Nrow; i++)
|
||||
{
|
||||
LD4S(state1, 2, i, thread, threads);
|
||||
LD4S(state2, rowInOut, i, thread, threads);
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state[j] ^= state1[j] + state2[j];
|
||||
|
||||
round_lyra(state);
|
||||
}
|
||||
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state[j] ^= last[j];
|
||||
}
|
||||
|
||||
__constant__ uint2x4 blake2b_IV[2] = {
|
||||
0xf3bcc908lu, 0x6a09e667lu,
|
||||
0x84caa73blu, 0xbb67ae85lu,
|
||||
0xfe94f82blu, 0x3c6ef372lu,
|
||||
0x5f1d36f1lu, 0xa54ff53alu,
|
||||
0xade682d1lu, 0x510e527flu,
|
||||
0x2b3e6c1flu, 0x9b05688clu,
|
||||
0xfb41bd6blu, 0x1f83d9ablu,
|
||||
0x137e2179lu, 0x5be0cd19lu
|
||||
};
|
||||
|
||||
__global__ __launch_bounds__(64, 1)
|
||||
void lyra2_gpu_hash_32_1(uint32_t threads, uint32_t startNounce, uint2 *g_hash)
|
||||
{
|
||||
const uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
|
||||
if (thread < threads)
|
||||
{
|
||||
uint2 state[16];
|
||||
uint2x4 state[4];
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 0; i<4; i++) {
|
||||
LOHI(state[i].x, state[i].y, outputHash[threads*i + thread]);
|
||||
} //password
|
||||
state[0].x = state[1].x = __ldg(&g_hash[thread + threads * 0]);
|
||||
state[0].y = state[1].y = __ldg(&g_hash[thread + threads * 1]);
|
||||
state[0].z = state[1].z = __ldg(&g_hash[thread + threads * 2]);
|
||||
state[0].w = state[1].w = __ldg(&g_hash[thread + threads * 3]);
|
||||
state[2] = blake2b_IV[0];
|
||||
state[3] = blake2b_IV[1];
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 0; i<4; i++) {
|
||||
state[i + 4] = state[i];
|
||||
} //salt
|
||||
for (int i = 0; i<24; i++)
|
||||
round_lyra(state); //because 12 is not enough
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 0; i<8; i++) {
|
||||
state[i + 8] = blake2b_IV[i];
|
||||
}
|
||||
((uint2x4*)DMatrix)[threads * 0 + thread] = state[0];
|
||||
((uint2x4*)DMatrix)[threads * 1 + thread] = state[1];
|
||||
((uint2x4*)DMatrix)[threads * 2 + thread] = state[2];
|
||||
((uint2x4*)DMatrix)[threads * 3 + thread] = state[3];
|
||||
}
|
||||
}
|
||||
|
||||
// blake2blyra x2
|
||||
//#pragma unroll 24
|
||||
for (int i = 0; i<24; i++) {
|
||||
#if __CUDA_ARCH__ < 300
|
||||
__global__ __launch_bounds__(TPB20, 1)
|
||||
#elif __CUDA_ARCH__ < 500
|
||||
__global__ __launch_bounds__(TPB30, 1)
|
||||
#elif __CUDA_ARCH__ == 500
|
||||
__global__ __launch_bounds__(TPB50, 1)
|
||||
#else
|
||||
__global__ __launch_bounds__(TPB52, 1)
|
||||
#endif
|
||||
void lyra2_gpu_hash_32_2(uint32_t threads, uint32_t startNounce, uint64_t *g_hash)
|
||||
{
|
||||
const uint32_t thread = blockDim.y * blockIdx.x + threadIdx.y;
|
||||
|
||||
if (thread < threads)
|
||||
{
|
||||
uint2 state[4];
|
||||
state[0] = __ldg(&DMatrix[(0 * threads + thread) * blockDim.x + threadIdx.x]);
|
||||
state[1] = __ldg(&DMatrix[(1 * threads + thread) * blockDim.x + threadIdx.x]);
|
||||
state[2] = __ldg(&DMatrix[(2 * threads + thread) * blockDim.x + threadIdx.x]);
|
||||
state[3] = __ldg(&DMatrix[(3 * threads + thread) * blockDim.x + threadIdx.x]);
|
||||
|
||||
reduceDuplex(state, thread, threads);
|
||||
|
||||
reduceDuplexRowSetup(1, 0, 2, state, thread, threads);
|
||||
reduceDuplexRowSetup(2, 1, 3, state, thread, threads);
|
||||
reduceDuplexRowSetup(3, 0, 4, state, thread, threads);
|
||||
reduceDuplexRowSetup(4, 3, 5, state, thread, threads);
|
||||
reduceDuplexRowSetup(5, 2, 6, state, thread, threads);
|
||||
reduceDuplexRowSetup(6, 1, 7, state, thread, threads);
|
||||
|
||||
uint32_t rowa = WarpShuffle(state[0].x, 0, 4) & 7;
|
||||
reduceDuplexRowt(7, rowa, 0, state, thread, threads);
|
||||
rowa = WarpShuffle(state[0].x, 0, 4) & 7;
|
||||
reduceDuplexRowt(0, rowa, 3, state, thread, threads);
|
||||
rowa = WarpShuffle(state[0].x, 0, 4) & 7;
|
||||
reduceDuplexRowt(3, rowa, 6, state, thread, threads);
|
||||
rowa = WarpShuffle(state[0].x, 0, 4) & 7;
|
||||
reduceDuplexRowt(6, rowa, 1, state, thread, threads);
|
||||
rowa = WarpShuffle(state[0].x, 0, 4) & 7;
|
||||
reduceDuplexRowt(1, rowa, 4, state, thread, threads);
|
||||
rowa = WarpShuffle(state[0].x, 0, 4) & 7;
|
||||
reduceDuplexRowt(4, rowa, 7, state, thread, threads);
|
||||
rowa = WarpShuffle(state[0].x, 0, 4) & 7;
|
||||
reduceDuplexRowt(7, rowa, 2, state, thread, threads);
|
||||
rowa = WarpShuffle(state[0].x, 0, 4) & 7;
|
||||
reduceDuplexRowt_8(rowa, state, thread, threads);
|
||||
|
||||
DMatrix[(0 * threads + thread) * blockDim.x + threadIdx.x] = state[0];
|
||||
DMatrix[(1 * threads + thread) * blockDim.x + threadIdx.x] = state[1];
|
||||
DMatrix[(2 * threads + thread) * blockDim.x + threadIdx.x] = state[2];
|
||||
DMatrix[(3 * threads + thread) * blockDim.x + threadIdx.x] = state[3];
|
||||
}
|
||||
}
|
||||
|
||||
__global__ __launch_bounds__(64, 1)
|
||||
void lyra2_gpu_hash_32_3(uint32_t threads, uint32_t startNounce, uint2 *g_hash)
|
||||
{
|
||||
const uint32_t thread = blockDim.x * blockIdx.x + threadIdx.x;
|
||||
|
||||
uint28 state[4];
|
||||
|
||||
if (thread < threads)
|
||||
{
|
||||
state[0] = __ldg4(&((uint2x4*)DMatrix)[threads * 0 + thread]);
|
||||
state[1] = __ldg4(&((uint2x4*)DMatrix)[threads * 1 + thread]);
|
||||
state[2] = __ldg4(&((uint2x4*)DMatrix)[threads * 2 + thread]);
|
||||
state[3] = __ldg4(&((uint2x4*)DMatrix)[threads * 3 + thread]);
|
||||
|
||||
for (int i = 0; i < 12; i++)
|
||||
round_lyra(state);
|
||||
} //because 12 is not enough
|
||||
|
||||
uint2 Matrix[96][8]; // not cool
|
||||
|
||||
// reducedSqueezeRow0
|
||||
#pragma unroll 8
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
#pragma unroll 12
|
||||
for (int j = 0; j<12; j++) {
|
||||
Matrix[j + 84 - 12 * i][0] = state[j];
|
||||
}
|
||||
round_lyra(state);
|
||||
}
|
||||
|
||||
// reducedSqueezeRow1
|
||||
#pragma unroll 8
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
#pragma unroll 12
|
||||
for (int j = 0; j<12; j++) {
|
||||
state[j] ^= Matrix[j + 12 * i][0];
|
||||
}
|
||||
round_lyra(state);
|
||||
#pragma unroll 12
|
||||
for (int j = 0; j<12; j++) {
|
||||
Matrix[j + 84 - 12 * i][1] = Matrix[j + 12 * i][0] ^ state[j];
|
||||
}
|
||||
}
|
||||
|
||||
reduceDuplexRowSetup(1, 0, 2,state, Matrix);
|
||||
reduceDuplexRowSetup(2, 1, 3, state, Matrix);
|
||||
reduceDuplexRowSetup(3, 0, 4, state, Matrix);
|
||||
reduceDuplexRowSetup(4, 3, 5, state, Matrix);
|
||||
reduceDuplexRowSetup(5, 2, 6, state, Matrix);
|
||||
reduceDuplexRowSetup(6, 1, 7, state, Matrix);
|
||||
|
||||
uint32_t rowa;
|
||||
rowa = state[0].x & 7;
|
||||
reduceDuplexRow(7, rowa, 0);
|
||||
rowa = state[0].x & 7;
|
||||
reduceDuplexRow(0, rowa, 3);
|
||||
rowa = state[0].x & 7;
|
||||
reduceDuplexRow(3, rowa, 6);
|
||||
rowa = state[0].x & 7;
|
||||
reduceDuplexRow(6, rowa, 1);
|
||||
rowa = state[0].x & 7;
|
||||
reduceDuplexRow(1, rowa, 4);
|
||||
rowa = state[0].x & 7;
|
||||
reduceDuplexRow(4, rowa, 7);
|
||||
rowa = state[0].x & 7;
|
||||
reduceDuplexRow(7, rowa, 2);
|
||||
rowa = state[0].x & 7;
|
||||
reduceDuplexRow(2, rowa, 5);
|
||||
|
||||
absorbblock(rowa);
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 0; i<4; i++) {
|
||||
outputHash[threads*i + thread] = devectorize(state[i]);
|
||||
} //password
|
||||
g_hash[thread + threads * 0] = state[0].x;
|
||||
g_hash[thread + threads * 1] = state[0].y;
|
||||
g_hash[thread + threads * 2] = state[0].z;
|
||||
g_hash[thread + threads * 3] = state[0].w;
|
||||
|
||||
} //thread
|
||||
}
|
||||
#else
|
||||
#if __CUDA_ARCH__ < 500
|
||||
|
||||
/* for unsupported SM arch */
|
||||
__device__ void* DMatrix;
|
||||
#endif
|
||||
__global__ void lyra2_gpu_hash_32_1(uint32_t threads, uint32_t startNounce, uint2 *g_hash) {}
|
||||
__global__ void lyra2_gpu_hash_32_2(uint32_t threads, uint32_t startNounce, uint64_t *g_hash) {}
|
||||
__global__ void lyra2_gpu_hash_32_3(uint32_t threads, uint32_t startNounce, uint2 *g_hash) {}
|
||||
#endif
|
||||
|
||||
__host__
|
||||
void lyra2_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNounce, uint64_t *d_outputHash, int order)
|
||||
void lyra2_cpu_init(int thr_id, uint32_t threads, uint64_t *d_matrix)
|
||||
{
|
||||
const uint32_t threadsperblock = TPB;
|
||||
int dev_id = device_map[thr_id % MAX_GPUS];
|
||||
// just assign the device pointer allocated in main loop
|
||||
cudaMemcpyToSymbol(DMatrix, &d_matrix, sizeof(uint64_t*), 0, cudaMemcpyHostToDevice);
|
||||
}
|
||||
|
||||
dim3 grid((threads + threadsperblock - 1) / threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
__host__
|
||||
void lyra2_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNounce, uint64_t *d_hash, bool gtx750ti)
|
||||
{
|
||||
int dev_id = device_map[thr_id % MAX_GPUS];
|
||||
|
||||
lyra2_gpu_hash_32 <<<grid, block>>> (threads, startNounce, d_outputHash);
|
||||
uint32_t tpb = TPB52;
|
||||
|
||||
if (cuda_arch[dev_id] >= 520) tpb = TPB52;
|
||||
else if (cuda_arch[dev_id] >= 500) tpb = TPB50;
|
||||
else if (cuda_arch[dev_id] >= 200) tpb = TPB20;
|
||||
|
||||
dim3 grid1((threads * 4 + tpb - 1) / tpb);
|
||||
dim3 block1(4, tpb >> 2);
|
||||
|
||||
dim3 grid2((threads + 64 - 1) / 64);
|
||||
dim3 block2(64);
|
||||
|
||||
dim3 grid3((threads + tpb - 1) / tpb);
|
||||
dim3 block3(tpb);
|
||||
|
||||
size_t shared_mem = 0;
|
||||
|
||||
//if (cuda_arch[dev_id] < 500) cudaFuncSetCacheConfig(lyra2_gpu_hash_32_2, cudaFuncCachePreferShared);
|
||||
|
||||
if (cuda_arch[dev_id] >= 520)
|
||||
{
|
||||
lyra2_gpu_hash_32_1 << <grid2, block2 >> > (threads, startNounce, (uint2*)d_hash);
|
||||
|
||||
lyra2_gpu_hash_32_2 << <grid1, block1, 24 * (8 - 0) * sizeof(uint2) * tpb >> > (threads, startNounce, d_hash);
|
||||
|
||||
lyra2_gpu_hash_32_3 << <grid2, block2 >> > (threads, startNounce, (uint2*)d_hash);
|
||||
}
|
||||
else if (cuda_arch[dev_id] >= 500)
|
||||
{
|
||||
if (gtx750ti)
|
||||
// 8Warpに調整のため、8192バイト確保する
|
||||
shared_mem = 8192;
|
||||
else
|
||||
// 10Warpに調整のため、6144バイト確保する
|
||||
shared_mem = 6144;
|
||||
|
||||
|
||||
lyra2_gpu_hash_32_1_sm5 << <grid2, block2 >> > (threads, startNounce, (uint2*)d_hash);
|
||||
|
||||
lyra2_gpu_hash_32_2_sm5 << <grid1, block1, shared_mem >> > (threads, startNounce, (uint2*)d_hash);
|
||||
|
||||
lyra2_gpu_hash_32_3_sm5 << <grid2, block2 >> > (threads, startNounce, (uint2*)d_hash);
|
||||
}
|
||||
else
|
||||
lyra2_gpu_hash_32_sm2 << < grid3, block3 >> > (threads, startNounce, d_hash);
|
||||
}
|
||||
@@ -0,0 +1,228 @@
|
||||
#include <memory.h>
|
||||
|
||||
#ifdef __INTELLISENSE__
|
||||
/* just for vstudio code colors */
|
||||
#undef __CUDA_ARCH__
|
||||
#define __CUDA_ARCH__ 500
|
||||
#endif
|
||||
|
||||
#include "cuda_helper.h"
|
||||
|
||||
#define TPB30 160
|
||||
#define TPB20 160
|
||||
|
||||
#if (__CUDA_ARCH__ >= 200 && __CUDA_ARCH__ <= 350) || !defined(__CUDA_ARCH__)
|
||||
__constant__ static uint2 blake2b_IV_sm2[8] = {
|
||||
{ 0xf3bcc908, 0x6a09e667 },
|
||||
{ 0x84caa73b, 0xbb67ae85 },
|
||||
{ 0xfe94f82b, 0x3c6ef372 },
|
||||
{ 0x5f1d36f1, 0xa54ff53a },
|
||||
{ 0xade682d1, 0x510e527f },
|
||||
{ 0x2b3e6c1f, 0x9b05688c },
|
||||
{ 0xfb41bd6b, 0x1f83d9ab },
|
||||
{ 0x137e2179, 0x5be0cd19 }
|
||||
};
|
||||
#endif
|
||||
|
||||
#if __CUDA_ARCH__ >= 200 && __CUDA_ARCH__ <= 350
|
||||
|
||||
#define reduceDuplexRow(rowIn, rowInOut, rowOut) { \
|
||||
for (int i = 0; i < 8; i++) { \
|
||||
for (int j = 0; j < 12; j++) \
|
||||
state[j] ^= Matrix[12 * i + j][rowIn] + Matrix[12 * i + j][rowInOut]; \
|
||||
round_lyra(state); \
|
||||
for (int j = 0; j < 12; j++) \
|
||||
Matrix[j + 12 * i][rowOut] ^= state[j]; \
|
||||
Matrix[0 + 12 * i][rowInOut] ^= state[11]; \
|
||||
Matrix[1 + 12 * i][rowInOut] ^= state[0]; \
|
||||
Matrix[2 + 12 * i][rowInOut] ^= state[1]; \
|
||||
Matrix[3 + 12 * i][rowInOut] ^= state[2]; \
|
||||
Matrix[4 + 12 * i][rowInOut] ^= state[3]; \
|
||||
Matrix[5 + 12 * i][rowInOut] ^= state[4]; \
|
||||
Matrix[6 + 12 * i][rowInOut] ^= state[5]; \
|
||||
Matrix[7 + 12 * i][rowInOut] ^= state[6]; \
|
||||
Matrix[8 + 12 * i][rowInOut] ^= state[7]; \
|
||||
Matrix[9 + 12 * i][rowInOut] ^= state[8]; \
|
||||
Matrix[10+ 12 * i][rowInOut] ^= state[9]; \
|
||||
Matrix[11+ 12 * i][rowInOut] ^= state[10]; \
|
||||
} \
|
||||
}
|
||||
|
||||
#define absorbblock(in) { \
|
||||
state[0] ^= Matrix[0][in]; \
|
||||
state[1] ^= Matrix[1][in]; \
|
||||
state[2] ^= Matrix[2][in]; \
|
||||
state[3] ^= Matrix[3][in]; \
|
||||
state[4] ^= Matrix[4][in]; \
|
||||
state[5] ^= Matrix[5][in]; \
|
||||
state[6] ^= Matrix[6][in]; \
|
||||
state[7] ^= Matrix[7][in]; \
|
||||
state[8] ^= Matrix[8][in]; \
|
||||
state[9] ^= Matrix[9][in]; \
|
||||
state[10] ^= Matrix[10][in]; \
|
||||
state[11] ^= Matrix[11][in]; \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
round_lyra(state); \
|
||||
}
|
||||
|
||||
static __device__ __forceinline__
|
||||
void Gfunc(uint2 & a, uint2 &b, uint2 &c, uint2 &d)
|
||||
{
|
||||
a += b; d ^= a; d = SWAPUINT2(d);
|
||||
c += d; b ^= c; b = ROR2(b, 24);
|
||||
a += b; d ^= a; d = ROR2(d, 16);
|
||||
c += d; b ^= c; b = ROR2(b, 63);
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
static void round_lyra(uint2 *s)
|
||||
{
|
||||
Gfunc(s[0], s[4], s[8], s[12]);
|
||||
Gfunc(s[1], s[5], s[9], s[13]);
|
||||
Gfunc(s[2], s[6], s[10], s[14]);
|
||||
Gfunc(s[3], s[7], s[11], s[15]);
|
||||
Gfunc(s[0], s[5], s[10], s[15]);
|
||||
Gfunc(s[1], s[6], s[11], s[12]);
|
||||
Gfunc(s[2], s[7], s[8], s[13]);
|
||||
Gfunc(s[3], s[4], s[9], s[14]);
|
||||
}
|
||||
|
||||
__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
|
||||
for (int j = 0; j < 12; j++)
|
||||
state[j] ^= Matrix[12 * i + j][rowIn] + Matrix[12 * i + j][rowInOut];
|
||||
|
||||
round_lyra(state);
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 12; j++)
|
||||
Matrix[j + 84 - 12 * i][rowOut] = Matrix[12 * i + j][rowIn] ^ state[j];
|
||||
|
||||
Matrix[0 + 12 * i][rowInOut] ^= state[11];
|
||||
Matrix[1 + 12 * i][rowInOut] ^= state[0];
|
||||
Matrix[2 + 12 * i][rowInOut] ^= state[1];
|
||||
Matrix[3 + 12 * i][rowInOut] ^= state[2];
|
||||
Matrix[4 + 12 * i][rowInOut] ^= state[3];
|
||||
Matrix[5 + 12 * i][rowInOut] ^= state[4];
|
||||
Matrix[6 + 12 * i][rowInOut] ^= state[5];
|
||||
Matrix[7 + 12 * i][rowInOut] ^= state[6];
|
||||
Matrix[8 + 12 * i][rowInOut] ^= state[7];
|
||||
Matrix[9 + 12 * i][rowInOut] ^= state[8];
|
||||
Matrix[10 + 12 * i][rowInOut] ^= state[9];
|
||||
Matrix[11 + 12 * i][rowInOut] ^= state[10];
|
||||
}
|
||||
}
|
||||
|
||||
__global__ __launch_bounds__(TPB30, 1)
|
||||
void lyra2_gpu_hash_32_sm2(uint32_t threads, uint32_t startNounce, uint64_t *g_hash)
|
||||
{
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
uint2 state[16];
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 0; i<4; i++) {
|
||||
LOHI(state[i].x, state[i].y, g_hash[threads*i + thread]);
|
||||
} //password
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 0; i<4; i++) {
|
||||
state[i + 4] = state[i];
|
||||
} //salt
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 0; i<8; i++) {
|
||||
state[i + 8] = blake2b_IV_sm2[i];
|
||||
}
|
||||
|
||||
// blake2blyra x2
|
||||
//#pragma unroll 24
|
||||
for (int i = 0; i<24; i++) {
|
||||
round_lyra(state);
|
||||
} //because 12 is not enough
|
||||
|
||||
uint2 Matrix[96][8]; // not cool
|
||||
|
||||
// reducedSqueezeRow0
|
||||
#pragma unroll 8
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
#pragma unroll 12
|
||||
for (int j = 0; j<12; j++) {
|
||||
Matrix[j + 84 - 12 * i][0] = state[j];
|
||||
}
|
||||
round_lyra(state);
|
||||
}
|
||||
|
||||
// reducedSqueezeRow1
|
||||
#pragma unroll 8
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
#pragma unroll 12
|
||||
for (int j = 0; j<12; j++) {
|
||||
state[j] ^= Matrix[j + 12 * i][0];
|
||||
}
|
||||
round_lyra(state);
|
||||
#pragma unroll 12
|
||||
for (int j = 0; j<12; j++) {
|
||||
Matrix[j + 84 - 12 * i][1] = Matrix[j + 12 * i][0] ^ state[j];
|
||||
}
|
||||
}
|
||||
|
||||
reduceDuplexRowSetup(1, 0, 2, state, Matrix);
|
||||
reduceDuplexRowSetup(2, 1, 3, state, Matrix);
|
||||
reduceDuplexRowSetup(3, 0, 4, state, Matrix);
|
||||
reduceDuplexRowSetup(4, 3, 5, state, Matrix);
|
||||
reduceDuplexRowSetup(5, 2, 6, state, Matrix);
|
||||
reduceDuplexRowSetup(6, 1, 7, state, Matrix);
|
||||
|
||||
uint32_t rowa;
|
||||
rowa = state[0].x & 7;
|
||||
reduceDuplexRow(7, rowa, 0);
|
||||
rowa = state[0].x & 7;
|
||||
reduceDuplexRow(0, rowa, 3);
|
||||
rowa = state[0].x & 7;
|
||||
reduceDuplexRow(3, rowa, 6);
|
||||
rowa = state[0].x & 7;
|
||||
reduceDuplexRow(6, rowa, 1);
|
||||
rowa = state[0].x & 7;
|
||||
reduceDuplexRow(1, rowa, 4);
|
||||
rowa = state[0].x & 7;
|
||||
reduceDuplexRow(4, rowa, 7);
|
||||
rowa = state[0].x & 7;
|
||||
reduceDuplexRow(7, rowa, 2);
|
||||
rowa = state[0].x & 7;
|
||||
reduceDuplexRow(2, rowa, 5);
|
||||
|
||||
absorbblock(rowa);
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 0; i<4; i++) {
|
||||
g_hash[threads*i + thread] = devectorize(state[i]);
|
||||
}
|
||||
|
||||
} //thread
|
||||
}
|
||||
|
||||
#else
|
||||
/* if __CUDA_ARCH__ < 200 .. host */
|
||||
__global__ void lyra2_gpu_hash_32_sm2(uint32_t threads, uint32_t startNounce, uint64_t *g_hash) {}
|
||||
#endif
|
||||
@@ -0,0 +1,701 @@
|
||||
#include <memory.h>
|
||||
|
||||
#ifdef __INTELLISENSE__
|
||||
/* just for vstudio code colors */
|
||||
#undef __CUDA_ARCH__
|
||||
#define __CUDA_ARCH__ 500
|
||||
#endif
|
||||
|
||||
#include "cuda_helper.h"
|
||||
|
||||
#define TPB50 32
|
||||
|
||||
#if __CUDA_ARCH__ == 500
|
||||
#include "cuda_lyra2_vectors.h"
|
||||
|
||||
#define Nrow 8
|
||||
#define Ncol 8
|
||||
#define memshift 3
|
||||
|
||||
__device__ uint2 *DMatrix;
|
||||
|
||||
__device__ __forceinline__ uint2 LD4S(const int index)
|
||||
{
|
||||
extern __shared__ uint2 shared_mem[];
|
||||
|
||||
return shared_mem[(index * blockDim.y + threadIdx.y) * blockDim.x + threadIdx.x];
|
||||
}
|
||||
|
||||
__device__ __forceinline__ void ST4S(const int index, const uint2 data)
|
||||
{
|
||||
extern __shared__ uint2 shared_mem[];
|
||||
|
||||
shared_mem[(index * blockDim.y + threadIdx.y) * blockDim.x + threadIdx.x] = data;
|
||||
}
|
||||
|
||||
#if __CUDA_ARCH__ >= 300
|
||||
__device__ __forceinline__ uint32_t WarpShuffle(uint32_t a, uint32_t b, uint32_t c)
|
||||
{
|
||||
return __shfl(a, b, c);
|
||||
}
|
||||
|
||||
__device__ __forceinline__ uint2 WarpShuffle(uint2 a, uint32_t b, uint32_t c)
|
||||
{
|
||||
return make_uint2(__shfl(a.x, b, c), __shfl(a.y, b, c));
|
||||
}
|
||||
|
||||
__device__ __forceinline__ void WarpShuffle3(uint2 &a1, uint2 &a2, uint2 &a3, uint32_t b1, uint32_t b2, uint32_t b3, uint32_t c)
|
||||
{
|
||||
a1 = WarpShuffle(a1, b1, c);
|
||||
a2 = WarpShuffle(a2, b2, c);
|
||||
a3 = WarpShuffle(a3, b3, c);
|
||||
}
|
||||
|
||||
#else
|
||||
__device__ __forceinline__ uint32_t WarpShuffle(uint32_t a, uint32_t b, uint32_t c)
|
||||
{
|
||||
extern __shared__ uint2 shared_mem[];
|
||||
|
||||
const uint32_t thread = blockDim.x * threadIdx.y + threadIdx.x;
|
||||
uint32_t *_ptr = (uint32_t*)shared_mem;
|
||||
|
||||
__threadfence_block();
|
||||
uint32_t buf = _ptr[thread];
|
||||
|
||||
_ptr[thread] = a;
|
||||
__threadfence_block();
|
||||
uint32_t result = _ptr[(thread&~(c - 1)) + (b&(c - 1))];
|
||||
|
||||
__threadfence_block();
|
||||
_ptr[thread] = buf;
|
||||
|
||||
__threadfence_block();
|
||||
return result;
|
||||
}
|
||||
|
||||
__device__ __forceinline__ uint2 WarpShuffle(uint2 a, uint32_t b, uint32_t c)
|
||||
{
|
||||
extern __shared__ uint2 shared_mem[];
|
||||
|
||||
const uint32_t thread = blockDim.x * threadIdx.y + threadIdx.x;
|
||||
|
||||
__threadfence_block();
|
||||
uint2 buf = shared_mem[thread];
|
||||
|
||||
shared_mem[thread] = a;
|
||||
__threadfence_block();
|
||||
uint2 result = shared_mem[(thread&~(c - 1)) + (b&(c - 1))];
|
||||
|
||||
__threadfence_block();
|
||||
shared_mem[thread] = buf;
|
||||
|
||||
__threadfence_block();
|
||||
return result;
|
||||
}
|
||||
|
||||
__device__ __forceinline__ void WarpShuffle3(uint2 &a1, uint2 &a2, uint2 &a3, uint32_t b1, uint32_t b2, uint32_t b3, uint32_t c)
|
||||
{
|
||||
extern __shared__ uint2 shared_mem[];
|
||||
|
||||
const uint32_t thread = blockDim.x * threadIdx.y + threadIdx.x;
|
||||
|
||||
__threadfence_block();
|
||||
uint2 buf = shared_mem[thread];
|
||||
|
||||
shared_mem[thread] = a1;
|
||||
__threadfence_block();
|
||||
a1 = shared_mem[(thread&~(c - 1)) + (b1&(c - 1))];
|
||||
__threadfence_block();
|
||||
shared_mem[thread] = a2;
|
||||
__threadfence_block();
|
||||
a2 = shared_mem[(thread&~(c - 1)) + (b2&(c - 1))];
|
||||
__threadfence_block();
|
||||
shared_mem[thread] = a3;
|
||||
__threadfence_block();
|
||||
a3 = shared_mem[(thread&~(c - 1)) + (b3&(c - 1))];
|
||||
|
||||
__threadfence_block();
|
||||
shared_mem[thread] = buf;
|
||||
__threadfence_block();
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
static __device__ __forceinline__
|
||||
void Gfunc(uint2 &a, uint2 &b, uint2 &c, uint2 &d)
|
||||
{
|
||||
a += b; d ^= a; d = SWAPUINT2(d);
|
||||
c += d; b ^= c; b = ROR2(b, 24);
|
||||
a += b; d ^= a; d = ROR2(d, 16);
|
||||
c += d; b ^= c; b = ROR2(b, 63);
|
||||
}
|
||||
|
||||
__device__ __forceinline__ void round_lyra(uint2 s[4])
|
||||
{
|
||||
Gfunc(s[0], s[1], s[2], s[3]);
|
||||
WarpShuffle3(s[1], s[2], s[3], threadIdx.x + 1, threadIdx.x + 2, threadIdx.x + 3, 4);
|
||||
Gfunc(s[0], s[1], s[2], s[3]);
|
||||
WarpShuffle3(s[1], s[2], s[3], threadIdx.x + 3, threadIdx.x + 2, threadIdx.x + 1, 4);
|
||||
}
|
||||
|
||||
static __device__ __forceinline__
|
||||
void round_lyra(uint2x4* s)
|
||||
{
|
||||
Gfunc(s[0].x, s[1].x, s[2].x, s[3].x);
|
||||
Gfunc(s[0].y, s[1].y, s[2].y, s[3].y);
|
||||
Gfunc(s[0].z, s[1].z, s[2].z, s[3].z);
|
||||
Gfunc(s[0].w, s[1].w, s[2].w, s[3].w);
|
||||
Gfunc(s[0].x, s[1].y, s[2].z, s[3].w);
|
||||
Gfunc(s[0].y, s[1].z, s[2].w, s[3].x);
|
||||
Gfunc(s[0].z, s[1].w, s[2].x, s[3].y);
|
||||
Gfunc(s[0].w, s[1].x, s[2].y, s[3].z);
|
||||
}
|
||||
|
||||
static __device__ __forceinline__
|
||||
void reduceDuplexV5(uint2 state[4], const uint32_t thread, const uint32_t threads)
|
||||
{
|
||||
uint2 state1[3], state2[3];
|
||||
|
||||
const uint32_t ps0 = (memshift * Ncol * 0 * threads + thread)*blockDim.x + threadIdx.x;
|
||||
const uint32_t ps1 = (memshift * Ncol * 1 * threads + thread)*blockDim.x + threadIdx.x;
|
||||
const uint32_t ps2 = (memshift * Ncol * 2 * threads + thread)*blockDim.x + threadIdx.x;
|
||||
const uint32_t ps3 = (memshift * Ncol * 3 * threads + thread)*blockDim.x + threadIdx.x;
|
||||
const uint32_t ps4 = (memshift * Ncol * 4 * threads + thread)*blockDim.x + threadIdx.x;
|
||||
const uint32_t ps5 = (memshift * Ncol * 5 * threads + thread)*blockDim.x + threadIdx.x;
|
||||
const uint32_t ps6 = (memshift * Ncol * 6 * threads + thread)*blockDim.x + threadIdx.x;
|
||||
const uint32_t ps7 = (memshift * Ncol * 7 * threads + thread)*blockDim.x + threadIdx.x;
|
||||
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
const uint32_t s0 = memshift * Ncol * 0 + (Ncol - 1 - i) * memshift;
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
ST4S(s0 + j, state[j]);
|
||||
round_lyra(state);
|
||||
}
|
||||
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
const uint32_t s0 = memshift * Ncol * 0 + i * memshift;
|
||||
const uint32_t s1 = ps1 + (7 - i)*memshift* threads*blockDim.x;
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state1[j] = LD4S(s0 + j);
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state[j] ^= state1[j];
|
||||
|
||||
round_lyra(state);
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
*(DMatrix + s1 + j*threads*blockDim.x) = state1[j] ^ state[j];
|
||||
}
|
||||
|
||||
// 1, 0, 2
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
const uint32_t s0 = memshift * Ncol * 0 + i * memshift;
|
||||
const uint32_t s1 = ps1 + i * memshift* threads*blockDim.x;
|
||||
const uint32_t s2 = ps2 + (7 - i)*memshift* threads*blockDim.x;
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state1[j] = *(DMatrix + s1 + j*threads*blockDim.x);
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state2[j] = LD4S(s0 + j);
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state[j] ^= state1[j] + state2[j];
|
||||
|
||||
round_lyra(state);
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
*(DMatrix + s2 + j*threads*blockDim.x) = state1[j] ^ state[j];
|
||||
|
||||
//一個手前のスレッドからデータを貰う(同時に一個先のスレッドにデータを送る)
|
||||
uint2 Data0 = state[0];
|
||||
uint2 Data1 = state[1];
|
||||
uint2 Data2 = state[2];
|
||||
WarpShuffle3(Data0, Data1, Data2, threadIdx.x - 1, threadIdx.x - 1, threadIdx.x - 1, 4);
|
||||
|
||||
if (threadIdx.x == 0)
|
||||
{
|
||||
state2[0] ^= Data2;
|
||||
state2[1] ^= Data0;
|
||||
state2[2] ^= Data1;
|
||||
}
|
||||
else
|
||||
{
|
||||
state2[0] ^= Data0;
|
||||
state2[1] ^= Data1;
|
||||
state2[2] ^= Data2;
|
||||
}
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
ST4S(s0 + j, state2[j]);
|
||||
}
|
||||
|
||||
// 2, 1, 3
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
const uint32_t s1 = ps1 + i * memshift* threads*blockDim.x;
|
||||
const uint32_t s2 = ps2 + i * memshift* threads*blockDim.x;
|
||||
const uint32_t s3 = ps3 + (7 - i)*memshift* threads*blockDim.x;
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state1[j] = *(DMatrix + s2 + j*threads*blockDim.x);
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state2[j] = *(DMatrix + s1 + j*threads*blockDim.x);
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state[j] ^= state1[j] + state2[j];
|
||||
|
||||
round_lyra(state);
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
*(DMatrix + s3 + j*threads*blockDim.x) = state1[j] ^ state[j];
|
||||
|
||||
//一個手前のスレッドからデータを貰う(同時に一個先のスレッドにデータを送る)
|
||||
uint2 Data0 = state[0];
|
||||
uint2 Data1 = state[1];
|
||||
uint2 Data2 = state[2];
|
||||
WarpShuffle3(Data0, Data1, Data2, threadIdx.x - 1, threadIdx.x - 1, threadIdx.x - 1, 4);
|
||||
|
||||
if (threadIdx.x == 0)
|
||||
{
|
||||
state2[0] ^= Data2;
|
||||
state2[1] ^= Data0;
|
||||
state2[2] ^= Data1;
|
||||
}
|
||||
else
|
||||
{
|
||||
state2[0] ^= Data0;
|
||||
state2[1] ^= Data1;
|
||||
state2[2] ^= Data2;
|
||||
}
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
*(DMatrix + s1 + j*threads*blockDim.x) = state2[j];
|
||||
}
|
||||
|
||||
// 3, 0, 4
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
const uint32_t ls0 = memshift * Ncol * 0 + i * memshift;
|
||||
const uint32_t s0 = ps0 + i * memshift* threads*blockDim.x;
|
||||
const uint32_t s3 = ps3 + i * memshift* threads*blockDim.x;
|
||||
const uint32_t s4 = ps4 + (7 - i)*memshift* threads*blockDim.x;
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state1[j] = *(DMatrix + s3 + j*threads*blockDim.x);
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state2[j] = LD4S(ls0 + j);
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state[j] ^= state1[j] + state2[j];
|
||||
|
||||
round_lyra(state);
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
*(DMatrix + s4 + j*threads*blockDim.x) = state1[j] ^ state[j];
|
||||
|
||||
//一個手前のスレッドからデータを貰う(同時に一個先のスレッドにデータを送る)
|
||||
uint2 Data0 = state[0];
|
||||
uint2 Data1 = state[1];
|
||||
uint2 Data2 = state[2];
|
||||
WarpShuffle3(Data0, Data1, Data2, threadIdx.x - 1, threadIdx.x - 1, threadIdx.x - 1, 4);
|
||||
|
||||
if (threadIdx.x == 0)
|
||||
{
|
||||
state2[0] ^= Data2;
|
||||
state2[1] ^= Data0;
|
||||
state2[2] ^= Data1;
|
||||
}
|
||||
else
|
||||
{
|
||||
state2[0] ^= Data0;
|
||||
state2[1] ^= Data1;
|
||||
state2[2] ^= Data2;
|
||||
}
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
*(DMatrix + s0 + j*threads*blockDim.x) = state2[j];
|
||||
}
|
||||
|
||||
// 4, 3, 5
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
const uint32_t s3 = ps3 + i * memshift* threads*blockDim.x;
|
||||
const uint32_t s4 = ps4 + i * memshift* threads*blockDim.x;
|
||||
const uint32_t s5 = ps5 + (7 - i)*memshift* threads*blockDim.x;
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state1[j] = *(DMatrix + s4 + j*threads*blockDim.x);
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state2[j] = *(DMatrix + s3 + j*threads*blockDim.x);
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state[j] ^= state1[j] + state2[j];
|
||||
|
||||
round_lyra(state);
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
*(DMatrix + s5 + j*threads*blockDim.x) = state1[j] ^ state[j];
|
||||
|
||||
//一個手前のスレッドからデータを貰う(同時に一個先のスレッドにデータを送る)
|
||||
uint2 Data0 = state[0];
|
||||
uint2 Data1 = state[1];
|
||||
uint2 Data2 = state[2];
|
||||
WarpShuffle3(Data0, Data1, Data2, threadIdx.x - 1, threadIdx.x - 1, threadIdx.x - 1, 4);
|
||||
|
||||
if (threadIdx.x == 0)
|
||||
{
|
||||
state2[0] ^= Data2;
|
||||
state2[1] ^= Data0;
|
||||
state2[2] ^= Data1;
|
||||
}
|
||||
else
|
||||
{
|
||||
state2[0] ^= Data0;
|
||||
state2[1] ^= Data1;
|
||||
state2[2] ^= Data2;
|
||||
}
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
*(DMatrix + s3 + j*threads*blockDim.x) = state2[j];
|
||||
}
|
||||
|
||||
// 5, 2, 6
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
const uint32_t s2 = ps2 + i * memshift* threads*blockDim.x;
|
||||
const uint32_t s5 = ps5 + i * memshift* threads*blockDim.x;
|
||||
const uint32_t s6 = ps6 + (7 - i)*memshift* threads*blockDim.x;
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state1[j] = *(DMatrix + s5 + j*threads*blockDim.x);
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state2[j] = *(DMatrix + s2 + j*threads*blockDim.x);
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state[j] ^= state1[j] + state2[j];
|
||||
|
||||
round_lyra(state);
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
*(DMatrix + s6 + j*threads*blockDim.x) = state1[j] ^ state[j];
|
||||
|
||||
//一個手前のスレッドからデータを貰う(同時に一個先のスレッドにデータを送る)
|
||||
uint2 Data0 = state[0];
|
||||
uint2 Data1 = state[1];
|
||||
uint2 Data2 = state[2];
|
||||
WarpShuffle3(Data0, Data1, Data2, threadIdx.x - 1, threadIdx.x - 1, threadIdx.x - 1, 4);
|
||||
|
||||
if (threadIdx.x == 0)
|
||||
{
|
||||
state2[0] ^= Data2;
|
||||
state2[1] ^= Data0;
|
||||
state2[2] ^= Data1;
|
||||
}
|
||||
else
|
||||
{
|
||||
state2[0] ^= Data0;
|
||||
state2[1] ^= Data1;
|
||||
state2[2] ^= Data2;
|
||||
}
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
*(DMatrix + s2 + j*threads*blockDim.x) = state2[j];
|
||||
}
|
||||
|
||||
// 6, 1, 7
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
const uint32_t s1 = ps1 + i * memshift* threads*blockDim.x;
|
||||
const uint32_t s6 = ps6 + i * memshift* threads*blockDim.x;
|
||||
const uint32_t s7 = ps7 + (7 - i)*memshift* threads*blockDim.x;
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state1[j] = *(DMatrix + s6 + j*threads*blockDim.x);
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state2[j] = *(DMatrix + s1 + j*threads*blockDim.x);
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state[j] ^= state1[j] + state2[j];
|
||||
|
||||
round_lyra(state);
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
*(DMatrix + s7 + j*threads*blockDim.x) = state1[j] ^ state[j];
|
||||
|
||||
//一個手前のスレッドからデータを貰う(同時に一個先のスレッドにデータを送る)
|
||||
uint2 Data0 = state[0];
|
||||
uint2 Data1 = state[1];
|
||||
uint2 Data2 = state[2];
|
||||
WarpShuffle3(Data0, Data1, Data2, threadIdx.x - 1, threadIdx.x - 1, threadIdx.x - 1, 4);
|
||||
|
||||
if (threadIdx.x == 0)
|
||||
{
|
||||
state2[0] ^= Data2;
|
||||
state2[1] ^= Data0;
|
||||
state2[2] ^= Data1;
|
||||
}
|
||||
else
|
||||
{
|
||||
state2[0] ^= Data0;
|
||||
state2[1] ^= Data1;
|
||||
state2[2] ^= Data2;
|
||||
}
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
*(DMatrix + s1 + j*threads*blockDim.x) = state2[j];
|
||||
}
|
||||
}
|
||||
|
||||
static __device__ __forceinline__
|
||||
void reduceDuplexRowV50(const int rowIn, const int rowInOut, const int rowOut, uint2 state[4], const uint32_t thread, const uint32_t threads)
|
||||
{
|
||||
const uint32_t ps1 = (memshift * Ncol * rowIn*threads + thread)*blockDim.x + threadIdx.x;
|
||||
const uint32_t ps2 = (memshift * Ncol * rowInOut *threads + thread)*blockDim.x + threadIdx.x;
|
||||
const uint32_t ps3 = (memshift * Ncol * rowOut*threads + thread)*blockDim.x + threadIdx.x;
|
||||
|
||||
#pragma unroll 1
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
uint2 state1[3], state2[3];
|
||||
|
||||
const uint32_t s1 = ps1 + i*memshift*threads *blockDim.x;
|
||||
const uint32_t s2 = ps2 + i*memshift*threads *blockDim.x;
|
||||
const uint32_t s3 = ps3 + i*memshift*threads *blockDim.x;
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++) {
|
||||
state1[j] = *(DMatrix + s1 + j*threads*blockDim.x);
|
||||
state2[j] = *(DMatrix + s2 + j*threads*blockDim.x);
|
||||
}
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++) {
|
||||
state1[j] += state2[j];
|
||||
state[j] ^= state1[j];
|
||||
}
|
||||
|
||||
round_lyra(state);
|
||||
|
||||
//一個手前のスレッドからデータを貰う(同時に一個先のスレッドにデータを送る)
|
||||
uint2 Data0 = state[0];
|
||||
uint2 Data1 = state[1];
|
||||
uint2 Data2 = state[2];
|
||||
WarpShuffle3(Data0, Data1, Data2, threadIdx.x - 1, threadIdx.x - 1, threadIdx.x - 1, 4);
|
||||
|
||||
if (threadIdx.x == 0)
|
||||
{
|
||||
state2[0] ^= Data2;
|
||||
state2[1] ^= Data0;
|
||||
state2[2] ^= Data1;
|
||||
}
|
||||
else
|
||||
{
|
||||
state2[0] ^= Data0;
|
||||
state2[1] ^= Data1;
|
||||
state2[2] ^= Data2;
|
||||
}
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
{
|
||||
*(DMatrix + s2 + j*threads*blockDim.x) = state2[j];
|
||||
*(DMatrix + s3 + j*threads*blockDim.x) ^= state[j];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static __device__ __forceinline__
|
||||
void reduceDuplexRowV50_8(const int rowInOut, uint2 state[4], const uint32_t thread, const uint32_t threads)
|
||||
{
|
||||
const uint32_t ps1 = (memshift * Ncol * 2*threads + thread)*blockDim.x + threadIdx.x;
|
||||
const uint32_t ps2 = (memshift * Ncol * rowInOut *threads + thread)*blockDim.x + threadIdx.x;
|
||||
const uint32_t ps3 = (memshift * Ncol * 5*threads + thread)*blockDim.x + threadIdx.x;
|
||||
|
||||
uint2 state1[3], last[3];
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++) {
|
||||
state1[j] = *(DMatrix + ps1 + j*threads*blockDim.x);
|
||||
last[j] = *(DMatrix + ps2 + j*threads*blockDim.x);
|
||||
}
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++) {
|
||||
state1[j] += last[j];
|
||||
state[j] ^= state1[j];
|
||||
}
|
||||
|
||||
round_lyra(state);
|
||||
|
||||
//一個手前のスレッドからデータを貰う(同時に一個先のスレッドにデータを送る)
|
||||
uint2 Data0 = state[0];
|
||||
uint2 Data1 = state[1];
|
||||
uint2 Data2 = state[2];
|
||||
WarpShuffle3(Data0, Data1, Data2, threadIdx.x - 1, threadIdx.x - 1, threadIdx.x - 1, 4);
|
||||
|
||||
if (threadIdx.x == 0)
|
||||
{
|
||||
last[0] ^= Data2;
|
||||
last[1] ^= Data0;
|
||||
last[2] ^= Data1;
|
||||
}
|
||||
else
|
||||
{
|
||||
last[0] ^= Data0;
|
||||
last[1] ^= Data1;
|
||||
last[2] ^= Data2;
|
||||
}
|
||||
|
||||
if (rowInOut == 5)
|
||||
{
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
last[j] ^= state[j];
|
||||
}
|
||||
|
||||
for (int i = 1; i < 8; i++)
|
||||
{
|
||||
const uint32_t s1 = ps1 + i*memshift*threads *blockDim.x;
|
||||
const uint32_t s2 = ps2 + i*memshift*threads *blockDim.x;
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state[j] ^= *(DMatrix + s1 + j*threads*blockDim.x) + *(DMatrix + s2 + j*threads*blockDim.x);
|
||||
|
||||
round_lyra(state);
|
||||
}
|
||||
|
||||
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 3; j++)
|
||||
state[j] ^= last[j];
|
||||
|
||||
}
|
||||
|
||||
__global__ __launch_bounds__(64, 1)
|
||||
void lyra2_gpu_hash_32_1_sm5(uint32_t threads, uint32_t startNounce, uint2 *g_hash)
|
||||
{
|
||||
const uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
|
||||
const uint2x4 blake2b_IV[2] = {
|
||||
{ { 0xf3bcc908, 0x6a09e667 }, { 0x84caa73b, 0xbb67ae85 }, { 0xfe94f82b, 0x3c6ef372 }, { 0x5f1d36f1, 0xa54ff53a } },
|
||||
{ { 0xade682d1, 0x510e527f }, { 0x2b3e6c1f, 0x9b05688c }, { 0xfb41bd6b, 0x1f83d9ab }, { 0x137e2179, 0x5be0cd19 } }
|
||||
};
|
||||
|
||||
if (thread < threads)
|
||||
{
|
||||
uint2x4 state[4];
|
||||
|
||||
((uint2*)state)[0] = __ldg(&g_hash[thread]);
|
||||
((uint2*)state)[1] = __ldg(&g_hash[thread + threads]);
|
||||
((uint2*)state)[2] = __ldg(&g_hash[thread + threads * 2]);
|
||||
((uint2*)state)[3] = __ldg(&g_hash[thread + threads * 3]);
|
||||
|
||||
state[1] = state[0];
|
||||
state[2] = blake2b_IV[0];
|
||||
state[3] = blake2b_IV[1];
|
||||
|
||||
for (int i = 0; i < 24; i++)
|
||||
round_lyra(state); //because 12 is not enough
|
||||
|
||||
((uint2x4*)DMatrix)[0 * threads + thread] = state[0];
|
||||
((uint2x4*)DMatrix)[1 * threads + thread] = state[1];
|
||||
((uint2x4*)DMatrix)[2 * threads + thread] = state[2];
|
||||
((uint2x4*)DMatrix)[3 * threads + thread] = state[3];
|
||||
}
|
||||
}
|
||||
|
||||
__global__ __launch_bounds__(TPB50, 1)
|
||||
void lyra2_gpu_hash_32_2_sm5(uint32_t threads, uint32_t startNounce, uint2 *g_hash)
|
||||
{
|
||||
const uint32_t thread = (blockDim.y * blockIdx.x + threadIdx.y);
|
||||
|
||||
if (thread < threads)
|
||||
{
|
||||
uint2 state[4];
|
||||
|
||||
state[0] = __ldg(&DMatrix[(0 * threads + thread)*blockDim.x + threadIdx.x]);
|
||||
state[1] = __ldg(&DMatrix[(1 * threads + thread)*blockDim.x + threadIdx.x]);
|
||||
state[2] = __ldg(&DMatrix[(2 * threads + thread)*blockDim.x + threadIdx.x]);
|
||||
state[3] = __ldg(&DMatrix[(3 * threads + thread)*blockDim.x + threadIdx.x]);
|
||||
|
||||
reduceDuplexV5(state, thread, threads);
|
||||
|
||||
uint32_t rowa = WarpShuffle(state[0].x, 0, 4) & 7;
|
||||
reduceDuplexRowV50(7, rowa, 0, state, thread, threads);
|
||||
rowa = WarpShuffle(state[0].x, 0, 4) & 7;
|
||||
reduceDuplexRowV50(0, rowa, 3, state, thread, threads);
|
||||
rowa = WarpShuffle(state[0].x, 0, 4) & 7;
|
||||
reduceDuplexRowV50(3, rowa, 6, state, thread, threads);
|
||||
rowa = WarpShuffle(state[0].x, 0, 4) & 7;
|
||||
reduceDuplexRowV50(6, rowa, 1, state, thread, threads);
|
||||
rowa = WarpShuffle(state[0].x, 0, 4) & 7;
|
||||
reduceDuplexRowV50(1, rowa, 4, state, thread, threads);
|
||||
rowa = WarpShuffle(state[0].x, 0, 4) & 7;
|
||||
reduceDuplexRowV50(4, rowa, 7, state, thread, threads);
|
||||
rowa = WarpShuffle(state[0].x, 0, 4) & 7;
|
||||
reduceDuplexRowV50(7, rowa, 2, state, thread, threads);
|
||||
rowa = WarpShuffle(state[0].x, 0, 4) & 7;
|
||||
reduceDuplexRowV50_8(rowa, state, thread, threads);
|
||||
|
||||
DMatrix[(0 * threads + thread)*blockDim.x + threadIdx.x] = state[0];
|
||||
DMatrix[(1 * threads + thread)*blockDim.x + threadIdx.x] = state[1];
|
||||
DMatrix[(2 * threads + thread)*blockDim.x + threadIdx.x] = state[2];
|
||||
DMatrix[(3 * threads + thread)*blockDim.x + threadIdx.x] = state[3];
|
||||
}
|
||||
}
|
||||
|
||||
__global__ __launch_bounds__(64, 1)
|
||||
void lyra2_gpu_hash_32_3_sm5(uint32_t threads, uint32_t startNounce, uint2 *g_hash)
|
||||
{
|
||||
const uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
|
||||
if (thread < threads)
|
||||
{
|
||||
uint2x4 state[4];
|
||||
|
||||
state[0] = __ldg4(&((uint2x4*)DMatrix)[0 * threads + thread]);
|
||||
state[1] = __ldg4(&((uint2x4*)DMatrix)[1 * threads + thread]);
|
||||
state[2] = __ldg4(&((uint2x4*)DMatrix)[2 * threads + thread]);
|
||||
state[3] = __ldg4(&((uint2x4*)DMatrix)[3 * threads + thread]);
|
||||
|
||||
for (int i = 0; i < 12; i++)
|
||||
round_lyra(state);
|
||||
|
||||
g_hash[thread] = ((uint2*)state)[0];
|
||||
g_hash[thread + threads] = ((uint2*)state)[1];
|
||||
g_hash[thread + threads * 2] = ((uint2*)state)[2];
|
||||
g_hash[thread + threads * 3] = ((uint2*)state)[3];
|
||||
}
|
||||
}
|
||||
|
||||
#else
|
||||
/* if __CUDA_ARCH__ != 500 .. host */
|
||||
__global__ void lyra2_gpu_hash_32_1_sm5(uint32_t threads, uint32_t startNounce, uint2 *g_hash) {}
|
||||
__global__ void lyra2_gpu_hash_32_2_sm5(uint32_t threads, uint32_t startNounce, uint2 *g_hash) {}
|
||||
__global__ void lyra2_gpu_hash_32_3_sm5(uint32_t threads, uint32_t startNounce, uint2 *g_hash) {}
|
||||
#endif
|
||||
@@ -12,6 +12,10 @@
|
||||
|
||||
#include "cuda_helper.h"
|
||||
|
||||
#if __CUDA_ARCH__ < 300
|
||||
#define __shfl(x, y) (x)
|
||||
#endif
|
||||
|
||||
#if __CUDA_ARCH__ < 320 && !defined(__ldg4)
|
||||
#define __ldg4(x) (*(x))
|
||||
#endif
|
||||
@@ -81,7 +85,8 @@ typedef struct __align__(256) ulonglong16 {
|
||||
|
||||
typedef struct __align__(16) uint28 {
|
||||
uint2 x, y, z, w;
|
||||
} uint28;
|
||||
} uint2x4;
|
||||
typedef uint2x4 uint28; /* name deprecated */
|
||||
|
||||
typedef struct __builtin_align__(32) uint48 {
|
||||
uint4 s0,s1;
|
||||
@@ -544,6 +549,7 @@ static __forceinline__ __device__ uint16 swapvec(const uint16 &buf)
|
||||
|
||||
static __device__ __forceinline__ uint28 shuffle4(const uint28 &var, int lane)
|
||||
{
|
||||
#if __CUDA_ARCH__ >= 300
|
||||
uint28 res;
|
||||
res.x.x = __shfl(var.x.x, lane);
|
||||
res.x.y = __shfl(var.x.y, lane);
|
||||
@@ -554,10 +560,14 @@ static __device__ __forceinline__ uint28 shuffle4(const uint28 &var, int lane)
|
||||
res.w.x = __shfl(var.w.x, lane);
|
||||
res.w.y = __shfl(var.w.y, lane);
|
||||
return res;
|
||||
#else
|
||||
return var;
|
||||
#endif
|
||||
}
|
||||
|
||||
static __device__ __forceinline__ ulonglong4 shuffle4(ulonglong4 var, int lane)
|
||||
{
|
||||
#if __CUDA_ARCH__ >= 300
|
||||
ulonglong4 res;
|
||||
uint2 temp;
|
||||
temp = vectorize(var.x);
|
||||
@@ -577,6 +587,9 @@ static __device__ __forceinline__ ulonglong4 shuffle4(ulonglong4 var, int lane)
|
||||
temp.y = __shfl(temp.y, lane);
|
||||
res.w = devectorize(temp);
|
||||
return res;
|
||||
#else
|
||||
return var;
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif // #ifndef CUDA_LYRA_VECTOR_H
|
||||
+493
-453
File diff suppressed because it is too large.
Load diff
+65
-33
@@ -10,18 +10,20 @@ extern "C" {
|
||||
#include "cuda_helper.h"
|
||||
|
||||
static uint64_t* d_hash[MAX_GPUS];
|
||||
//static uint64_t* d_hash2[MAX_GPUS];
|
||||
static uint64_t* d_matrix[MAX_GPUS];
|
||||
|
||||
extern void blake256_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void blake256_cpu_hash_80(const int thr_id, const uint32_t threads, const uint32_t startNonce, uint64_t *Hash, int order);
|
||||
extern void blake256_cpu_setBlock_80(uint32_t *pdata);
|
||||
|
||||
extern void keccak256_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNonce, uint64_t *d_outputHash, int order);
|
||||
extern void keccak256_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void keccak256_cpu_free(int thr_id);
|
||||
extern void skein256_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNonce, uint64_t *d_outputHash, int order);
|
||||
extern void skein256_cpu_init(int thr_id, uint32_t threads);
|
||||
|
||||
//extern void lyra2_cpu_init(int thr_id, uint32_t threads, uint64_t *hash);
|
||||
extern void lyra2_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNonce, uint64_t *d_outputHash, int order);
|
||||
extern void lyra2_cpu_init(int thr_id, uint32_t threads, uint64_t *d_matrix);
|
||||
extern void lyra2_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNonce, uint64_t *d_outputHash, bool gtx750ti);
|
||||
|
||||
extern void groestl256_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void groestl256_cpu_free(int thr_id);
|
||||
@@ -46,12 +48,14 @@ extern uint32_t groestl256_getSecNonce(int thr_id, int num);
|
||||
|
||||
extern "C" void lyra2re_hash(void *state, const void *input)
|
||||
{
|
||||
uint32_t hashA[8], hashB[8];
|
||||
|
||||
sph_blake256_context ctx_blake;
|
||||
sph_keccak256_context ctx_keccak;
|
||||
sph_skein256_context ctx_skein;
|
||||
sph_groestl256_context ctx_groestl;
|
||||
|
||||
uint32_t hashA[8], hashB[8];
|
||||
sph_blake256_set_rounds(14);
|
||||
|
||||
sph_blake256_init(&ctx_blake);
|
||||
sph_blake256(&ctx_blake, input, 80);
|
||||
@@ -81,32 +85,52 @@ extern "C" int scanhash_lyra2(int thr_id, struct work* work, uint32_t max_nonce,
|
||||
uint32_t *pdata = work->data;
|
||||
uint32_t *ptarget = work->target;
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
int intensity = (device_sm[device_map[thr_id]] >= 500 && !is_windows()) ? 18 : 17;
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1U << intensity); // 18=256*256*4;
|
||||
throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0x00ff;
|
||||
ptarget[7] = 0x00ff;
|
||||
|
||||
static bool gtx750ti;
|
||||
static uint32_t throughput[MAX_GPUS];
|
||||
if (!init[thr_id])
|
||||
{
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
int dev_id = device_map[thr_id];
|
||||
cudaSetDevice(dev_id);
|
||||
CUDA_LOG_ERROR();
|
||||
|
||||
blake256_cpu_init(thr_id, throughput);
|
||||
keccak256_cpu_init(thr_id,throughput);
|
||||
skein256_cpu_init(thr_id, throughput);
|
||||
groestl256_cpu_init(thr_id, throughput);
|
||||
int intensity = (device_sm[dev_id] >= 500 && !is_windows()) ? 17 : 16;
|
||||
if (device_sm[device_map[thr_id]] == 500) intensity = 15;
|
||||
int temp = intensity;
|
||||
throughput[thr_id] = cuda_default_throughput(thr_id, 1U << intensity); // 18=256*256*4;
|
||||
if (init[thr_id]) throughput[thr_id] = min(throughput[thr_id], max_nonce - first_nonce);
|
||||
|
||||
// DMatrix
|
||||
// cudaMalloc(&d_hash2[thr_id], (size_t)16 * 8 * 8 * sizeof(uint64_t) * throughput);
|
||||
// lyra2_cpu_init(thr_id, throughput, d_hash2[thr_id]);
|
||||
cudaDeviceProp props;
|
||||
cudaGetDeviceProperties(&props, dev_id);
|
||||
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hash[thr_id], (size_t)32 * throughput));
|
||||
if (strstr(props.name, "750 Ti")) gtx750ti = true;
|
||||
else gtx750ti = false;
|
||||
|
||||
//blake256_cpu_init(thr_id, throughput);
|
||||
keccak256_cpu_init(thr_id, throughput[thr_id]);
|
||||
skein256_cpu_init(thr_id, throughput[thr_id]);
|
||||
groestl256_cpu_init(thr_id, throughput[thr_id]);
|
||||
|
||||
if (device_sm[dev_id] >= 500)
|
||||
{
|
||||
size_t matrix_sz = device_sm[dev_id] > 500 ? sizeof(uint64_t) * 4 * 4 : sizeof(uint64_t) * 8 * 8 * 3 * 4;
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_matrix[thr_id], matrix_sz * throughput[thr_id]));
|
||||
lyra2_cpu_init(thr_id, throughput[thr_id], d_matrix[thr_id]);
|
||||
}
|
||||
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hash[thr_id], (size_t)32 * throughput[thr_id]));
|
||||
|
||||
init[thr_id] = true;
|
||||
if (temp != intensity){
|
||||
gpulog(LOG_INFO, thr_id, "Intensity set to %u, %u cuda threads",
|
||||
intensity, throughput[thr_id]);
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t endiandata[20];
|
||||
uint32_t _ALIGN(128) endiandata[20];
|
||||
for (int k=0; k < 20; k++)
|
||||
be32enc(&endiandata[k], pdata[k]);
|
||||
|
||||
@@ -117,15 +141,15 @@ extern "C" int scanhash_lyra2(int thr_id, struct work* work, uint32_t max_nonce,
|
||||
int order = 0;
|
||||
uint32_t foundNonce;
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce + throughput;
|
||||
|
||||
blake256_cpu_hash_80(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
|
||||
keccak256_cpu_hash_32(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
|
||||
lyra2_cpu_hash_32(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
|
||||
skein256_cpu_hash_32(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
|
||||
blake256_cpu_hash_80(thr_id, throughput[thr_id], pdata[19], d_hash[thr_id], order++);
|
||||
keccak256_cpu_hash_32(thr_id, throughput[thr_id], pdata[19], d_hash[thr_id], order++);
|
||||
lyra2_cpu_hash_32(thr_id, throughput[thr_id], pdata[19], d_hash[thr_id], gtx750ti);
|
||||
skein256_cpu_hash_32(thr_id, throughput[thr_id], pdata[19], d_hash[thr_id], order++);
|
||||
TRACE("S")
|
||||
|
||||
foundNonce = groestl256_cpu_hash_32(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
|
||||
*hashes_done = pdata[19] - first_nonce + throughput[thr_id];
|
||||
|
||||
foundNonce = groestl256_cpu_hash_32(thr_id, throughput[thr_id], pdata[19], d_hash[thr_id], order++);
|
||||
if (foundNonce != UINT32_MAX)
|
||||
{
|
||||
uint32_t _ALIGN(64) vhash64[8];
|
||||
@@ -136,16 +160,16 @@ extern "C" int scanhash_lyra2(int thr_id, struct work* work, uint32_t max_nonce,
|
||||
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
|
||||
int res = 1;
|
||||
uint32_t secNonce = groestl256_getSecNonce(thr_id, 1);
|
||||
bn_store_hash_target_ratio(vhash64, ptarget, work);
|
||||
work_set_target_ratio(work, vhash64);
|
||||
if (secNonce != UINT32_MAX)
|
||||
{
|
||||
be32enc(&endiandata[19], secNonce);
|
||||
lyra2re_hash(vhash64, endiandata);
|
||||
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
|
||||
if (opt_debug)
|
||||
applog(LOG_BLUE, "GPU #%d: found second nonce %08x", device_map[thr_id], secNonce);
|
||||
gpulog(LOG_BLUE, thr_id, "found second nonce %08x", secNonce);
|
||||
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio)
|
||||
bn_store_hash_target_ratio(vhash64, ptarget, work);
|
||||
work_set_target_ratio(work, vhash64);
|
||||
pdata[21] = secNonce;
|
||||
res++;
|
||||
}
|
||||
@@ -153,14 +177,19 @@ extern "C" int scanhash_lyra2(int thr_id, struct work* work, uint32_t max_nonce,
|
||||
pdata[19] = foundNonce;
|
||||
return res;
|
||||
} else {
|
||||
applog(LOG_WARNING, "GPU #%d: result for %08x does not validate on CPU!", device_map[thr_id], foundNonce);
|
||||
gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", foundNonce);
|
||||
}
|
||||
}
|
||||
|
||||
pdata[19] += throughput;
|
||||
if ((uint64_t)throughput[thr_id] + pdata[19] >= max_nonce) {
|
||||
pdata[19] = max_nonce;
|
||||
break;
|
||||
}
|
||||
pdata[19] += throughput[thr_id];
|
||||
|
||||
} while (pdata[19] < max_nonce && !work_restart[thr_id].restart);
|
||||
} while (!work_restart[thr_id].restart);
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -170,12 +199,15 @@ extern "C" void free_lyra2(int thr_id)
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
cudaFree(d_hash[thr_id]);
|
||||
cudaFree(d_matrix[thr_id]);
|
||||
|
||||
keccak256_cpu_free(thr_id);
|
||||
groestl256_cpu_free(thr_id);
|
||||
|
||||
init[thr_id] = false;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
}
|
||||
+197
-54
@@ -10,26 +10,32 @@ extern "C" {
|
||||
#include "miner.h"
|
||||
#include "cuda_helper.h"
|
||||
|
||||
#include <math.h>
|
||||
|
||||
static _ALIGN(64) uint64_t *d_hash[MAX_GPUS];
|
||||
static uint64_t *d_hash2[MAX_GPUS];
|
||||
static uint64_t *d_hash[MAX_GPUS];
|
||||
static uint64_t* d_matrix[MAX_GPUS];
|
||||
|
||||
extern void blake256_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void blake256_cpu_hash_80(const int thr_id, const uint32_t threads, const uint32_t startNonce, uint64_t *Hash, int order);
|
||||
extern void blake256_cpu_setBlock_80(uint32_t *pdata);
|
||||
extern void keccak256_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNonce, uint64_t *d_outputHash, int order);
|
||||
extern void keccak256_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void keccak256_cpu_free(int thr_id);
|
||||
extern void blakeKeccak256_cpu_hash_80(const int thr_id, const uint32_t threads, const uint32_t startNonce, uint64_t *Hash, int order);
|
||||
extern void blakeKeccakcube256_cpu_hash_80(const int thr_id, const uint32_t threads, const uint32_t startNonce, uint64_t *Hash, int order);
|
||||
|
||||
extern void skein256_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNonce, uint64_t *d_outputHash, int order);
|
||||
extern void skein256_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void cubehash256_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNounce, uint64_t *d_hash, int order);
|
||||
|
||||
extern void lyra2v2_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNonce, uint64_t *d_outputHash, int order);
|
||||
extern void lyra2v2_cpu_init(int thr_id, uint32_t threads, uint64_t* matrix);
|
||||
extern void lyra2v2_cpu_init(int thr_id, uint32_t threads, uint64_t* d_matrix);
|
||||
|
||||
extern void bmw256_setTarget(const void *ptarget);
|
||||
//extern void bmw256_setTarget(const void *ptarget);
|
||||
extern void bmw256_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void bmw256_cpu_free(int thr_id);
|
||||
extern void bmw256_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNounce, uint64_t *g_hash, uint32_t *resultnonces);
|
||||
extern void bmw256_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNounce, uint64_t *g_hash, uint32_t *resultnonces, uint32_t Target);
|
||||
extern void bmw256_cpu_hash_32(int thr_id, uint32_t threads, uint32_t startNounce, uint64_t *g_hash, uint32_t *resultnonces, uint32_t Target, uint32_t **result);
|
||||
|
||||
void lyra2v2_hash(void *state, const void *input)
|
||||
{
|
||||
@@ -41,6 +47,8 @@ void lyra2v2_hash(void *state, const void *input)
|
||||
sph_bmw256_context ctx_bmw;
|
||||
sph_cubehash256_context ctx_cube;
|
||||
|
||||
sph_blake256_set_rounds(14);
|
||||
|
||||
sph_blake256_init(&ctx_blake);
|
||||
sph_blake256(&ctx_blake, input, 80);
|
||||
sph_blake256_close(&ctx_blake, hashA);
|
||||
@@ -70,104 +78,237 @@ void lyra2v2_hash(void *state, const void *input)
|
||||
memcpy(state, hashA, 32);
|
||||
}
|
||||
|
||||
#ifdef _DEBUG
|
||||
#define TRACE(algo) { \
|
||||
if (max_nonce == 1 && pdata[19] <= 1) { \
|
||||
uint32_t* debugbuf = NULL; \
|
||||
cudaMallocHost(&debugbuf, 32); \
|
||||
cudaMemcpy(debugbuf, d_hash[thr_id], 32, cudaMemcpyDeviceToHost); \
|
||||
printf("lyra2 %s %08x %08x %08x %08x...%08x... ¥n", algo, swab32(debugbuf[0]), swab32(debugbuf[1]), \
|
||||
swab32(debugbuf[2]), swab32(debugbuf[3]), swab32(debugbuf[7])); \
|
||||
cudaFreeHost(debugbuf); \
|
||||
} \
|
||||
}
|
||||
#else
|
||||
#define TRACE(algo) {}
|
||||
#endif
|
||||
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
static uint32_t throughput[MAX_GPUS] = { 0 };
|
||||
|
||||
extern "C" int scanhash_lyra2v2(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
|
||||
{
|
||||
uint32_t *pdata = work->data;
|
||||
uint32_t *ptarget = work->target;
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
int intensity = (device_sm[device_map[thr_id]] > 500 && !is_windows()) ? 18 : 17;
|
||||
unsigned int defthr = 1U << intensity;
|
||||
uint32_t throughput = device_intensity(device_map[thr_id], __func__, defthr);
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0x00ff;
|
||||
ptarget[7] = 0x000f;
|
||||
|
||||
if (!init[thr_id])
|
||||
{
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
//cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);
|
||||
//if (opt_n_gputhreads == 1)
|
||||
// cudaDeviceSetCacheConfig(cudaFuncCachePreferL1);
|
||||
blake256_cpu_init(thr_id, throughput);
|
||||
keccak256_cpu_init(thr_id,throughput);
|
||||
skein256_cpu_init(thr_id, throughput);
|
||||
bmw256_cpu_init(thr_id, throughput);
|
||||
int dev_id = device_map[thr_id];
|
||||
cudaDeviceProp props;
|
||||
cudaGetDeviceProperties(&props, dev_id);
|
||||
|
||||
if (device_sm[device_map[thr_id]] < 300) {
|
||||
applog(LOG_ERR, "Device SM 3.0 or more recent required!");
|
||||
proper_exit(1);
|
||||
return -1;
|
||||
int intensity = 0;
|
||||
// Pascal
|
||||
if (strstr(props.name, "1080")) intensity = 22;
|
||||
else if (strstr(props.name, "1070")) intensity = 21;
|
||||
// Maxwell
|
||||
else if (strstr(props.name, "TITAN X")) intensity = 21;
|
||||
else if (strstr(props.name, "980")) intensity = 21;
|
||||
else if (strstr(props.name, "970")) intensity = 20;
|
||||
else if (strstr(props.name, "960")) intensity = 20;
|
||||
else if (strstr(props.name, "950")) intensity = 19;
|
||||
else if (strstr(props.name, "750 Ti")) intensity = 19;
|
||||
else if (strstr(props.name, "750")) intensity = 18;
|
||||
// Kepler〜Fermi
|
||||
else if (strstr(props.name, "TITAN Z")) intensity = 20;
|
||||
else if (strstr(props.name, "TITAN")) intensity = 19;
|
||||
else if (strstr(props.name, "780")) intensity = 19;
|
||||
else if (strstr(props.name, "760")) intensity = 18;
|
||||
else if (strstr(props.name, "730")) intensity = 16;
|
||||
else if (strstr(props.name, "720")) intensity = 15;
|
||||
else if (strstr(props.name, "710")) intensity = 16;
|
||||
else if (strstr(props.name, "690")) intensity = 20;
|
||||
else if (strstr(props.name, "680")) intensity = 19;
|
||||
else if (strstr(props.name, "660")) intensity = 18;
|
||||
else if (strstr(props.name, "650 Ti")) intensity = 18;
|
||||
else if (strstr(props.name, "640")) intensity = 17;
|
||||
else if (strstr(props.name, "630")) intensity = 16;
|
||||
else if (strstr(props.name, "620")) intensity = 15;
|
||||
|
||||
else if (strstr(props.name, "90")) intensity = 18; //590
|
||||
else if (strstr(props.name, "80")) intensity = 18; //480 580
|
||||
else if (strstr(props.name, "70")) intensity = 18; //470 570 670 770
|
||||
else if (strstr(props.name, "65")) intensity = 17; //465
|
||||
else if (strstr(props.name, "60")) intensity = 17; //460 560
|
||||
else if (strstr(props.name, "55")) intensity = 17; //555
|
||||
else if (strstr(props.name, "50")) intensity = 17; //450 550Ti 650
|
||||
else if (strstr(props.name, "45")) intensity = 16; //545
|
||||
else if (strstr(props.name, "40")) intensity = 15; //440
|
||||
else if (strstr(props.name, "30")) intensity = 15; //430 530
|
||||
else if (strstr(props.name, "20")) intensity = 14; //420 520
|
||||
else if (strstr(props.name, "10")) intensity = 14; //510 610
|
||||
|
||||
if (intensity != 0 && opt_eco_mode) intensity -= 3.0;
|
||||
|
||||
if (intensity == 0)
|
||||
{
|
||||
intensity = (device_sm[dev_id] > 500 && !is_windows()) ? 20 : 18;
|
||||
throughput[thr_id] = cuda_default_throughput(dev_id, 1UL << (int)intensity);
|
||||
}
|
||||
else
|
||||
{
|
||||
//uint32_t adds = 0;
|
||||
// double d = floor(intensity);
|
||||
|
||||
// DMatrix
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hash2[thr_id], 16 * 4 * 4 * sizeof(uint64_t) * throughput));
|
||||
lyra2v2_cpu_init(thr_id, throughput, d_hash2[thr_id]);
|
||||
/* if ((intensity - d) > 0.0) {
|
||||
adds = (uint32_t)floor((intensity - d) * (1 << (int)(d - 10.0)) * 1024;
|
||||
throughput = (1 << (int)d) + adds;
|
||||
gpulog(LOG_INFO, thr_id, "Adding %u threads to intensity %u, %u cuda threads",
|
||||
adds, (int)d, throughput);
|
||||
}
|
||||
else if (gpus_intensity[n] != (1 << (int)intensity)) {
|
||||
throughput = (1 << (int)intensity);
|
||||
applog(LOG_INFO, "Intensity set to %u, %u cuda threads",
|
||||
v, gpus_intensity[n]);
|
||||
}
|
||||
*/
|
||||
uint32_t temp = 1UL << intensity;
|
||||
throughput[thr_id] = cuda_default_throughput(dev_id, temp);
|
||||
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hash[thr_id], (size_t)throughput * 32));
|
||||
if (temp == throughput[thr_id])
|
||||
{
|
||||
gpulog(LOG_INFO, thr_id, "Intensity set to %u, %u cuda threads",
|
||||
intensity, throughput[thr_id]);
|
||||
}
|
||||
}
|
||||
cudaSetDevice(dev_id);
|
||||
if (opt_cudaschedule == -1 && gpu_threads == 1) {
|
||||
cudaDeviceReset();
|
||||
// reduce cpu usage
|
||||
cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);
|
||||
CUDA_LOG_ERROR();
|
||||
}
|
||||
cudaDeviceSetCacheConfig(cudaFuncCachePreferL1);
|
||||
|
||||
//blake256_cpu_init(thr_id, throughput);
|
||||
//keccak256_cpu_init(thr_id,throughput);
|
||||
skein256_cpu_init(thr_id, throughput[thr_id]);
|
||||
bmw256_cpu_init(thr_id, throughput[thr_id]);
|
||||
|
||||
// SM 3 implentation requires a bit more memory
|
||||
//if (device_sm[dev_id] < 300 || cuda_arch[dev_id] < 300)
|
||||
// matrix_sz = 16 * sizeof(uint64_t) * 4 * 4;
|
||||
//else
|
||||
size_t matrix_sz = sizeof(uint64_t) * 4 * 4;
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_matrix[thr_id], matrix_sz * throughput[thr_id]));
|
||||
lyra2v2_cpu_init(thr_id, throughput[thr_id], d_matrix[thr_id]);
|
||||
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hash[thr_id], (size_t)32 * throughput[thr_id]));
|
||||
|
||||
api_set_throughput(thr_id, throughput[thr_id]);
|
||||
init[thr_id] = true;
|
||||
}
|
||||
else throughput[thr_id] = min(throughput[thr_id], max_nonce - first_nonce);
|
||||
|
||||
uint32_t endiandata[20];
|
||||
for (int k=0; k < 20; k++)
|
||||
be32enc(&endiandata[k], ((uint32_t*)pdata)[k]);
|
||||
for (int k = 0; k < 20; k++)
|
||||
be32enc(&endiandata[k], pdata[k]);
|
||||
|
||||
blake256_cpu_setBlock_80(pdata);
|
||||
bmw256_setTarget(ptarget);
|
||||
//bmw256_setTarget(ptarget);
|
||||
|
||||
//uint32_t *vhash64[2];
|
||||
do {
|
||||
int order = 0;
|
||||
uint32_t foundNonces[2] = { 0, 0 };
|
||||
|
||||
blake256_cpu_hash_80(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
|
||||
keccak256_cpu_hash_32(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
|
||||
cubehash256_cpu_hash_32(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
|
||||
lyra2v2_cpu_hash_32(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
|
||||
skein256_cpu_hash_32(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
|
||||
cubehash256_cpu_hash_32(thr_id, throughput,pdata[19], d_hash[thr_id], order++);
|
||||
blakeKeccak256_cpu_hash_80(thr_id, throughput[thr_id], pdata[19], d_hash[thr_id], order++);
|
||||
//blakeKeccakcube256_cpu_hash_80(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
|
||||
TRACE("blake :");
|
||||
//keccak256_cpu_hash_32(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
|
||||
TRACE("keccak :");
|
||||
cubehash256_cpu_hash_32(thr_id, throughput[thr_id], pdata[19], d_hash[thr_id], order++);
|
||||
TRACE("cube :");
|
||||
lyra2v2_cpu_hash_32(thr_id, throughput[thr_id], pdata[19], d_hash[thr_id], order++);
|
||||
TRACE("lyra2 :");
|
||||
skein256_cpu_hash_32(thr_id, throughput[thr_id], pdata[19], d_hash[thr_id], order++);
|
||||
TRACE("skein :");
|
||||
cubehash256_cpu_hash_32(thr_id, throughput[thr_id], pdata[19], d_hash[thr_id], order++);
|
||||
TRACE("cube :");
|
||||
|
||||
bmw256_cpu_hash_32(thr_id, throughput, pdata[19], d_hash[thr_id], foundNonces);
|
||||
bmw256_cpu_hash_32(thr_id, throughput[thr_id], pdata[19], d_hash[thr_id], foundNonces, ptarget[7]);
|
||||
//bmw256_cpu_hash_32(thr_id, throughput, pdata[19], d_hash[thr_id], foundNonces, ptarget[7], vhash64);
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce + throughput[thr_id];
|
||||
|
||||
|
||||
/*if (foundNonces[1] != 0)
|
||||
{
|
||||
if (fulltest(vhash64[0], ptarget))
|
||||
{
|
||||
gpulog(LOG_WARNING, thr_id, "result two foundNonces!");
|
||||
pdata[19] = foundNonces[1];
|
||||
pdata[21] = foundNonces[0];
|
||||
work_set_target_ratio(work, vhash64[0]);
|
||||
if (bn_hash_target_ratio(vhash64[1], ptarget) > work->shareratio) {
|
||||
work_set_target_ratio(work, vhash64[1]);
|
||||
}
|
||||
return 2;
|
||||
}
|
||||
}
|
||||
if (foundNonces[0] != 0)
|
||||
{
|
||||
if (fulltest(vhash64[0], ptarget))
|
||||
{
|
||||
gpulog(LOG_WARNING, thr_id, "result one foundNonce!");
|
||||
pdata[19] = foundNonces[0];
|
||||
work_set_target_ratio(work, vhash64[0]);
|
||||
return 1;
|
||||
}
|
||||
}*/
|
||||
|
||||
if (foundNonces[0] != 0)
|
||||
{
|
||||
const uint32_t Htarg = ptarget[7];
|
||||
uint32_t vhash64[8];
|
||||
be32enc(&endiandata[19], foundNonces[0]);
|
||||
lyra2v2_hash(vhash64, endiandata);
|
||||
if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget))
|
||||
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget))
|
||||
{
|
||||
int res = 1;
|
||||
bn_store_hash_target_ratio(vhash64, ptarget, work);
|
||||
work_set_target_ratio(work, vhash64);
|
||||
pdata[19] = foundNonces[0];
|
||||
// check if there was another one...
|
||||
*hashes_done = pdata[19] - first_nonce + throughput;
|
||||
if (foundNonces[1] != 0)
|
||||
{
|
||||
be32enc(&endiandata[19], foundNonces[1]);
|
||||
lyra2v2_hash(vhash64, endiandata);
|
||||
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio)
|
||||
bn_store_hash_target_ratio(vhash64, ptarget, work);
|
||||
pdata[21] = foundNonces[1];
|
||||
xchg(pdata[19], pdata[21]);
|
||||
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio) {
|
||||
work_set_target_ratio(work, vhash64);
|
||||
}
|
||||
res++;
|
||||
}
|
||||
pdata[19] = foundNonces[0];
|
||||
MyStreamSynchronize(NULL, 0, device_map[thr_id]);
|
||||
return res;
|
||||
}
|
||||
else
|
||||
else if (vhash64[7] > ptarget[7])
|
||||
{
|
||||
if (vhash64[7] > Htarg) // don't show message if it is equal but fails fulltest
|
||||
applog(LOG_WARNING, "GPU #%d: result does not validate on CPU!", thr_id);
|
||||
gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", foundNonces[0]);
|
||||
}
|
||||
}
|
||||
|
||||
pdata[19] += throughput;
|
||||
if ((uint64_t)throughput[thr_id] + pdata[19] >= max_nonce) {
|
||||
pdata[19] = max_nonce;
|
||||
break;
|
||||
}
|
||||
pdata[19] += throughput[thr_id];
|
||||
|
||||
} while (!work_restart[thr_id].restart && (max_nonce > ((uint64_t)(pdata[19]) + throughput)));
|
||||
} while (!work_restart[thr_id].restart && !abort_flag);
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce + 1;
|
||||
MyStreamSynchronize(NULL, 0, device_map[thr_id]);
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -177,13 +318,15 @@ extern "C" void free_lyra2v2(int thr_id)
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
cudaFree(d_hash[thr_id]);
|
||||
cudaFree(d_hash2[thr_id]);
|
||||
cudaFree(d_matrix[thr_id]);
|
||||
|
||||
bmw256_cpu_free(thr_id);
|
||||
//keccak256_cpu_free(thr_id);
|
||||
|
||||
init[thr_id] = false;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
}
|
||||
@@ -39,9 +39,6 @@ extern "C" {
|
||||
# include <malloc.h>
|
||||
# define alloca _alloca
|
||||
# elif !defined HAVE_ALLOCA
|
||||
# ifdef __cplusplus
|
||||
extern "C"
|
||||
# endif
|
||||
void *alloca (size_t);
|
||||
# endif
|
||||
#endif
|
||||
@@ -265,8 +262,10 @@ void sha256d(unsigned char *hash, const unsigned char *data, int len);
|
||||
struct work;
|
||||
|
||||
extern int scanhash_blake256(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done, int8_t blakerounds);
|
||||
extern int scanhash_blake2s(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
extern int scanhash_bmw(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
extern int scanhash_c11(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
extern int scanhash_decred(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
extern int scanhash_deep(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
extern int scanhash_keccak256(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
extern int scanhash_fresh(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
@@ -283,11 +282,12 @@ extern int scanhash_nist5(int thr_id, struct work *work, uint32_t max_nonce, uns
|
||||
extern int scanhash_pentablake(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
extern int scanhash_quark(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
extern int scanhash_qubit(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
extern int scanhash_sib(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
extern int scanhash_skeincoin(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
extern int scanhash_skein2(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
extern int scanhash_spreadx11(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
extern int scanhash_s3(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
extern int scanhash_whirlx(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
extern int scanhash_vanilla(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done, int8_t blake_rounds);
|
||||
extern int scanhash_whirl(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
extern int scanhash_x11(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
extern int scanhash_x13(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
extern int scanhash_x14(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
@@ -295,8 +295,6 @@ extern int scanhash_x15(int thr_id, struct work* work, uint32_t max_nonce, unsig
|
||||
extern int scanhash_x17(int thr_id, struct work* work, 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_spreadx11(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
|
||||
extern int scanhash_sha256d(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
extern int scanhash_scrypt(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done,
|
||||
unsigned char *scratchbuf, struct timeval *tv_start, struct timeval *tv_end);
|
||||
@@ -304,11 +302,13 @@ extern int scanhash_scrypt_jane(int thr_id, struct work *work, uint32_t max_nonc
|
||||
unsigned char *scratchbuf, struct timeval *tv_start, struct timeval *tv_end);
|
||||
|
||||
/* free device allocated memory per algo */
|
||||
void miner_free_device(int thr_id);
|
||||
void algo_free_all(int thr_id);
|
||||
|
||||
extern void free_blake256(int thr_id);
|
||||
extern void free_blake2s(int thr_id);
|
||||
extern void free_bmw(int thr_id);
|
||||
extern void free_c11(int thr_id);
|
||||
extern void free_decred(int thr_id);
|
||||
extern void free_deep(int thr_id);
|
||||
extern void free_keccak256(int thr_id);
|
||||
extern void free_fresh(int thr_id);
|
||||
@@ -325,11 +325,12 @@ extern void free_nist5(int thr_id);
|
||||
extern void free_pentablake(int thr_id);
|
||||
extern void free_quark(int thr_id);
|
||||
extern void free_qubit(int thr_id);
|
||||
extern void free_sib(int thr_id);
|
||||
extern void free_skeincoin(int thr_id);
|
||||
extern void free_skein2(int thr_id);
|
||||
extern void free_spreadx11(int thr_id);
|
||||
extern void free_s3(int thr_id);
|
||||
extern void free_whirlx(int thr_id);
|
||||
extern void free_vanilla(int thr_id);
|
||||
extern void free_whirl(int thr_id);
|
||||
extern void free_x11(int thr_id);
|
||||
extern void free_x13(int thr_id);
|
||||
extern void free_x14(int thr_id);
|
||||
@@ -444,6 +445,7 @@ struct option {
|
||||
#endif
|
||||
extern int options_count();
|
||||
|
||||
extern bool opt_eco_mode;
|
||||
extern bool opt_benchmark;
|
||||
extern bool opt_debug;
|
||||
extern bool opt_quiet;
|
||||
@@ -452,11 +454,13 @@ extern bool opt_showdiff;
|
||||
extern bool opt_tracegpu;
|
||||
extern int opt_n_threads;
|
||||
extern int active_gpus;
|
||||
extern int gpu_threads;
|
||||
extern int opt_timeout;
|
||||
extern bool want_longpoll;
|
||||
extern bool have_longpoll;
|
||||
extern bool want_stratum;
|
||||
extern bool have_stratum;
|
||||
extern bool opt_stratum_stats;
|
||||
extern char *opt_cert;
|
||||
extern char *opt_proxy;
|
||||
extern long opt_proxy_type;
|
||||
@@ -485,6 +489,24 @@ extern long device_sm[MAX_GPUS];
|
||||
extern uint32_t gpus_intensity[MAX_GPUS];
|
||||
extern int opt_cudaschedule;
|
||||
|
||||
// cuda.cpp
|
||||
int cuda_num_devices();
|
||||
void cuda_devicenames();
|
||||
void cuda_reset_device(int thr_id, bool *init);
|
||||
void cuda_shutdown();
|
||||
int cuda_finddevice(char *name);
|
||||
int cuda_version();
|
||||
void cuda_print_devices();
|
||||
int cuda_gpu_clocks(struct cgpu_info *gpu);
|
||||
int cuda_available_memory(int thr_id);
|
||||
|
||||
uint32_t cuda_default_throughput(int thr_id, uint32_t defcount);
|
||||
#define device_intensity(t,f,d) cuda_default_throughput(t,d)
|
||||
|
||||
void cuda_log_lasterror(int thr_id, const char* func, int line);
|
||||
void cuda_clear_lasterror();
|
||||
#define CUDA_LOG_ERROR() cuda_log_lasterror(thr_id, __func__, __LINE__)
|
||||
|
||||
#define CL_N "\x1B[0m"
|
||||
#define CL_RED "\x1B[31m"
|
||||
#define CL_GRN "\x1B[32m"
|
||||
@@ -518,23 +540,33 @@ extern int opt_cudaschedule;
|
||||
|
||||
extern void format_hashrate(double hashrate, char *output);
|
||||
extern void applog(int prio, const char *fmt, ...);
|
||||
extern void gpulog(int prio, int thr_id, const char *fmt, ...);
|
||||
void get_defconfig_path(char *out, size_t bufsize, char *argv0);
|
||||
extern void cbin2hex(char *out, const char *in, size_t len);
|
||||
extern char *bin2hex(const unsigned char *in, size_t len);
|
||||
extern bool hex2bin(unsigned char *p, const char *hexstr, size_t len);
|
||||
extern bool hex2bin(void *output, const char *hexstr, size_t len);
|
||||
extern int timeval_subtract(struct timeval *result, struct timeval *x,
|
||||
struct timeval *y);
|
||||
extern bool fulltest(const uint32_t *hash, const uint32_t *target);
|
||||
void diff_to_target(struct work* work, double diff);
|
||||
void diff_to_target(uint32_t* target, double diff);
|
||||
void work_set_target(struct work* work, double diff);
|
||||
double target_to_diff(uint32_t* target);
|
||||
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);
|
||||
double bn_hash_target_ratio(uint32_t* hash, uint32_t* target);
|
||||
void bn_store_hash_target_ratio(uint32_t* hash, uint32_t* target, struct work* work);
|
||||
void work_set_target_ratio(struct work* work, uint32_t* hash);
|
||||
|
||||
// bench
|
||||
extern int bench_algo;
|
||||
void bench_init(int threads);
|
||||
void bench_free();
|
||||
bool bench_algo_switch_next(int thr_id);
|
||||
void bench_set_throughput(int thr_id, uint32_t throughput);
|
||||
void bench_display_results();
|
||||
|
||||
struct stratum_job {
|
||||
char *job_id;
|
||||
@@ -588,7 +620,7 @@ struct tx {
|
||||
};
|
||||
|
||||
struct work {
|
||||
uint32_t data[32];
|
||||
uint32_t data[48];
|
||||
uint32_t target[8];
|
||||
uint32_t maxvote;
|
||||
|
||||
@@ -601,6 +633,8 @@ struct work {
|
||||
uint64_t u64[1];
|
||||
} noncerange;
|
||||
|
||||
uint32_t nonces[2];
|
||||
|
||||
double targetdiff;
|
||||
double shareratio;
|
||||
double sharediff;
|
||||
@@ -610,12 +644,12 @@ struct work {
|
||||
uint32_t scanned_from;
|
||||
uint32_t scanned_to;
|
||||
|
||||
/* custom stuff */
|
||||
void * extradata;
|
||||
|
||||
/* pok getwork txs */
|
||||
uint32_t tx_count;
|
||||
struct tx txs[POK_MAX_TXS];
|
||||
|
||||
char *txs2;
|
||||
char *workid;
|
||||
};
|
||||
|
||||
#define POK_BOOL_MASK 0x00008000
|
||||
@@ -635,15 +669,17 @@ struct pool_infos {
|
||||
#define POOL_ST_DISABLED 4
|
||||
#define POOL_ST_REMOVED 8
|
||||
uint16_t status;
|
||||
int algo;
|
||||
char name[64];
|
||||
// credentials
|
||||
char url[256];
|
||||
char url[512];
|
||||
char short_url[64];
|
||||
char user[64];
|
||||
char pass[128];
|
||||
char pass[384];
|
||||
// config options
|
||||
double max_diff;
|
||||
double max_rate;
|
||||
int shares_limit;
|
||||
int time_limit;
|
||||
int scantime;
|
||||
// connection
|
||||
@@ -659,6 +695,10 @@ struct pool_infos {
|
||||
uint32_t wait_time;
|
||||
uint32_t accepted_count;
|
||||
uint32_t rejected_count;
|
||||
uint32_t solved_count;
|
||||
uint32_t stales_count;
|
||||
time_t last_share_time;
|
||||
double best_share;
|
||||
uint32_t disconnects;
|
||||
};
|
||||
|
||||
@@ -670,8 +710,8 @@ void pool_init_defaults(void);
|
||||
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);
|
||||
bool pool_switch(int thr_id, int pooln);
|
||||
bool pool_switch_next(int thr_id);
|
||||
int pool_get_first_valid(int startfrom);
|
||||
bool parse_pool_array(json_t *obj);
|
||||
void pool_dump_infos(void);
|
||||
@@ -736,13 +776,17 @@ void restart_threads(void);
|
||||
size_t time2str(char* buf, time_t timer);
|
||||
char* atime2str(time_t timer);
|
||||
|
||||
void applog_hash(unsigned char *hash);
|
||||
void applog_compare_hash(unsigned char *hash, unsigned char *hash2);
|
||||
void applog_hex(void *data, int len);
|
||||
void applog_hash(void *hash);
|
||||
void applog_hash64(void *hash);
|
||||
void applog_compare_hash(void *hash, void *hash_ref);
|
||||
|
||||
void print_hash_tests(void);
|
||||
void blake256hash(void *output, const void *input, int8_t rounds);
|
||||
void blake2s_hash(void *output, const void *input);
|
||||
void bmw_hash(void *state, const void *input);
|
||||
void c11hash(void *output, const void *input);
|
||||
void decred_hash(void *state, const void *input);
|
||||
void deephash(void *state, const void *input);
|
||||
void luffa_hash(void *state, const void *input);
|
||||
void fresh_hash(void *state, const void *input);
|
||||
@@ -761,10 +805,11 @@ void quarkhash(void *state, const void *input);
|
||||
void qubithash(void *state, const void *input);
|
||||
void scrypthash(void* output, const void* input);
|
||||
void scryptjane_hash(void* output, const void* input);
|
||||
void sibhash(void *output, const void *input);
|
||||
void skeincoinhash(void *output, const void *input);
|
||||
void skein2hash(void *output, const void *input);
|
||||
void spreadhash(void *output, const void *input);
|
||||
void s3hash(void *output, const void *input);
|
||||
void wcoinhash(void *state, const void *input);
|
||||
void whirlxHash(void *state, const void *input);
|
||||
void x11hash(void *output, const void *input);
|
||||
void x13hash(void *output, const void *input);
|
||||
|
||||
+19
-13
@@ -37,18 +37,24 @@ int scanhash_myriad(int thr_id, struct work *work, uint32_t max_nonce, unsigned
|
||||
uint32_t *pdata = work->data;
|
||||
uint32_t *ptarget = work->target;
|
||||
uint32_t start_nonce = pdata[19];
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1 << 17);
|
||||
throughput = min(throughput, max_nonce - start_nonce);
|
||||
uint32_t throughput = cuda_default_throughput(thr_id, 1U << 17);
|
||||
if (init[thr_id]) throughput = min(throughput, max_nonce - start_nonce);
|
||||
|
||||
uint32_t *outputHash = (uint32_t*)malloc(throughput * 64);
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0x0000ff;
|
||||
ptarget[7] = 0x0000ff;
|
||||
|
||||
// init
|
||||
if(!init[thr_id])
|
||||
{
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
if (opt_cudaschedule == -1 && gpu_threads == 1) {
|
||||
cudaDeviceReset();
|
||||
// reduce cpu usage
|
||||
cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);
|
||||
CUDA_LOG_ERROR();
|
||||
}
|
||||
myriadgroestl_cpu_init(thr_id, throughput);
|
||||
init[thr_id] = true;
|
||||
}
|
||||
@@ -63,28 +69,26 @@ int scanhash_myriad(int thr_id, struct work *work, uint32_t max_nonce, unsigned
|
||||
// GPU
|
||||
uint32_t foundNounce = UINT32_MAX;
|
||||
|
||||
*hashes_done = pdata[19] - start_nonce + throughput;
|
||||
|
||||
myriadgroestl_cpu_hash(thr_id, throughput, pdata[19], outputHash, &foundNounce);
|
||||
|
||||
if (foundNounce < UINT32_MAX)
|
||||
*hashes_done = pdata[19] - start_nonce + throughput;
|
||||
|
||||
if (foundNounce < UINT32_MAX && bench_algo < 0)
|
||||
{
|
||||
uint32_t _ALIGN(64) vhash[8];
|
||||
endiandata[19] = swab32(foundNounce);
|
||||
myriadhash(vhash, endiandata);
|
||||
if (vhash[7] <= ptarget[7] && fulltest(vhash, ptarget)) {
|
||||
bn_store_hash_target_ratio(vhash, ptarget, work);
|
||||
work_set_target_ratio(work, vhash);
|
||||
pdata[19] = foundNounce;
|
||||
free(outputHash);
|
||||
return 1;
|
||||
} else {
|
||||
applog(LOG_WARNING, "GPU #%d: result for nonce %08x does not validate on CPU!",
|
||||
device_map[thr_id], foundNounce);
|
||||
gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", foundNounce);
|
||||
}
|
||||
}
|
||||
|
||||
if ((uint64_t) pdata[19] + throughput > max_nonce) {
|
||||
*hashes_done = pdata[19] - start_nonce;
|
||||
if ((uint64_t) throughput + pdata[19] >= max_nonce) {
|
||||
pdata[19] = max_nonce;
|
||||
break;
|
||||
}
|
||||
@@ -92,6 +96,8 @@ int scanhash_myriad(int thr_id, struct work *work, uint32_t max_nonce, unsigned
|
||||
|
||||
} while (!work_restart[thr_id].restart);
|
||||
|
||||
*hashes_done = max_nonce - start_nonce;
|
||||
|
||||
free(outputHash);
|
||||
return 0;
|
||||
}
|
||||
@@ -102,10 +108,10 @@ void free_myriad(int thr_id)
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
myriadgroestl_cpu_free(thr_id);
|
||||
init[thr_id] = false;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
}
|
||||
+1371
-611
File diff suppressed because it is too large.
Load diff
@@ -482,7 +482,7 @@ static __forceinline__ __device__ uint32_t rotateR(uint32_t vec4, uint32_t shift
|
||||
// require a uint32_t[9] ret array
|
||||
// note: djm neoscrypt implementation is near the limits of gpu capabilities
|
||||
// and weird behaviors can happen when tuning device functions code...
|
||||
__device__ void shift256R(uint32_t* ret, const uint8 &vec4, uint32_t shift)
|
||||
__device__ __forceinline__ void shift256R(uint32_t* ret, const uint8 &vec4, uint32_t shift)
|
||||
{
|
||||
uint8_t *v = (uint8_t*) &vec4.s0;
|
||||
uint8_t *r = (uint8_t*) ret;
|
||||
@@ -496,7 +496,7 @@ __device__ void shift256R(uint32_t* ret, const uint8 &vec4, uint32_t shift)
|
||||
#else
|
||||
|
||||
// same for SM 3.5+, really faster ?
|
||||
__device__ void shift256R(uint32_t* ret, const uint8 &vec4, uint32_t shift)
|
||||
__device__ __forceinline__ void shift256R(uint32_t* ret, const uint8 &vec4, uint32_t shift)
|
||||
{
|
||||
uint32_t truc = 0, truc2 = cuda_swab32(vec4.s7), truc3 = 0;
|
||||
asm("shf.r.clamp.b32 %0, %1, %2, %3;" : "=r"(truc) : "r"(truc3), "r"(truc2), "r"(shift));
|
||||
|
||||
+68
-35
@@ -1,11 +1,14 @@
|
||||
#include <cuda_runtime.h>
|
||||
#include "miner.h"
|
||||
#include "neoscrypt/neoscrypt.h"
|
||||
#include <string.h>
|
||||
#include <miner.h>
|
||||
|
||||
extern void neoscrypt_setBlockTarget(uint32_t * data, const void *ptarget);
|
||||
extern void neoscrypt_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void neoscrypt_cpu_free(int thr_id);
|
||||
extern uint32_t neoscrypt_cpu_hash_k4(int thr_id, uint32_t threads, uint32_t startNounce, int have_stratum, int order);
|
||||
#include "neoscrypt.h"
|
||||
|
||||
extern void neoscrypt_setBlockTarget(uint32_t* const data, uint32_t* const ptarget);
|
||||
|
||||
extern void neoscrypt_init_2stream(int thr_id, uint32_t threads);
|
||||
extern void neoscrypt_free_2stream(int thr_id);
|
||||
extern void neoscrypt_hash_k4_2stream(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *resNonces, bool stratum);
|
||||
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
|
||||
@@ -16,27 +19,46 @@ int scanhash_neoscrypt(int thr_id, struct work* work, uint32_t max_nonce, unsign
|
||||
uint32_t *ptarget = work->target;
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
|
||||
int dev_id = device_map[thr_id];
|
||||
int intensity = is_windows() ? 18 : 19;
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1U << intensity);
|
||||
// Pascal
|
||||
if (strstr(device_name[dev_id], "GTX 10")) intensity = 22;
|
||||
// Maxwell
|
||||
else if (strstr(device_name[dev_id], "TITAN X")) intensity = 21;
|
||||
else if (strstr(device_name[dev_id], "980")) intensity = 21;
|
||||
else if (strstr(device_name[dev_id], "970")) intensity = 20;
|
||||
else if (strstr(device_name[dev_id], "960")) intensity = 20;
|
||||
else if (strstr(device_name[dev_id], "950")) intensity = 19;
|
||||
else if (strstr(device_name[dev_id], "750 Ti")) intensity = 19;
|
||||
else if (strstr(device_name[dev_id], "750")) intensity = 19;
|
||||
|
||||
uint32_t throughput = cuda_default_throughput(thr_id, 1U << intensity);
|
||||
throughput = throughput / 32; /* set for max intensity ~= 20 */
|
||||
throughput = min(throughput, max_nonce - first_nonce + 1);
|
||||
api_set_throughput(thr_id, throughput);
|
||||
|
||||
if (init[thr_id]) throughput = min(throughput, max_nonce - first_nonce + 1);
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0x0000ff;
|
||||
ptarget[7] = 0x00ff;
|
||||
|
||||
if (!init[thr_id])
|
||||
{
|
||||
int dev_id = device_map[thr_id];
|
||||
cudaDeviceSynchronize();
|
||||
cudaSetDevice(dev_id);
|
||||
cudaDeviceSetCacheConfig(cudaFuncCachePreferL1);
|
||||
if (opt_cudaschedule == -1 && gpu_threads == 1) {
|
||||
cudaDeviceReset();
|
||||
// reduce cpu usage
|
||||
cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);
|
||||
cudaGetLastError(); // reset errors if device is not "reset"
|
||||
}
|
||||
|
||||
if (device_sm[dev_id] <= 300) {
|
||||
applog(LOG_ERR, "Sorry neoscrypt is not supported on SM 3.0 devices");
|
||||
gpulog(LOG_ERR, thr_id, "Sorry neoscrypt is not supported on SM 3.0 devices");
|
||||
proper_exit(EXIT_CODE_CUDA_ERROR);
|
||||
}
|
||||
|
||||
applog(LOG_INFO, "Using %d cuda threads", throughput);
|
||||
neoscrypt_cpu_init(thr_id, throughput);
|
||||
gpulog(LOG_INFO, thr_id, "Using %d cuda threads", throughput);
|
||||
neoscrypt_init_2stream(thr_id, throughput);
|
||||
|
||||
init[thr_id] = true;
|
||||
}
|
||||
@@ -44,42 +66,52 @@ int scanhash_neoscrypt(int thr_id, struct work* work, uint32_t max_nonce, unsign
|
||||
if (have_stratum) {
|
||||
for (int k = 0; k < 20; k++)
|
||||
be32enc(&endiandata[k], pdata[k]);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
for (int k = 0; k < 20; k++)
|
||||
endiandata[k] = pdata[k];
|
||||
}
|
||||
|
||||
neoscrypt_setBlockTarget(endiandata,ptarget);
|
||||
neoscrypt_setBlockTarget(endiandata, ptarget);
|
||||
|
||||
do {
|
||||
uint32_t foundNonce = neoscrypt_cpu_hash_k4(thr_id, throughput, pdata[19], have_stratum, 0);
|
||||
if (foundNonce != UINT32_MAX)
|
||||
{
|
||||
uint32_t _ALIGN(64) vhash64[8];
|
||||
uint32_t foundNonces[2] = { UINT32_MAX, UINT32_MAX };
|
||||
neoscrypt_hash_k4_2stream(thr_id, throughput, pdata[19], foundNonces, have_stratum);
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce + 1;
|
||||
*hashes_done = pdata[19] - first_nonce + throughput;
|
||||
|
||||
if (foundNonces[0] != UINT32_MAX)
|
||||
{
|
||||
uint32_t _ALIGN(64) vhash[8];
|
||||
|
||||
if (have_stratum) {
|
||||
be32enc(&endiandata[19], foundNonce);
|
||||
} else {
|
||||
endiandata[19] = foundNonce;
|
||||
be32enc(&endiandata[19], foundNonces[0]);
|
||||
}
|
||||
neoscrypt((uchar*)vhash64, (uchar*) endiandata, 0x80000620U);
|
||||
else {
|
||||
endiandata[19] = foundNonces[0];
|
||||
}
|
||||
neoscrypt((uchar*)vhash, (uchar*)endiandata, 0x80000620U);
|
||||
|
||||
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
|
||||
bn_store_hash_target_ratio(vhash64, ptarget, work);
|
||||
pdata[19] = foundNonce;
|
||||
if (vhash[7] <= ptarget[7] && fulltest(vhash, ptarget)) {
|
||||
work_set_target_ratio(work, vhash);
|
||||
pdata[19] = foundNonces[0];
|
||||
return 1;
|
||||
} else {
|
||||
applog(LOG_WARNING, "GPU #%d: result for nonce %08x does not validate on CPU!", device_map[thr_id], foundNonce);
|
||||
}
|
||||
else {
|
||||
gpulog(LOG_WARNING, thr_id, "nonce %08x does not validate on CPU!", foundNonces[0]);
|
||||
}
|
||||
}
|
||||
|
||||
if ((uint64_t)throughput + pdata[19] >= max_nonce) {
|
||||
pdata[19] = max_nonce;
|
||||
break;
|
||||
}
|
||||
|
||||
pdata[19] += throughput;
|
||||
|
||||
} while (!work_restart[thr_id].restart && (max_nonce > ((uint64_t)(pdata[19]) + throughput)));
|
||||
} while (!work_restart[thr_id].restart);
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce + 1;
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -89,10 +121,11 @@ void free_neoscrypt(int thr_id)
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
neoscrypt_cpu_free(thr_id);
|
||||
neoscrypt_free_2stream(thr_id);
|
||||
init[thr_id] = false;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -25,9 +25,6 @@
|
||||
#include "nvml.h"
|
||||
#include "cuda_runtime.h"
|
||||
|
||||
// cuda.cpp
|
||||
int cuda_num_devices();
|
||||
|
||||
#ifdef USE_WRAPNVML
|
||||
|
||||
extern nvml_handle *hnvml;
|
||||
@@ -52,7 +49,7 @@ uint32_t limit_prev[MAX_GPUS] = { 0 };
|
||||
static void *wrap_dlopen(const char *filename) {
|
||||
HMODULE h = LoadLibrary(filename);
|
||||
if (!h && opt_debug) {
|
||||
applog(LOG_DEBUG, "dlopen(%d): failed to load %s",
|
||||
applog(LOG_DEBUG, "dlopen(%d): failed to load %s",
|
||||
GetLastError(), filename);
|
||||
}
|
||||
return (void*)h;
|
||||
@@ -71,7 +68,7 @@ uint32_t limit_prev[MAX_GPUS] = { 0 };
|
||||
static void *wrap_dlopen(const char *filename) {
|
||||
void *h = dlopen(filename, RTLD_NOW);
|
||||
if (h == NULL && opt_debug) {
|
||||
applog(LOG_DEBUG, "dlopen(%d): failed to load %s",
|
||||
applog(LOG_DEBUG, "dlopen(%d): failed to load %s",
|
||||
errno, filename);
|
||||
}
|
||||
return (void*)h;
|
||||
@@ -698,6 +695,7 @@ int nvml_get_info(nvml_handle *nvmlh, int cudaindex, uint16_t &vid, uint16_t &pi
|
||||
return -ENODEV;
|
||||
|
||||
subids = nvmlh->nvml_pci_subsys_id[gpuindex];
|
||||
if (!subids) subids = nvmlh->nvml_pci_device_id[gpuindex];
|
||||
pid = subids >> 16;
|
||||
vid = subids & 0xFFFF;
|
||||
return 0;
|
||||
@@ -848,6 +846,10 @@ int nvapi_getinfo(unsigned int devNum, uint16_t &vid, uint16_t &pid)
|
||||
|
||||
pid = pDeviceId >> 16;
|
||||
vid = pDeviceId & 0xFFFF;
|
||||
if (vid == 0x10DE && pSubSystemId) {
|
||||
vid = pSubSystemId & 0xFFFF;
|
||||
pid = pSubSystemId >> 16;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -935,7 +937,7 @@ int nvapi_init()
|
||||
if (ret == NVAPI_OK && busId == device_bus_ids[g]) {
|
||||
nvapi_dev_map[g] = i;
|
||||
if (opt_debug)
|
||||
applog(LOG_DEBUG, "CUDA GPU#%d matches NVAPI GPU %d by busId %u",
|
||||
applog(LOG_DEBUG, "CUDA GPU %d matches NVAPI GPU %d by busId %u",
|
||||
g, i, busId);
|
||||
break;
|
||||
}
|
||||
@@ -1048,7 +1050,6 @@ int gpu_busid(struct cgpu_info *gpu)
|
||||
return busid;
|
||||
}
|
||||
|
||||
/* not used in api (too much variable) */
|
||||
unsigned int gpu_power(struct cgpu_info *gpu)
|
||||
{
|
||||
unsigned int mw = 0;
|
||||
@@ -1063,6 +1064,10 @@ unsigned int gpu_power(struct cgpu_info *gpu)
|
||||
mw = pct; // to fix
|
||||
}
|
||||
#endif
|
||||
if (gpu->gpu_power > 0) {
|
||||
// average
|
||||
mw = (gpu->gpu_power + mw) / 2;
|
||||
}
|
||||
return mw;
|
||||
}
|
||||
|
||||
@@ -1099,67 +1104,32 @@ static int translate_vendor_id(uint16_t vid, char *vendorname)
|
||||
return vid;
|
||||
}
|
||||
}
|
||||
if (opt_debug)
|
||||
if (opt_debug && vid != 0x10DE)
|
||||
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);
|
||||
int dev_id = hnvml->nvml_cuda_device_id[id];
|
||||
nvml_get_info(hnvml, dev_id, vid, pid);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
#ifdef WIN32
|
||||
for (unsigned id = 0; id < nvapi_dev_cnt; id++) {
|
||||
if (device_bus_ids[id] == pci_bus_id) {
|
||||
nvapi_getinfo(nvapi_dev_map[id], vid, pid);
|
||||
break;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
return translate_vendor_id(vid, vendorname);
|
||||
#endif
|
||||
}
|
||||
|
||||
int gpu_info(struct cgpu_info *gpu)
|
||||
@@ -1176,13 +1146,7 @@ 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_serial(hnvml, id, gpu->gpu_sn, sizeof(gpu->gpu_sn));
|
||||
nvml_get_bios(hnvml, id, gpu->gpu_desc, sizeof(gpu->gpu_desc));
|
||||
}
|
||||
|
||||
+52
-367
@@ -1,25 +1,20 @@
|
||||
/**
|
||||
* Penta Blake-512 Cuda Kernel (Tested on SM 5.0)
|
||||
*
|
||||
* Tanguy Pruvot - Aug. 2014
|
||||
* Penta Blake
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include <memory.h>
|
||||
#include "miner.h"
|
||||
|
||||
extern "C" {
|
||||
#include "sph/sph_blake.h"
|
||||
#include <stdint.h>
|
||||
#include <memory.h>
|
||||
}
|
||||
|
||||
/* threads per block */
|
||||
#define TPB 192
|
||||
|
||||
/* hash by cpu with blake 256 */
|
||||
extern "C" void pentablakehash(void *output, const void *input)
|
||||
{
|
||||
unsigned char hash[128];
|
||||
#define hashB hash + 64
|
||||
unsigned char _ALIGN(128) hash[64];
|
||||
|
||||
sph_blake512_context ctx;
|
||||
|
||||
sph_blake512_init(&ctx);
|
||||
@@ -27,15 +22,15 @@ extern "C" void pentablakehash(void *output, const void *input)
|
||||
sph_blake512_close(&ctx, hash);
|
||||
|
||||
sph_blake512(&ctx, hash, 64);
|
||||
sph_blake512_close(&ctx, hashB);
|
||||
|
||||
sph_blake512(&ctx, hashB, 64);
|
||||
sph_blake512_close(&ctx, hash);
|
||||
|
||||
sph_blake512(&ctx, hash, 64);
|
||||
sph_blake512_close(&ctx, hashB);
|
||||
sph_blake512_close(&ctx, hash);
|
||||
|
||||
sph_blake512(&ctx, hashB, 64);
|
||||
sph_blake512(&ctx, hash, 64);
|
||||
sph_blake512_close(&ctx, hash);
|
||||
|
||||
sph_blake512(&ctx, hash, 64);
|
||||
sph_blake512_close(&ctx, hash);
|
||||
|
||||
memcpy(output, hash, 32);
|
||||
@@ -43,324 +38,13 @@ extern "C" void pentablakehash(void *output, const void *input)
|
||||
|
||||
#include "cuda_helper.h"
|
||||
|
||||
__constant__
|
||||
static uint32_t __align__(32) c_Target[8];
|
||||
|
||||
__constant__
|
||||
static uint64_t __align__(32) c_data[32];
|
||||
|
||||
static uint32_t *d_hash[MAX_GPUS];
|
||||
static uint32_t *d_resNounce[MAX_GPUS];
|
||||
static uint32_t *h_resNounce[MAX_GPUS];
|
||||
static uint32_t extra_results[2] = { UINT32_MAX, UINT32_MAX };
|
||||
|
||||
/* prefer uint32_t to prevent size conversions = speed +5/10 % */
|
||||
__constant__
|
||||
static uint32_t __align__(32) c_sigma[16][16];
|
||||
const uint32_t host_sigma[16][16] = {
|
||||
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
|
||||
{14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
|
||||
{11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
|
||||
{ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
|
||||
{ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
|
||||
{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },
|
||||
{12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
|
||||
{13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
|
||||
{ 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 },
|
||||
{10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13 , 0 },
|
||||
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
|
||||
{14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
|
||||
{11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
|
||||
{ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
|
||||
{ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
|
||||
{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 }
|
||||
};
|
||||
|
||||
__device__ __constant__
|
||||
static const uint64_t __align__(32) c_IV512[8] = {
|
||||
0x6a09e667f3bcc908ULL,
|
||||
0xbb67ae8584caa73bULL,
|
||||
0x3c6ef372fe94f82bULL,
|
||||
0xa54ff53a5f1d36f1ULL,
|
||||
0x510e527fade682d1ULL,
|
||||
0x9b05688c2b3e6c1fULL,
|
||||
0x1f83d9abfb41bd6bULL,
|
||||
0x5be0cd19137e2179ULL
|
||||
};
|
||||
|
||||
__device__ __constant__
|
||||
const uint64_t c_u512[16] =
|
||||
{
|
||||
0x243f6a8885a308d3ULL, 0x13198a2e03707344ULL,
|
||||
0xa4093822299f31d0ULL, 0x082efa98ec4e6c89ULL,
|
||||
0x452821e638d01377ULL, 0xbe5466cf34e90c6cULL,
|
||||
0xc0ac29b7c97c50ddULL, 0x3f84d5b5b5470917ULL,
|
||||
0x9216d5d98979fb1bULL, 0xd1310ba698dfb5acULL,
|
||||
0x2ffd72dbd01adfb7ULL, 0xb8e1afed6a267e96ULL,
|
||||
0xba7c9045f12c7f99ULL, 0x24a19947b3916cf7ULL,
|
||||
0x0801f2e2858efc16ULL, 0x636920d871574e69ULL
|
||||
};
|
||||
|
||||
#define G(a,b,c,d,x) { \
|
||||
uint32_t idx1 = c_sigma[i][x]; \
|
||||
uint32_t idx2 = c_sigma[i][x+1]; \
|
||||
v[a] += (m[idx1] ^ c_u512[idx2]) + v[b]; \
|
||||
v[d] = SWAPDWORDS(v[d] ^ v[a]); \
|
||||
v[c] += v[d]; \
|
||||
v[b] = ROTR64(v[b] ^ v[c], 25); \
|
||||
v[a] += (m[idx2] ^ c_u512[idx1]) + v[b]; \
|
||||
v[d] = ROTR64(v[d] ^ v[a], 16); \
|
||||
v[c] += v[d]; \
|
||||
v[b] = ROTR64(v[b] ^ v[c], 11); \
|
||||
}
|
||||
|
||||
// Hash-Padding
|
||||
__device__ __constant__
|
||||
static const uint64_t d_constHashPadding[8] = {
|
||||
0x0000000000000080ull,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0x0100000000000000ull,
|
||||
0,
|
||||
0x0002000000000000ull
|
||||
};
|
||||
|
||||
__device__ static
|
||||
void pentablake_compress(uint64_t *h, const uint64_t *block, const uint64_t T0)
|
||||
{
|
||||
uint64_t v[16], m[16], i;
|
||||
|
||||
#pragma unroll 16
|
||||
for(i = 0; i < 16; i++) {
|
||||
m[i] = cuda_swab64(block[i]);
|
||||
}
|
||||
|
||||
#pragma unroll 8
|
||||
for (i = 0; i < 8; i++)
|
||||
v[i] = h[i];
|
||||
|
||||
v[ 8] = c_u512[0];
|
||||
v[ 9] = c_u512[1];
|
||||
v[10] = c_u512[2];
|
||||
v[11] = c_u512[3];
|
||||
v[12] = c_u512[4] ^ T0;
|
||||
v[13] = c_u512[5] ^ T0;
|
||||
v[14] = c_u512[6];
|
||||
v[15] = c_u512[7];
|
||||
|
||||
//#pragma unroll 16
|
||||
for( i = 0; i < 16; i++)
|
||||
{
|
||||
/* column step */
|
||||
G(0, 4, 0x8, 0xC, 0x0);
|
||||
G(1, 5, 0x9, 0xD, 0x2);
|
||||
G(2, 6, 0xA, 0xE, 0x4);
|
||||
G(3, 7, 0xB, 0xF, 0x6);
|
||||
/* diagonal step */
|
||||
G(0, 5, 0xA, 0xF, 0x8);
|
||||
G(1, 6, 0xB, 0xC, 0xA);
|
||||
G(2, 7, 0x8, 0xD, 0xC);
|
||||
G(3, 4, 0x9, 0xE, 0xE);
|
||||
}
|
||||
|
||||
//#pragma unroll 16
|
||||
for (i = 0; i < 16; i++) {
|
||||
uint32_t idx = i % 8;
|
||||
h[idx] ^= v[i];
|
||||
}
|
||||
}
|
||||
|
||||
__global__
|
||||
void pentablake_gpu_hash_80(uint32_t threads, const uint32_t startNounce, void *outputHash)
|
||||
{
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
uint64_t h[8];
|
||||
uint64_t buf[16];
|
||||
uint32_t nounce = startNounce + thread;
|
||||
|
||||
//#pragma unroll 8
|
||||
for(int i=0; i<8; i++)
|
||||
h[i] = c_IV512[i];
|
||||
|
||||
//#pragma unroll 16
|
||||
for (int i=0; i < 16; i++)
|
||||
buf[i] = c_data[i];
|
||||
|
||||
// The test Nonce
|
||||
((uint32_t*)buf)[19] = cuda_swab32(nounce);
|
||||
|
||||
pentablake_compress(h, buf, 640ULL);
|
||||
|
||||
#if __CUDA_ARCH__ < 300
|
||||
uint32_t *outHash = (uint32_t *)outputHash + 16 * thread;
|
||||
#pragma unroll 8
|
||||
for (uint32_t i=0; i < 8; i++) {
|
||||
outHash[2*i] = cuda_swab32( _HIDWORD(h[i]) );
|
||||
outHash[2*i+1] = cuda_swab32( _LODWORD(h[i]) );
|
||||
}
|
||||
#else
|
||||
uint64_t *outHash = (uint64_t *)outputHash + 8 * thread;
|
||||
for (uint32_t i=0; i < 8; i++) {
|
||||
outHash[i] = cuda_swab64( h[i] );
|
||||
}
|
||||
#endif
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
__host__
|
||||
void pentablake_cpu_hash_80(int thr_id, uint32_t threads, const uint32_t startNounce, uint32_t *d_outputHash, int order)
|
||||
{
|
||||
const uint32_t threadsperblock = TPB;
|
||||
|
||||
dim3 grid((threads + threadsperblock-1)/threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
size_t shared_size = 0;
|
||||
|
||||
pentablake_gpu_hash_80 <<<grid, block, shared_size>>> (threads, startNounce, d_outputHash);
|
||||
|
||||
MyStreamSynchronize(NULL, order, thr_id);
|
||||
}
|
||||
|
||||
|
||||
__global__
|
||||
void pentablake_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint64_t *g_hash)
|
||||
{
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
|
||||
if (thread < threads)
|
||||
{
|
||||
uint64_t *inpHash = &g_hash[thread<<3]; // hashPosition * 8
|
||||
uint64_t buf[16]; // 128 Bytes
|
||||
uint64_t h[8]; // State
|
||||
|
||||
#pragma unroll 8
|
||||
for (int i=0; i<8; i++)
|
||||
h[i] = c_IV512[i];
|
||||
|
||||
// Message for first round
|
||||
#pragma unroll 8
|
||||
for (int i=0; i < 8; ++i)
|
||||
buf[i] = inpHash[i];
|
||||
|
||||
#pragma unroll 8
|
||||
for (int i=0; i < 8; i++)
|
||||
buf[i+8] = d_constHashPadding[i];
|
||||
|
||||
// Ending round
|
||||
pentablake_compress(h, buf, 512);
|
||||
|
||||
#if __CUDA_ARCH__ < 300
|
||||
uint32_t *outHash = (uint32_t*)&g_hash[thread<<3];
|
||||
#pragma unroll 8
|
||||
for (int i=0; i < 8; i++) {
|
||||
outHash[2*i+0] = cuda_swab32( _HIDWORD(h[i]) );
|
||||
outHash[2*i+1] = cuda_swab32( _LODWORD(h[i]) );
|
||||
}
|
||||
#else
|
||||
uint64_t *outHash = &g_hash[thread<<3];
|
||||
for (int i=0; i < 8; i++) {
|
||||
outHash[i] = cuda_swab64(h[i]);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
__host__
|
||||
void pentablake_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_outputHash, int order)
|
||||
{
|
||||
const uint32_t threadsperblock = TPB;
|
||||
|
||||
dim3 grid((threads + threadsperblock-1)/threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
size_t shared_size = 0;
|
||||
|
||||
pentablake_gpu_hash_64 <<<grid, block, shared_size>>> (threads, startNounce, (uint64_t*)d_outputHash);
|
||||
|
||||
MyStreamSynchronize(NULL, order, thr_id);
|
||||
}
|
||||
|
||||
__global__
|
||||
void pentablake_gpu_check_hash(uint32_t threads, uint32_t startNounce, uint32_t *g_hash, uint32_t *resNounce)
|
||||
{
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
uint32_t nounce = startNounce + thread;
|
||||
uint32_t *inpHash = &g_hash[thread<<4];
|
||||
uint32_t h[8];
|
||||
|
||||
#pragma unroll 8
|
||||
for (int i=0; i < 8; i++)
|
||||
h[i] = inpHash[i];
|
||||
|
||||
for (int i = 7; i >= 0; i--) {
|
||||
uint32_t hash = h[i]; // cuda_swab32(h[i]);
|
||||
if (hash > c_Target[i]) {
|
||||
return;
|
||||
}
|
||||
if (hash < c_Target[i]) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* keep the smallest nounce, + extra one if found */
|
||||
if (resNounce[0] > nounce) {
|
||||
resNounce[1] = resNounce[0];
|
||||
resNounce[0] = nounce;
|
||||
}
|
||||
else
|
||||
resNounce[1] = nounce;
|
||||
}
|
||||
}
|
||||
|
||||
__host__ static
|
||||
uint32_t pentablake_check_hash(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_inputHash, int order)
|
||||
{
|
||||
const uint32_t threadsperblock = TPB;
|
||||
uint32_t result = UINT32_MAX;
|
||||
|
||||
dim3 grid((threads + threadsperblock-1)/threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
size_t shared_size = 0;
|
||||
|
||||
/* Check error on Ctrl+C or kill to prevent segfaults on exit */
|
||||
if (cudaMemset(d_resNounce[thr_id], 0xff, 2*sizeof(uint32_t)) != cudaSuccess)
|
||||
return result;
|
||||
|
||||
pentablake_gpu_check_hash <<<grid, block, shared_size>>> (threads, startNounce, d_inputHash, d_resNounce[thr_id]);
|
||||
|
||||
CUDA_SAFE_CALL(cudaThreadSynchronize());
|
||||
if (cudaSuccess == cudaMemcpy(h_resNounce[thr_id], d_resNounce[thr_id], 2*sizeof(uint32_t), cudaMemcpyDeviceToHost)) {
|
||||
cudaThreadSynchronize();
|
||||
result = h_resNounce[thr_id][0];
|
||||
extra_results[0] = h_resNounce[thr_id][1];
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
__host__
|
||||
void pentablake_cpu_setBlock_80(uint32_t *pdata, const uint32_t *ptarget)
|
||||
{
|
||||
uint8_t data[128];
|
||||
memcpy((void*) data, (void*) pdata, 80);
|
||||
memset(data+80, 0, 48);
|
||||
|
||||
// to swab...
|
||||
data[80] = 0x80;
|
||||
data[111] = 1;
|
||||
data[126] = 0x02;
|
||||
data[127] = 0x80;
|
||||
|
||||
CUDA_SAFE_CALL(cudaMemcpyToSymbol(c_data, data, sizeof(data), 0, cudaMemcpyHostToDevice));
|
||||
CUDA_SAFE_CALL(cudaMemcpyToSymbol(c_sigma, host_sigma, sizeof(host_sigma), 0, cudaMemcpyHostToDevice));
|
||||
CUDA_SAFE_CALL(cudaMemcpyToSymbol(c_Target, ptarget, 32, 0, cudaMemcpyHostToDevice));
|
||||
}
|
||||
extern void quark_blake512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_blake512_cpu_free(int thr_id);
|
||||
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_blake512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
|
||||
@@ -371,19 +55,26 @@ extern "C" int scanhash_pentablake(int thr_id, struct work *work, uint32_t max_n
|
||||
uint32_t *ptarget = work->target;
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
int rc = 0;
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 128U * 2560); // 18.5
|
||||
throughput = min(throughput, max_nonce - first_nonce);
|
||||
uint32_t throughput = cuda_default_throughput(thr_id, 1U << 19);
|
||||
if (init[thr_id]) throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0x000F;
|
||||
ptarget[7] = 0x000F;
|
||||
|
||||
if (!init[thr_id]) {
|
||||
if (active_gpus > 1) {
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
if (opt_cudaschedule == -1 && gpu_threads == 1) {
|
||||
cudaDeviceReset();
|
||||
// reduce cpu usage
|
||||
cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);
|
||||
CUDA_LOG_ERROR();
|
||||
}
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hash[thr_id], 64 * throughput));
|
||||
CUDA_SAFE_CALL(cudaMallocHost(&h_resNounce[thr_id], 2*sizeof(uint32_t)));
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_resNounce[thr_id], 2*sizeof(uint32_t)));
|
||||
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hash[thr_id], (size_t) 64 * throughput));
|
||||
|
||||
quark_blake512_cpu_init(thr_id, throughput);
|
||||
cuda_check_cpu_init(thr_id, throughput);
|
||||
CUDA_LOG_ERROR();
|
||||
|
||||
init[thr_id] = true;
|
||||
}
|
||||
@@ -391,22 +82,22 @@ extern "C" int scanhash_pentablake(int thr_id, struct work *work, uint32_t max_n
|
||||
for (int k=0; k < 20; k++)
|
||||
be32enc(&endiandata[k], pdata[k]);
|
||||
|
||||
pentablake_cpu_setBlock_80(endiandata, ptarget);
|
||||
quark_blake512_cpu_setBlock_80(thr_id, endiandata);
|
||||
cuda_check_cpu_setTarget(ptarget);
|
||||
|
||||
do {
|
||||
int order = 0;
|
||||
|
||||
// GPU HASH
|
||||
pentablake_cpu_hash_80(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
|
||||
|
||||
pentablake_cpu_hash_64(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
|
||||
pentablake_cpu_hash_64(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
|
||||
pentablake_cpu_hash_64(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
|
||||
pentablake_cpu_hash_64(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
|
||||
quark_blake512_cpu_hash_80(thr_id, throughput, pdata[19], d_hash[thr_id]); order++;
|
||||
quark_blake512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
quark_blake512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
quark_blake512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
quark_blake512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce + throughput;
|
||||
|
||||
uint32_t foundNonce = pentablake_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
|
||||
uint32_t foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]);
|
||||
if (foundNonce != UINT32_MAX)
|
||||
{
|
||||
uint32_t vhash[8];
|
||||
@@ -416,30 +107,23 @@ extern "C" int scanhash_pentablake(int thr_id, struct work *work, uint32_t max_n
|
||||
|
||||
if (vhash[7] <= ptarget[7] && fulltest(vhash, ptarget)) {
|
||||
rc = 1;
|
||||
bn_store_hash_target_ratio(vhash, ptarget, work);
|
||||
if (extra_results[0] != UINT32_MAX) {
|
||||
// Rare but possible if the throughput is big
|
||||
be32enc(&endiandata[19], extra_results[0]);
|
||||
pentablakehash(vhash, endiandata);
|
||||
if (bn_hash_target_ratio(vhash, ptarget) > work->shareratio)
|
||||
bn_store_hash_target_ratio(vhash, ptarget, work);
|
||||
applog(LOG_NOTICE, "GPU found more than one result yippee!");
|
||||
pdata[21] = extra_results[0];
|
||||
extra_results[0] = UINT32_MAX;
|
||||
rc++;
|
||||
}
|
||||
work_set_target_ratio(work, vhash);
|
||||
pdata[19] = foundNonce;
|
||||
return rc;
|
||||
} else {
|
||||
applog(LOG_WARNING, "GPU #%d: result for nounce %08x does not validate on CPU!", device_map[thr_id], foundNonce);
|
||||
gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", foundNonce);
|
||||
}
|
||||
}
|
||||
|
||||
if ((uint64_t) throughput + pdata[19] >= max_nonce) {
|
||||
pdata[19] = max_nonce;
|
||||
break;
|
||||
}
|
||||
|
||||
pdata[19] += throughput;
|
||||
|
||||
} while (pdata[19] < max_nonce && !work_restart[thr_id].restart);
|
||||
} while (!work_restart[thr_id].restart);
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce + 1;
|
||||
return rc;
|
||||
}
|
||||
|
||||
@@ -449,13 +133,14 @@ void free_pentablake(int thr_id)
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
cudaFree(d_hash[thr_id]);
|
||||
cudaFree(h_resNounce[thr_id]);
|
||||
cudaFree(d_resNounce[thr_id]);
|
||||
|
||||
init[thr_id] = false;
|
||||
quark_blake512_cpu_free(thr_id);
|
||||
cuda_check_cpu_free(thr_id);
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
|
||||
init[thr_id] = false;
|
||||
}
|
||||
@@ -9,6 +9,7 @@
|
||||
|
||||
#include "miner.h"
|
||||
#include "compat.h"
|
||||
#include "algos.h"
|
||||
|
||||
// to move in miner.h
|
||||
extern bool allow_gbt;
|
||||
@@ -18,6 +19,7 @@ extern bool check_dups;
|
||||
extern double opt_max_diff;
|
||||
extern double opt_max_rate;
|
||||
extern int opt_scantime;
|
||||
extern int opt_shares_limit;
|
||||
extern int opt_time_limit;
|
||||
|
||||
extern char* rpc_url;
|
||||
@@ -28,6 +30,7 @@ extern char* short_url;
|
||||
extern struct work _ALIGN(64) g_work;
|
||||
extern struct stratum_ctx stratum;
|
||||
extern pthread_mutex_t stratum_work_lock;
|
||||
extern pthread_mutex_t stats_lock;
|
||||
extern bool get_work(struct thr_info *thr, struct work *work);
|
||||
extern bool stratum_need_reset;
|
||||
extern time_t firstwork_time;
|
||||
@@ -37,6 +40,8 @@ extern volatile int pool_switch_count;
|
||||
extern volatile bool pool_is_switching;
|
||||
extern uint8_t conditional_state[MAX_GPUS];
|
||||
|
||||
extern double thr_hashrates[MAX_GPUS];
|
||||
|
||||
extern struct option options[];
|
||||
|
||||
#define CFG_NULL 0
|
||||
@@ -51,11 +56,11 @@ struct opt_config_array {
|
||||
{ CFG_POOL, "pass", NULL },
|
||||
{ CFG_POOL, "userpass", NULL },
|
||||
{ CFG_POOL, "name", "pool-name" },
|
||||
{ CFG_POOL, "algo", "pool-algo" },
|
||||
{ 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, "disabled", "pool-disabled" },
|
||||
{ CFG_POOL, "time-limit", "pool-time-limit" },
|
||||
{ CFG_NULL, NULL, NULL }
|
||||
};
|
||||
@@ -74,10 +79,12 @@ void pool_set_creds(int pooln)
|
||||
p->id = pooln;
|
||||
p->status |= POOL_ST_DEFINED;
|
||||
// init pool options as "unset"
|
||||
// until cmdline is not fully parsed...
|
||||
// until cmdline is fully parsed...
|
||||
p->algo = -1;
|
||||
p->max_diff = -1.;
|
||||
p->max_rate = -1.;
|
||||
p->scantime = -1;
|
||||
p->shares_limit = -1;
|
||||
p->time_limit = -1;
|
||||
|
||||
p->allow_mininginfo = allow_mininginfo;
|
||||
@@ -102,9 +109,11 @@ void pool_init_defaults()
|
||||
struct pool_infos *p;
|
||||
for (int i=0; i<num_pools; i++) {
|
||||
p = &pools[i];
|
||||
if (p->algo == -1) p->algo = (int) opt_algo;
|
||||
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->shares_limit == -1) p->shares_limit = opt_shares_limit;
|
||||
if (p->time_limit == -1) p->time_limit = opt_time_limit;
|
||||
}
|
||||
}
|
||||
@@ -113,11 +122,14 @@ void pool_init_defaults()
|
||||
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, "algo")) {
|
||||
p->algo = algo_to_int(arg);
|
||||
return;
|
||||
}
|
||||
if (!strcasecmp(key, "scantime")) {
|
||||
p->scantime = atoi(arg);
|
||||
return;
|
||||
@@ -130,11 +142,15 @@ void pool_set_attr(int pooln, const char* key, char* arg)
|
||||
p->max_rate = atof(arg);
|
||||
return;
|
||||
}
|
||||
if (!strcasecmp(key, "shares-limit")) {
|
||||
p->shares_limit = atoi(arg);
|
||||
return;
|
||||
}
|
||||
if (!strcasecmp(key, "time-limit")) {
|
||||
p->time_limit = atoi(arg);
|
||||
return;
|
||||
}
|
||||
if (!strcasecmp(key, "removed")) {
|
||||
if (!strcasecmp(key, "disabled")) {
|
||||
int removed = atoi(arg);
|
||||
if (removed) {
|
||||
p->status |= POOL_ST_REMOVED;
|
||||
@@ -144,9 +160,10 @@ void pool_set_attr(int pooln, const char* key, char* arg)
|
||||
}
|
||||
|
||||
// pool switching code
|
||||
bool pool_switch(int pooln)
|
||||
bool pool_switch(int thr_id, int pooln)
|
||||
{
|
||||
int prevn = cur_pooln;
|
||||
bool algo_switch = false;
|
||||
struct pool_infos *prev = &pools[cur_pooln];
|
||||
struct pool_infos* p = NULL;
|
||||
|
||||
@@ -182,15 +199,40 @@ bool pool_switch(int pooln)
|
||||
opt_scantime = p->scantime;
|
||||
opt_max_diff = p->max_diff;
|
||||
opt_max_rate = p->max_rate;
|
||||
opt_shares_limit = p->shares_limit;
|
||||
opt_time_limit = p->time_limit;
|
||||
|
||||
want_stratum = have_stratum = (p->type & POOL_STRATUM) != 0;
|
||||
|
||||
// yiimp stats reporting
|
||||
opt_stratum_stats = (strstr(p->pass, "stats") != NULL) || (strcmp(p->user, "benchmark") == 0);
|
||||
|
||||
pthread_mutex_unlock(&stratum_work_lock);
|
||||
|
||||
// algo "blind" switch without free, not proper
|
||||
// todo: barrier required to free algo resources
|
||||
if (p->algo != (int) opt_algo) {
|
||||
|
||||
if (opt_algo != ALGO_AUTO) {
|
||||
|
||||
algo_switch = true;
|
||||
|
||||
pthread_mutex_lock(&stats_lock);
|
||||
for (int n=0; n<opt_n_threads; n++)
|
||||
thr_hashrates[n] = 0.;
|
||||
stats_purge_all();
|
||||
if (check_dups)
|
||||
hashlog_purge_all();
|
||||
pthread_mutex_unlock(&stats_lock);
|
||||
}
|
||||
|
||||
opt_algo = (enum sha_algos) p->algo;
|
||||
}
|
||||
|
||||
if (prevn != cur_pooln) {
|
||||
|
||||
pool_switch_count++;
|
||||
net_diff = 0;
|
||||
g_work_time = 0;
|
||||
g_work.data[0] = 0;
|
||||
pool_is_switching = true;
|
||||
@@ -255,11 +297,11 @@ int pool_get_first_valid(int startfrom)
|
||||
}
|
||||
|
||||
// switch to next available pool
|
||||
bool pool_switch_next()
|
||||
bool pool_switch_next(int thr_id)
|
||||
{
|
||||
if (num_pools > 1) {
|
||||
int pooln = pool_get_first_valid(cur_pooln+1);
|
||||
return pool_switch(pooln);
|
||||
return pool_switch(thr_id, pooln);
|
||||
} else {
|
||||
// no switch possible
|
||||
if (!opt_quiet)
|
||||
@@ -279,7 +321,7 @@ bool pool_switch_url(char *params)
|
||||
cur_pooln = prevn;
|
||||
if (nextn == prevn)
|
||||
return false;
|
||||
return pool_switch(nextn);
|
||||
return pool_switch(-1, nextn);
|
||||
}
|
||||
|
||||
// Parse pools array in json config
|
||||
@@ -353,6 +395,7 @@ bool parse_pool_array(json_t *obj)
|
||||
void pool_dump_infos()
|
||||
{
|
||||
struct pool_infos *p;
|
||||
if (opt_benchmark) return;
|
||||
for (int i=0; i<num_pools; i++) {
|
||||
p = &pools[i];
|
||||
applog(LOG_DEBUG, "POOL %01d: %s USER %s -s %d", i,
|
||||
|
||||
+36
-22
@@ -1,11 +1,20 @@
|
||||
#include <stdio.h>
|
||||
#include <memory.h>
|
||||
|
||||
#undef WANT_BMW512_80
|
||||
|
||||
#include "cuda_helper.h"
|
||||
|
||||
#ifdef WANT_BMW512_80
|
||||
__constant__ uint64_t c_PaddedMessage80[16]; // padded message (80 bytes + padding)
|
||||
#endif
|
||||
|
||||
#include "cuda_bmw512_30.cu"
|
||||
#include "cuda_bmw512_sm3.cuh"
|
||||
|
||||
#ifdef __INTELLISENSE__
|
||||
/* just for vstudio code colors */
|
||||
#define __CUDA_ARCH__ 500
|
||||
#endif
|
||||
|
||||
#undef SHL
|
||||
#undef SHR
|
||||
@@ -21,7 +30,8 @@ __constant__ uint64_t c_PaddedMessage80[16]; // padded message (80 bytes + paddi
|
||||
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])
|
||||
|
||||
__device__ void Compression512_64_first(uint2 *msg, uint2 *hash)
|
||||
__device__
|
||||
void Compression512_64_first(uint2 *msg, uint2 *hash)
|
||||
{
|
||||
// Compression ref. implementation
|
||||
uint2 q[32];
|
||||
@@ -380,6 +390,8 @@ void quark_bmw512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint64_t *
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef WANT_BMW512_80
|
||||
|
||||
__global__ __launch_bounds__(256, 2)
|
||||
void quark_bmw512_gpu_hash_80(uint32_t threads, uint32_t startNounce, uint64_t *g_hash)
|
||||
{
|
||||
@@ -436,12 +448,6 @@ void quark_bmw512_gpu_hash_80(uint32_t threads, uint32_t startNounce, uint64_t *
|
||||
}
|
||||
}
|
||||
|
||||
__host__
|
||||
void quark_bmw512_cpu_init(int thr_id, uint32_t threads)
|
||||
{
|
||||
cuda_get_arch(thr_id);
|
||||
}
|
||||
|
||||
__host__
|
||||
void quark_bmw512_cpu_setBlock_80(void *pdata)
|
||||
{
|
||||
@@ -454,6 +460,28 @@ void quark_bmw512_cpu_setBlock_80(void *pdata)
|
||||
cudaMemcpyToSymbol(c_PaddedMessage80, PaddedMessage, 16*sizeof(uint64_t), 0, cudaMemcpyHostToDevice);
|
||||
}
|
||||
|
||||
__host__
|
||||
void quark_bmw512_cpu_hash_80(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_hash, int order)
|
||||
{
|
||||
const uint32_t threadsperblock = 128;
|
||||
dim3 grid((threads + threadsperblock-1)/threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
int dev_id = device_map[thr_id];
|
||||
|
||||
if (device_sm[dev_id] > 300 && cuda_arch[dev_id] > 300)
|
||||
quark_bmw512_gpu_hash_80<<<grid, block>>>(threads, startNounce, (uint64_t*)d_hash);
|
||||
else
|
||||
quark_bmw512_gpu_hash_80_30<<<grid, block>>>(threads, startNounce, (uint64_t*)d_hash);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
__host__
|
||||
void quark_bmw512_cpu_init(int thr_id, uint32_t threads)
|
||||
{
|
||||
cuda_get_arch(thr_id);
|
||||
}
|
||||
|
||||
__host__
|
||||
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)
|
||||
{
|
||||
@@ -467,17 +495,3 @@ void quark_bmw512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce
|
||||
else
|
||||
quark_bmw512_gpu_hash_64_30<<<grid, block>>>(threads, startNounce, (uint64_t*)d_hash, d_nonceVector);
|
||||
}
|
||||
|
||||
__host__
|
||||
void quark_bmw512_cpu_hash_80(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_hash, int order)
|
||||
{
|
||||
const uint32_t threadsperblock = 128;
|
||||
dim3 grid((threads + threadsperblock-1)/threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
|
||||
int dev_id = device_map[thr_id];
|
||||
if (device_sm[dev_id] > 300 && cuda_arch[dev_id] > 300)
|
||||
quark_bmw512_gpu_hash_80<<<grid, block>>>(threads, startNounce, (uint64_t*)d_hash);
|
||||
else
|
||||
quark_bmw512_gpu_hash_80_30<<<grid, block>>>(threads, startNounce, (uint64_t*)d_hash);
|
||||
}
|
||||
@@ -1,6 +1,11 @@
|
||||
#include <stdio.h>
|
||||
#include <memory.h>
|
||||
|
||||
#ifdef __INTELLISENSE__
|
||||
/* for vstudio code colors */
|
||||
#define __CUDA_ARCH__ 300
|
||||
#endif
|
||||
|
||||
#include "cuda_helper.h"
|
||||
|
||||
#define SHL(x, n) ((x) << (n))
|
||||
@@ -12,7 +17,8 @@
|
||||
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])
|
||||
|
||||
static __constant__ uint64_t d_constMem[16] = {
|
||||
#if !defined(__CUDA_ARCH__) || (__CUDA_ARCH__ >= 200 && __CUDA_ARCH__ < 500) || defined(_DEBUG)
|
||||
__constant__ uint64_t d_constMem[16] = {
|
||||
SPH_C64(0x8081828384858687),
|
||||
SPH_C64(0x88898A8B8C8D8E8F),
|
||||
SPH_C64(0x9091929394959697),
|
||||
@@ -30,6 +36,13 @@ static __constant__ uint64_t d_constMem[16] = {
|
||||
SPH_C64(0xF0F1F2F3F4F5F6F7),
|
||||
SPH_C64(0xF8F9FAFBFCFDFEFF)
|
||||
};
|
||||
# ifdef __GNUC__
|
||||
// windows and linux doesnt require the same ifdef for __constant__
|
||||
# pragma GCC diagnostic ignored "-Wunused-variable"
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ < 500 || defined(_DEBUG))
|
||||
|
||||
__device__
|
||||
void Compression512_30(uint64_t *msg, uint64_t *hash)
|
||||
@@ -213,6 +226,8 @@ void quark_bmw512_gpu_hash_64_30(uint32_t threads, uint32_t startNounce, uint64_
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef WANT_BMW512_80
|
||||
|
||||
__global__
|
||||
void quark_bmw512_gpu_hash_80_30(uint32_t threads, uint32_t startNounce, uint64_t *g_hash)
|
||||
{
|
||||
@@ -250,3 +265,11 @@ void quark_bmw512_gpu_hash_80_30(uint32_t threads, uint32_t startNounce, uint64_
|
||||
outpHash[i] = ((uint2*)message)[i+8];
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#else /* stripped stubs for other archs */
|
||||
__global__ void quark_bmw512_gpu_hash_64_30(uint32_t threads, uint32_t startNounce, uint64_t *g_hash, uint32_t *g_nonceVector) {}
|
||||
__global__ void quark_bmw512_gpu_hash_80_30(uint32_t threads, uint32_t startNounce, uint64_t *g_hash) {}
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
#include "cuda_helper.h"
|
||||
|
||||
/* commonly used cuda quark kernels prototypes */
|
||||
|
||||
extern void quark_blake512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_blake512_cpu_free(int thr_id);
|
||||
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_blake512_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_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_groestl512_cpu_free(int thr_id);
|
||||
|
||||
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 quark_compactTest_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_compactTest_cpu_free(int thr_id);
|
||||
extern void quark_compactTest_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *inpHashes, uint32_t *d_validNonceTable,
|
||||
uint32_t *d_nonces1, uint32_t *nrm1, uint32_t *d_nonces2, uint32_t *nrm2, int order);
|
||||
extern void quark_compactTest_single_false_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *inpHashes, uint32_t *d_validNonceTable,
|
||||
uint32_t *d_nonces1, uint32_t *nrm1, int order);
|
||||
|
||||
extern uint32_t cuda_check_hash_branch(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_inputHash, int order);
|
||||
@@ -2,10 +2,14 @@
|
||||
#include <memory.h>
|
||||
#include <sys/types.h> // off_t
|
||||
|
||||
#include "miner.h"
|
||||
#include "cuda_helper.h"
|
||||
|
||||
#define ROTR(x,n) ROTR64(x,n)
|
||||
|
||||
// use sp kernel on SM 5+
|
||||
#define SP_KERNEL
|
||||
|
||||
#define USE_SHUFFLE 0
|
||||
|
||||
__constant__
|
||||
@@ -14,23 +18,26 @@ static uint64_t c_PaddedMessage80[16]; // padded message (80 bytes + padding)
|
||||
// ---------------------------- BEGIN CUDA quark_blake512 functions ------------------------------------
|
||||
|
||||
__device__ __constant__
|
||||
static const uint8_t c_sigma[16][16] = {
|
||||
static const uint8_t c_sigma_big[16][16] = {
|
||||
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
|
||||
{14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
|
||||
{11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
|
||||
{ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
|
||||
{ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
|
||||
{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },
|
||||
|
||||
{12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
|
||||
{13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
|
||||
{ 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 },
|
||||
{10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13 , 0 },
|
||||
|
||||
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
|
||||
{14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
|
||||
{11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
|
||||
{ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
|
||||
{ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
|
||||
{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 }};
|
||||
{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 }
|
||||
};
|
||||
|
||||
__device__ __constant__
|
||||
static const uint64_t c_u512[16] =
|
||||
@@ -59,7 +66,7 @@ static const uint64_t c_u512[16] =
|
||||
}
|
||||
|
||||
__device__ __forceinline__
|
||||
void quark_blake512_compress( uint64_t *h, const uint64_t *block, const uint8_t ((*sigma)[16]), const uint64_t *u512, const int T0)
|
||||
void quark_blake512_compress(uint64_t *h, const uint64_t *block, const uint8_t ((*sigma)[16]), const uint64_t *u512, const int T0)
|
||||
{
|
||||
uint64_t v[16];
|
||||
uint64_t m[16];
|
||||
@@ -107,16 +114,10 @@ void quark_blake512_compress( uint64_t *h, const uint64_t *block, const uint8_t
|
||||
h[7] ^= v[7] ^ v[15];
|
||||
}
|
||||
|
||||
// Hash-Padding
|
||||
__device__ __constant__
|
||||
static const uint64_t d_constHashPadding[8] = {
|
||||
0x0000000000000080ull, 0, 0, 0,
|
||||
0, 0x0100000000000000ull, 0, 0x0002000000000000ull
|
||||
};
|
||||
|
||||
__global__ __launch_bounds__(256, 4)
|
||||
void quark_blake512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint32_t *g_nonceVector, uint64_t *g_hash)
|
||||
{
|
||||
#if !defined(SP_KERNEL) || __CUDA_ARCH__ < 500
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
|
||||
#if USE_SHUFFLE
|
||||
@@ -152,12 +153,18 @@ void quark_blake512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint32_t
|
||||
for (int i=0; i < 8; ++i)
|
||||
buf[i] = inpHash[i];
|
||||
|
||||
#pragma unroll 8
|
||||
for (int i=0; i < 8; i++)
|
||||
buf[i+8] = d_constHashPadding[i];
|
||||
// Hash Pad
|
||||
buf[8] = 0x0000000000000080ull;
|
||||
buf[9] = 0;
|
||||
buf[10] = 0;
|
||||
buf[11] = 0;
|
||||
buf[12] = 0;
|
||||
buf[13] = 0x0100000000000000ull;
|
||||
buf[14] = 0;
|
||||
buf[15] = 0x0002000000000000ull;
|
||||
|
||||
// Ending round
|
||||
quark_blake512_compress( h, buf, c_sigma, c_u512, 512 );
|
||||
quark_blake512_compress(h, buf, c_sigma_big, c_u512, 512);
|
||||
|
||||
#if __CUDA_ARCH__ <= 350
|
||||
uint32_t *outHash = (uint32_t*)&g_hash[hashPosition * 8U];
|
||||
@@ -173,11 +180,13 @@ void quark_blake512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint32_t
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#endif /* SP */
|
||||
}
|
||||
|
||||
__global__ __launch_bounds__(256,4)
|
||||
void quark_blake512_gpu_hash_80(uint32_t threads, uint32_t startNounce, void *outputHash)
|
||||
{
|
||||
//#if !defined(SP_KERNEL) || __CUDA_ARCH__ < 500
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
@@ -201,7 +210,7 @@ void quark_blake512_gpu_hash_80(uint32_t threads, uint32_t startNounce, void *ou
|
||||
0x5be0cd19137e2179ULL
|
||||
};
|
||||
|
||||
quark_blake512_compress(h, buf, c_sigma, c_u512, 640);
|
||||
quark_blake512_compress(h, buf, c_sigma_big, c_u512, 640);
|
||||
|
||||
#if __CUDA_ARCH__ <= 350
|
||||
uint32_t *outHash = (uint32_t*)outputHash + (thread * 16U);
|
||||
@@ -217,54 +226,94 @@ void quark_blake512_gpu_hash_80(uint32_t threads, uint32_t startNounce, void *ou
|
||||
}
|
||||
#endif
|
||||
}
|
||||
//#endif
|
||||
}
|
||||
|
||||
#ifdef SP_KERNEL
|
||||
#include "cuda_quark_blake512_sp.cuh"
|
||||
#endif
|
||||
|
||||
__host__
|
||||
void quark_blake512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_outputHash, int order)
|
||||
{
|
||||
#ifdef SP_KERNEL
|
||||
int dev_id = device_map[thr_id];
|
||||
if (device_sm[dev_id] >= 500 && cuda_arch[dev_id] >= 500)
|
||||
quark_blake512_cpu_hash_64_sp(threads, startNounce, d_nonceVector, d_outputHash);
|
||||
else
|
||||
#endif
|
||||
{
|
||||
const uint32_t threadsperblock = 256;
|
||||
dim3 grid((threads + threadsperblock-1)/threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
quark_blake512_gpu_hash_64<<<grid, block>>>(threads, startNounce, d_nonceVector, (uint64_t*)d_outputHash);
|
||||
}
|
||||
MyStreamSynchronize(NULL, order, thr_id);
|
||||
}
|
||||
|
||||
__host__
|
||||
void quark_blake512_cpu_hash_80(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_outputHash)
|
||||
{
|
||||
#ifdef SP_KERNEL
|
||||
int dev_id = device_map[thr_id];
|
||||
if (device_sm[dev_id] >= 500 && cuda_arch[dev_id] >= 500)
|
||||
quark_blake512_cpu_hash_80_sp(threads, startNounce, d_outputHash);
|
||||
else
|
||||
#endif
|
||||
{
|
||||
const uint32_t threadsperblock = 256;
|
||||
dim3 grid((threads + threadsperblock-1)/threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
|
||||
quark_blake512_gpu_hash_80<<<grid, block>>>(threads, startNounce, d_outputHash);
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------- END CUDA quark_blake512 functions ------------------------------------
|
||||
|
||||
__host__
|
||||
void quark_blake512_cpu_init(int thr_id, uint32_t threads)
|
||||
{
|
||||
CUDA_SAFE_CALL(cudaGetLastError());
|
||||
cuda_get_arch(thr_id);
|
||||
}
|
||||
|
||||
__host__
|
||||
void quark_blake512_cpu_setBlock_80(int thr_id, uint32_t *pdata)
|
||||
void quark_blake512_cpu_free(int thr_id)
|
||||
{
|
||||
uint64_t message[16];
|
||||
}
|
||||
|
||||
memcpy(message, pdata, 80);
|
||||
message[10] = 0x80;
|
||||
message[11] = 0;
|
||||
message[12] = 0;
|
||||
message[13] = 0x0100000000000000ull;
|
||||
message[14] = 0;
|
||||
message[15] = 0x8002000000000000ull; // 0x280
|
||||
// ----------------------------- Host midstate for 80-bytes input ------------------------------------
|
||||
|
||||
cudaMemcpyToSymbol(c_PaddedMessage80, message, sizeof(message), 0, cudaMemcpyHostToDevice);
|
||||
CUDA_SAFE_CALL(cudaGetLastError());
|
||||
#undef SPH_C32
|
||||
#undef SPH_T32
|
||||
#undef SPH_C64
|
||||
#undef SPH_T64
|
||||
|
||||
extern "C" {
|
||||
#include "sph/sph_blake.h"
|
||||
}
|
||||
|
||||
__host__
|
||||
void quark_blake512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_outputHash, int order)
|
||||
void quark_blake512_cpu_setBlock_80(int thr_id, uint32_t *endiandata)
|
||||
{
|
||||
const uint32_t threadsperblock = 256;
|
||||
#ifdef SP_KERNEL
|
||||
int dev_id = device_map[thr_id];
|
||||
if (device_sm[dev_id] >= 500 && cuda_arch[dev_id] >= 500)
|
||||
quark_blake512_cpu_setBlock_80_sp(thr_id, (uint64_t*) endiandata);
|
||||
else
|
||||
#endif
|
||||
{
|
||||
uint64_t message[16];
|
||||
|
||||
dim3 grid((threads + threadsperblock-1)/threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
memcpy(message, endiandata, 80);
|
||||
message[10] = 0x80;
|
||||
message[11] = 0;
|
||||
message[12] = 0;
|
||||
message[13] = 0x0100000000000000ull;
|
||||
message[14] = 0;
|
||||
message[15] = 0x8002000000000000ull; // 0x280
|
||||
|
||||
quark_blake512_gpu_hash_64<<<grid, block>>>(threads, startNounce, d_nonceVector, (uint64_t*)d_outputHash);
|
||||
|
||||
//MyStreamSynchronize(NULL, order, thr_id);
|
||||
}
|
||||
|
||||
__host__
|
||||
void quark_blake512_cpu_hash_80(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_outputHash)
|
||||
{
|
||||
const uint32_t threadsperblock = 256;
|
||||
|
||||
dim3 grid((threads + threadsperblock-1)/threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
|
||||
quark_blake512_gpu_hash_80<<<grid, block>>>(threads, startNounce, d_outputHash);
|
||||
cudaMemcpyToSymbol(c_PaddedMessage80, message, sizeof(message), 0, cudaMemcpyHostToDevice);
|
||||
}
|
||||
CUDA_LOG_ERROR();
|
||||
}
|
||||
@@ -0,0 +1,665 @@
|
||||
/* sp implementation of blake */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <memory.h>
|
||||
#include "miner.h"
|
||||
|
||||
// Should stay outside the ifdef on WIN64 (wtf)
|
||||
#include "cuda_vector_uint2x4.h"
|
||||
__constant__ static uint2 c_PaddedM[16];
|
||||
__constant__ static uint2x4 c_Hostprecalc[4];
|
||||
|
||||
#if __CUDA_ARCH__ >= 500 || !defined(__CUDA_ARCH__)
|
||||
|
||||
#undef G
|
||||
#define vectorizelow(/* uint32_t*/ v) make_uint2(v,0)
|
||||
#define vectorizehigh(/*uint32_t*/ v) make_uint2(0,v)
|
||||
|
||||
static __device__ __forceinline__ uint2 cuda_swap(uint2 v) {
|
||||
const uint32_t t = cuda_swab32(v.x);
|
||||
v.x = cuda_swab32(v.y);
|
||||
v.y = t;
|
||||
return v;
|
||||
}
|
||||
|
||||
|
||||
__constant__ uint2 c_512_u2[16] =
|
||||
{
|
||||
{ 0x85a308d3UL, 0x243f6a88 }, { 0x03707344UL, 0x13198a2e },
|
||||
{ 0x299f31d0UL, 0xa4093822 }, { 0xec4e6c89UL, 0x082efa98 },
|
||||
{ 0x38d01377UL, 0x452821e6 }, { 0x34e90c6cUL, 0xbe5466cf },
|
||||
{ 0xc97c50ddUL, 0xc0ac29b7 }, { 0xb5470917UL, 0x3f84d5b5 },
|
||||
{ 0x8979fb1bUL, 0x9216d5d9 }, { 0x98dfb5acUL, 0xd1310ba6 },
|
||||
{ 0xd01adfb7UL, 0x2ffd72db }, { 0x6a267e96UL, 0xb8e1afed },
|
||||
{ 0xf12c7f99UL, 0xba7c9045 }, { 0xb3916cf7UL, 0x24a19947 },
|
||||
{ 0x858efc16UL, 0x0801f2e2 }, { 0x71574e69UL, 0x636920d8 }
|
||||
};
|
||||
|
||||
__constant__ uint8_t c_sigma[6][16] = {
|
||||
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
|
||||
{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
|
||||
{ 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
|
||||
{ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
|
||||
{ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
|
||||
{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 }
|
||||
};
|
||||
|
||||
// ---------------------------- BEGIN CUDA quark_blake512 functions ------------------------------------
|
||||
|
||||
#define Gprecalc(a,b,c,d,idx1,idx2) { \
|
||||
v[a] += (block[idx2] ^ c_512_u2[idx1]) + v[b]; \
|
||||
v[d] = eorswap32( v[d] , v[a]); \
|
||||
v[c] += v[d]; \
|
||||
v[b] = ROR2(v[b] ^ v[c], 25); \
|
||||
v[a] += (block[idx1] ^ c_512_u2[idx2]) + v[b]; \
|
||||
v[d] = ROR16(v[d] ^ v[a]); \
|
||||
v[c] += v[d]; \
|
||||
v[b] = ROR2(v[b] ^ v[c], 11); \
|
||||
}
|
||||
|
||||
#define GprecalcHost(a,b,c,d,idx1,idx2) { \
|
||||
v[a] += (block[idx2] ^ u512[idx1]) + v[b]; \
|
||||
v[d] = ROTR64( v[d] ^ v[a],32); \
|
||||
v[c] += v[d]; \
|
||||
v[b] = ROTR64(v[b] ^ v[c], 25); \
|
||||
v[a] += (block[idx1] ^ u512[idx2]) + v[b]; \
|
||||
v[d] = ROTR64(v[d] ^ v[a],16); \
|
||||
v[c] += v[d]; \
|
||||
v[b] = ROTR64(v[b] ^ v[c], 11); \
|
||||
}
|
||||
|
||||
#define G(a,b,c,d,x) { \
|
||||
uint32_t idx1 = c_sigma[i][x]; \
|
||||
uint32_t idx2 = c_sigma[i][x+1]; \
|
||||
v[a] += (block[idx1] ^ c_512_u2[idx2]) + v[b]; \
|
||||
v[d] = eorswap32(v[d] , v[a]); \
|
||||
v[c] += v[d]; \
|
||||
v[b] = ROR2( v[b] ^ v[c], 25); \
|
||||
v[a] += (block[idx2] ^ c_512_u2[idx1]) + v[b]; \
|
||||
v[d] = ROR16( v[d] ^ v[a]); \
|
||||
v[c] += v[d]; \
|
||||
v[b] = ROR2( v[b] ^ v[c], 11); \
|
||||
}
|
||||
|
||||
__global__
|
||||
#if __CUDA_ARCH__ > 500
|
||||
__launch_bounds__(256, 1)
|
||||
#endif
|
||||
void quark_blake512_gpu_hash_64_sp(uint32_t threads, uint32_t startNounce, uint32_t *const __restrict__ g_nonceVector, uint2* g_hash)
|
||||
{
|
||||
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);
|
||||
const uint32_t hashPosition = nounce - startNounce;
|
||||
|
||||
uint2 msg[16];
|
||||
|
||||
uint2x4 *phash = (uint2x4*)&g_hash[hashPosition * 8U];
|
||||
uint2x4 *outpt = (uint2x4*)msg;
|
||||
outpt[0] = phash[0];
|
||||
outpt[1] = phash[1];
|
||||
|
||||
uint2 block[16];
|
||||
block[0].x = cuda_swab32(msg[0].y);
|
||||
block[0].y = cuda_swab32(msg[0].x);
|
||||
block[1].x = cuda_swab32(msg[1].y);
|
||||
block[1].y = cuda_swab32(msg[1].x);
|
||||
block[2].x = cuda_swab32(msg[2].y);
|
||||
block[2].y = cuda_swab32(msg[2].x);
|
||||
block[3].x = cuda_swab32(msg[3].y);
|
||||
block[3].y = cuda_swab32(msg[3].x);
|
||||
block[4].x = cuda_swab32(msg[4].y);
|
||||
block[4].y = cuda_swab32(msg[4].x);
|
||||
block[5].x = cuda_swab32(msg[5].y);
|
||||
block[5].y = cuda_swab32(msg[5].x);
|
||||
block[6].x = cuda_swab32(msg[6].y);
|
||||
block[6].y = cuda_swab32(msg[6].x);
|
||||
block[7].x = cuda_swab32(msg[7].y);
|
||||
block[7].y = cuda_swab32(msg[7].x);
|
||||
|
||||
block[8] = vectorizehigh(0x80000000);
|
||||
block[9] = vectorizelow(0x0);
|
||||
block[10] = vectorizelow(0x0);
|
||||
block[11] = vectorizelow(0x0);
|
||||
block[12] = vectorizelow(0x0);
|
||||
block[13] = vectorizelow(0x1);
|
||||
block[14] = vectorizelow(0x0);
|
||||
block[15] = vectorizelow(0x200);
|
||||
|
||||
const uint2 h[8] = {
|
||||
{ 0xf3bcc908UL, 0x6a09e667UL },
|
||||
{ 0x84caa73bUL, 0xbb67ae85UL },
|
||||
{ 0xfe94f82bUL, 0x3c6ef372UL },
|
||||
{ 0x5f1d36f1UL, 0xa54ff53aUL },
|
||||
{ 0xade682d1UL, 0x510e527fUL },
|
||||
{ 0x2b3e6c1fUL, 0x9b05688cUL },
|
||||
{ 0xfb41bd6bUL, 0x1f83d9abUL },
|
||||
{ 0x137e2179UL, 0x5be0cd19UL }
|
||||
};
|
||||
|
||||
uint2 v[16] = {
|
||||
h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7],
|
||||
c_512_u2[0], c_512_u2[1], c_512_u2[2], c_512_u2[3],
|
||||
c_512_u2[4], c_512_u2[5], c_512_u2[6], c_512_u2[7]
|
||||
};
|
||||
v[12].x ^= 512U;
|
||||
v[13].x ^= 512U;
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0x1, 0x0)
|
||||
Gprecalc(1, 5, 9, 13, 0x3, 0x2)
|
||||
Gprecalc(2, 6, 10, 14, 0x5, 0x4)
|
||||
Gprecalc(3, 7, 11, 15, 0x7, 0x6)
|
||||
Gprecalc(0, 5, 10, 15, 0x9, 0x8)
|
||||
Gprecalc(1, 6, 11, 12, 0xb, 0xa)
|
||||
Gprecalc(2, 7, 8, 13, 0xd, 0xc)
|
||||
Gprecalc(3, 4, 9, 14, 0xf, 0xe)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0xa, 0xe)
|
||||
Gprecalc(1, 5, 9, 13, 0x8, 0x4)
|
||||
Gprecalc(2, 6, 10, 14, 0xf, 0x9)
|
||||
Gprecalc(3, 7, 11, 15, 0x6, 0xd)
|
||||
Gprecalc(0, 5, 10, 15, 0xc, 0x1)
|
||||
Gprecalc(1, 6, 11, 12, 0x2, 0x0)
|
||||
Gprecalc(2, 7, 8, 13, 0x7, 0xb)
|
||||
Gprecalc(3, 4, 9, 14, 0x3, 0x5)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0x8, 0xb)
|
||||
Gprecalc(1, 5, 9, 13, 0x0, 0xc)
|
||||
Gprecalc(2, 6, 10, 14, 0x2, 0x5)
|
||||
Gprecalc(3, 7, 11, 15, 0xd, 0xf)
|
||||
Gprecalc(0, 5, 10, 15, 0xe, 0xa)
|
||||
Gprecalc(1, 6, 11, 12, 0x6, 0x3)
|
||||
Gprecalc(2, 7, 8, 13, 0x1, 0x7)
|
||||
Gprecalc(3, 4, 9, 14, 0x4, 0x9)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0x9, 0x7)
|
||||
Gprecalc(1, 5, 9, 13, 0x1, 0x3)
|
||||
Gprecalc(2, 6, 10, 14, 0xc, 0xd)
|
||||
Gprecalc(3, 7, 11, 15, 0xe, 0xb)
|
||||
Gprecalc(0, 5, 10, 15, 0x6, 0x2)
|
||||
Gprecalc(1, 6, 11, 12, 0xa, 0x5)
|
||||
Gprecalc(2, 7, 8, 13, 0x0, 0x4)
|
||||
Gprecalc(3, 4, 9, 14, 0x8, 0xf)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0x0, 0x9)
|
||||
Gprecalc(1, 5, 9, 13, 0x7, 0x5)
|
||||
Gprecalc(2, 6, 10, 14, 0x4, 0x2)
|
||||
Gprecalc(3, 7, 11, 15, 0xf, 0xa)
|
||||
Gprecalc(0, 5, 10, 15, 0x1, 0xe)
|
||||
Gprecalc(1, 6, 11, 12, 0xc, 0xb)
|
||||
Gprecalc(2, 7, 8, 13, 0x8, 0x6)
|
||||
Gprecalc(3, 4, 9, 14, 0xd, 0x3)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0xc, 0x2)
|
||||
Gprecalc(1, 5, 9, 13, 0xa, 0x6)
|
||||
Gprecalc(2, 6, 10, 14, 0xb, 0x0)
|
||||
Gprecalc(3, 7, 11, 15, 0x3, 0x8)
|
||||
Gprecalc(0, 5, 10, 15, 0xd, 0x4)
|
||||
Gprecalc(1, 6, 11, 12, 0x5, 0x7)
|
||||
Gprecalc(2, 7, 8, 13, 0xe, 0xf)
|
||||
Gprecalc(3, 4, 9, 14, 0x9, 0x1)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0x5, 0xc)
|
||||
Gprecalc(1, 5, 9, 13, 0xf, 0x1)
|
||||
Gprecalc(2, 6, 10, 14, 0xd, 0xe)
|
||||
Gprecalc(3, 7, 11, 15, 0xa, 0x4)
|
||||
Gprecalc(0, 5, 10, 15, 0x7, 0x0)
|
||||
Gprecalc(1, 6, 11, 12, 0x3, 0x6)
|
||||
Gprecalc(2, 7, 8, 13, 0x2, 0x9)
|
||||
Gprecalc(3, 4, 9, 14, 0xb, 0x8)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0xb, 0xd)
|
||||
Gprecalc(1, 5, 9, 13, 0xe, 0x7)
|
||||
Gprecalc(2, 6, 10, 14, 0x1, 0xc)
|
||||
Gprecalc(3, 7, 11, 15, 0x9, 0x3)
|
||||
Gprecalc(0, 5, 10, 15, 0x0, 0x5)
|
||||
Gprecalc(1, 6, 11, 12, 0x4, 0xf)
|
||||
Gprecalc(2, 7, 8, 13, 0x6, 0x8)
|
||||
Gprecalc(3, 4, 9, 14, 0xa, 0x2)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0xf, 0x6)
|
||||
Gprecalc(1, 5, 9, 13, 0x9, 0xe)
|
||||
Gprecalc(2, 6, 10, 14, 0x3, 0xb)
|
||||
Gprecalc(3, 7, 11, 15, 0x8, 0x0)
|
||||
Gprecalc(0, 5, 10, 15, 0x2, 0xc)
|
||||
Gprecalc(1, 6, 11, 12, 0x7, 0xd)
|
||||
Gprecalc(2, 7, 8, 13, 0x4, 0x1)
|
||||
Gprecalc(3, 4, 9, 14, 0x5, 0xa)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0x2, 0xa)
|
||||
Gprecalc(1, 5, 9, 13, 0x4, 0x8)
|
||||
Gprecalc(2, 6, 10, 14, 0x6, 0x7)
|
||||
Gprecalc(3, 7, 11, 15, 0x5, 0x1)
|
||||
Gprecalc(0, 5, 10, 15, 0xb, 0xf)
|
||||
Gprecalc(1, 6, 11, 12, 0xe, 0x9)
|
||||
Gprecalc(2, 7, 8, 13, 0xc, 0x3)
|
||||
Gprecalc(3, 4, 9, 14, 0x0, 0xd)
|
||||
|
||||
#if __CUDA_ARCH__ == 500
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0x1, 0x0)
|
||||
Gprecalc(1, 5, 9, 13, 0x3, 0x2)
|
||||
Gprecalc(2, 6, 10, 14, 0x5, 0x4)
|
||||
Gprecalc(3, 7, 11, 15, 0x7, 0x6)
|
||||
Gprecalc(0, 5, 10, 15, 0x9, 0x8)
|
||||
Gprecalc(1, 6, 11, 12, 0xb, 0xa)
|
||||
Gprecalc(2, 7, 8, 13, 0xd, 0xc)
|
||||
Gprecalc(3, 4, 9, 14, 0xf, 0xe)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0xa, 0xe)
|
||||
Gprecalc(1, 5, 9, 13, 0x8, 0x4)
|
||||
Gprecalc(2, 6, 10, 14, 0xf, 0x9)
|
||||
Gprecalc(3, 7, 11, 15, 0x6, 0xd)
|
||||
Gprecalc(0, 5, 10, 15, 0xc, 0x1)
|
||||
Gprecalc(1, 6, 11, 12, 0x2, 0x0)
|
||||
Gprecalc(2, 7, 8, 13, 0x7, 0xb)
|
||||
Gprecalc(3, 4, 9, 14, 0x3, 0x5)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0x8, 0xb)
|
||||
Gprecalc(1, 5, 9, 13, 0x0, 0xc)
|
||||
Gprecalc(2, 6, 10, 14, 0x2, 0x5)
|
||||
Gprecalc(3, 7, 11, 15, 0xd, 0xf)
|
||||
Gprecalc(0, 5, 10, 15, 0xe, 0xa)
|
||||
Gprecalc(1, 6, 11, 12, 0x6, 0x3)
|
||||
Gprecalc(2, 7, 8, 13, 0x1, 0x7)
|
||||
Gprecalc(3, 4, 9, 14, 0x4, 0x9)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0x9, 0x7)
|
||||
Gprecalc(1, 5, 9, 13, 0x1, 0x3)
|
||||
Gprecalc(2, 6, 10, 14, 0xc, 0xd)
|
||||
Gprecalc(3, 7, 11, 15, 0xe, 0xb)
|
||||
Gprecalc(0, 5, 10, 15, 0x6, 0x2)
|
||||
Gprecalc(1, 6, 11, 12, 0xa, 0x5)
|
||||
Gprecalc(2, 7, 8, 13, 0x0, 0x4)
|
||||
Gprecalc(3, 4, 9, 14, 0x8, 0xf)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0x0, 0x9)
|
||||
Gprecalc(1, 5, 9, 13, 0x7, 0x5)
|
||||
Gprecalc(2, 6, 10, 14, 0x4, 0x2)
|
||||
Gprecalc(3, 7, 11, 15, 0xf, 0xa)
|
||||
Gprecalc(0, 5, 10, 15, 0x1, 0xe)
|
||||
Gprecalc(1, 6, 11, 12, 0xc, 0xb)
|
||||
Gprecalc(2, 7, 8, 13, 0x8, 0x6)
|
||||
Gprecalc(3, 4, 9, 14, 0xd, 0x3)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0xc, 0x2)
|
||||
Gprecalc(1, 5, 9, 13, 0xa, 0x6)
|
||||
Gprecalc(2, 6, 10, 14, 0xb, 0x0)
|
||||
Gprecalc(3, 7, 11, 15, 0x3, 0x8)
|
||||
Gprecalc(0, 5, 10, 15, 0xd, 0x4)
|
||||
Gprecalc(1, 6, 11, 12, 0x5, 0x7)
|
||||
Gprecalc(2, 7, 8, 13, 0xe, 0xf)
|
||||
Gprecalc(3, 4, 9, 14, 0x9, 0x1)
|
||||
|
||||
#else
|
||||
|
||||
for (int i = 0; i < 6; i++)
|
||||
{
|
||||
/* column step */
|
||||
G(0, 4, 8, 12, 0);
|
||||
G(1, 5, 9, 13, 2);
|
||||
G(2, 6, 10, 14, 4);
|
||||
G(3, 7, 11, 15, 6);
|
||||
/* diagonal step */
|
||||
G(0, 5, 10, 15, 8);
|
||||
G(1, 6, 11, 12, 10);
|
||||
G(2, 7, 8, 13, 12);
|
||||
G(3, 4, 9, 14, 14);
|
||||
}
|
||||
#endif
|
||||
|
||||
v[0] = cuda_swap(h[0] ^ v[0] ^ v[8]);
|
||||
v[1] = cuda_swap(h[1] ^ v[1] ^ v[9]);
|
||||
v[2] = cuda_swap(h[2] ^ v[2] ^ v[10]);
|
||||
v[3] = cuda_swap(h[3] ^ v[3] ^ v[11]);
|
||||
v[4] = cuda_swap(h[4] ^ v[4] ^ v[12]);
|
||||
v[5] = cuda_swap(h[5] ^ v[5] ^ v[13]);
|
||||
v[6] = cuda_swap(h[6] ^ v[6] ^ v[14]);
|
||||
v[7] = cuda_swap(h[7] ^ v[7] ^ v[15]);
|
||||
|
||||
phash = (uint2x4*)v;
|
||||
outpt = (uint2x4*)&g_hash[hashPosition * 8U];
|
||||
outpt[0] = phash[0];
|
||||
outpt[1] = phash[1];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
__global__
|
||||
__launch_bounds__(128, 8)
|
||||
void quark_blake512_gpu_hash_80_sp(uint32_t threads, uint32_t startNounce, uint2 *outputHash)
|
||||
{
|
||||
const uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
const uint32_t nounce = startNounce + thread;
|
||||
uint2 block[16];
|
||||
|
||||
block[0] = c_PaddedM[0];
|
||||
block[1] = c_PaddedM[1];
|
||||
block[2] = c_PaddedM[2];
|
||||
block[3] = c_PaddedM[3];
|
||||
block[4] = c_PaddedM[4];
|
||||
block[5] = c_PaddedM[5];
|
||||
block[6] = c_PaddedM[6];
|
||||
block[7] = c_PaddedM[7];
|
||||
block[8] = c_PaddedM[8];
|
||||
block[9].y = c_PaddedM[9].y;
|
||||
|
||||
block[10] = vectorizehigh(0x80000000);
|
||||
block[11] = vectorizelow(0);
|
||||
block[12] = vectorizelow(0);
|
||||
block[13] = vectorizelow(0x1);
|
||||
block[14] = vectorizelow(0);
|
||||
block[15] = vectorizelow(0x280);
|
||||
block[9].x = nounce;
|
||||
|
||||
const uint2 h[8] = {
|
||||
{ 0xf3bcc908UL, 0x6a09e667UL },
|
||||
{ 0x84caa73bUL, 0xbb67ae85UL },
|
||||
{ 0xfe94f82bUL, 0x3c6ef372UL },
|
||||
{ 0x5f1d36f1UL, 0xa54ff53aUL },
|
||||
{ 0xade682d1UL, 0x510e527fUL },
|
||||
{ 0x2b3e6c1fUL, 0x9b05688cUL },
|
||||
{ 0xfb41bd6bUL, 0x1f83d9abUL },
|
||||
{ 0x137e2179UL, 0x5be0cd19UL }
|
||||
};
|
||||
|
||||
uint2 v[16];
|
||||
uint2x4 *outpt = (uint2x4*)v;
|
||||
|
||||
outpt[0] = c_Hostprecalc[0];
|
||||
outpt[1] = c_Hostprecalc[1];
|
||||
outpt[2] = c_Hostprecalc[2];
|
||||
outpt[3] = c_Hostprecalc[3];
|
||||
|
||||
v[0] += (block[9] ^ c_512_u2[8]);
|
||||
v[15] = ROR16(v[15] ^ v[0]);
|
||||
v[10] += v[15];
|
||||
v[5] = ROR2(v[5] ^ v[10], 11);
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0xa, 0xe)
|
||||
|
||||
// Gprecalc(1, 5, 9, 13, 0x8, 0x4)
|
||||
v[1] += v[5];
|
||||
v[13] = eorswap32(v[13], v[1]);
|
||||
v[9] += v[13];
|
||||
|
||||
v[5] = ROR2(v[5] ^ v[9], 25);
|
||||
v[1] += (block[8] ^ c_512_u2[4]) + v[5];
|
||||
v[13] = ROR16(v[13] ^ v[1]);
|
||||
v[9] += v[13];
|
||||
v[5] = ROR2(v[5] ^ v[9], 11);
|
||||
|
||||
// Gprecalc(2, 6, 10, 14, 0xf, 0x9)
|
||||
v[2] += (block[9] ^ c_512_u2[0xf]);
|
||||
v[14] = eorswap32(v[14], v[2]);
|
||||
v[10] += v[14];
|
||||
v[6] = ROR2(v[6] ^ v[10], 25);
|
||||
v[2] += (block[0xf] ^ c_512_u2[9]) + v[6];
|
||||
v[14] = ROR16(v[14] ^ v[2]);
|
||||
v[10] += v[14];
|
||||
v[6] = ROR2(v[6] ^ v[10], 11);
|
||||
|
||||
// Gprecalc(3, 7, 11, 15, 0x6, 0xd)
|
||||
v[15] = eorswap32( v[15] , v[3]);
|
||||
v[11] += v[15];
|
||||
v[7] = ROR2(v[7] ^ v[11], 25);
|
||||
v[3] += (block[6] ^ c_512_u2[0xd]) + v[7];
|
||||
v[15] = ROR16(v[15] ^ v[3]);
|
||||
v[11] += v[15];
|
||||
v[7] = ROR2(v[7] ^ v[11], 11);
|
||||
|
||||
Gprecalc(0, 5, 10, 15, 0xc, 0x1)
|
||||
Gprecalc(1, 6, 11, 12, 0x2, 0x0)
|
||||
Gprecalc(2, 7, 8, 13, 0x7, 0xb)
|
||||
Gprecalc(3, 4, 9, 14, 0x3, 0x5)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0x8, 0xb)
|
||||
Gprecalc(1, 5, 9, 13, 0x0, 0xc)
|
||||
Gprecalc(2, 6, 10, 14, 0x2, 0x5)
|
||||
Gprecalc(3, 7, 11, 15, 0xd, 0xf)
|
||||
Gprecalc(0, 5, 10, 15, 0xe, 0xa)
|
||||
Gprecalc(1, 6, 11, 12, 0x6, 0x3)
|
||||
Gprecalc(2, 7, 8, 13, 0x1, 0x7)
|
||||
Gprecalc(3, 4, 9, 14, 0x4, 0x9)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0x9, 0x7)
|
||||
Gprecalc(1, 5, 9, 13, 0x1, 0x3)
|
||||
Gprecalc(2, 6, 10, 14, 0xc, 0xd)
|
||||
Gprecalc(3, 7, 11, 15, 0xe, 0xb)
|
||||
Gprecalc(0, 5, 10, 15, 0x6, 0x2)
|
||||
Gprecalc(1, 6, 11, 12, 0xa, 0x5)
|
||||
Gprecalc(2, 7, 8, 13, 0x0, 0x4)
|
||||
Gprecalc(3, 4, 9, 14, 0x8, 0xf)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0x0, 0x9)
|
||||
Gprecalc(1, 5, 9, 13, 0x7, 0x5)
|
||||
Gprecalc(2, 6, 10, 14, 0x4, 0x2)
|
||||
Gprecalc(3, 7, 11, 15, 0xf, 0xa)
|
||||
Gprecalc(0, 5, 10, 15, 0x1, 0xe)
|
||||
Gprecalc(1, 6, 11, 12, 0xc, 0xb)
|
||||
Gprecalc(2, 7, 8, 13, 0x8, 0x6)
|
||||
Gprecalc(3, 4, 9, 14, 0xd, 0x3)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0xc, 0x2)
|
||||
Gprecalc(1, 5, 9, 13, 0xa, 0x6)
|
||||
Gprecalc(2, 6, 10, 14, 0xb, 0x0)
|
||||
Gprecalc(3, 7, 11, 15, 0x3, 0x8)
|
||||
Gprecalc(0, 5, 10, 15, 0xd, 0x4)
|
||||
Gprecalc(1, 6, 11, 12, 0x5, 0x7)
|
||||
Gprecalc(2, 7, 8, 13, 0xe, 0xf)
|
||||
Gprecalc(3, 4, 9, 14, 0x9, 0x1)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0x5, 0xc)
|
||||
Gprecalc(1, 5, 9, 13, 0xf, 0x1)
|
||||
Gprecalc(2, 6, 10, 14, 0xd, 0xe)
|
||||
Gprecalc(3, 7, 11, 15, 0xa, 0x4)
|
||||
Gprecalc(0, 5, 10, 15, 0x7, 0x0)
|
||||
Gprecalc(1, 6, 11, 12, 0x3, 0x6)
|
||||
Gprecalc(2, 7, 8, 13, 0x2, 0x9)
|
||||
Gprecalc(3, 4, 9, 14, 0xb, 0x8)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0xb, 0xd)
|
||||
Gprecalc(1, 5, 9, 13, 0xe, 0x7)
|
||||
Gprecalc(2, 6, 10, 14, 0x1, 0xc)
|
||||
Gprecalc(3, 7, 11, 15, 0x9, 0x3)
|
||||
Gprecalc(0, 5, 10, 15, 0x0, 0x5)
|
||||
Gprecalc(1, 6, 11, 12, 0x4, 0xf)
|
||||
Gprecalc(2, 7, 8, 13, 0x6, 0x8)
|
||||
Gprecalc(3, 4, 9, 14, 0xa, 0x2)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0xf, 0x6)
|
||||
Gprecalc(1, 5, 9, 13, 0x9, 0xe)
|
||||
Gprecalc(2, 6, 10, 14, 0x3, 0xb)
|
||||
Gprecalc(3, 7, 11, 15, 0x8, 0x0)
|
||||
Gprecalc(0, 5, 10, 15, 0x2, 0xc)
|
||||
Gprecalc(1, 6, 11, 12, 0x7, 0xd)
|
||||
Gprecalc(2, 7, 8, 13, 0x4, 0x1)
|
||||
Gprecalc(3, 4, 9, 14, 0x5, 0xa)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0x2, 0xa)
|
||||
Gprecalc(1, 5, 9, 13, 0x4, 0x8)
|
||||
Gprecalc(2, 6, 10, 14, 0x6, 0x7)
|
||||
Gprecalc(3, 7, 11, 15, 0x5, 0x1)
|
||||
Gprecalc(0, 5, 10, 15, 0xb, 0xf)
|
||||
Gprecalc(1, 6, 11, 12, 0xe, 0x9)
|
||||
Gprecalc(2, 7, 8, 13, 0xc, 0x3)
|
||||
Gprecalc(3, 4, 9, 14, 0x0, 0xd)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0x1, 0x0)
|
||||
Gprecalc(1, 5, 9, 13, 0x3, 0x2)
|
||||
Gprecalc(2, 6, 10, 14, 0x5, 0x4)
|
||||
Gprecalc(3, 7, 11, 15, 0x7, 0x6)
|
||||
Gprecalc(0, 5, 10, 15, 0x9, 0x8)
|
||||
Gprecalc(1, 6, 11, 12, 0xb, 0xa)
|
||||
Gprecalc(2, 7, 8, 13, 0xd, 0xc)
|
||||
Gprecalc(3, 4, 9, 14, 0xf, 0xe)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0xa, 0xe)
|
||||
Gprecalc(1, 5, 9, 13, 0x8, 0x4)
|
||||
Gprecalc(2, 6, 10, 14, 0xf, 0x9)
|
||||
Gprecalc(3, 7, 11, 15, 0x6, 0xd)
|
||||
Gprecalc(0, 5, 10, 15, 0xc, 0x1)
|
||||
Gprecalc(1, 6, 11, 12, 0x2, 0x0)
|
||||
Gprecalc(2, 7, 8, 13, 0x7, 0xb)
|
||||
Gprecalc(3, 4, 9, 14, 0x3, 0x5)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0x8, 0xb)
|
||||
Gprecalc(1, 5, 9, 13, 0x0, 0xc)
|
||||
Gprecalc(2, 6, 10, 14, 0x2, 0x5)
|
||||
Gprecalc(3, 7, 11, 15, 0xd, 0xf)
|
||||
Gprecalc(0, 5, 10, 15, 0xe, 0xa)
|
||||
Gprecalc(1, 6, 11, 12, 0x6, 0x3)
|
||||
Gprecalc(2, 7, 8, 13, 0x1, 0x7)
|
||||
Gprecalc(3, 4, 9, 14, 0x4, 0x9)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0x9, 0x7)
|
||||
Gprecalc(1, 5, 9, 13, 0x1, 0x3)
|
||||
Gprecalc(2, 6, 10, 14, 0xc, 0xd)
|
||||
Gprecalc(3, 7, 11, 15, 0xe, 0xb)
|
||||
Gprecalc(0, 5, 10, 15, 0x6, 0x2)
|
||||
Gprecalc(1, 6, 11, 12, 0xa, 0x5)
|
||||
Gprecalc(2, 7, 8, 13, 0x0, 0x4)
|
||||
Gprecalc(3, 4, 9, 14, 0x8, 0xf)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0x0, 0x9)
|
||||
Gprecalc(1, 5, 9, 13, 0x7, 0x5)
|
||||
Gprecalc(2, 6, 10, 14, 0x4, 0x2)
|
||||
Gprecalc(3, 7, 11, 15, 0xf, 0xa)
|
||||
Gprecalc(0, 5, 10, 15, 0x1, 0xe)
|
||||
Gprecalc(1, 6, 11, 12, 0xc, 0xb)
|
||||
Gprecalc(2, 7, 8, 13, 0x8, 0x6)
|
||||
Gprecalc(3, 4, 9, 14, 0xd, 0x3)
|
||||
|
||||
Gprecalc(0, 4, 8, 12, 0xc, 0x2)
|
||||
Gprecalc(1, 5, 9, 13, 0xa, 0x6)
|
||||
Gprecalc(2, 6, 10, 14, 0xb, 0x0)
|
||||
Gprecalc(3, 7, 11, 15, 0x3, 0x8)
|
||||
Gprecalc(0, 5, 10, 15, 0xd, 0x4)
|
||||
Gprecalc(1, 6, 11, 12, 0x5, 0x7)
|
||||
Gprecalc(2, 7, 8, 13, 0xe, 0xf)
|
||||
Gprecalc(3, 4, 9, 14, 0x9, 0x1)
|
||||
|
||||
v[0] = cuda_swap(h[0] ^ v[0] ^ v[8]);
|
||||
v[1] = cuda_swap(h[1] ^ v[1] ^ v[9]);
|
||||
v[2] = cuda_swap(h[2] ^ v[2] ^ v[10]);
|
||||
v[3] = cuda_swap(h[3] ^ v[3] ^ v[11]);
|
||||
v[4] = cuda_swap(h[4] ^ v[4] ^ v[12]);
|
||||
v[5] = cuda_swap(h[5] ^ v[5] ^ v[13]);
|
||||
v[6] = cuda_swap(h[6] ^ v[6] ^ v[14]);
|
||||
v[7] = cuda_swap(h[7] ^ v[7] ^ v[15]);
|
||||
|
||||
uint2x4 *phash = (uint2x4*)v;
|
||||
outpt = (uint2x4*) &outputHash[thread * 8U];
|
||||
outpt[0] = phash[0];
|
||||
outpt[1] = phash[1];
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------- END CUDA quark_blake512 functions ------------------------------------
|
||||
|
||||
__host__ void quark_blake512_cpu_setBlock_80_sp(int thr_id, uint64_t *pdata)
|
||||
{
|
||||
uint64_t block[16];
|
||||
uint64_t PaddedMessage[10];
|
||||
uint64_t *peker = (uint64_t*) &PaddedMessage[0];
|
||||
for (int i = 0; i < 10; i++)
|
||||
PaddedMessage[i] = cuda_swab64(pdata[i]);
|
||||
|
||||
CUDA_SAFE_CALL(cudaMemcpyToSymbol((c_PaddedM), PaddedMessage, 10 * sizeof(uint64_t)));
|
||||
|
||||
block[0] = peker[0];
|
||||
block[1] = peker[1];
|
||||
block[2] = peker[2];
|
||||
block[3] = peker[3];
|
||||
block[4] = peker[4];
|
||||
block[5] = peker[5];
|
||||
block[6] = peker[6];
|
||||
block[7] = peker[7];
|
||||
block[8] = peker[8];
|
||||
block[9] = peker[9];
|
||||
block[10] = 0x8000000000000000;
|
||||
block[11] = 0;
|
||||
block[12] = 0;
|
||||
block[13] = 1;
|
||||
block[14] = 0;
|
||||
block[15] = 0x280;
|
||||
|
||||
const uint64_t u512[16] = {
|
||||
0x243f6a8885a308d3ULL, 0x13198a2e03707344ULL,
|
||||
0xa4093822299f31d0ULL, 0x082efa98ec4e6c89ULL,
|
||||
0x452821e638d01377ULL, 0xbe5466cf34e90c6cULL,
|
||||
0xc0ac29b7c97c50ddULL, 0x3f84d5b5b5470917ULL,
|
||||
0x9216d5d98979fb1bULL, 0xd1310ba698dfb5acULL,
|
||||
0x2ffd72dbd01adfb7ULL, 0xb8e1afed6a267e96ULL,
|
||||
0xba7c9045f12c7f99ULL, 0x24a19947b3916cf7ULL,
|
||||
0x0801f2e2858efc16ULL, 0x636920d871574e69ULL
|
||||
};
|
||||
|
||||
uint64_t h[8] = {
|
||||
0x6a09e667f3bcc908ULL,
|
||||
0xbb67ae8584caa73bULL,
|
||||
0x3c6ef372fe94f82bULL,
|
||||
0xa54ff53a5f1d36f1ULL,
|
||||
0x510e527fade682d1ULL,
|
||||
0x9b05688c2b3e6c1fULL,
|
||||
0x1f83d9abfb41bd6bULL,
|
||||
0x5be0cd19137e2179ULL
|
||||
};
|
||||
|
||||
uint64_t v[16] = {
|
||||
h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7],
|
||||
u512[0], u512[1], u512[2], u512[3], u512[4] ^ 640U, u512[5] ^ 640U, u512[6], u512[7]
|
||||
};
|
||||
|
||||
GprecalcHost(0, 4, 8, 12, 0x1, 0x0)
|
||||
GprecalcHost(1, 5, 9, 13, 0x3, 0x2)
|
||||
GprecalcHost(2, 6, 10, 14, 0x5, 0x4)
|
||||
GprecalcHost(3, 7, 11, 15, 0x7, 0x6)
|
||||
|
||||
GprecalcHost(1, 6, 11, 12, 0xb, 0xa)
|
||||
GprecalcHost(2, 7, 8, 13, 0xd, 0xc)
|
||||
|
||||
v[0] += (block[8] ^ u512[9]) + v[5];
|
||||
v[15] = ROTR64(v[15] ^ v[0], 32); \
|
||||
v[10] += v[15];
|
||||
v[5] = ROTR64(v[5] ^ v[10], 25);
|
||||
v[0] += v[5];
|
||||
|
||||
GprecalcHost(3, 4, 9, 14, 0xf, 0xe);
|
||||
|
||||
v[1] += (block[0x4] ^ u512[0x8]);
|
||||
v[2] += v[6];
|
||||
|
||||
v[3] += (block[0xd] ^ u512[6]) + v[7];
|
||||
|
||||
CUDA_SAFE_CALL(cudaMemcpyToSymbol(c_Hostprecalc, v, 128, 0, cudaMemcpyHostToDevice));
|
||||
}
|
||||
|
||||
#else
|
||||
// __CUDA_ARCH__ < 500
|
||||
__host__ void quark_blake512_cpu_setBlock_80_sp(int thr_id, uint64_t *pdata) {}
|
||||
__global__ void quark_blake512_gpu_hash_64_sp(uint32_t, uint32_t startNounce, uint32_t *const __restrict__ g_nonceVector, uint2 *const __restrict__ g_hash) {}
|
||||
__global__ void quark_blake512_gpu_hash_80_sp(uint32_t, uint32_t startNounce, uint2 *outputHash) {}
|
||||
#endif
|
||||
|
||||
__host__
|
||||
void quark_blake512_cpu_hash_64_sp(uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_outputHash)
|
||||
{
|
||||
const uint32_t threadsperblock = 32;
|
||||
dim3 grid((threads + threadsperblock-1)/threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
quark_blake512_gpu_hash_64_sp <<<grid, block>>>(threads, startNounce, d_nonceVector, (uint2*)d_outputHash);
|
||||
}
|
||||
|
||||
__host__
|
||||
void quark_blake512_cpu_hash_80_sp(uint32_t threads, uint32_t startNounce, uint32_t *d_outputHash)
|
||||
{
|
||||
const uint32_t threadsperblock = 64;
|
||||
dim3 grid((threads + threadsperblock - 1) / threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
quark_blake512_gpu_hash_80_sp <<<grid, block>>>(threads, startNounce, (uint2*)d_outputHash);
|
||||
}
|
||||
+140
-112
@@ -1,13 +1,21 @@
|
||||
/**
|
||||
* __shfl_up require SM 3.0 arch!
|
||||
*
|
||||
* SM 2 alternative method by tpruvot@github 2015
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <memory.h>
|
||||
|
||||
#include "cuda_helper.h"
|
||||
#include <sm_30_intrinsics.h>
|
||||
|
||||
static uint32_t *d_tempBranch1Nonces[MAX_GPUS];
|
||||
static uint32_t *d_numValid[MAX_GPUS];
|
||||
#ifdef __INTELLISENSE__
|
||||
/* just for vstudio code colors */
|
||||
#define __CUDA_ARCH__ 300
|
||||
#define __shfl_up(var, delta, width) (0)
|
||||
#endif
|
||||
|
||||
static uint32_t *h_numValid[MAX_GPUS];
|
||||
|
||||
static uint32_t *d_tempBranch1Nonces[MAX_GPUS];
|
||||
static uint32_t *d_partSum[2][MAX_GPUS]; // für bis zu vier partielle Summen
|
||||
|
||||
// True/False tester
|
||||
@@ -28,47 +36,50 @@ __device__ cuda_compactTestFunction_t d_QuarkTrueFunction = QuarkTrueTest, d_Qua
|
||||
cuda_compactTestFunction_t h_QuarkTrueFunction[MAX_GPUS], h_QuarkFalseFunction[MAX_GPUS];
|
||||
|
||||
// Setup/Alloc Function
|
||||
__host__ void quark_compactTest_cpu_init(int thr_id, uint32_t threads)
|
||||
__host__
|
||||
void quark_compactTest_cpu_init(int thr_id, uint32_t threads)
|
||||
{
|
||||
int dev_id = device_map[thr_id];
|
||||
cuda_get_arch(thr_id);
|
||||
|
||||
cudaMemcpyFromSymbol(&h_QuarkTrueFunction[thr_id], d_QuarkTrueFunction, sizeof(cuda_compactTestFunction_t));
|
||||
cudaMemcpyFromSymbol(&h_QuarkFalseFunction[thr_id], d_QuarkFalseFunction, sizeof(cuda_compactTestFunction_t));
|
||||
|
||||
// wir brauchen auch Speicherplatz auf dem Device
|
||||
cudaMalloc(&d_tempBranch1Nonces[thr_id], sizeof(uint32_t) * threads * 2);
|
||||
cudaMalloc(&d_numValid[thr_id], 2*sizeof(uint32_t));
|
||||
if (cuda_arch[dev_id] >= 300) {
|
||||
uint32_t s1 = (threads / 256) * 2;
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_tempBranch1Nonces[thr_id], sizeof(uint32_t) * threads * 2));
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_partSum[0][thr_id], sizeof(uint32_t) * s1)); // BLOCKSIZE (Threads/Block)
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_partSum[1][thr_id], sizeof(uint32_t) * s1)); // BLOCKSIZE (Threads/Block)
|
||||
} else {
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_tempBranch1Nonces[thr_id], sizeof(uint32_t) * threads));
|
||||
}
|
||||
|
||||
cudaMallocHost(&h_numValid[thr_id], 2*sizeof(uint32_t));
|
||||
|
||||
uint32_t s1;
|
||||
s1 = (threads / 256) * 2;
|
||||
|
||||
cudaMalloc(&d_partSum[0][thr_id], sizeof(uint32_t) * s1); // BLOCKSIZE (Threads/Block)
|
||||
cudaMalloc(&d_partSum[1][thr_id], sizeof(uint32_t) * s1); // BLOCKSIZE (Threads/Block)
|
||||
}
|
||||
|
||||
// Because all alloc should have a free...
|
||||
__host__ void quark_compactTest_cpu_free(int thr_id)
|
||||
__host__
|
||||
void quark_compactTest_cpu_free(int thr_id)
|
||||
{
|
||||
cudaFree(d_tempBranch1Nonces[thr_id]);
|
||||
cudaFree(d_numValid[thr_id]);
|
||||
|
||||
cudaFree(d_partSum[0][thr_id]);
|
||||
cudaFree(d_partSum[1][thr_id]);
|
||||
int dev_id = device_map[thr_id];
|
||||
|
||||
cudaFreeHost(h_numValid[thr_id]);
|
||||
|
||||
if (cuda_arch[dev_id] >= 300) {
|
||||
cudaFree(d_tempBranch1Nonces[thr_id]);
|
||||
cudaFree(d_partSum[0][thr_id]);
|
||||
cudaFree(d_partSum[1][thr_id]);
|
||||
} else {
|
||||
cudaFree(d_tempBranch1Nonces[thr_id]);
|
||||
}
|
||||
}
|
||||
|
||||
#if __CUDA_ARCH__ < 300
|
||||
/**
|
||||
* __shfl_up() calculates a source lane ID by subtracting delta from the caller's lane ID, and clamping to the range 0..width-1
|
||||
*/
|
||||
#undef __shfl_up
|
||||
#define __shfl_up(var, delta, width) (0)
|
||||
#endif
|
||||
|
||||
// Die Summenfunktion (vom NVIDIA SDK)
|
||||
__global__ void quark_compactTest_gpu_SCAN(uint32_t *data, int width, uint32_t *partial_sums=NULL, cuda_compactTestFunction_t testFunc=NULL, uint32_t threads=0, uint32_t startNounce=0, uint32_t *inpHashes=NULL, uint32_t *d_validNonceTable=NULL)
|
||||
__global__
|
||||
void quark_compactTest_gpu_SCAN(uint32_t *data, const int width, uint32_t *partial_sums=NULL, cuda_compactTestFunction_t testFunc=NULL,
|
||||
uint32_t threads=0, uint32_t startNounce=0, uint32_t *inpHashes=NULL, uint32_t *d_validNonceTable=NULL)
|
||||
{
|
||||
extern __shared__ uint32_t sums[];
|
||||
#if __CUDA_ARCH__ >= 300
|
||||
__shared__ uint32_t sums[32];
|
||||
int id = ((blockIdx.x * blockDim.x) + threadIdx.x);
|
||||
//int lane_id = id % warpSize;
|
||||
int lane_id = id % width;
|
||||
@@ -91,19 +102,16 @@ __global__ void quark_compactTest_gpu_SCAN(uint32_t *data, int width, uint32_t *
|
||||
{
|
||||
// keine Nonce-Liste
|
||||
inpHash = &inpHashes[id<<4];
|
||||
}else
|
||||
{
|
||||
} else {
|
||||
// Nonce-Liste verfügbar
|
||||
int nonce = d_validNonceTable[id] - startNounce;
|
||||
inpHash = &inpHashes[nonce<<4];
|
||||
}
|
||||
value = (*testFunc)(inpHash);
|
||||
}else
|
||||
{
|
||||
} else {
|
||||
value = 0;
|
||||
}
|
||||
}else
|
||||
{
|
||||
} else {
|
||||
value = data[id];
|
||||
}
|
||||
|
||||
@@ -115,12 +123,11 @@ __global__ void quark_compactTest_gpu_SCAN(uint32_t *data, int width, uint32_t *
|
||||
// those threads where the thread 'i' away would have
|
||||
// been out of bounds of the warp are unaffected. This
|
||||
// creates the scan sum.
|
||||
#pragma unroll
|
||||
|
||||
#pragma unroll
|
||||
for (int i=1; i<=width; i*=2)
|
||||
{
|
||||
uint32_t n = __shfl_up((int)value, i, width);
|
||||
|
||||
if (lane_id >= i) value += n;
|
||||
}
|
||||
|
||||
@@ -147,8 +154,7 @@ __global__ void quark_compactTest_gpu_SCAN(uint32_t *data, int width, uint32_t *
|
||||
for (int i=1; i<=width; i*=2)
|
||||
{
|
||||
uint32_t n = __shfl_up((int)warp_sum, i, width);
|
||||
|
||||
if (lane_id >= i) warp_sum += n;
|
||||
if (lane_id >= i) warp_sum += n;
|
||||
}
|
||||
|
||||
sums[lane_id] = warp_sum;
|
||||
@@ -175,10 +181,12 @@ __global__ void quark_compactTest_gpu_SCAN(uint32_t *data, int width, uint32_t *
|
||||
{
|
||||
partial_sums[blockIdx.x] = value;
|
||||
}
|
||||
#endif // SM3+
|
||||
}
|
||||
|
||||
// Uniform add: add partial sums array
|
||||
__global__ void quark_compactTest_gpu_ADD(uint32_t *data, uint32_t *partial_sums, int len)
|
||||
__global__
|
||||
void quark_compactTest_gpu_ADD(uint32_t *data, uint32_t *partial_sums, int len)
|
||||
{
|
||||
__shared__ uint32_t buf;
|
||||
int id = ((blockIdx.x * blockDim.x) + threadIdx.x);
|
||||
@@ -194,22 +202,21 @@ __global__ void quark_compactTest_gpu_ADD(uint32_t *data, uint32_t *partial_sums
|
||||
data[id] += buf;
|
||||
}
|
||||
|
||||
// Der Scatter
|
||||
__global__ void quark_compactTest_gpu_SCATTER(uint32_t *sum, uint32_t *outp, cuda_compactTestFunction_t testFunc, uint32_t threads=0, uint32_t startNounce=0, uint32_t *inpHashes=NULL, uint32_t *d_validNonceTable=NULL)
|
||||
__global__
|
||||
void quark_compactTest_gpu_SCATTER(uint32_t *sum, uint32_t *outp, cuda_compactTestFunction_t testFunc,
|
||||
uint32_t threads=0, uint32_t startNounce=0, uint32_t *inpHashes=NULL, uint32_t *d_validNonceTable=NULL)
|
||||
{
|
||||
int id = ((blockIdx.x * blockDim.x) + threadIdx.x);
|
||||
uint32_t actNounce = id;
|
||||
uint32_t value;
|
||||
if (id < threads)
|
||||
{
|
||||
// uint32_t nounce = startNounce + id;
|
||||
uint32_t *inpHash;
|
||||
if(d_validNonceTable == NULL)
|
||||
{
|
||||
// keine Nonce-Liste
|
||||
inpHash = &inpHashes[id<<4];
|
||||
}else
|
||||
{
|
||||
} else {
|
||||
// Nonce-Liste verfügbar
|
||||
int nonce = d_validNonceTable[id] - startNounce;
|
||||
actNounce = nonce;
|
||||
@@ -217,13 +224,11 @@ __global__ void quark_compactTest_gpu_SCATTER(uint32_t *sum, uint32_t *outp, cud
|
||||
}
|
||||
|
||||
value = (*testFunc)(inpHash);
|
||||
}else
|
||||
{
|
||||
} else {
|
||||
value = 0;
|
||||
}
|
||||
|
||||
if( value )
|
||||
{
|
||||
if (value) {
|
||||
int idx = sum[id];
|
||||
if(idx > 0)
|
||||
outp[idx-1] = startNounce + actNounce;
|
||||
@@ -244,12 +249,12 @@ __host__ static uint32_t quark_compactTest_roundUpExp(uint32_t val)
|
||||
return mask;
|
||||
}
|
||||
|
||||
__host__ void quark_compactTest_cpu_singleCompaction(int thr_id, uint32_t threads, uint32_t *nrm,
|
||||
uint32_t *d_nonces1, cuda_compactTestFunction_t function,
|
||||
uint32_t startNounce, uint32_t *inpHashes, uint32_t *d_validNonceTable)
|
||||
__host__
|
||||
void quark_compactTest_cpu_singleCompaction(int thr_id, uint32_t threads, uint32_t *nrm,uint32_t *d_nonces1,
|
||||
cuda_compactTestFunction_t function, uint32_t startNounce, uint32_t *inpHashes, uint32_t *d_validNonceTable)
|
||||
{
|
||||
int orgThreads = threads;
|
||||
threads = (int)quark_compactTest_roundUpExp((uint32_t)threads);
|
||||
threads = quark_compactTest_roundUpExp(threads);
|
||||
// threadsPerBlock ausrechnen
|
||||
int blockSize = 256;
|
||||
int nSummen = threads / blockSize;
|
||||
@@ -262,17 +267,15 @@ __host__ void quark_compactTest_cpu_singleCompaction(int thr_id, uint32_t thread
|
||||
bool callThrid = (thr2 > 0) ? true : false;
|
||||
|
||||
// Erster Initialscan
|
||||
quark_compactTest_gpu_SCAN<<<thr1,blockSize, 32*sizeof(uint32_t)>>>(
|
||||
quark_compactTest_gpu_SCAN <<<thr1,blockSize>>>(
|
||||
d_tempBranch1Nonces[thr_id], 32, d_partSum[0][thr_id], function, orgThreads, startNounce, inpHashes, d_validNonceTable);
|
||||
|
||||
// weitere Scans
|
||||
if(callThrid)
|
||||
{
|
||||
quark_compactTest_gpu_SCAN<<<thr2,blockSize, 32*sizeof(uint32_t)>>>(d_partSum[0][thr_id], 32, d_partSum[1][thr_id]);
|
||||
quark_compactTest_gpu_SCAN<<<1, thr2, 32*sizeof(uint32_t)>>>(d_partSum[1][thr_id], (thr2>32) ? 32 : thr2);
|
||||
}else
|
||||
{
|
||||
quark_compactTest_gpu_SCAN<<<thr3,blockSize2, 32*sizeof(uint32_t)>>>(d_partSum[0][thr_id], (blockSize2>32) ? 32 : blockSize2);
|
||||
if(callThrid) {
|
||||
quark_compactTest_gpu_SCAN<<<thr2,blockSize>>>(d_partSum[0][thr_id], 32, d_partSum[1][thr_id]);
|
||||
quark_compactTest_gpu_SCAN<<<1, thr2>>>(d_partSum[1][thr_id], (thr2>32) ? 32 : thr2);
|
||||
} else {
|
||||
quark_compactTest_gpu_SCAN<<<thr3,blockSize2>>>(d_partSum[0][thr_id], (blockSize2>32) ? 32 : blockSize2);
|
||||
}
|
||||
|
||||
// Sync + Anzahl merken
|
||||
@@ -283,15 +286,11 @@ __host__ void quark_compactTest_cpu_singleCompaction(int thr_id, uint32_t thread
|
||||
else
|
||||
cudaMemcpy(nrm, &(d_partSum[0][thr_id])[nSummen-1], sizeof(uint32_t), cudaMemcpyDeviceToHost);
|
||||
|
||||
|
||||
// Addieren
|
||||
if(callThrid)
|
||||
{
|
||||
if(callThrid) {
|
||||
quark_compactTest_gpu_ADD<<<thr2-1, blockSize>>>(d_partSum[0][thr_id]+blockSize, d_partSum[1][thr_id], blockSize*thr2);
|
||||
}
|
||||
quark_compactTest_gpu_ADD<<<thr1-1, blockSize>>>(d_tempBranch1Nonces[thr_id]+blockSize, d_partSum[0][thr_id], threads);
|
||||
|
||||
// Scatter
|
||||
|
||||
quark_compactTest_gpu_SCATTER<<<thr1,blockSize,0>>>(d_tempBranch1Nonces[thr_id], d_nonces1,
|
||||
function, orgThreads, startNounce, inpHashes, d_validNonceTable);
|
||||
|
||||
@@ -299,50 +298,79 @@ __host__ void quark_compactTest_cpu_singleCompaction(int thr_id, uint32_t thread
|
||||
cudaStreamSynchronize(NULL);
|
||||
}
|
||||
|
||||
#if __CUDA_ARCH__ < 300
|
||||
__global__ __launch_bounds__(128, 8)
|
||||
void quark_filter_gpu_sm2(const uint32_t threads, const uint32_t* d_hash, uint32_t* d_branch2, uint32_t* d_NonceBranch)
|
||||
{
|
||||
const uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
const uint32_t offset = thread * 16U; // 64U / sizeof(uint32_t);
|
||||
uint4 *psrc = (uint4*) (&d_hash[offset]);
|
||||
d_NonceBranch[thread] = ((uint8_t*)psrc)[0] & 0x8;
|
||||
if (d_NonceBranch[thread]) return;
|
||||
// uint4 = 4x uint32_t = 16 bytes
|
||||
uint4 *pdst = (uint4*) (&d_branch2[offset]);
|
||||
pdst[0] = psrc[0];
|
||||
pdst[1] = psrc[1];
|
||||
pdst[2] = psrc[2];
|
||||
pdst[3] = psrc[3];
|
||||
}
|
||||
}
|
||||
|
||||
__global__ __launch_bounds__(128, 8)
|
||||
void quark_merge_gpu_sm2(const uint32_t threads, uint32_t* d_hash, uint32_t* d_branch2, uint32_t* const d_NonceBranch)
|
||||
{
|
||||
const uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads && !d_NonceBranch[thread])
|
||||
{
|
||||
const uint32_t offset = thread * 16U;
|
||||
uint4 *pdst = (uint4*) (&d_hash[offset]);
|
||||
uint4 *psrc = (uint4*) (&d_branch2[offset]);
|
||||
pdst[0] = psrc[0];
|
||||
pdst[1] = psrc[1];
|
||||
pdst[2] = psrc[2];
|
||||
pdst[3] = psrc[3];
|
||||
}
|
||||
}
|
||||
#else
|
||||
__global__ void quark_filter_gpu_sm2(const uint32_t threads, const uint32_t* d_hash, uint32_t* d_branch2, uint32_t* d_NonceBranch) {}
|
||||
__global__ void quark_merge_gpu_sm2(const uint32_t threads, uint32_t* d_hash, uint32_t* d_branch2, uint32_t* const d_NonceBranch) {}
|
||||
#endif
|
||||
|
||||
__host__
|
||||
uint32_t quark_filter_cpu_sm2(const int thr_id, const uint32_t threads, const uint32_t *inpHashes, uint32_t* d_branch2)
|
||||
{
|
||||
const uint32_t threadsperblock = 128;
|
||||
dim3 grid((threads + threadsperblock - 1) / threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
// extract algo permution hashes to a second branch buffer
|
||||
quark_filter_gpu_sm2 <<<grid, block>>> (threads, inpHashes, d_branch2, d_tempBranch1Nonces[thr_id]);
|
||||
return threads;
|
||||
}
|
||||
|
||||
__host__
|
||||
void quark_merge_cpu_sm2(const int thr_id, const uint32_t threads, uint32_t *outpHashes, uint32_t* d_branch2)
|
||||
{
|
||||
const uint32_t threadsperblock = 128;
|
||||
dim3 grid((threads + threadsperblock - 1) / threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
// put back second branch hashes to the common buffer d_hash
|
||||
quark_merge_gpu_sm2 <<<grid, block>>> (threads, outpHashes, d_branch2, d_tempBranch1Nonces[thr_id]);
|
||||
}
|
||||
|
||||
////// ACHTUNG: Diese funktion geht aktuell nur mit threads > 65536 (Am besten 256 * 1024 oder 256*2048)
|
||||
__host__ void quark_compactTest_cpu_dualCompaction(int thr_id, uint32_t threads, uint32_t *nrm,
|
||||
uint32_t *d_nonces1, uint32_t *d_nonces2,
|
||||
uint32_t startNounce, uint32_t *inpHashes, uint32_t *d_validNonceTable)
|
||||
__host__
|
||||
void quark_compactTest_cpu_dualCompaction(int thr_id, uint32_t threads, uint32_t *nrm, uint32_t *d_nonces1,
|
||||
uint32_t *d_nonces2, uint32_t startNounce, uint32_t *inpHashes, uint32_t *d_validNonceTable)
|
||||
{
|
||||
quark_compactTest_cpu_singleCompaction(thr_id, threads, &nrm[0], d_nonces1, h_QuarkTrueFunction[thr_id], startNounce, inpHashes, d_validNonceTable);
|
||||
quark_compactTest_cpu_singleCompaction(thr_id, threads, &nrm[1], d_nonces2, h_QuarkFalseFunction[thr_id], startNounce, inpHashes, d_validNonceTable);
|
||||
|
||||
/*
|
||||
// threadsPerBlock ausrechnen
|
||||
int blockSize = 256;
|
||||
int thr1 = threads / blockSize;
|
||||
int thr2 = threads / (blockSize*blockSize);
|
||||
|
||||
// 1
|
||||
quark_compactTest_gpu_SCAN<<<thr1,blockSize, 32*sizeof(uint32_t)>>>(d_tempBranch1Nonces[thr_id], 32, d_partSum1[thr_id], h_QuarkTrueFunction[thr_id], threads, startNounce, inpHashes);
|
||||
quark_compactTest_gpu_SCAN<<<thr2,blockSize, 32*sizeof(uint32_t)>>>(d_partSum1[thr_id], 32, d_partSum2[thr_id]);
|
||||
quark_compactTest_gpu_SCAN<<<1, thr2, 32*sizeof(uint32_t)>>>(d_partSum2[thr_id], (thr2>32) ? 32 : thr2);
|
||||
cudaStreamSynchronize(NULL);
|
||||
cudaMemcpy(&nrm[0], &(d_partSum2[thr_id])[thr2-1], sizeof(uint32_t), cudaMemcpyDeviceToHost);
|
||||
quark_compactTest_gpu_ADD<<<thr2-1, blockSize>>>(d_partSum1[thr_id]+blockSize, d_partSum2[thr_id], blockSize*thr2);
|
||||
quark_compactTest_gpu_ADD<<<thr1-1, blockSize>>>(d_tempBranch1Nonces[thr_id]+blockSize, d_partSum1[thr_id], threads);
|
||||
|
||||
// 2
|
||||
quark_compactTest_gpu_SCAN<<<thr1,blockSize, 32*sizeof(uint32_t)>>>(d_tempBranch2Nonces[thr_id], 32, d_partSum1[thr_id], h_QuarkFalseFunction[thr_id], threads, startNounce, inpHashes);
|
||||
quark_compactTest_gpu_SCAN<<<thr2,blockSize, 32*sizeof(uint32_t)>>>(d_partSum1[thr_id], 32, d_partSum2[thr_id]);
|
||||
quark_compactTest_gpu_SCAN<<<1, thr2, 32*sizeof(uint32_t)>>>(d_partSum2[thr_id], (thr2>32) ? 32 : thr2);
|
||||
cudaStreamSynchronize(NULL);
|
||||
cudaMemcpy(&nrm[1], &(d_partSum2[thr_id])[thr2-1], sizeof(uint32_t), cudaMemcpyDeviceToHost);
|
||||
quark_compactTest_gpu_ADD<<<thr2-1, blockSize>>>(d_partSum1[thr_id]+blockSize, d_partSum2[thr_id], blockSize*thr2);
|
||||
quark_compactTest_gpu_ADD<<<thr1-1, blockSize>>>(d_tempBranch2Nonces[thr_id]+blockSize, d_partSum1[thr_id], threads);
|
||||
|
||||
// Hier ist noch eine Besonderheit: in d_tempBranch1Nonces sind die element von 1...nrm1 die Interessanten
|
||||
// Schritt 3: Scatter
|
||||
quark_compactTest_gpu_SCATTER<<<thr1,blockSize,0>>>(d_tempBranch1Nonces[thr_id], d_nonces1, h_QuarkTrueFunction[thr_id], threads, startNounce, inpHashes);
|
||||
quark_compactTest_gpu_SCATTER<<<thr1,blockSize,0>>>(d_tempBranch2Nonces[thr_id], d_nonces2, h_QuarkFalseFunction[thr_id], threads, startNounce, inpHashes);
|
||||
cudaStreamSynchronize(NULL);
|
||||
*/
|
||||
}
|
||||
|
||||
__host__ void quark_compactTest_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *inpHashes, uint32_t *d_validNonceTable,
|
||||
uint32_t *d_nonces1, uint32_t *nrm1,
|
||||
uint32_t *d_nonces2, uint32_t *nrm2,
|
||||
int order)
|
||||
__host__
|
||||
void quark_compactTest_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *inpHashes,
|
||||
uint32_t *d_validNonceTable, uint32_t *d_nonces1, uint32_t *nrm1, uint32_t *d_nonces2, uint32_t *nrm2, int order)
|
||||
{
|
||||
// Wenn validNonceTable genutzt wird, dann werden auch nur die Nonces betrachtet, die dort enthalten sind
|
||||
// "threads" ist in diesem Fall auf die Länge dieses Array's zu setzen!
|
||||
@@ -356,15 +384,15 @@ __host__ void quark_compactTest_cpu_hash_64(int thr_id, uint32_t threads, uint32
|
||||
*nrm2 = h_numValid[thr_id][1];
|
||||
}
|
||||
|
||||
__host__ void quark_compactTest_single_false_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *inpHashes, uint32_t *d_validNonceTable,
|
||||
uint32_t *d_nonces1, uint32_t *nrm1,
|
||||
int order)
|
||||
__host__
|
||||
void quark_compactTest_single_false_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *inpHashes,
|
||||
uint32_t *d_validNonceTable, uint32_t *d_nonces1, uint32_t *nrm1, int order)
|
||||
{
|
||||
// Wenn validNonceTable genutzt wird, dann werden auch nur die Nonces betrachtet, die dort enthalten sind
|
||||
// "threads" ist in diesem Fall auf die Länge dieses Array's zu setzen!
|
||||
|
||||
quark_compactTest_cpu_singleCompaction(thr_id, threads, h_numValid[thr_id], d_nonces1, h_QuarkFalseFunction[thr_id], startNounce, inpHashes, d_validNonceTable);
|
||||
|
||||
cudaStreamSynchronize(NULL); // Das original braucht zwar etwas CPU-Last, ist an dieser Stelle aber evtl besser
|
||||
cudaStreamSynchronize(NULL);
|
||||
*nrm1 = h_numValid[thr_id][0];
|
||||
}
|
||||
}
|
||||
@@ -141,6 +141,14 @@ void quark_groestl512_cpu_init(int thr_id, uint32_t threads)
|
||||
quark_groestl512_sm20_init(thr_id, threads);
|
||||
}
|
||||
|
||||
__host__
|
||||
void quark_groestl512_cpu_free(int thr_id)
|
||||
{
|
||||
int dev_id = device_map[thr_id];
|
||||
if (device_sm[dev_id] < 300 || cuda_arch[dev_id] < 300)
|
||||
quark_groestl512_sm20_free(thr_id);
|
||||
}
|
||||
|
||||
__host__
|
||||
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)
|
||||
{
|
||||
|
||||
@@ -5,6 +5,8 @@
|
||||
#define MAXWELL_OR_FERMI 0
|
||||
#define USE_SHARED 1
|
||||
|
||||
static unsigned int *d_textures[MAX_GPUS][8];
|
||||
|
||||
// #define SPH_C32(x) ((uint32_t)(x ## U))
|
||||
// #define SPH_T32(x) ((x) & SPH_C32(0xFFFFFFFF))
|
||||
|
||||
@@ -50,7 +52,7 @@ extern uint32_t T2dn_cpu[];
|
||||
extern uint32_t T3up_cpu[];
|
||||
extern uint32_t T3dn_cpu[];
|
||||
|
||||
#if __CUDA_ARCH__ < 300
|
||||
#if __CUDA_ARCH__ < 300 || defined(_DEBUG)
|
||||
|
||||
__device__ __forceinline__
|
||||
void quark_groestl512_perm_P(uint32_t *a, char *mixtabs)
|
||||
@@ -204,7 +206,7 @@ void quark_groestl512_perm_Q(uint32_t *a, char *mixtabs)
|
||||
__global__
|
||||
void quark_groestl512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint32_t *g_hash, uint32_t *g_nonceVector)
|
||||
{
|
||||
#if __CUDA_ARCH__ < 300
|
||||
#if __CUDA_ARCH__ < 300 || defined(_DEBUG)
|
||||
extern __shared__ char mixtabs[];
|
||||
|
||||
if (threadIdx.x < 256)
|
||||
@@ -274,28 +276,38 @@ void quark_groestl512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint32
|
||||
#endif
|
||||
}
|
||||
|
||||
#define texDef(texname, texmem, texsource, texsize) \
|
||||
#define texDef(id, texname, texmem, texsource, texsize) { \
|
||||
unsigned int *texmem; \
|
||||
cudaMalloc(&texmem, texsize); \
|
||||
d_textures[thr_id][id] = texmem; \
|
||||
cudaMemcpy(texmem, texsource, texsize, cudaMemcpyHostToDevice); \
|
||||
texname.normalized = 0; \
|
||||
texname.filterMode = cudaFilterModePoint; \
|
||||
texname.addressMode[0] = cudaAddressModeClamp; \
|
||||
{ cudaChannelFormatDesc channelDesc = cudaCreateChannelDesc<unsigned int>(); \
|
||||
cudaBindTexture(NULL, &texname, texmem, &channelDesc, texsize ); } \
|
||||
cudaBindTexture(NULL, &texname, texmem, &channelDesc, texsize ); \
|
||||
} \
|
||||
}
|
||||
|
||||
__host__
|
||||
void quark_groestl512_sm20_init(int thr_id, uint32_t threads)
|
||||
{
|
||||
// Texturen mit obigem Makro initialisieren
|
||||
texDef(t0up1, d_T0up, T0up_cpu, sizeof(uint32_t)*256);
|
||||
texDef(t0dn1, d_T0dn, T0dn_cpu, sizeof(uint32_t)*256);
|
||||
texDef(t1up1, d_T1up, T1up_cpu, sizeof(uint32_t)*256);
|
||||
texDef(t1dn1, d_T1dn, T1dn_cpu, sizeof(uint32_t)*256);
|
||||
texDef(t2up1, d_T2up, T2up_cpu, sizeof(uint32_t)*256);
|
||||
texDef(t2dn1, d_T2dn, T2dn_cpu, sizeof(uint32_t)*256);
|
||||
texDef(t3up1, d_T3up, T3up_cpu, sizeof(uint32_t)*256);
|
||||
texDef(t3dn1, d_T3dn, T3dn_cpu, sizeof(uint32_t)*256);
|
||||
texDef(0, t0up1, d_T0up, T0up_cpu, sizeof(uint32_t)*256);
|
||||
texDef(1, t0dn1, d_T0dn, T0dn_cpu, sizeof(uint32_t)*256);
|
||||
texDef(2, t1up1, d_T1up, T1up_cpu, sizeof(uint32_t)*256);
|
||||
texDef(3, t1dn1, d_T1dn, T1dn_cpu, sizeof(uint32_t)*256);
|
||||
texDef(4, t2up1, d_T2up, T2up_cpu, sizeof(uint32_t)*256);
|
||||
texDef(5, t2dn1, d_T2dn, T2dn_cpu, sizeof(uint32_t)*256);
|
||||
texDef(6, t3up1, d_T3up, T3up_cpu, sizeof(uint32_t)*256);
|
||||
texDef(7, t3dn1, d_T3dn, T3dn_cpu, sizeof(uint32_t)*256);
|
||||
}
|
||||
|
||||
__host__
|
||||
void quark_groestl512_sm20_free(int thr_id)
|
||||
{
|
||||
for (int i=0; i<8; i++)
|
||||
cudaFree(d_textures[thr_id][i]);
|
||||
}
|
||||
|
||||
__host__
|
||||
|
||||
@@ -1,9 +1,20 @@
|
||||
#define SP_KERNEL
|
||||
|
||||
#ifdef SP_KERNEL
|
||||
#include "cuda_skein512_sp.cuh"
|
||||
#undef TFBIG_KINIT
|
||||
#undef TFBIG_ADDKEY
|
||||
#undef TFBIG_MIX
|
||||
#else
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <memory.h>
|
||||
|
||||
#include "cuda_helper.h"
|
||||
|
||||
#endif
|
||||
|
||||
static __constant__ uint64_t c_PaddedMessage80[20]; // padded message (80 bytes + 72 bytes midstate + align)
|
||||
|
||||
// Take a look at: https://www.schneier.com/skein1.3.pdf
|
||||
@@ -395,6 +406,7 @@ uint64_t skein_rotl64(const uint64_t x, const int offset)
|
||||
__global__
|
||||
void quark_skein512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint64_t * const __restrict__ g_hash, uint32_t *g_nonceVector)
|
||||
{
|
||||
#if !defined(SP_KERNEL) || __CUDA_ARCH__ < 500
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
@@ -497,6 +509,7 @@ void quark_skein512_gpu_hash_64(uint32_t threads, uint32_t startNounce, uint64_t
|
||||
for(int i=0; i<8; i++)
|
||||
outpHash[i] = devectorize(p[i]);
|
||||
}
|
||||
#endif /* SM < 5.0 */
|
||||
}
|
||||
|
||||
__global__
|
||||
@@ -890,6 +903,11 @@ void quark_skein512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNoun
|
||||
int dev_id = device_map[thr_id];
|
||||
|
||||
// uint2 uint64 variants for SM 3.2+
|
||||
#ifdef SP_KERNEL
|
||||
if (device_sm[dev_id] >= 500 && cuda_arch[dev_id] >= 500)
|
||||
quark_skein512_cpu_hash_64(threads, startNounce, d_nonceVector, d_hash); /* sp.cuh */
|
||||
else
|
||||
#endif
|
||||
if (device_sm[dev_id] > 300 && cuda_arch[dev_id] > 300)
|
||||
quark_skein512_gpu_hash_64 <<<grid, block>>> (threads, startNounce, (uint64_t*)d_hash, d_nonceVector);
|
||||
else
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
+192
-154
@@ -11,126 +11,114 @@ extern "C"
|
||||
#include "miner.h"
|
||||
|
||||
#include "cuda_helper.h"
|
||||
#include "cuda_quark.h"
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
extern uint32_t quark_filter_cpu_sm2(const int thr_id, const uint32_t threads, const uint32_t *inpHashes, uint32_t* d_branch2);
|
||||
extern void quark_merge_cpu_sm2(const int thr_id, const uint32_t threads, uint32_t *outpHashes, uint32_t* d_branch2);
|
||||
|
||||
static uint32_t *d_hash[MAX_GPUS];
|
||||
static uint32_t* d_hash_br2[MAX_GPUS]; // SM 2
|
||||
|
||||
// Speicher zur Generierung der Noncevektoren für die bedingten Hashes
|
||||
static uint32_t *d_branch1Nonces[MAX_GPUS];
|
||||
static uint32_t *d_branch2Nonces[MAX_GPUS];
|
||||
static uint32_t *d_branch3Nonces[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_blake512_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_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 quark_compactTest_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_compactTest_cpu_free(int thr_id);
|
||||
extern void quark_compactTest_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *inpHashes, uint32_t *d_validNonceTable,
|
||||
uint32_t *d_nonces1, uint32_t *nrm1,
|
||||
uint32_t *d_nonces2, uint32_t *nrm2,
|
||||
int order);
|
||||
extern void quark_compactTest_single_false_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *inpHashes, uint32_t *d_validNonceTable,
|
||||
uint32_t *d_nonces1, uint32_t *nrm1,
|
||||
int order);
|
||||
|
||||
extern uint32_t cuda_check_hash_branch(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_inputHash, int order);
|
||||
|
||||
|
||||
// Original Quarkhash Funktion aus einem miner Quelltext
|
||||
extern "C" void quarkhash(void *state, const void *input)
|
||||
{
|
||||
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;
|
||||
|
||||
unsigned char hash[64];
|
||||
unsigned char _ALIGN(128) hash[64];
|
||||
|
||||
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_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;
|
||||
|
||||
if (hash[0] & 0x8)
|
||||
{
|
||||
sph_groestl512_init(&ctx_groestl);
|
||||
sph_groestl512 (&ctx_groestl, (const void*) hash, 64);
|
||||
sph_groestl512_close(&ctx_groestl, (void*) hash);
|
||||
}
|
||||
else
|
||||
{
|
||||
sph_skein512_init(&ctx_skein);
|
||||
sph_skein512 (&ctx_skein, (const void*) hash, 64);
|
||||
sph_skein512_close(&ctx_skein, (void*) hash);
|
||||
}
|
||||
|
||||
sph_groestl512_init(&ctx_groestl);
|
||||
sph_groestl512 (&ctx_groestl, (const void*) hash, 64);
|
||||
sph_groestl512_close(&ctx_groestl, (void*) hash);
|
||||
sph_blake512_init(&ctx_blake);
|
||||
sph_blake512 (&ctx_blake, input, 80);
|
||||
sph_blake512_close(&ctx_blake, (void*) hash);
|
||||
|
||||
sph_jh512_init(&ctx_jh);
|
||||
sph_jh512 (&ctx_jh, (const void*) hash, 64);
|
||||
sph_jh512_close(&ctx_jh, (void*) hash);
|
||||
sph_bmw512_init(&ctx_bmw);
|
||||
sph_bmw512 (&ctx_bmw, (const void*) hash, 64);
|
||||
sph_bmw512_close(&ctx_bmw, (void*) hash);
|
||||
|
||||
if (hash[0] & 0x8)
|
||||
{
|
||||
sph_blake512_init(&ctx_blake);
|
||||
sph_blake512 (&ctx_blake, (const void*) hash, 64);
|
||||
sph_blake512_close(&ctx_blake, (void*) hash);
|
||||
}
|
||||
else
|
||||
{
|
||||
sph_bmw512_init(&ctx_bmw);
|
||||
sph_bmw512 (&ctx_bmw, (const void*) hash, 64);
|
||||
sph_bmw512_close(&ctx_bmw, (void*) hash);
|
||||
}
|
||||
if (hash[0] & 0x8)
|
||||
{
|
||||
sph_groestl512_init(&ctx_groestl);
|
||||
sph_groestl512 (&ctx_groestl, (const void*) hash, 64);
|
||||
sph_groestl512_close(&ctx_groestl, (void*) hash);
|
||||
}
|
||||
else
|
||||
{
|
||||
sph_skein512_init(&ctx_skein);
|
||||
sph_skein512 (&ctx_skein, (const void*) hash, 64);
|
||||
sph_skein512_close(&ctx_skein, (void*) hash);
|
||||
}
|
||||
|
||||
sph_keccak512_init(&ctx_keccak);
|
||||
sph_keccak512 (&ctx_keccak, (const void*) hash, 64);
|
||||
sph_keccak512_close(&ctx_keccak, (void*) hash);
|
||||
sph_groestl512_init(&ctx_groestl);
|
||||
sph_groestl512 (&ctx_groestl, (const void*) hash, 64);
|
||||
sph_groestl512_close(&ctx_groestl, (void*) hash);
|
||||
|
||||
sph_skein512_init(&ctx_skein);
|
||||
sph_skein512 (&ctx_skein, (const void*) hash, 64);
|
||||
sph_skein512_close(&ctx_skein, (void*) hash);
|
||||
sph_jh512_init(&ctx_jh);
|
||||
sph_jh512 (&ctx_jh, (const void*) hash, 64);
|
||||
sph_jh512_close(&ctx_jh, (void*) hash);
|
||||
|
||||
if (hash[0] & 0x8)
|
||||
{
|
||||
sph_keccak512_init(&ctx_keccak);
|
||||
sph_keccak512 (&ctx_keccak, (const void*) hash, 64);
|
||||
sph_keccak512_close(&ctx_keccak, (void*) hash);
|
||||
}
|
||||
else
|
||||
{
|
||||
sph_jh512_init(&ctx_jh);
|
||||
sph_jh512 (&ctx_jh, (const void*) hash, 64);
|
||||
sph_jh512_close(&ctx_jh, (void*) hash);
|
||||
}
|
||||
if (hash[0] & 0x8)
|
||||
{
|
||||
sph_blake512_init(&ctx_blake);
|
||||
sph_blake512 (&ctx_blake, (const void*) hash, 64);
|
||||
sph_blake512_close(&ctx_blake, (void*) hash);
|
||||
}
|
||||
else
|
||||
{
|
||||
sph_bmw512_init(&ctx_bmw);
|
||||
sph_bmw512 (&ctx_bmw, (const void*) hash, 64);
|
||||
sph_bmw512_close(&ctx_bmw, (void*) hash);
|
||||
}
|
||||
|
||||
memcpy(state, hash, 32);
|
||||
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);
|
||||
|
||||
if (hash[0] & 0x8)
|
||||
{
|
||||
sph_keccak512_init(&ctx_keccak);
|
||||
sph_keccak512 (&ctx_keccak, (const void*) hash, 64);
|
||||
sph_keccak512_close(&ctx_keccak, (void*) hash);
|
||||
}
|
||||
else
|
||||
{
|
||||
sph_jh512_init(&ctx_jh);
|
||||
sph_jh512 (&ctx_jh, (const void*) hash, 64);
|
||||
sph_jh512_close(&ctx_jh, (void*) hash);
|
||||
}
|
||||
|
||||
memcpy(state, hash, 32);
|
||||
}
|
||||
|
||||
#ifdef _DEBUG
|
||||
#define TRACE(algo) { \
|
||||
if (max_nonce == 1 && pdata[19] <= 1) { \
|
||||
uint32_t* debugbuf = NULL; \
|
||||
cudaMallocHost(&debugbuf, 32); \
|
||||
cudaMemcpy(debugbuf, d_hash[thr_id], 32, cudaMemcpyDeviceToHost); \
|
||||
printf("quark %s %08x %08x %08x %08x...%08x... \n", algo, swab32(debugbuf[0]), swab32(debugbuf[1]), \
|
||||
swab32(debugbuf[2]), swab32(debugbuf[3]), swab32(debugbuf[7])); \
|
||||
cudaFreeHost(debugbuf); \
|
||||
} \
|
||||
}
|
||||
#else
|
||||
#define TRACE(algo) {}
|
||||
#endif
|
||||
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
|
||||
extern "C" int scanhash_quark(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
|
||||
@@ -140,18 +128,26 @@ extern "C" int scanhash_quark(int thr_id, struct work* work, uint32_t max_nonce,
|
||||
uint32_t *ptarget = work->target;
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1 << 20); // 256*4096
|
||||
throughput = min(throughput, max_nonce - first_nonce);
|
||||
int dev_id = device_map[thr_id];
|
||||
uint32_t def_thr = 1U << 20; // 256*4096
|
||||
uint32_t throughput = cuda_default_throughput(thr_id, def_thr);
|
||||
if (init[thr_id]) throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0x00F;
|
||||
ptarget[7] = 0x00F;
|
||||
|
||||
if (!init[thr_id])
|
||||
{
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaSetDevice(dev_id);
|
||||
if (opt_cudaschedule == -1 && gpu_threads == 1) {
|
||||
cudaDeviceReset();
|
||||
// reduce cpu usage
|
||||
cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);
|
||||
CUDA_LOG_ERROR();
|
||||
}
|
||||
|
||||
// Konstanten kopieren, Speicher belegen
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hash[thr_id], 16 * sizeof(uint32_t) * throughput));
|
||||
cudaGetLastError();
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hash[thr_id], (size_t) 64 * throughput));
|
||||
|
||||
quark_blake512_cpu_init(thr_id, throughput);
|
||||
quark_groestl512_cpu_init(thr_id, throughput);
|
||||
@@ -159,12 +155,18 @@ extern "C" int scanhash_quark(int thr_id, struct work* work, uint32_t max_nonce,
|
||||
quark_bmw512_cpu_init(thr_id, throughput);
|
||||
quark_keccak512_cpu_init(thr_id, throughput);
|
||||
quark_jh512_cpu_init(thr_id, throughput);
|
||||
cuda_check_cpu_init(thr_id, throughput);
|
||||
quark_compactTest_cpu_init(thr_id, throughput);
|
||||
|
||||
cudaMalloc(&d_branch1Nonces[thr_id], sizeof(uint32_t)*throughput);
|
||||
cudaMalloc(&d_branch2Nonces[thr_id], sizeof(uint32_t)*throughput);
|
||||
cudaMalloc(&d_branch3Nonces[thr_id], sizeof(uint32_t)*throughput);
|
||||
if (cuda_arch[dev_id] >= 300) {
|
||||
cudaMalloc(&d_branch1Nonces[thr_id], sizeof(uint32_t)*throughput);
|
||||
cudaMalloc(&d_branch2Nonces[thr_id], sizeof(uint32_t)*throughput);
|
||||
cudaMalloc(&d_branch3Nonces[thr_id], sizeof(uint32_t)*throughput);
|
||||
} else {
|
||||
cudaMalloc(&d_hash_br2[thr_id], (size_t) 64 * throughput);
|
||||
}
|
||||
|
||||
cuda_check_cpu_init(thr_id, throughput);
|
||||
CUDA_SAFE_CALL(cudaGetLastError());
|
||||
|
||||
init[thr_id] = true;
|
||||
}
|
||||
@@ -177,73 +179,108 @@ extern "C" int scanhash_quark(int thr_id, struct work* work, uint32_t max_nonce,
|
||||
|
||||
do {
|
||||
int order = 0;
|
||||
uint32_t foundNonce;
|
||||
uint32_t nrm1=0, nrm2=0, nrm3=0;
|
||||
|
||||
// erstes Blake512 Hash mit CUDA
|
||||
quark_blake512_cpu_hash_80(thr_id, throughput, pdata[19], d_hash[thr_id]); order++;
|
||||
|
||||
// das ist der unbedingte Branch für BMW512
|
||||
TRACE("blake :");
|
||||
quark_bmw512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
TRACE("bmw :");
|
||||
|
||||
quark_compactTest_single_false_cpu_hash_64(thr_id, throughput, pdata[19], d_hash[thr_id], NULL,
|
||||
d_branch3Nonces[thr_id], &nrm3,
|
||||
if (cuda_arch[dev_id] >= 300) {
|
||||
|
||||
quark_compactTest_single_false_cpu_hash_64(thr_id, throughput, pdata[19], d_hash[thr_id], NULL,
|
||||
d_branch3Nonces[thr_id], &nrm3, order++);
|
||||
|
||||
// nur den Skein Branch weiterverfolgen
|
||||
quark_skein512_cpu_hash_64(thr_id, nrm3, pdata[19], d_branch3Nonces[thr_id], d_hash[thr_id], order++);
|
||||
|
||||
// das ist der unbedingte Branch für Groestl512
|
||||
quark_groestl512_cpu_hash_64(thr_id, nrm3, pdata[19], d_branch3Nonces[thr_id], d_hash[thr_id], order++);
|
||||
|
||||
// das ist der unbedingte Branch für JH512
|
||||
quark_jh512_cpu_hash_64(thr_id, nrm3, pdata[19], d_branch3Nonces[thr_id], d_hash[thr_id], order++);
|
||||
|
||||
// quarkNonces in branch1 und branch2 aufsplitten gemäss if (hash[0] & 0x8)
|
||||
quark_compactTest_cpu_hash_64(thr_id, nrm3, pdata[19], d_hash[thr_id], d_branch3Nonces[thr_id],
|
||||
d_branch1Nonces[thr_id], &nrm1,
|
||||
d_branch2Nonces[thr_id], &nrm2,
|
||||
order++);
|
||||
|
||||
// nur den Skein Branch weiterverfolgen
|
||||
quark_skein512_cpu_hash_64(thr_id, nrm3, pdata[19], d_branch3Nonces[thr_id], d_hash[thr_id], order++);
|
||||
|
||||
// das ist der unbedingte Branch für Groestl512
|
||||
quark_groestl512_cpu_hash_64(thr_id, nrm3, pdata[19], d_branch3Nonces[thr_id], d_hash[thr_id], order++);
|
||||
// das ist der bedingte Branch für Blake512
|
||||
quark_blake512_cpu_hash_64(thr_id, nrm1, pdata[19], d_branch1Nonces[thr_id], d_hash[thr_id], order++);
|
||||
|
||||
// das ist der unbedingte Branch für JH512
|
||||
quark_jh512_cpu_hash_64(thr_id, nrm3, pdata[19], d_branch3Nonces[thr_id], d_hash[thr_id], order++);
|
||||
// das ist der bedingte Branch für Bmw512
|
||||
quark_bmw512_cpu_hash_64(thr_id, nrm2, pdata[19], d_branch2Nonces[thr_id], d_hash[thr_id], order++);
|
||||
|
||||
// quarkNonces in branch1 und branch2 aufsplitten gemäss if (hash[0] & 0x8)
|
||||
quark_compactTest_cpu_hash_64(thr_id, nrm3, pdata[19], d_hash[thr_id], d_branch3Nonces[thr_id],
|
||||
d_branch1Nonces[thr_id], &nrm1,
|
||||
d_branch2Nonces[thr_id], &nrm2,
|
||||
order++);
|
||||
// das ist der unbedingte Branch für Keccak512
|
||||
quark_keccak512_cpu_hash_64(thr_id, nrm3, pdata[19], d_branch3Nonces[thr_id], d_hash[thr_id], order++);
|
||||
|
||||
// das ist der bedingte Branch für Blake512
|
||||
quark_blake512_cpu_hash_64(thr_id, nrm1, pdata[19], d_branch1Nonces[thr_id], d_hash[thr_id], order++);
|
||||
// das ist der unbedingte Branch für Skein512
|
||||
quark_skein512_cpu_hash_64(thr_id, nrm3, pdata[19], d_branch3Nonces[thr_id], d_hash[thr_id], order++);
|
||||
|
||||
// das ist der bedingte Branch für Bmw512
|
||||
quark_bmw512_cpu_hash_64(thr_id, nrm2, pdata[19], d_branch2Nonces[thr_id], d_hash[thr_id], order++);
|
||||
// quarkNonces in branch1 und branch2 aufsplitten gemäss if (hash[0] & 0x8)
|
||||
quark_compactTest_cpu_hash_64(thr_id, nrm3, pdata[19], d_hash[thr_id], d_branch3Nonces[thr_id],
|
||||
d_branch1Nonces[thr_id], &nrm1,
|
||||
d_branch2Nonces[thr_id], &nrm2,
|
||||
order++);
|
||||
|
||||
// das ist der unbedingte Branch für Keccak512
|
||||
quark_keccak512_cpu_hash_64(thr_id, nrm3, pdata[19], d_branch3Nonces[thr_id], d_hash[thr_id], order++);
|
||||
quark_keccak512_cpu_hash_64(thr_id, nrm1, pdata[19], d_branch1Nonces[thr_id], d_hash[thr_id], order++);
|
||||
quark_jh512_cpu_hash_64(thr_id, nrm2, pdata[19], d_branch2Nonces[thr_id], d_hash[thr_id], order++);
|
||||
|
||||
// das ist der unbedingte Branch für Skein512
|
||||
quark_skein512_cpu_hash_64(thr_id, nrm3, pdata[19], d_branch3Nonces[thr_id], d_hash[thr_id], order++);
|
||||
foundNonce = cuda_check_hash_branch(thr_id, nrm3, pdata[19], d_branch3Nonces[thr_id], d_hash[thr_id], order++);
|
||||
|
||||
// quarkNonces in branch1 und branch2 aufsplitten gemäss if (hash[0] & 0x8)
|
||||
quark_compactTest_cpu_hash_64(thr_id, nrm3, pdata[19], d_hash[thr_id], d_branch3Nonces[thr_id],
|
||||
d_branch1Nonces[thr_id], &nrm1,
|
||||
d_branch2Nonces[thr_id], &nrm2,
|
||||
order++);
|
||||
} else {
|
||||
/* algo permutations are made with 2 different buffers */
|
||||
|
||||
// das ist der bedingte Branch für Keccak512
|
||||
quark_keccak512_cpu_hash_64(thr_id, nrm1, pdata[19], d_branch1Nonces[thr_id], d_hash[thr_id], order++);
|
||||
quark_filter_cpu_sm2(thr_id, throughput, d_hash[thr_id], d_hash_br2[thr_id]);
|
||||
quark_groestl512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
quark_skein512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash_br2[thr_id], order++);
|
||||
quark_merge_cpu_sm2(thr_id, throughput, d_hash[thr_id], d_hash_br2[thr_id]);
|
||||
TRACE("perm1 :");
|
||||
|
||||
// das ist der bedingte Branch für JH512
|
||||
quark_jh512_cpu_hash_64(thr_id, nrm2, pdata[19], d_branch2Nonces[thr_id], d_hash[thr_id], order++);
|
||||
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_filter_cpu_sm2(thr_id, throughput, d_hash[thr_id], d_hash_br2[thr_id]);
|
||||
quark_blake512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
quark_bmw512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash_br2[thr_id], order++);
|
||||
quark_merge_cpu_sm2(thr_id, throughput, d_hash[thr_id], d_hash_br2[thr_id]);
|
||||
TRACE("perm2 :");
|
||||
|
||||
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 :");
|
||||
|
||||
quark_filter_cpu_sm2(thr_id, throughput, d_hash[thr_id], d_hash_br2[thr_id]);
|
||||
quark_keccak512_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_br2[thr_id], order++);
|
||||
quark_merge_cpu_sm2(thr_id, throughput, d_hash[thr_id], d_hash_br2[thr_id]);
|
||||
TRACE("perm3 :");
|
||||
|
||||
CUDA_LOG_ERROR();
|
||||
foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]);
|
||||
}
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce + 1;
|
||||
|
||||
// Scan nach Gewinner Hashes auf der GPU
|
||||
uint32_t foundNonce = cuda_check_hash_branch(thr_id, nrm3, pdata[19], d_branch3Nonces[thr_id], d_hash[thr_id], order++);
|
||||
if (foundNonce != 0xffffffff)
|
||||
if (foundNonce != UINT32_MAX)
|
||||
{
|
||||
uint32_t vhash64[8];
|
||||
uint32_t vhash[8];
|
||||
be32enc(&endiandata[19], foundNonce);
|
||||
quarkhash(vhash64, endiandata);
|
||||
quarkhash(vhash, endiandata);
|
||||
|
||||
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
|
||||
bn_store_hash_target_ratio(vhash64, ptarget, work);
|
||||
if (vhash[7] <= ptarget[7] && fulltest(vhash, ptarget)) {
|
||||
work_set_target_ratio(work, vhash);
|
||||
pdata[19] = foundNonce;
|
||||
return 1;
|
||||
} else {
|
||||
applog(LOG_WARNING, "GPU #%d: result for nonce %08x does not validate on CPU!", device_map[thr_id], foundNonce);
|
||||
gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", foundNonce);
|
||||
applog_hash((uchar*) vhash);
|
||||
applog_hash((uchar*) ptarget);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -261,8 +298,7 @@ extern "C" void free_quark(int thr_id)
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaDeviceSynchronize();
|
||||
cudaThreadSynchronize();
|
||||
|
||||
cudaFree(d_hash[thr_id]);
|
||||
|
||||
@@ -270,10 +306,12 @@ extern "C" void free_quark(int thr_id)
|
||||
cudaFree(d_branch2Nonces[thr_id]);
|
||||
cudaFree(d_branch3Nonces[thr_id]);
|
||||
|
||||
quark_blake512_cpu_free(thr_id);
|
||||
quark_groestl512_cpu_free(thr_id);
|
||||
quark_compactTest_cpu_free(thr_id);
|
||||
|
||||
cuda_check_cpu_free(thr_id);
|
||||
init[thr_id] = false;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
}
|
||||
+21
-15
@@ -13,6 +13,7 @@ extern "C" {
|
||||
#include "miner.h"
|
||||
|
||||
#include "cuda_helper.h"
|
||||
#include "x11/cuda_x11.h"
|
||||
|
||||
static uint32_t *d_hash[MAX_GPUS];
|
||||
|
||||
@@ -20,12 +21,6 @@ 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 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);
|
||||
|
||||
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 "C" void deephash(void *state, const void *input)
|
||||
{
|
||||
uint8_t _ALIGN(64) hash[64];
|
||||
@@ -58,8 +53,8 @@ extern "C" int scanhash_deep(int thr_id, struct work* work, uint32_t max_nonce,
|
||||
uint32_t *pdata = work->data;
|
||||
uint32_t *ptarget = work->target;
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1U << 19); // 256*256*8
|
||||
throughput = min(throughput, (max_nonce - first_nonce));
|
||||
uint32_t throughput = cuda_default_throughput(thr_id, 1U << 19); // 256*256*8
|
||||
if (init[thr_id]) throughput = min(throughput, (max_nonce - first_nonce));
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0x0000f;
|
||||
@@ -67,8 +62,14 @@ extern "C" int scanhash_deep(int thr_id, struct work* work, uint32_t max_nonce,
|
||||
if (!init[thr_id])
|
||||
{
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
if (opt_cudaschedule == -1 && gpu_threads == 1) {
|
||||
cudaDeviceReset();
|
||||
// reduce cpu usage
|
||||
cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);
|
||||
}
|
||||
CUDA_LOG_ERROR();
|
||||
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hash[thr_id], throughput * 64));
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hash[thr_id], (size_t) 64 * throughput));
|
||||
|
||||
qubit_luffa512_cpu_init(thr_id, throughput);
|
||||
x11_cubehash512_cpu_init(thr_id, throughput);
|
||||
@@ -104,12 +105,12 @@ extern "C" int scanhash_deep(int thr_id, struct work* work, uint32_t max_nonce,
|
||||
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
|
||||
int res = 1;
|
||||
uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1);
|
||||
bn_store_hash_target_ratio(vhash64, ptarget, work);
|
||||
work_set_target_ratio(work, vhash64);
|
||||
if (secNonce != 0) {
|
||||
be32enc(&endiandata[19], secNonce);
|
||||
deephash(vhash64, endiandata);
|
||||
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio)
|
||||
bn_store_hash_target_ratio(vhash64, ptarget, work);
|
||||
work_set_target_ratio(work, vhash64);
|
||||
pdata[21] = secNonce;
|
||||
res++;
|
||||
}
|
||||
@@ -117,13 +118,18 @@ extern "C" int scanhash_deep(int thr_id, struct work* work, uint32_t max_nonce,
|
||||
return res;
|
||||
}
|
||||
else {
|
||||
applog(LOG_WARNING, "GPU #%d: result for nonce %08x does not validate on CPU!", device_map[thr_id], foundNonce);
|
||||
gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", foundNonce);
|
||||
}
|
||||
}
|
||||
|
||||
if ((uint64_t)throughput + pdata[19] >= max_nonce) {
|
||||
pdata[19] = max_nonce;
|
||||
break;
|
||||
}
|
||||
|
||||
pdata[19] += throughput;
|
||||
|
||||
} while (pdata[19] < max_nonce && !work_restart[thr_id].restart);
|
||||
} while (!work_restart[thr_id].restart);
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce + 1;
|
||||
return 0;
|
||||
@@ -135,7 +141,7 @@ extern "C" void free_deep(int thr_id)
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
cudaFree(d_hash[thr_id]);
|
||||
|
||||
@@ -143,4 +149,4 @@ extern "C" void free_deep(int thr_id)
|
||||
init[thr_id] = false;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
}
|
||||
+19
-16
@@ -36,19 +36,23 @@ extern "C" int scanhash_luffa(int thr_id, struct work* work, uint32_t max_nonce,
|
||||
uint32_t *pdata = work->data;
|
||||
uint32_t *ptarget = work->target;
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1U << 22); // 256*256*8*8
|
||||
throughput = min(throughput, max_nonce - first_nonce);
|
||||
uint32_t throughput = cuda_default_throughput(thr_id, 1U << 21);
|
||||
if (init[thr_id]) throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0x0000f;
|
||||
ptarget[7] = 0x0000f;
|
||||
|
||||
if (!init[thr_id])
|
||||
{
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
if (opt_cudaschedule == -1) // to reduce cpu usage...
|
||||
if (opt_cudaschedule == -1 && gpu_threads == 1) {
|
||||
cudaDeviceReset();
|
||||
// reduce cpu usage
|
||||
cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);
|
||||
CUDA_LOG_ERROR();
|
||||
}
|
||||
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hash[thr_id], throughput * 64));
|
||||
CUDA_SAFE_CALL(cudaMalloc(&d_hash[thr_id], (size_t) 64 * throughput));
|
||||
|
||||
qubit_luffa512_cpu_init(thr_id, throughput);
|
||||
cuda_check_cpu_init(thr_id, throughput);
|
||||
@@ -63,10 +67,9 @@ extern "C" int scanhash_luffa(int thr_id, struct work* work, uint32_t max_nonce,
|
||||
cuda_check_cpu_setTarget(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], 0);
|
||||
|
||||
qubit_luffa512_cpu_hash_80(thr_id, (int) throughput, pdata[19], d_hash[thr_id], order++);
|
||||
*hashes_done = pdata[19] - first_nonce + throughput;
|
||||
|
||||
uint32_t foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]);
|
||||
if (foundNonce != UINT32_MAX)
|
||||
@@ -76,16 +79,16 @@ extern "C" int scanhash_luffa(int thr_id, struct work* work, uint32_t max_nonce,
|
||||
luffa_hash(vhash64, endiandata);
|
||||
|
||||
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
|
||||
bn_store_hash_target_ratio(vhash64, ptarget, work);
|
||||
work_set_target_ratio(work, vhash64);
|
||||
pdata[19] = foundNonce;
|
||||
return 1;
|
||||
} else {
|
||||
applog(LOG_WARNING, "GPU #%d: result for nonce %08x does not validate on CPU!", device_map[thr_id], foundNonce);
|
||||
gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", foundNonce);
|
||||
}
|
||||
}
|
||||
|
||||
if ((uint64_t) throughput + pdata[19] > max_nonce) {
|
||||
// pdata[19] = max_nonce;
|
||||
if ((uint64_t) throughput + pdata[19] >= max_nonce) {
|
||||
pdata[19] = max_nonce;
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -93,7 +96,7 @@ extern "C" int scanhash_luffa(int thr_id, struct work* work, uint32_t max_nonce,
|
||||
|
||||
} while (!work_restart[thr_id].restart);
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce + 1;
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -103,12 +106,12 @@ extern "C" void free_luffa(int thr_id)
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
cudaFree(d_hash[thr_id]);
|
||||
|
||||
cuda_check_cpu_free(thr_id);
|
||||
init[thr_id] = false;
|
||||
|
||||
init[thr_id] = false;
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
}
|
||||
+26
-29
@@ -13,6 +13,7 @@ extern "C" {
|
||||
#include "miner.h"
|
||||
|
||||
#include "cuda_helper.h"
|
||||
#include "x11/cuda_x11.h"
|
||||
|
||||
static uint32_t *d_hash[MAX_GPUS];
|
||||
|
||||
@@ -20,25 +21,10 @@ 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 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);
|
||||
|
||||
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);
|
||||
|
||||
extern "C" void qubithash(void *state, const void *input)
|
||||
{
|
||||
uint8_t _ALIGN(128) hash[64];
|
||||
|
||||
// luffa1-cubehash2-shavite3-simd4-echo5
|
||||
|
||||
sph_luffa512_context ctx_luffa;
|
||||
@@ -47,8 +33,6 @@ extern "C" void qubithash(void *state, const void *input)
|
||||
sph_simd512_context ctx_simd;
|
||||
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);
|
||||
@@ -80,15 +64,21 @@ extern "C" int scanhash_qubit(int thr_id, struct work* work, uint32_t max_nonce,
|
||||
uint32_t *pdata = work->data;
|
||||
uint32_t *ptarget = work->target;
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1U << 19); // 256*256*8
|
||||
throughput = min(throughput, max_nonce - first_nonce);
|
||||
uint32_t throughput = cuda_default_throughput(thr_id, 1U << 19); // 256*256*8
|
||||
if (init[thr_id]) throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0x0000ff;
|
||||
ptarget[7] = 0x007f;
|
||||
|
||||
if (!init[thr_id])
|
||||
{
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
if (opt_cudaschedule == -1 && gpu_threads == 1) {
|
||||
cudaDeviceReset();
|
||||
// reduce cpu usage
|
||||
cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);
|
||||
CUDA_LOG_ERROR();
|
||||
}
|
||||
|
||||
qubit_luffa512_cpu_init(thr_id, throughput);
|
||||
x11_cubehash512_cpu_init(thr_id, throughput);
|
||||
@@ -96,7 +86,7 @@ extern "C" int scanhash_qubit(int thr_id, struct work* work, uint32_t max_nonce,
|
||||
x11_simd512_cpu_init(thr_id, throughput);
|
||||
x11_echo512_cpu_init(thr_id, throughput);
|
||||
|
||||
CUDA_CALL_OR_RET_X(cudaMalloc(&d_hash[thr_id], 16 * sizeof(uint32_t) * throughput), 0);
|
||||
CUDA_CALL_OR_RET_X(cudaMalloc(&d_hash[thr_id], (size_t) 64 * throughput), 0);
|
||||
|
||||
cuda_check_cpu_init(thr_id, throughput);
|
||||
|
||||
@@ -132,12 +122,12 @@ extern "C" int scanhash_qubit(int thr_id, struct work* work, uint32_t max_nonce,
|
||||
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);
|
||||
bn_store_hash_target_ratio(vhash64, ptarget, work);
|
||||
work_set_target_ratio(work, vhash64);
|
||||
if (secNonce != 0) {
|
||||
be32enc(&endiandata[19], secNonce);
|
||||
qubithash(vhash64, endiandata);
|
||||
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio)
|
||||
bn_store_hash_target_ratio(vhash64, ptarget, work);
|
||||
work_set_target_ratio(work, vhash64);
|
||||
pdata[21] = secNonce;
|
||||
res++;
|
||||
}
|
||||
@@ -149,11 +139,16 @@ extern "C" int scanhash_qubit(int thr_id, struct work* work, uint32_t max_nonce,
|
||||
}
|
||||
}
|
||||
|
||||
if ((uint64_t) throughput + pdata[19] >= max_nonce) {
|
||||
pdata[19] = max_nonce;
|
||||
break;
|
||||
}
|
||||
|
||||
pdata[19] += throughput;
|
||||
|
||||
} while (pdata[19] < max_nonce && !work_restart[thr_id].restart);
|
||||
} while (!work_restart[thr_id].restart);
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce + 1;
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -163,12 +158,14 @@ extern "C" void free_qubit(int thr_id)
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
cudaFree(d_hash[thr_id]);
|
||||
|
||||
x11_simd512_cpu_free(thr_id);
|
||||
|
||||
cuda_check_cpu_free(thr_id);
|
||||
init[thr_id] = false;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
}
|
||||
+5
-5
@@ -60,8 +60,8 @@ IDI_ICON1 ICON "ccminer.ico"
|
||||
//
|
||||
|
||||
VS_VERSION_INFO VERSIONINFO
|
||||
FILEVERSION 1,6,6,0
|
||||
PRODUCTVERSION 1,6,6,0
|
||||
FILEVERSION 1,7,6,0
|
||||
PRODUCTVERSION 1,7,6,0
|
||||
FILEFLAGSMASK 0x3fL
|
||||
#ifdef _DEBUG
|
||||
FILEFLAGS 0x21L
|
||||
@@ -76,10 +76,10 @@ BEGIN
|
||||
BEGIN
|
||||
BLOCK "040904e4"
|
||||
BEGIN
|
||||
VALUE "FileVersion", "1.6.6"
|
||||
VALUE "LegalCopyright", "Copyright (C) 2015"
|
||||
VALUE "FileVersion", "1.7.6"
|
||||
VALUE "LegalCopyright", "Copyright (C) 2016"
|
||||
VALUE "ProductName", "ccminer"
|
||||
VALUE "ProductVersion", "1.6.6"
|
||||
VALUE "ProductVersion", "1.7.6"
|
||||
END
|
||||
END
|
||||
BLOCK "VarFileInfo"
|
||||
|
||||
+30
-5
@@ -395,6 +395,9 @@ unsigned char GetNfactor(unsigned int nTimestamp)
|
||||
} else if (!strcmp(jane_params, "RAD") || !strcasecmp(jane_params, "RadioactiveCoin")) {
|
||||
// InternetCoin:1389196388, minN: 4, maxN: 30
|
||||
Ntimestamp = 1389196388; minN= 4; maxN= 30;
|
||||
} else if (!strcmp(jane_params, "LEO") || !strcasecmp(jane_params, "LEOCoin")) {
|
||||
// LEOCoin:1402845776, minN: 4, maxN: 30
|
||||
Ntimestamp = 1402845776; minN= 4; maxN= 30;
|
||||
} else {
|
||||
if (sscanf(jane_params, "%u,%u,%u", &Ntimestamp, &minN, &maxN) != 3)
|
||||
if (sscanf(jane_params, "%u", &Nfactor) == 1) return Nfactor; // skip bounding against minN, maxN
|
||||
@@ -426,10 +429,21 @@ unsigned char GetNfactor(unsigned int nTimestamp)
|
||||
return Nfactor;
|
||||
}
|
||||
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
|
||||
// cleanup
|
||||
void free_scrypt_jane(int thr_id)
|
||||
{
|
||||
// todo ?
|
||||
int dev_id = device_map[thr_id];
|
||||
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaSetDevice(dev_id);
|
||||
cudaDeviceSynchronize();
|
||||
cudaDeviceReset(); // well, simple way to free ;)
|
||||
|
||||
init[thr_id] = false;
|
||||
}
|
||||
|
||||
#define bswap_32x4(x) ((((x) << 24) & 0xff000000u) | (((x) << 8) & 0x00ff0000u) \
|
||||
@@ -467,7 +481,19 @@ int scanhash_scrypt_jane(int thr_id, struct work *work, uint32_t max_nonce, unsi
|
||||
s_Nfactor = Nfactor;
|
||||
}
|
||||
|
||||
int throughput = cuda_throughput(thr_id);
|
||||
static __thread int throughput = 0;
|
||||
if(!init[thr_id]) {
|
||||
int dev_id = device_map[thr_id];
|
||||
|
||||
cudaSetDevice(dev_id);
|
||||
cudaDeviceSynchronize();
|
||||
cudaDeviceReset();
|
||||
cudaSetDevice(dev_id);
|
||||
throughput = cuda_throughput(thr_id);
|
||||
applog(LOG_INFO, "GPU #%d: cuda throughput is %d", dev_id, throughput);
|
||||
|
||||
init[thr_id] = true;
|
||||
}
|
||||
|
||||
if(throughput == 0)
|
||||
return -1;
|
||||
@@ -602,7 +628,7 @@ int scanhash_scrypt_jane(int thr_id, struct work *work, uint32_t max_nonce, unsi
|
||||
|
||||
if (memcmp(thash, &hash[cur][8*i], 32) == 0)
|
||||
{
|
||||
bn_store_hash_target_ratio(thash, ptarget, work);
|
||||
work_set_target_ratio(work, thash);
|
||||
*hashes_done = n - pdata[19];
|
||||
pdata[19] = tmp_nonce;
|
||||
scrypt_free(&Vbuf);
|
||||
@@ -612,8 +638,7 @@ int scanhash_scrypt_jane(int thr_id, struct work *work, uint32_t max_nonce, unsi
|
||||
gettimeofday(tv_end, NULL);
|
||||
return 1;
|
||||
} else {
|
||||
applog(LOG_WARNING, "GPU #%d: %s result does not validate on CPU! (i=%d, s=%d)",
|
||||
device_map[thr_id], device_name[thr_id], i, cur);
|
||||
gpulog(LOG_WARNING, thr_id, "result does not validate on CPU! (i=%d, s=%d)", i, cur);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+29
-6
@@ -685,10 +685,22 @@ static int lastFactor = 0;
|
||||
|
||||
static void computeGold(uint32_t* const input, uint32_t *reference, uchar *scratchpad);
|
||||
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
|
||||
// cleanup
|
||||
void free_scrypt(int thr_id)
|
||||
{
|
||||
// todo ?
|
||||
int dev_id = device_map[thr_id];
|
||||
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
// trivial way to free all...
|
||||
cudaSetDevice(dev_id);
|
||||
cudaDeviceSynchronize();
|
||||
cudaDeviceReset();
|
||||
|
||||
init[thr_id] = false;
|
||||
}
|
||||
|
||||
// Scrypt proof of work algorithm
|
||||
@@ -701,9 +713,21 @@ int scanhash_scrypt(int thr_id, struct work *work, uint32_t max_nonce, unsigned
|
||||
int result = 0;
|
||||
uint32_t *pdata = work->data;
|
||||
uint32_t *ptarget = work->target;
|
||||
int throughput = cuda_throughput(thr_id);
|
||||
static __thread int throughput = 0;
|
||||
|
||||
if(throughput == 0)
|
||||
if (!init[thr_id]) {
|
||||
int dev_id = device_map[thr_id];
|
||||
cudaSetDevice(dev_id);
|
||||
cudaDeviceSynchronize();
|
||||
cudaDeviceReset();
|
||||
cudaSetDevice(dev_id);
|
||||
throughput = cuda_throughput(thr_id);
|
||||
applog(LOG_INFO, "GPU #%d: cuda throughput is %d", dev_id, throughput);
|
||||
|
||||
init[thr_id] = true;
|
||||
}
|
||||
|
||||
if (throughput == 0)
|
||||
return -1;
|
||||
|
||||
gettimeofday(tv_start, NULL);
|
||||
@@ -908,11 +932,10 @@ int scanhash_scrypt(int thr_id, struct work *work, uint32_t max_nonce, unsigned
|
||||
}
|
||||
|
||||
if (!good) {
|
||||
applog(LOG_WARNING, "GPU #%d: %s result does not validate on CPU! (i=%d, s=%d)",
|
||||
device_map[thr_id], device_name[thr_id], i, cur);
|
||||
gpulog(LOG_WARNING, thr_id, "result does not validate on CPU! (i=%d, s=%d)", i, cur);
|
||||
} else {
|
||||
*hashes_done = n - pdata[19];
|
||||
bn_store_hash_target_ratio(refhash, ptarget, work);
|
||||
work_set_target_ratio(work, refhash);
|
||||
pdata[19] = nonce[cur] + i;
|
||||
result = 1;
|
||||
goto byebye;
|
||||
|
||||
+12
-2
@@ -404,10 +404,10 @@ void cuda_blake256_hash( uint64_t *g_out, uint32_t nonce, uint32_t *g_good, bool
|
||||
|
||||
static std::map<int, uint32_t *> context_good[2];
|
||||
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
|
||||
bool default_prepare_blake256(int thr_id, const uint32_t host_pdata[20], const uint32_t host_ptarget[8])
|
||||
{
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
|
||||
if (!init[thr_id])
|
||||
{
|
||||
// allocate pinned host memory for good hashes
|
||||
@@ -441,3 +441,13 @@ void default_do_blake256(dim3 grid, dim3 threads, int thr_id, int stream, uint32
|
||||
cudaMemcpyDeviceToHost, context_streams[stream][thr_id]));
|
||||
}
|
||||
}
|
||||
|
||||
void default_free_blake256(int thr_id)
|
||||
{
|
||||
if (init[thr_id]) {
|
||||
cudaFree(context_good[0][thr_id]);
|
||||
cudaFree(context_good[1][thr_id]);
|
||||
init[thr_id] = false;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -24,6 +24,8 @@
|
||||
#define __ldg(x) (*(x))
|
||||
#endif
|
||||
|
||||
#if !defined(__CUDA_ARCH__) || __CUDA_ARCH__ >= 300
|
||||
|
||||
// grab lane ID
|
||||
static __device__ __inline__ unsigned int __laneId() { unsigned int laneId; asm( "mov.u32 %0, %%laneid;" : "=r"( laneId ) ); return laneId; }
|
||||
|
||||
@@ -635,3 +637,6 @@ template <int ALGO> __global__ void nv2_scrypt_core_kernelB_LG(uint32_t *g_odata
|
||||
|
||||
__transposed_write_BC(B, C, (uint4*)(g_odata), 1);
|
||||
}
|
||||
|
||||
#endif /* prevent SM 2 */
|
||||
|
||||
@@ -144,9 +144,8 @@ int cuda_throughput(int thr_id)
|
||||
cuCtxCreate( &ctx, CU_CTX_SCHED_YIELD, device_map[thr_id] );
|
||||
cuCtxSetCurrent(ctx);
|
||||
#else
|
||||
checkCudaErrors(cudaSetDeviceFlags(cudaDeviceScheduleYield));
|
||||
checkCudaErrors(cudaSetDevice(device_map[thr_id]));
|
||||
// checkCudaErrors(cudaFree(0));
|
||||
checkCudaErrors(cudaSetDeviceFlags(cudaDeviceScheduleYield));
|
||||
#endif
|
||||
|
||||
KernelInterface *kernel;
|
||||
@@ -256,7 +255,7 @@ inline int _ConvertSMVer2Cores(int major, int minor)
|
||||
}
|
||||
|
||||
// If we don't find the values, we default use the previous one to run properly
|
||||
applog(LOG_WARNING, "MapSMtoCores for SM %d.%d is undefined. Default to use %d Cores/SM", major, minor, 128);
|
||||
applog(LOG_WARNING, "MapSMtoCores for SM %d.%d is undefined. Default to use %d Cores/SM", major, minor, 128);
|
||||
return 128;
|
||||
}
|
||||
|
||||
|
||||
@@ -28,6 +28,8 @@ typedef enum
|
||||
#define __ldg(x) (*(x))
|
||||
#endif
|
||||
|
||||
#if !defined(__CUDA_ARCH__) || __CUDA_ARCH__ >= 300
|
||||
|
||||
// scratchbuf constants (pointers to scratch buffer for each warp, i.e. 32 hashes)
|
||||
__constant__ uint32_t* c_V[TOTAL_WARP_LIMIT];
|
||||
|
||||
@@ -736,3 +738,5 @@ bool TitanKernel::run_kernel(dim3 grid, dim3 threads, int WARPS_PER_BLOCK, int t
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
#endif /* prevent SM 2 */
|
||||
+3
-2
@@ -398,7 +398,7 @@ public:
|
||||
|
||||
unsigned int GetSerializeSize(int, int=0) const
|
||||
{
|
||||
return pend - pbegin;
|
||||
return (unsigned int) (pend - pbegin);
|
||||
}
|
||||
|
||||
template<typename Stream>
|
||||
@@ -593,7 +593,8 @@ void Unserialize(Stream& is, std::basic_string<C>& str, int, int)
|
||||
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));
|
||||
size_t sz = v.size() + v.size() * sizeof(T);
|
||||
return (GetSizeOfCompactSize((uint64_t)sz));
|
||||
}
|
||||
|
||||
template<typename T, typename A, typename V>
|
||||
|
||||
@@ -11,16 +11,18 @@
|
||||
#include <openssl/sha.h>
|
||||
|
||||
static uint32_t *d_hash[MAX_GPUS];
|
||||
static __thread bool sm5 = true;
|
||||
|
||||
extern void quark_skein512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void skein512_cpu_setBlock_80(void *pdata);
|
||||
extern void skein512_cpu_hash_80(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_hash, int swap);
|
||||
|
||||
extern void skeincoin_init(int thr_id);
|
||||
extern void skeincoin_free(int thr_id);
|
||||
extern void skeincoin_setBlock_80(int thr_id, void *pdata);
|
||||
extern uint32_t skeincoin_hash_sm5(int thr_id, uint32_t threads, uint32_t startNounce, int swap, uint64_t target64, uint32_t *secNonce);
|
||||
|
||||
static __device__ __constant__ uint32_t sha256_hashTable[] = {
|
||||
static __device__ uint32_t sha256_hashTable[] = {
|
||||
0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
|
||||
};
|
||||
|
||||
@@ -355,14 +357,14 @@ extern "C" int scanhash_skeincoin(int thr_id, struct work* work, uint32_t max_no
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
const int swap = 1;
|
||||
|
||||
bool sm5 = (device_sm[device_map[thr_id]] >= 500);
|
||||
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));
|
||||
uint32_t throughput = cuda_default_throughput(thr_id, 1U << 20);
|
||||
if (init[thr_id]) throughput = min(throughput, (max_nonce - first_nonce));
|
||||
|
||||
uint32_t foundNonce, secNonce = 0;
|
||||
uint64_t target64;
|
||||
uint64_t target64 = 0;
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0x03;
|
||||
@@ -370,11 +372,17 @@ extern "C" int scanhash_skeincoin(int thr_id, struct work* work, uint32_t max_no
|
||||
if (!init[thr_id])
|
||||
{
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
if (opt_cudaschedule == -1 && gpu_threads == 1) {
|
||||
cudaDeviceReset();
|
||||
// reduce cpu usage
|
||||
cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);
|
||||
CUDA_LOG_ERROR();
|
||||
}
|
||||
|
||||
if (sm5) {
|
||||
skeincoin_init(thr_id);
|
||||
} else {
|
||||
cudaMalloc(&d_hash[thr_id], throughput * 64U);
|
||||
cudaMalloc(&d_hash[thr_id], (size_t) 64 * throughput);
|
||||
quark_skein512_cpu_init(thr_id, throughput);
|
||||
cuda_check_cpu_init(thr_id, throughput);
|
||||
CUDA_SAFE_CALL(cudaDeviceSynchronize());
|
||||
@@ -418,7 +426,7 @@ extern "C" int scanhash_skeincoin(int thr_id, struct work* work, uint32_t max_no
|
||||
if (vhash[7] <= ptarget[7] && fulltest(vhash, ptarget)) {
|
||||
int res = 1;
|
||||
uint8_t num = res;
|
||||
bn_store_hash_target_ratio(vhash, ptarget, work);
|
||||
work_set_target_ratio(work, vhash);
|
||||
if (checkSecnonce) {
|
||||
secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], num);
|
||||
}
|
||||
@@ -431,7 +439,7 @@ extern "C" int scanhash_skeincoin(int thr_id, struct work* work, uint32_t max_no
|
||||
endiandata[19] = swab32_if(secNonce, swap);
|
||||
skeincoinhash(vhash, endiandata);
|
||||
if (bn_hash_target_ratio(vhash, ptarget) > work->shareratio)
|
||||
bn_store_hash_target_ratio(vhash, ptarget, work);
|
||||
work_set_target_ratio(work, vhash);
|
||||
pdata[19+res*2] = swab32_if(secNonce, !swap);
|
||||
res++;
|
||||
}
|
||||
@@ -447,13 +455,11 @@ extern "C" int scanhash_skeincoin(int thr_id, struct work* work, uint32_t max_no
|
||||
return res;
|
||||
}
|
||||
else {
|
||||
applog(LOG_WARNING, "GPU #%d: result for nonce %08x does not validate on CPU!", device_map[thr_id], foundNonce);
|
||||
gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", foundNonce);
|
||||
}
|
||||
}
|
||||
|
||||
if ((uint64_t) throughput + pdata[19] > max_nonce) {
|
||||
//applog(LOG_DEBUG, "done... max=%u", max_nonce);
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
if ((uint64_t) throughput + pdata[19] >= max_nonce) {
|
||||
pdata[19] = max_nonce;
|
||||
break;
|
||||
}
|
||||
@@ -462,6 +468,8 @@ extern "C" int scanhash_skeincoin(int thr_id, struct work* work, uint32_t max_no
|
||||
|
||||
} while (!work_restart[thr_id].restart);
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -471,11 +479,15 @@ extern "C" void free_skeincoin(int thr_id)
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
cudaFree(d_hash[thr_id]);
|
||||
if (sm5)
|
||||
skeincoin_free(thr_id);
|
||||
else {
|
||||
cudaFree(d_hash[thr_id]);
|
||||
cuda_check_cpu_free(thr_id);
|
||||
}
|
||||
|
||||
cuda_check_cpu_free(thr_id);
|
||||
init[thr_id] = false;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
|
||||
+31
-17
@@ -16,6 +16,7 @@ extern void quark_skein512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void skein512_cpu_setBlock_80(void *pdata);
|
||||
extern void skein512_cpu_hash_80(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_hash, int swap);
|
||||
|
||||
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);
|
||||
|
||||
void skein2hash(void *output, const void *input)
|
||||
@@ -36,23 +37,35 @@ void skein2hash(void *output, const void *input)
|
||||
|
||||
static bool init[MAX_GPUS] = { 0 };
|
||||
|
||||
static __inline uint32_t swab32_if(uint32_t val, bool iftrue) {
|
||||
return iftrue ? swab32(val) : val;
|
||||
}
|
||||
|
||||
int scanhash_skein2(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
|
||||
{
|
||||
int dev_id = device_map[thr_id];
|
||||
uint32_t *pdata = work->data;
|
||||
uint32_t *ptarget = work->target;
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
const int swap = 1; // to toggle nonce endian
|
||||
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1 << 19); // 256*256*8
|
||||
throughput = min(throughput, (max_nonce - first_nonce));
|
||||
uint32_t throughput = cuda_default_throughput(thr_id, 1U << 19); // 256*256*8
|
||||
if (init[thr_id]) throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0;
|
||||
|
||||
if (!init[thr_id])
|
||||
{
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaSetDevice(dev_id);
|
||||
if (opt_cudaschedule == -1 && gpu_threads == 1) {
|
||||
cudaDeviceReset();
|
||||
// reduce cpu usage
|
||||
cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);
|
||||
CUDA_LOG_ERROR();
|
||||
}
|
||||
|
||||
cudaMalloc(&d_hash[thr_id], throughput * 64U);
|
||||
cudaMalloc(&d_hash[thr_id], (size_t) 64 * throughput);
|
||||
|
||||
quark_skein512_cpu_init(thr_id, throughput);
|
||||
cuda_check_cpu_init(thr_id, throughput);
|
||||
@@ -73,7 +86,7 @@ int scanhash_skein2(int thr_id, struct work* work, uint32_t max_nonce, unsigned
|
||||
int order = 0;
|
||||
|
||||
// Hash with CUDA
|
||||
skein512_cpu_hash_80(thr_id, throughput, pdata[19], d_hash[thr_id], 0);
|
||||
skein512_cpu_hash_80(thr_id, throughput, pdata[19], d_hash[thr_id], swap);
|
||||
quark_skein512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce + throughput;
|
||||
@@ -83,33 +96,32 @@ int scanhash_skein2(int thr_id, struct work* work, uint32_t max_nonce, unsigned
|
||||
{
|
||||
uint32_t _ALIGN(64) vhash64[8];
|
||||
|
||||
endiandata[19] = foundNonce;
|
||||
endiandata[19] = swab32_if(foundNonce, swap);
|
||||
skein2hash(vhash64, endiandata);
|
||||
|
||||
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
|
||||
int res = 1;
|
||||
uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1);
|
||||
bn_store_hash_target_ratio(vhash64, ptarget, work);
|
||||
work_set_target_ratio(work, vhash64);
|
||||
if (secNonce != 0) {
|
||||
if (!opt_quiet)
|
||||
applog(LOG_BLUE, "GPU #%d: found second nonce %08x !", device_map[thr_id], swab32(secNonce));
|
||||
applog(LOG_BLUE, "GPU #%d: found second nonce %08x !", dev_id, swab32(secNonce));
|
||||
|
||||
endiandata[19] = secNonce;
|
||||
endiandata[19] = swab32_if(secNonce, swap);
|
||||
skein2hash(vhash64, endiandata);
|
||||
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio)
|
||||
bn_store_hash_target_ratio(vhash64, ptarget, work);
|
||||
pdata[21] = swab32(secNonce);
|
||||
work_set_target_ratio(work, vhash64);
|
||||
pdata[21] = swab32_if(secNonce, !swap);
|
||||
res++;
|
||||
}
|
||||
pdata[19] = swab32(foundNonce);
|
||||
pdata[19] = swab32_if(foundNonce, !swap);
|
||||
return res;
|
||||
} else {
|
||||
applog(LOG_WARNING, "GPU #%d: result for nonce %08x does not validate on CPU!", device_map[thr_id], foundNonce);
|
||||
gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", foundNonce);
|
||||
}
|
||||
}
|
||||
|
||||
if ((uint64_t) throughput + pdata[19] > max_nonce) {
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
if ((uint64_t) throughput + pdata[19] >= max_nonce) {
|
||||
pdata[19] = max_nonce;
|
||||
break;
|
||||
}
|
||||
@@ -118,6 +130,8 @@ int scanhash_skein2(int thr_id, struct work* work, uint32_t max_nonce, unsigned
|
||||
|
||||
} while (!work_restart[thr_id].restart);
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -127,7 +141,7 @@ void free_skein2(int thr_id)
|
||||
if (!init[thr_id])
|
||||
return;
|
||||
|
||||
cudaSetDevice(device_map[thr_id]);
|
||||
cudaThreadSynchronize();
|
||||
|
||||
cudaFree(d_hash[thr_id]);
|
||||
|
||||
@@ -135,4 +149,4 @@ void free_skein2(int thr_id)
|
||||
init[thr_id] = false;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
}
|
||||
@@ -36,6 +36,8 @@
|
||||
|
||||
#include "sph_blake.h"
|
||||
|
||||
int blake256_rounds = 14;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
@@ -1055,6 +1057,13 @@ sph_blake256_addbits_and_close(void *cc, unsigned ub, unsigned n, void *dst)
|
||||
sph_blake256_init(cc);
|
||||
}
|
||||
|
||||
/* see sph_blake.h */
|
||||
void
|
||||
sph_blake256_set_rounds(int rounds)
|
||||
{
|
||||
blake256_rounds = rounds;
|
||||
}
|
||||
|
||||
#if SPH_64
|
||||
|
||||
/* see sph_blake.h */
|
||||
|
||||
+387
@@ -0,0 +1,387 @@
|
||||
/**
|
||||
* BLAKE2 reference source code package - reference C implementations
|
||||
*
|
||||
* Written in 2012 by Samuel Neves <sneves@dei.uc.pt>
|
||||
*
|
||||
* To the extent possible under law, the author(s) have dedicated all copyright
|
||||
* and related and neighboring rights to this software to the public domain
|
||||
* worldwide. This software is distributed without any warranty.
|
||||
*
|
||||
* You should have received a copy of the CC0 Public Domain Dedication along with
|
||||
* this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "sph_types.h"
|
||||
#include "blake2s.h"
|
||||
|
||||
static const uint32_t blake2s_IV[8] =
|
||||
{
|
||||
0x6A09E667UL, 0xBB67AE85UL, 0x3C6EF372UL, 0xA54FF53AUL,
|
||||
0x510E527FUL, 0x9B05688CUL, 0x1F83D9ABUL, 0x5BE0CD19UL
|
||||
};
|
||||
|
||||
static const uint8_t blake2s_sigma[10][16] =
|
||||
{
|
||||
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } ,
|
||||
{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 } ,
|
||||
{ 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 } ,
|
||||
{ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 } ,
|
||||
{ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 } ,
|
||||
{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 } ,
|
||||
{ 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 } ,
|
||||
{ 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 } ,
|
||||
{ 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 } ,
|
||||
{ 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13 , 0 } ,
|
||||
};
|
||||
|
||||
static inline int blake2s_set_lastnode( blake2s_state *S )
|
||||
{
|
||||
S->f[1] = ~0U;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int blake2s_clear_lastnode( blake2s_state *S )
|
||||
{
|
||||
S->f[1] = 0U;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Some helper functions, not necessarily useful */
|
||||
static inline int blake2s_set_lastblock( blake2s_state *S )
|
||||
{
|
||||
if( S->last_node ) blake2s_set_lastnode( S );
|
||||
|
||||
S->f[0] = ~0U;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int blake2s_clear_lastblock( blake2s_state *S )
|
||||
{
|
||||
if( S->last_node ) blake2s_clear_lastnode( S );
|
||||
|
||||
S->f[0] = 0U;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int blake2s_increment_counter( blake2s_state *S, const uint32_t inc )
|
||||
{
|
||||
S->t[0] += inc;
|
||||
S->t[1] += ( S->t[0] < inc );
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Parameter-related functions
|
||||
static inline int blake2s_param_set_digest_length( blake2s_param *P, const uint8_t digest_length )
|
||||
{
|
||||
P->digest_length = digest_length;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int blake2s_param_set_fanout( blake2s_param *P, const uint8_t fanout )
|
||||
{
|
||||
P->fanout = fanout;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int blake2s_param_set_max_depth( blake2s_param *P, const uint8_t depth )
|
||||
{
|
||||
P->depth = depth;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int blake2s_param_set_leaf_length( blake2s_param *P, const uint32_t leaf_length )
|
||||
{
|
||||
store32( &P->leaf_length, leaf_length );
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int blake2s_param_set_node_offset( blake2s_param *P, const uint64_t node_offset )
|
||||
{
|
||||
store48( P->node_offset, node_offset );
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int blake2s_param_set_node_depth( blake2s_param *P, const uint8_t node_depth )
|
||||
{
|
||||
P->node_depth = node_depth;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int blake2s_param_set_inner_length( blake2s_param *P, const uint8_t inner_length )
|
||||
{
|
||||
P->inner_length = inner_length;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int blake2s_param_set_salt( blake2s_param *P, const uint8_t salt[BLAKE2S_SALTBYTES] )
|
||||
{
|
||||
memcpy( P->salt, salt, BLAKE2S_SALTBYTES );
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int blake2s_param_set_personal( blake2s_param *P, const uint8_t personal[BLAKE2S_PERSONALBYTES] )
|
||||
{
|
||||
memcpy( P->personal, personal, BLAKE2S_PERSONALBYTES );
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int blake2s_init0( blake2s_state *S )
|
||||
{
|
||||
memset( S, 0, sizeof( blake2s_state ) );
|
||||
|
||||
for( int i = 0; i < 8; ++i ) S->h[i] = blake2s_IV[i];
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* init2 xors IV with input parameter block */
|
||||
int blake2s_init_param( blake2s_state *S, const blake2s_param *P )
|
||||
{
|
||||
blake2s_init0( S );
|
||||
uint32_t *p = ( uint32_t * )( P );
|
||||
|
||||
/* IV XOR ParamBlock */
|
||||
for( size_t i = 0; i < 8; ++i )
|
||||
S->h[i] ^= load32( &p[i] );
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
// Sequential blake2s initialization
|
||||
int blake2s_init( blake2s_state *S, const uint8_t outlen )
|
||||
{
|
||||
blake2s_param P[1];
|
||||
|
||||
/* Move interval verification here? */
|
||||
if ( ( !outlen ) || ( outlen > BLAKE2S_OUTBYTES ) ) return -1;
|
||||
|
||||
P->digest_length = outlen;
|
||||
P->key_length = 0;
|
||||
P->fanout = 1;
|
||||
P->depth = 1;
|
||||
store32( &P->leaf_length, 0 );
|
||||
store48( &P->node_offset, 0 );
|
||||
P->node_depth = 0;
|
||||
P->inner_length = 0;
|
||||
// memset(P->reserved, 0, sizeof(P->reserved) );
|
||||
memset( P->salt, 0, sizeof( P->salt ) );
|
||||
memset( P->personal, 0, sizeof( P->personal ) );
|
||||
return blake2s_init_param( S, P );
|
||||
}
|
||||
|
||||
int blake2s_init_key( blake2s_state *S, const uint8_t outlen, const void *key, const uint8_t keylen )
|
||||
{
|
||||
blake2s_param P[1];
|
||||
|
||||
if ( ( !outlen ) || ( outlen > BLAKE2S_OUTBYTES ) ) return -1;
|
||||
|
||||
if ( !key || !keylen || keylen > BLAKE2S_KEYBYTES ) return -1;
|
||||
|
||||
P->digest_length = outlen;
|
||||
P->key_length = keylen;
|
||||
P->fanout = 1;
|
||||
P->depth = 1;
|
||||
store32( &P->leaf_length, 0 );
|
||||
store48( &P->node_offset, 0 );
|
||||
P->node_depth = 0;
|
||||
P->inner_length = 0;
|
||||
// memset(P->reserved, 0, sizeof(P->reserved) );
|
||||
memset( P->salt, 0, sizeof( P->salt ) );
|
||||
memset( P->personal, 0, sizeof( P->personal ) );
|
||||
|
||||
if( blake2s_init_param( S, P ) < 0 ) return -1;
|
||||
|
||||
{
|
||||
uint8_t block[BLAKE2S_BLOCKBYTES];
|
||||
memset( block, 0, BLAKE2S_BLOCKBYTES );
|
||||
memcpy( block, key, keylen );
|
||||
blake2s_update( S, block, BLAKE2S_BLOCKBYTES );
|
||||
secure_zero_memory( block, BLAKE2S_BLOCKBYTES ); /* Burn the key from stack */
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int blake2s_compress( blake2s_state *S, const uint8_t block[BLAKE2S_BLOCKBYTES] )
|
||||
{
|
||||
uint32_t m[16];
|
||||
uint32_t v[16];
|
||||
|
||||
for( size_t i = 0; i < 16; ++i )
|
||||
m[i] = load32( block + i * sizeof( m[i] ) );
|
||||
|
||||
for( size_t i = 0; i < 8; ++i )
|
||||
v[i] = S->h[i];
|
||||
|
||||
v[ 8] = blake2s_IV[0];
|
||||
v[ 9] = blake2s_IV[1];
|
||||
v[10] = blake2s_IV[2];
|
||||
v[11] = blake2s_IV[3];
|
||||
v[12] = S->t[0] ^ blake2s_IV[4];
|
||||
v[13] = S->t[1] ^ blake2s_IV[5];
|
||||
v[14] = S->f[0] ^ blake2s_IV[6];
|
||||
v[15] = S->f[1] ^ blake2s_IV[7];
|
||||
#define G(r,i,a,b,c,d) \
|
||||
do { \
|
||||
a = a + b + m[blake2s_sigma[r][2*i+0]]; \
|
||||
d = SPH_ROTR32(d ^ a, 16); \
|
||||
c = c + d; \
|
||||
b = SPH_ROTR32(b ^ c, 12); \
|
||||
a = a + b + m[blake2s_sigma[r][2*i+1]]; \
|
||||
d = SPH_ROTR32(d ^ a, 8); \
|
||||
c = c + d; \
|
||||
b = SPH_ROTR32(b ^ c, 7); \
|
||||
} while(0)
|
||||
#define ROUND(r) \
|
||||
do { \
|
||||
G(r,0,v[ 0],v[ 4],v[ 8],v[12]); \
|
||||
G(r,1,v[ 1],v[ 5],v[ 9],v[13]); \
|
||||
G(r,2,v[ 2],v[ 6],v[10],v[14]); \
|
||||
G(r,3,v[ 3],v[ 7],v[11],v[15]); \
|
||||
G(r,4,v[ 0],v[ 5],v[10],v[15]); \
|
||||
G(r,5,v[ 1],v[ 6],v[11],v[12]); \
|
||||
G(r,6,v[ 2],v[ 7],v[ 8],v[13]); \
|
||||
G(r,7,v[ 3],v[ 4],v[ 9],v[14]); \
|
||||
} while(0)
|
||||
ROUND( 0 );
|
||||
ROUND( 1 );
|
||||
ROUND( 2 );
|
||||
ROUND( 3 );
|
||||
ROUND( 4 );
|
||||
ROUND( 5 );
|
||||
ROUND( 6 );
|
||||
ROUND( 7 );
|
||||
ROUND( 8 );
|
||||
ROUND( 9 );
|
||||
|
||||
for( size_t i = 0; i < 8; ++i )
|
||||
S->h[i] = S->h[i] ^ v[i] ^ v[i + 8];
|
||||
|
||||
#undef G
|
||||
#undef ROUND
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int blake2s_update( blake2s_state *S, const uint8_t *in, uint64_t inlen )
|
||||
{
|
||||
while( inlen > 0 )
|
||||
{
|
||||
size_t left = S->buflen;
|
||||
size_t fill = 2 * BLAKE2S_BLOCKBYTES - left;
|
||||
|
||||
if( inlen > fill )
|
||||
{
|
||||
memcpy( S->buf + left, in, fill ); // Fill buffer
|
||||
S->buflen += fill;
|
||||
blake2s_increment_counter( S, BLAKE2S_BLOCKBYTES );
|
||||
blake2s_compress( S, S->buf ); // Compress
|
||||
memcpy( S->buf, S->buf + BLAKE2S_BLOCKBYTES, BLAKE2S_BLOCKBYTES ); // Shift buffer left
|
||||
S->buflen -= BLAKE2S_BLOCKBYTES;
|
||||
in += fill;
|
||||
inlen -= fill;
|
||||
}
|
||||
else // inlen <= fill
|
||||
{
|
||||
memcpy(S->buf + left, in, (size_t) inlen);
|
||||
S->buflen += (size_t) inlen; // Be lazy, do not compress
|
||||
in += inlen;
|
||||
inlen -= inlen;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int blake2s_final( blake2s_state *S, uint8_t *out, uint8_t outlen )
|
||||
{
|
||||
uint8_t buffer[BLAKE2S_OUTBYTES];
|
||||
|
||||
if( S->buflen > BLAKE2S_BLOCKBYTES )
|
||||
{
|
||||
blake2s_increment_counter( S, BLAKE2S_BLOCKBYTES );
|
||||
blake2s_compress( S, S->buf );
|
||||
S->buflen -= BLAKE2S_BLOCKBYTES;
|
||||
memcpy( S->buf, S->buf + BLAKE2S_BLOCKBYTES, S->buflen );
|
||||
}
|
||||
|
||||
blake2s_increment_counter( S, ( uint32_t )S->buflen );
|
||||
blake2s_set_lastblock( S );
|
||||
memset( S->buf + S->buflen, 0, 2 * BLAKE2S_BLOCKBYTES - S->buflen ); /* Padding */
|
||||
blake2s_compress( S, S->buf );
|
||||
|
||||
for( int i = 0; i < 8; ++i ) /* Output full hash to temp buffer */
|
||||
store32( buffer + sizeof( S->h[i] ) * i, S->h[i] );
|
||||
|
||||
memcpy( out, buffer, outlen );
|
||||
return 0;
|
||||
}
|
||||
|
||||
int blake2s( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen )
|
||||
{
|
||||
blake2s_state S[1];
|
||||
|
||||
/* Verify parameters */
|
||||
if ( NULL == in ) return -1;
|
||||
|
||||
if ( NULL == out ) return -1;
|
||||
|
||||
if ( NULL == key ) keylen = 0; /* Fail here instead if keylen != 0 and key == NULL? */
|
||||
|
||||
if( keylen > 0 )
|
||||
{
|
||||
if( blake2s_init_key( S, outlen, key, keylen ) < 0 ) return -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
if( blake2s_init( S, outlen ) < 0 ) return -1;
|
||||
}
|
||||
|
||||
blake2s_update( S, ( uint8_t * )in, inlen );
|
||||
blake2s_final( S, out, outlen );
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if defined(__cplusplus)
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#if defined(BLAKE2S_SELFTEST)
|
||||
#include <string.h>
|
||||
#include "blake2-kat.h" /* test data not included */
|
||||
int main( int argc, char **argv )
|
||||
{
|
||||
uint8_t key[BLAKE2S_KEYBYTES];
|
||||
uint8_t buf[KAT_LENGTH];
|
||||
|
||||
for( size_t i = 0; i < BLAKE2S_KEYBYTES; ++i )
|
||||
key[i] = ( uint8_t )i;
|
||||
|
||||
for( size_t i = 0; i < KAT_LENGTH; ++i )
|
||||
buf[i] = ( uint8_t )i;
|
||||
|
||||
for( size_t i = 0; i < KAT_LENGTH; ++i )
|
||||
{
|
||||
uint8_t hash[BLAKE2S_OUTBYTES];
|
||||
blake2s( hash, buf, key, BLAKE2S_OUTBYTES, i, BLAKE2S_KEYBYTES );
|
||||
|
||||
if( 0 != memcmp( hash, blake2s_keyed_kat[i], BLAKE2S_OUTBYTES ) )
|
||||
{
|
||||
puts( "error" );
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
puts( "ok" );
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
+150
@@ -0,0 +1,150 @@
|
||||
/**
|
||||
* BLAKE2 reference source code package - reference C implementations
|
||||
*
|
||||
* Written in 2012 by Samuel Neves <sneves@dei.uc.pt>
|
||||
*
|
||||
* To the extent possible under law, the author(s) have dedicated all copyright
|
||||
* and related and neighboring rights to this software to the public domain
|
||||
* worldwide. This software is distributed without any warranty.
|
||||
*
|
||||
* You should have received a copy of the CC0 Public Domain Dedication along with
|
||||
* this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
|
||||
*/
|
||||
#pragma once
|
||||
#ifndef __BLAKE2_H__
|
||||
#define __BLAKE2_H__
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#include <inttypes.h>
|
||||
#define inline __inline
|
||||
#define ALIGN(x) __declspec(align(x))
|
||||
#else
|
||||
#define ALIGN(x) __attribute__((aligned(x)))
|
||||
#endif
|
||||
|
||||
/* blake2-impl.h */
|
||||
|
||||
static inline uint32_t load32(const void *src)
|
||||
{
|
||||
#if defined(NATIVE_LITTLE_ENDIAN)
|
||||
return *(uint32_t *)(src);
|
||||
#else
|
||||
const uint8_t *p = (uint8_t *)src;
|
||||
uint32_t w = *p++;
|
||||
w |= (uint32_t)(*p++) << 8;
|
||||
w |= (uint32_t)(*p++) << 16;
|
||||
w |= (uint32_t)(*p++) << 24;
|
||||
return w;
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline void store32(void *dst, uint32_t w)
|
||||
{
|
||||
#if defined(NATIVE_LITTLE_ENDIAN)
|
||||
*(uint32_t *)(dst) = w;
|
||||
#else
|
||||
uint8_t *p = (uint8_t *)dst;
|
||||
*p++ = (uint8_t)w; w >>= 8;
|
||||
*p++ = (uint8_t)w; w >>= 8;
|
||||
*p++ = (uint8_t)w; w >>= 8;
|
||||
*p++ = (uint8_t)w;
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline uint64_t load48(const void *src)
|
||||
{
|
||||
const uint8_t *p = (const uint8_t *)src;
|
||||
uint64_t w = *p++;
|
||||
w |= (uint64_t)(*p++) << 8;
|
||||
w |= (uint64_t)(*p++) << 16;
|
||||
w |= (uint64_t)(*p++) << 24;
|
||||
w |= (uint64_t)(*p++) << 32;
|
||||
w |= (uint64_t)(*p++) << 40;
|
||||
return w;
|
||||
}
|
||||
|
||||
static inline void store48(void *dst, uint64_t w)
|
||||
{
|
||||
uint8_t *p = (uint8_t *)dst;
|
||||
*p++ = (uint8_t)w; w >>= 8;
|
||||
*p++ = (uint8_t)w; w >>= 8;
|
||||
*p++ = (uint8_t)w; w >>= 8;
|
||||
*p++ = (uint8_t)w; w >>= 8;
|
||||
*p++ = (uint8_t)w; w >>= 8;
|
||||
*p++ = (uint8_t)w;
|
||||
}
|
||||
|
||||
/* prevents compiler optimizing out memset() */
|
||||
static inline void secure_zero_memory(void *v, size_t n)
|
||||
{
|
||||
volatile uint8_t *p = ( volatile uint8_t * )v;
|
||||
|
||||
while( n-- ) *p++ = 0;
|
||||
}
|
||||
|
||||
/* blake2.h */
|
||||
|
||||
enum blake2s_constant
|
||||
{
|
||||
BLAKE2S_BLOCKBYTES = 64,
|
||||
BLAKE2S_OUTBYTES = 32,
|
||||
BLAKE2S_KEYBYTES = 32,
|
||||
BLAKE2S_SALTBYTES = 8,
|
||||
BLAKE2S_PERSONALBYTES = 8
|
||||
};
|
||||
|
||||
#pragma pack(push, 1)
|
||||
typedef struct __blake2s_param
|
||||
{
|
||||
uint8_t digest_length; // 1
|
||||
uint8_t key_length; // 2
|
||||
uint8_t fanout; // 3
|
||||
uint8_t depth; // 4
|
||||
uint32_t leaf_length; // 8
|
||||
uint8_t node_offset[6];// 14
|
||||
uint8_t node_depth; // 15
|
||||
uint8_t inner_length; // 16
|
||||
// uint8_t reserved[0];
|
||||
uint8_t salt[BLAKE2S_SALTBYTES]; // 24
|
||||
uint8_t personal[BLAKE2S_PERSONALBYTES]; // 32
|
||||
} blake2s_param;
|
||||
|
||||
ALIGN( 64 ) typedef struct __blake2s_state
|
||||
{
|
||||
uint32_t h[8];
|
||||
uint32_t t[2];
|
||||
uint32_t f[2];
|
||||
uint8_t buf[2 * BLAKE2S_BLOCKBYTES];
|
||||
size_t buflen;
|
||||
uint8_t last_node;
|
||||
} blake2s_state;
|
||||
#pragma pack(pop)
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
int blake2s_compress( blake2s_state *S, const uint8_t block[BLAKE2S_BLOCKBYTES] );
|
||||
|
||||
// Streaming API
|
||||
int blake2s_init( blake2s_state *S, const uint8_t outlen );
|
||||
int blake2s_init_key( blake2s_state *S, const uint8_t outlen, const void *key, const uint8_t keylen );
|
||||
int blake2s_init_param( blake2s_state *S, const blake2s_param *P );
|
||||
int blake2s_update( blake2s_state *S, const uint8_t *in, uint64_t inlen );
|
||||
int blake2s_final( blake2s_state *S, uint8_t *out, uint8_t outlen );
|
||||
|
||||
// Simple API
|
||||
int blake2s( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen );
|
||||
|
||||
// Direct Hash Mining Helpers
|
||||
#define blake2s_salt32(out, in, inlen, key32) blake2s(out, in, key32, 32, inlen, 32) /* neoscrypt */
|
||||
#define blake2s_simple(out, in, inlen) blake2s(out, in, NULL, 32, inlen, 0)
|
||||
|
||||
#if defined(__cplusplus)
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
+1
-1
@@ -508,7 +508,7 @@ static inline int scanhash_sha256d_4way(int thr_id, uint32_t *pdata,
|
||||
pdata[19] = data[4 * 3 + i];
|
||||
sha256d_80_swap(hash, pdata);
|
||||
if (fulltest(hash, ptarget)) {
|
||||
bn_store_hash_target_ratio(hash, ptarget, work);
|
||||
work_set_target_ratio(work, hash);
|
||||
*hashes_done = n - first_nonce + 1;
|
||||
return 1;
|
||||
}
|
||||
|
||||
@@ -231,6 +231,11 @@ void sph_blake256_close(void *cc, void *dst);
|
||||
void sph_blake256_addbits_and_close(
|
||||
void *cc, unsigned ub, unsigned n, void *dst);
|
||||
|
||||
/**
|
||||
* Allow blakecoin and blake variants
|
||||
*/
|
||||
void sph_blake256_set_rounds(int rounds);
|
||||
|
||||
#if SPH_64
|
||||
|
||||
/**
|
||||
|
||||
@@ -0,0 +1,185 @@
|
||||
/* $Id: sph_gost.h 216 2010-06-08 09:46:57Z tp $ */
|
||||
/**
|
||||
* GOST interface. This is the interface for GOST R 12 with the
|
||||
* recommended parameters for SHA-3, with output lengths 256
|
||||
* and 512 bits.
|
||||
*
|
||||
* ==========================(LICENSE BEGIN)============================
|
||||
*
|
||||
* Copyright (c) 2007-2010 Projet RNRT SAPHIR
|
||||
*
|
||||
* 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)=============================
|
||||
*
|
||||
* @file sph_gost.h
|
||||
* @author Mish <mish@btchouse.com>
|
||||
*/
|
||||
|
||||
#ifndef SPH_GOST_H__
|
||||
#define SPH_GOST_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
|
||||
#include <stddef.h>
|
||||
#include "sph_types.h"
|
||||
|
||||
/**
|
||||
* Output size (in bits) for GOST-256.
|
||||
*/
|
||||
#define SPH_SIZE_gost256 256
|
||||
|
||||
/**
|
||||
* Output size (in bits) for GOST-512.
|
||||
*/
|
||||
#define SPH_SIZE_gost512 512
|
||||
|
||||
/**
|
||||
* This structure is a context for Keccak computations: it contains the
|
||||
* intermediate values and some data from the last entered block. Once a
|
||||
* GOST computation has been performed, the context can be reused for
|
||||
* another computation.
|
||||
*
|
||||
* The contents of this structure are private. A running GOST computation
|
||||
* can be cloned by copying the context (e.g. with a simple
|
||||
* <code>memcpy()</code>).
|
||||
*/
|
||||
|
||||
/**
|
||||
* This structure is a context for Gost-256 computations.
|
||||
*/
|
||||
|
||||
typedef struct {
|
||||
#ifndef DOXYGEN_IGNORE
|
||||
unsigned char buf[32]; /* first field, for alignment */
|
||||
size_t ptr;
|
||||
sph_u32 V[3][8];
|
||||
#endif
|
||||
} sph_gost256_context;
|
||||
|
||||
/**
|
||||
* This structure is a context for Gost-512 computations.
|
||||
*/
|
||||
typedef struct {
|
||||
#ifndef DOXYGEN_IGNORE
|
||||
unsigned char buf[64]; /* first field, for alignment */
|
||||
size_t ptr;
|
||||
sph_u32 V[5][8];
|
||||
#endif
|
||||
} sph_gost512_context;
|
||||
|
||||
|
||||
/**
|
||||
* Initialize a GOST-256 context. This process performs no memory allocation.
|
||||
*
|
||||
* @param cc the GOST-256 context (pointer to a
|
||||
* <code>sph_gost256_context</code>)
|
||||
*/
|
||||
void sph_gost256_init(void *cc);
|
||||
|
||||
/**
|
||||
* Process some data bytes. It is acceptable that <code>len</code> is zero
|
||||
* (in which case this function does nothing).
|
||||
*
|
||||
* @param cc the Gost-256 context
|
||||
* @param data the input data
|
||||
* @param len the input data length (in bytes)
|
||||
*/
|
||||
void sph_gost256(void *cc, const void *data, size_t len);
|
||||
|
||||
/**
|
||||
* Terminate the current GOST-256 computation and output the result into
|
||||
* the provided buffer. The destination buffer must be wide enough to
|
||||
* accomodate the result (32 bytes). The context is automatically
|
||||
* reinitialized.
|
||||
*
|
||||
* @param cc the GOST-256 context
|
||||
* @param dst the destination buffer
|
||||
*/
|
||||
void sph_gost256_close(void *cc, void *dst);
|
||||
|
||||
/**
|
||||
* Add a few additional bits (0 to 7) to the current computation, then
|
||||
* terminate it and output the result in the provided buffer, which must
|
||||
* be wide enough to accomodate the result (32 bytes). If bit number i
|
||||
* in <code>ub</code> has value 2^i, then the extra bits are those
|
||||
* numbered 7 downto 8-n (this is the big-endian convention at the byte
|
||||
* level). The context is automatically reinitialized.
|
||||
*
|
||||
* @param cc the GOST-256 context
|
||||
* @param ub the extra bits
|
||||
* @param n the number of extra bits (0 to 7)
|
||||
* @param dst the destination buffer
|
||||
*/
|
||||
void sph_gost256_addbits_and_close(
|
||||
void *cc, unsigned ub, unsigned n, void *dst);
|
||||
|
||||
/**
|
||||
* Initialize a Gost-512 context. This process performs no memory allocation.
|
||||
*
|
||||
* @param cc the GOST-512 context (pointer to a
|
||||
* <code>sph_gost512_context</code>)
|
||||
*/
|
||||
void sph_gost512_init(void *cc);
|
||||
|
||||
/**
|
||||
* Process some data bytes. It is acceptable that <code>len</code> is zero
|
||||
* (in which case this function does nothing).
|
||||
*
|
||||
* @param cc the GOST-512 context
|
||||
* @param data the input data
|
||||
* @param len the input data length (in bytes)
|
||||
*/
|
||||
void sph_gost512(void *cc, const void *data, size_t len);
|
||||
|
||||
/**
|
||||
* Terminate the current GOST-512 computation and output the result into
|
||||
* the provided buffer. The destination buffer must be wide enough to
|
||||
* accomodate the result (64 bytes). The context is automatically
|
||||
* reinitialized.
|
||||
*
|
||||
* @param cc the GOST-512 context
|
||||
* @param dst the destination buffer
|
||||
*/
|
||||
void sph_gost512_close(void *cc, void *dst);
|
||||
|
||||
/**
|
||||
* Add a few additional bits (0 to 7) to the current computation, then
|
||||
* terminate it and output the result in the provided buffer, which must
|
||||
* be wide enough to accomodate the result (64 bytes). If bit number i
|
||||
* in <code>ub</code> has value 2^i, then the extra bits are those
|
||||
* numbered 7 downto 8-n (this is the big-endian convention at the byte
|
||||
* level). The context is automatically reinitialized.
|
||||
*
|
||||
* @param cc the GOST-512 context
|
||||
* @param ub the extra bits
|
||||
* @param n the number of extra bits (0 to 7)
|
||||
* @param dst the destination buffer
|
||||
*/
|
||||
void sph_gost512_addbits_and_close(
|
||||
void *cc, unsigned ub, unsigned n, void *dst);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
+1045
File diff suppressed because it is too large.
Load diff
@@ -1,695 +0,0 @@
|
||||
/*
|
||||
|
||||
Based on libtommath and tomsfastmath by Tom St Denis
|
||||
|
||||
This is basically Barret reduction and it's setup from libtommath and
|
||||
basic bignum types and functions from tomsfastmath with some application
|
||||
specific optimizations like dropping sign handling and branches that are
|
||||
never reached, hard coding for a specific digit size (replacing slow ops like
|
||||
x % DIGIT_BIT with x & 31 etc).
|
||||
|
||||
Could probably do a lot better with CUDA, this code spills to local memory
|
||||
like a mofo due to dynamic array indexes.
|
||||
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#ifndef CHAR_BIT
|
||||
#define CHAR_BIT 8
|
||||
#endif
|
||||
|
||||
#ifndef MIN
|
||||
#define MIN(x,y) ((x)<(y)?(x):(y))
|
||||
#endif
|
||||
|
||||
#ifndef MAX
|
||||
#define MAX(x,y) ((x)>(y)?(x):(y))
|
||||
#endif
|
||||
|
||||
#define DIGIT_BIT 32
|
||||
#define FP_SIZE 20
|
||||
|
||||
typedef uint32_t fp_digit;
|
||||
typedef uint64_t fp_word;
|
||||
typedef fp_digit fp_min_u32;
|
||||
|
||||
/* return codes */
|
||||
#define FP_OKAY 0
|
||||
#define FP_VAL 1
|
||||
#define FP_MEM 2
|
||||
|
||||
/* equalities */
|
||||
#define FP_LT -1 /* less than */
|
||||
#define FP_EQ 0 /* equal to */
|
||||
#define FP_GT 1 /* greater than */
|
||||
|
||||
/* replies */
|
||||
#define FP_YES 1 /* yes response */
|
||||
#define FP_NO 0 /* no response */
|
||||
|
||||
typedef int fp_err;
|
||||
|
||||
typedef struct {
|
||||
int used;
|
||||
fp_digit dp[FP_SIZE];
|
||||
} fp_int;
|
||||
|
||||
#define USED(m) ((m)->used)
|
||||
#define DIGIT(m,k) ((m)->dp[(k)])
|
||||
|
||||
#define fp_iszero(a) (((a)->used == 0) ? FP_YES : FP_NO)
|
||||
#define fp_iseven(a) (((a)->used > 0 && (((a)->dp[0] & 1) == 0)) ? FP_YES : FP_NO)
|
||||
#define fp_isodd(a) (((a)->used > 0 && (((a)->dp[0] & 1) == 1)) ? FP_YES : FP_NO)
|
||||
#define fp_init(a) fp_zero((a))
|
||||
#define fp_mul(a,b,c) fp_mul_comba((a), (b), (c))
|
||||
|
||||
/* clamp digits */
|
||||
#define fp_clamp(a) { while ((a)->used && (a)->dp[(a)->used-1] == 0) --((a)->used); }
|
||||
|
||||
__device__ __host__ void fp_zero( fp_int *a )
|
||||
{
|
||||
for( int i = 0; i < FP_SIZE; i++ ) a->dp[i] = 0;
|
||||
a->used = 0;
|
||||
}
|
||||
|
||||
__device__ __host__ void fp_set( fp_int *a, fp_digit b )
|
||||
{
|
||||
fp_zero(a);
|
||||
a->dp[0] = b;
|
||||
a->used = a->dp[0] ? 1 : 0;
|
||||
}
|
||||
|
||||
__device__ __host__ int fp_cmp_mag( fp_int *a, fp_int *b )
|
||||
{
|
||||
if( a->used > b->used ) return FP_GT;
|
||||
else if( a->used < b->used ) return FP_LT;
|
||||
|
||||
for( int x = a->used - 1; x >= 0; x-- ) {
|
||||
|
||||
if( a->dp[x] > b->dp[x] ) return FP_GT;
|
||||
else if( a->dp[x] < b->dp[x] ) return FP_LT;
|
||||
}
|
||||
|
||||
return FP_EQ;
|
||||
}
|
||||
|
||||
/* unsigned addition */
|
||||
__device__ __host__ void s_fp_add(fp_int *a, fp_int *b, fp_int *c)
|
||||
{
|
||||
int x, y, oldused;
|
||||
fp_word t;
|
||||
|
||||
y = MAX(a->used, b->used);
|
||||
oldused = c->used;
|
||||
c->used = y;
|
||||
|
||||
t = 0;
|
||||
for (x = 0; x < y; x++) {
|
||||
t += ((fp_word)a->dp[x]) + ((fp_word)b->dp[x]);
|
||||
c->dp[x] = (fp_digit)t;
|
||||
t >>= DIGIT_BIT;
|
||||
}
|
||||
if (t != 0 && x < FP_SIZE) {
|
||||
c->dp[c->used++] = (fp_digit)t;
|
||||
++x;
|
||||
}
|
||||
|
||||
c->used = x;
|
||||
for (; x < oldused; x++) {
|
||||
c->dp[x] = 0;
|
||||
}
|
||||
fp_clamp(c);
|
||||
}
|
||||
|
||||
/* unsigned subtraction ||a|| >= ||b|| ALWAYS! */
|
||||
__device__ __host__ void s_fp_sub(fp_int *a, fp_int *b, fp_int *c)
|
||||
{
|
||||
int x, oldbused, oldused;
|
||||
fp_word t;
|
||||
|
||||
oldused = c->used;
|
||||
oldbused = b->used;
|
||||
c->used = a->used;
|
||||
t = 0;
|
||||
for (x = 0; x < oldbused; x++) {
|
||||
t = ((fp_word)a->dp[x]) - (((fp_word)b->dp[x]) + t);
|
||||
c->dp[x] = (fp_digit)t;
|
||||
t = (t >> DIGIT_BIT)&1;
|
||||
}
|
||||
for (; x < a->used; x++) {
|
||||
t = ((fp_word)a->dp[x]) - t;
|
||||
c->dp[x] = (fp_digit)t;
|
||||
t = (t >> DIGIT_BIT)&1;
|
||||
}
|
||||
for (; x < oldused; x++) {
|
||||
c->dp[x] = 0;
|
||||
}
|
||||
fp_clamp(c);
|
||||
}
|
||||
|
||||
__device__ __host__ void fp_add( fp_int *a, fp_int *b, fp_int *c )
|
||||
{
|
||||
s_fp_add (a, b, c);
|
||||
}
|
||||
|
||||
/* c = a - b */
|
||||
__device__ __host__ void fp_sub(fp_int *a, fp_int *b, fp_int *c)
|
||||
{
|
||||
// int sa, sb;
|
||||
|
||||
/* The first has a larger or equal magnitude */
|
||||
s_fp_sub (a, b, c);
|
||||
}
|
||||
|
||||
__device__ __host__ int fp_cmp(fp_int *a, fp_int *b)
|
||||
{
|
||||
return fp_cmp_mag(a, b);
|
||||
}
|
||||
|
||||
__device__ __host__ void fp_copy( fp_int *a, fp_int *b )
|
||||
{
|
||||
for( int i = 0; i < FP_SIZE; i++ ) b->dp[i] = a->dp[i];
|
||||
b->used = a->used;
|
||||
}
|
||||
|
||||
// TODO: use clz, return a->used - clz(a->dp[a->used-1])
|
||||
__device__ __host__ int fp_count_bits( fp_int *a )
|
||||
{
|
||||
int r;
|
||||
fp_digit q;
|
||||
|
||||
/* shortcut */
|
||||
if (a->used == 0) return 0;
|
||||
|
||||
/* get number of digits and add that */
|
||||
r = (a->used - 1) << 5;
|
||||
|
||||
/* take the last digit and count the bits in it */
|
||||
q = a->dp[a->used - 1];
|
||||
while (q > ((fp_digit) 0)) {
|
||||
++r;
|
||||
q >>= ((fp_digit) 1);
|
||||
}
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
__device__ __host__ void fp_rshd( fp_int *a, int x )
|
||||
{
|
||||
int y;
|
||||
|
||||
/* too many digits just zero and return */
|
||||
if (x >= a->used) {
|
||||
|
||||
fp_zero(a);
|
||||
return;
|
||||
}
|
||||
|
||||
/* shift */
|
||||
for (y = 0; y < a->used - x; y++) a->dp[y] = a->dp[y+x];
|
||||
|
||||
/* zero rest */
|
||||
for (; y < a->used; y++) a->dp[y] = 0;
|
||||
|
||||
/* decrement count */
|
||||
a->used -= x;
|
||||
fp_clamp(a);
|
||||
}
|
||||
|
||||
__device__ __host__ void fp_lshd(fp_int *a, int x)
|
||||
{
|
||||
int y;
|
||||
|
||||
/* move up and truncate as required */
|
||||
y = MIN(a->used + x - 1, (int)(FP_SIZE-1));
|
||||
|
||||
/* store new size */
|
||||
a->used = y + 1;
|
||||
|
||||
/* move digits */
|
||||
for (; y >= x; y--) a->dp[y] = a->dp[y-x];
|
||||
|
||||
/* zero lower digits */
|
||||
for (; y >= 0; y--) a->dp[y] = 0;
|
||||
|
||||
/* clamp digits */
|
||||
fp_clamp(a);
|
||||
}
|
||||
|
||||
/* c = a * 2**d */
|
||||
__device__ __host__ void fp_mul_2d( fp_int *a, int b, fp_int *c )
|
||||
{
|
||||
fp_digit carry, carrytmp, shift;
|
||||
int x;
|
||||
|
||||
/* copy it */
|
||||
fp_copy(a, c);
|
||||
|
||||
/* handle whole digits */
|
||||
if (b >= DIGIT_BIT) {
|
||||
fp_lshd(c, b >> 5);
|
||||
}
|
||||
b &= 31;
|
||||
|
||||
/* shift the digits */
|
||||
if (b != 0) {
|
||||
carry = 0;
|
||||
shift = DIGIT_BIT - b;
|
||||
for (x = 0; x < c->used; x++) {
|
||||
carrytmp = c->dp[x] >> shift;
|
||||
c->dp[x] = (c->dp[x] << b) + carry;
|
||||
carry = carrytmp;
|
||||
}
|
||||
|
||||
/* store last carry if room */
|
||||
if (carry && x < FP_SIZE) c->dp[c->used++] = carry;
|
||||
}
|
||||
fp_clamp(c);
|
||||
}
|
||||
|
||||
/* c = a * b */
|
||||
__device__ __host__ void fp_mul_d( fp_int *a, fp_digit b, fp_int *c )
|
||||
{
|
||||
fp_word w;
|
||||
int x, oldused;
|
||||
|
||||
oldused = c->used;
|
||||
c->used = a->used;
|
||||
w = 0;
|
||||
|
||||
for (x = 0; x < a->used; x++) {
|
||||
w = ((fp_word)a->dp[x]) * ((fp_word)b) + w;
|
||||
c->dp[x] = (fp_digit)w;
|
||||
w = w >> DIGIT_BIT;
|
||||
}
|
||||
|
||||
if (w != 0 && (a->used != FP_SIZE)) {
|
||||
c->dp[c->used++] = w;
|
||||
++x;
|
||||
}
|
||||
|
||||
for (; x < oldused; x++) c->dp[x] = 0;
|
||||
|
||||
fp_clamp(c);
|
||||
}
|
||||
|
||||
/* c = a mod 2**d */
|
||||
__device__ __host__ void fp_mod_2d( fp_int *a, int b, fp_int *c )
|
||||
{
|
||||
int x;
|
||||
|
||||
/* zero if count less than or equal to zero */
|
||||
if (b <= 0) {
|
||||
fp_zero(c);
|
||||
return;
|
||||
}
|
||||
|
||||
/* get copy of input */
|
||||
fp_copy(a, c);
|
||||
|
||||
/* if 2**d is larger than we just return */
|
||||
if (b >= (a->used << 5)) return;
|
||||
|
||||
/* zero digits above the last digit of the modulus */
|
||||
for (x = (b >> 5) + ((b & 31) == 0 ? 0 : 1); x < c->used; x++) {
|
||||
c->dp[x] = 0;
|
||||
}
|
||||
|
||||
/* clear the digit that is not completely outside/inside the modulus */
|
||||
c->dp[b >> 5] &= ~((fp_digit)0) >> (DIGIT_BIT - b);
|
||||
fp_clamp (c);
|
||||
}
|
||||
|
||||
/* c = a / 2**b */
|
||||
__device__ __host__ void fp_div_2d( fp_int *a, int b, fp_int *c, fp_int *d )
|
||||
{
|
||||
fp_digit D, r, rr;
|
||||
int x;
|
||||
fp_int t;
|
||||
|
||||
/* if the shift count is <= 0 then we do no work */
|
||||
if (b <= 0) {
|
||||
fp_copy (a, c);
|
||||
if (d != NULL) fp_zero (d);
|
||||
return;
|
||||
}
|
||||
|
||||
fp_zero(&t);
|
||||
|
||||
/* get the remainder */
|
||||
if (d != NULL) fp_mod_2d (a, b, &t);
|
||||
|
||||
/* copy */
|
||||
fp_copy(a, c);
|
||||
|
||||
/* shift by as many digits in the bit count */
|
||||
if (b >= (int)DIGIT_BIT) fp_rshd (c, b >> 5);
|
||||
|
||||
/* shift any bit count < DIGIT_BIT */
|
||||
D = (fp_digit) (b & 31);
|
||||
if (D != 0) {
|
||||
fp_digit *tmpc, mask, shift;
|
||||
|
||||
/* mask */
|
||||
mask = (((fp_digit)1) << D) - 1;
|
||||
|
||||
/* shift for lsb */
|
||||
shift = DIGIT_BIT - D;
|
||||
|
||||
/* alias */
|
||||
tmpc = c->dp + (c->used - 1);
|
||||
|
||||
/* carry */
|
||||
r = 0;
|
||||
for (x = c->used - 1; x >= 0; x--) {
|
||||
/* get the lower bits of this word in a temp */
|
||||
rr = *tmpc & mask;
|
||||
|
||||
/* shift the current word and mix in the carry bits from the previous word */
|
||||
*tmpc = (*tmpc >> D) | (r << shift);
|
||||
--tmpc;
|
||||
|
||||
/* set the carry to the carry bits of the current word found above */
|
||||
r = rr;
|
||||
}
|
||||
}
|
||||
fp_clamp (c);
|
||||
|
||||
if (d != NULL) fp_copy (&t, d);
|
||||
}
|
||||
|
||||
/* a/b => cb + d == a */
|
||||
__device__ __host__ void fp_div( fp_int *a, fp_int *b, fp_int *c, fp_int *d )
|
||||
{
|
||||
fp_int q, x, y, t1, t2;
|
||||
int n, t, i, norm;
|
||||
|
||||
/* if a < b then q=0, r = a */
|
||||
if( fp_cmp_mag(a, b) == FP_LT ) {
|
||||
|
||||
if (d != NULL) fp_copy(a, d);
|
||||
if (c != NULL) fp_zero(c);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
fp_init(&q);
|
||||
q.used = a->used + 2;
|
||||
fp_init(&t1);
|
||||
fp_init(&t2);
|
||||
fp_copy(a, &x);
|
||||
fp_copy(b, &y);
|
||||
|
||||
/* normalize both x and y, ensure that y >= b/2, [b == 2**DIGIT_BIT] */
|
||||
norm = fp_count_bits(&y) & 31;
|
||||
if (norm < (int)(DIGIT_BIT-1)) {
|
||||
norm = (DIGIT_BIT-1) - norm;
|
||||
fp_mul_2d (&x, norm, &x);
|
||||
fp_mul_2d (&y, norm, &y);
|
||||
}
|
||||
else {
|
||||
norm = 0;
|
||||
}
|
||||
|
||||
/* note hac does 0 based, so if used==5 then its 0,1,2,3,4, e.g. use 4 */
|
||||
n = x.used - 1;
|
||||
t = y.used - 1;
|
||||
|
||||
/* while (x >= y*b**n-t) do { q[n-t] += 1; x -= y*b**{n-t} } */
|
||||
fp_lshd (&y, n - t); /* y = y*b**{n-t} */
|
||||
|
||||
while (fp_cmp (&x, &y) != FP_LT) {
|
||||
++(q.dp[n - t]);
|
||||
fp_sub (&x, &y, &x);
|
||||
}
|
||||
|
||||
/* reset y by shifting it back down */
|
||||
fp_rshd (&y, n - t);
|
||||
|
||||
/* step 3. for i from n down to (t + 1) */
|
||||
for (i = n; i >= (t + 1); i--) {
|
||||
|
||||
if (i > x.used) continue;
|
||||
|
||||
/* step 3.1 if xi == yt then set q{i-t-1} to b-1,
|
||||
* otherwise set q{i-t-1} to (xi*b + x{i-1})/yt */
|
||||
if (x.dp[i] == y.dp[t]) {
|
||||
q.dp[i - t - 1] = ((((fp_word)1) << DIGIT_BIT) - 1);
|
||||
}
|
||||
else {
|
||||
fp_word tmp;
|
||||
tmp = ((fp_word) x.dp[i]) << ((fp_word) DIGIT_BIT);
|
||||
tmp |= ((fp_word) x.dp[i - 1]);
|
||||
tmp /= ((fp_word) y.dp[t]);
|
||||
q.dp[i - t - 1] = (fp_digit) (tmp);
|
||||
}
|
||||
|
||||
/* while (q{i-t-1} * (yt * b + y{t-1})) >
|
||||
xi * b**2 + xi-1 * b + xi-2
|
||||
|
||||
do q{i-t-1} -= 1;
|
||||
*/
|
||||
q.dp[i - t - 1] = (q.dp[i - t - 1] + 1);
|
||||
do {
|
||||
q.dp[i - t - 1] = (q.dp[i - t - 1] - 1);
|
||||
|
||||
/* find left hand */
|
||||
fp_zero (&t1);
|
||||
t1.dp[0] = (t - 1 < 0) ? 0 : y.dp[t - 1];
|
||||
t1.dp[1] = y.dp[t];
|
||||
t1.used = 2;
|
||||
fp_mul_d (&t1, q.dp[i - t - 1], &t1);
|
||||
|
||||
/* find right hand */
|
||||
t2.dp[0] = (i - 2 < 0) ? 0 : x.dp[i - 2];
|
||||
t2.dp[1] = (i - 1 < 0) ? 0 : x.dp[i - 1];
|
||||
t2.dp[2] = x.dp[i];
|
||||
t2.used = 3;
|
||||
} while (fp_cmp_mag(&t1, &t2) == FP_GT);
|
||||
|
||||
/* step 3.3 x = x - q{i-t-1} * y * b**{i-t-1} */
|
||||
fp_mul_d (&y, q.dp[i - t - 1], &t1);
|
||||
fp_lshd (&t1, i - t - 1);
|
||||
fp_sub (&x, &t1, &x);
|
||||
|
||||
}
|
||||
|
||||
/* now q is the quotient and x is the remainder
|
||||
* [which we have to normalize]
|
||||
*/
|
||||
|
||||
if (c != NULL) {
|
||||
fp_clamp (&q);
|
||||
fp_copy (&q, c);
|
||||
}
|
||||
|
||||
if (d != NULL) {
|
||||
fp_div_2d (&x, norm, &x, NULL);
|
||||
|
||||
/* the following is a kludge, essentially we were seeing the right remainder but
|
||||
with excess digits that should have been zero
|
||||
*/
|
||||
for (i = b->used; i < x.used; i++) x.dp[i] = 0;
|
||||
|
||||
fp_clamp(&x);
|
||||
fp_copy (&x, d);
|
||||
}
|
||||
}
|
||||
|
||||
__device__ __host__ void fp_2expt( fp_int *a, int b )
|
||||
{
|
||||
int z;
|
||||
|
||||
fp_zero (a);
|
||||
|
||||
z = b >> 5;
|
||||
|
||||
/* set the used count of where the bit will go */
|
||||
a->used = z + 1;
|
||||
|
||||
/* put the single bit in its place */
|
||||
a->dp[z] = ((fp_digit)1) << (b & 31);
|
||||
}
|
||||
|
||||
/* generic PxQ multiplier */
|
||||
__device__ __host__ void fp_mul_comba(fp_int *A, fp_int *B, fp_int *C)
|
||||
{
|
||||
int ix, iy, iz, tx, ty, pa;
|
||||
fp_digit c0, c1, c2, *tmpx, *tmpy;
|
||||
fp_int tmp, *dst;
|
||||
|
||||
c0 = c1 = c2 = 0;
|
||||
|
||||
/* get size of output and trim */
|
||||
pa = A->used + B->used;
|
||||
if (pa >= FP_SIZE) pa = FP_SIZE-1;
|
||||
|
||||
if (A == C || B == C) {
|
||||
fp_zero(&tmp);
|
||||
dst = &tmp;
|
||||
}
|
||||
else {
|
||||
fp_zero(C);
|
||||
dst = C;
|
||||
}
|
||||
|
||||
for (ix = 0; ix < pa; ix++) {
|
||||
|
||||
/* get offsets into the two bignums */
|
||||
ty = MIN(ix, B->used-1);
|
||||
tx = ix - ty;
|
||||
|
||||
/* setup temp aliases */
|
||||
tmpx = A->dp + tx;
|
||||
tmpy = B->dp + ty;
|
||||
|
||||
/* this is the number of times the loop will iterrate, essentially its
|
||||
while (tx++ < a->used && ty-- >= 0) { ... }
|
||||
*/
|
||||
iy = MIN(A->used-tx, ty+1);
|
||||
|
||||
/* execute loop */
|
||||
c0 = c1; c1 = c2; c2 = 0;
|
||||
|
||||
for (iz = 0; iz < iy; ++iz) {
|
||||
|
||||
fp_word t;
|
||||
t = (fp_word)c0 + ((fp_word)*tmpx++) * ((fp_word)*tmpy--);
|
||||
c0 = t;
|
||||
t = (fp_word)c1 + (t >> DIGIT_BIT);
|
||||
c1 = t;
|
||||
c2 += t >> DIGIT_BIT;
|
||||
}
|
||||
|
||||
/* store term */
|
||||
dst->dp[ix] = c0;
|
||||
}
|
||||
|
||||
dst->used = pa;
|
||||
fp_clamp(dst);
|
||||
fp_copy(dst, C);
|
||||
}
|
||||
|
||||
__device__ __host__ void fp_read_unsigned_bin(fp_int *a, unsigned char *b, int c)
|
||||
{
|
||||
/* zero the int */
|
||||
fp_zero (a);
|
||||
|
||||
unsigned char *pd = (unsigned char *)a->dp;
|
||||
|
||||
if ((unsigned)c > (FP_SIZE * sizeof(fp_digit))) {
|
||||
int excess = c - (FP_SIZE * sizeof(fp_digit));
|
||||
c -= excess;
|
||||
b += excess;
|
||||
}
|
||||
a->used = (c + sizeof(fp_digit) - 1)/sizeof(fp_digit);
|
||||
/* read the bytes in */
|
||||
for (c -= 1; c >= 0; c -= 1) {
|
||||
pd[c] = *b++;
|
||||
}
|
||||
|
||||
fp_clamp (a);
|
||||
}
|
||||
|
||||
__device__ __host__ void fp_reverse( unsigned char *s, int len )
|
||||
{
|
||||
int ix, iy;
|
||||
unsigned char t;
|
||||
|
||||
ix = 0;
|
||||
iy = len - 1;
|
||||
while (ix < iy) {
|
||||
t = s[ix];
|
||||
s[ix] = s[iy];
|
||||
s[iy] = t;
|
||||
++ix;
|
||||
--iy;
|
||||
}
|
||||
}
|
||||
|
||||
__device__ __host__ void fp_to_unsigned_bin( fp_int *a, unsigned char *b )
|
||||
{
|
||||
int x;
|
||||
fp_int t;
|
||||
|
||||
fp_copy(a, &t);
|
||||
|
||||
x = 0;
|
||||
while (fp_iszero (&t) == FP_NO) {
|
||||
b[x++] = (unsigned char) (t.dp[0] & 255);
|
||||
fp_div_2d (&t, 8, &t, NULL);
|
||||
}
|
||||
fp_reverse (b, x);
|
||||
}
|
||||
|
||||
__device__ __host__ void fp_reduce_setup( fp_int *a, fp_int *b )
|
||||
{
|
||||
fp_2expt (a, b->used << 6);
|
||||
fp_div (a, b, a, NULL);
|
||||
}
|
||||
|
||||
/* compare against a single digit */
|
||||
__device__ __host__ int fp_cmp_d( fp_int *a, fp_digit b )
|
||||
{
|
||||
/* compare based on magnitude */
|
||||
if (a->used > 1) return FP_GT;
|
||||
|
||||
/* compare the only digit of a to b */
|
||||
if (a->dp[0] > b) return FP_GT;
|
||||
else if (a->dp[0] < b) return FP_LT;
|
||||
|
||||
return FP_EQ;
|
||||
}
|
||||
|
||||
__device__ __host__ void fp_reduce( fp_int *x, fp_int *m, fp_int *mu )
|
||||
{
|
||||
fp_int q;
|
||||
int um = m->used;
|
||||
|
||||
if( fp_cmp (x, m) == FP_LT ) return;
|
||||
|
||||
/* q = x */
|
||||
fp_copy (x, &q);
|
||||
|
||||
/* q1 = x / b**(k-1) */
|
||||
fp_rshd (&q, um - 1);
|
||||
|
||||
fp_mul (&q, mu, &q);
|
||||
|
||||
/* q3 = q2 / b**(k+1) */
|
||||
fp_rshd (&q, um + 1);
|
||||
|
||||
/* x = x mod b**(k+1), quick (no division) */
|
||||
fp_mod_2d (x, ((um + 1) << 5), x);
|
||||
|
||||
/* q = q * m mod b**(k+1), quick (no division) */
|
||||
//s_fp_mul_digs (&q, m, &q, um + 1);
|
||||
// FIXME: actually multiply up to required digits instead of full multiply + truncation
|
||||
fp_mul(&q, m, &q);
|
||||
q.used = um + 1;
|
||||
for( int i = q.used; i < FP_SIZE; i++ ) q.dp[i] = 0;
|
||||
|
||||
/* x = x - q */
|
||||
fp_sub (x, &q, x);
|
||||
|
||||
/* If x < 0, add b**(k+1) to it */
|
||||
// FIXME: does this ever happen..?
|
||||
if (fp_cmp_d (x, 0) == FP_LT) {
|
||||
fp_set (&q, 1);
|
||||
fp_lshd (&q, um + 1);
|
||||
fp_add (x, &q, x);
|
||||
}
|
||||
|
||||
int count = 0;
|
||||
/* Back off if it's too big */
|
||||
while( fp_cmp (x, m) != FP_LT ) {
|
||||
s_fp_sub (x, m, x);
|
||||
count++;
|
||||
if( count > 100 ) {
|
||||
|
||||
//printf("FUCK ME I GOT STUCK IN THE REDUCE WHILE LOOP, AGAIN!!!!\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,291 +0,0 @@
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <memory.h>
|
||||
|
||||
#include "../cuda_helper.h"
|
||||
|
||||
__constant__ uint64_t c_PaddedMessage[32];
|
||||
|
||||
__constant__ uint32_t c_sigma[16][16];
|
||||
const uint32_t host_sigma[16][16] =
|
||||
{
|
||||
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
|
||||
{14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
|
||||
{11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
|
||||
{ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
|
||||
{ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
|
||||
{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },
|
||||
{12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
|
||||
{13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
|
||||
{ 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 },
|
||||
{10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13 , 0 },
|
||||
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
|
||||
{14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
|
||||
{11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
|
||||
{ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
|
||||
{ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
|
||||
{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 }
|
||||
};
|
||||
|
||||
static __device__ uint32_t HIWORD(const uint64_t x)
|
||||
{
|
||||
uint32_t result;
|
||||
asm(
|
||||
"{\n\t"
|
||||
".reg .u32 xl; \n\t"
|
||||
"mov.b64 {xl,%0},%1; \n\t"
|
||||
"}" : "=r"(result) : "l"(x)
|
||||
);
|
||||
return result;
|
||||
}
|
||||
|
||||
static __device__ uint32_t LOWORD(const uint64_t x)
|
||||
{
|
||||
uint32_t result;
|
||||
asm(
|
||||
"{\n\t"
|
||||
".reg .u32 xh; \n\t"
|
||||
"mov.b64 {%0,xh},%1; \n\t"
|
||||
"}" : "=r"(result) : "l"(x)
|
||||
);
|
||||
return result;
|
||||
}
|
||||
|
||||
__device__ __forceinline__ uint64_t SWAP64( const uint64_t x)
|
||||
{
|
||||
uint64_t temp[2];
|
||||
temp[0] = __byte_perm(HIWORD(x), 0, 0x0123);
|
||||
temp[1] = __byte_perm(LOWORD(x), 0, 0x0123);
|
||||
|
||||
return temp[0] | (temp[1]<<32);
|
||||
}
|
||||
|
||||
__host__ uint64_t host_SWAP64( uint64_t x )
|
||||
{
|
||||
return
|
||||
((x & 0xff00000000000000) >> 56) |
|
||||
((x & 0x00ff000000000000) >> 40) |
|
||||
((x & 0x0000ff0000000000) >> 24) |
|
||||
((x & 0x000000ff00000000) >> 8) |
|
||||
((x & 0x00000000ff000000) << 8) |
|
||||
((x & 0x0000000000ff0000) << 24) |
|
||||
((x & 0x000000000000ff00) << 40) |
|
||||
((x & 0x00000000000000ff) << 56);
|
||||
}
|
||||
|
||||
__constant__ uint64_t c_u512[16];
|
||||
const uint64_t host_u512[16] =
|
||||
{
|
||||
0x243f6a8885a308d3ULL, 0x13198a2e03707344ULL,
|
||||
0xa4093822299f31d0ULL, 0x082efa98ec4e6c89ULL,
|
||||
0x452821e638d01377ULL, 0xbe5466cf34e90c6cULL,
|
||||
0xc0ac29b7c97c50ddULL, 0x3f84d5b5b5470917ULL,
|
||||
0x9216d5d98979fb1bULL, 0xd1310ba698dfb5acULL,
|
||||
0x2ffd72dbd01adfb7ULL, 0xb8e1afed6a267e96ULL,
|
||||
0xba7c9045f12c7f99ULL, 0x24a19947b3916cf7ULL,
|
||||
0x0801f2e2858efc16ULL, 0x636920d871574e69ULL
|
||||
};
|
||||
|
||||
|
||||
__forceinline__ __device__ uint64_t ROTR(const uint64_t value, const int offset) {
|
||||
uint64_t result;
|
||||
#if __CUDA_ARCH__ >= 320
|
||||
if(offset < 32) {
|
||||
asm("{\n\t"
|
||||
" .reg .u32 tl,th,vl,vh; \n\t"
|
||||
"mov.b64 {tl,th},%1; \n\t"
|
||||
"shf.r.wrap.b32 vl,tl,th,%2; \n\t"
|
||||
"shf.r.wrap.b32 vh,th,tl,%2; \n\t"
|
||||
"mov.b64 %0,{vl,vh}; \n\t"
|
||||
"}"
|
||||
: "=l"(result) : "l"(value) , "r"(offset));
|
||||
} else {
|
||||
asm("{\n\t"
|
||||
" .reg .u32 tl,th,vl,vh; \n\t"
|
||||
"mov.b64 {tl,th},%1; \n\t"
|
||||
"shf.r.wrap.b32 vh,tl,th,%2; \n\t"
|
||||
"shf.r.wrap.b32 vl,th,tl,%2; \n\t"
|
||||
"mov.b64 %0,{vl,vh}; \n\t"
|
||||
"}"
|
||||
: "=l"(result) : "l"(value) , "r"(offset));
|
||||
}
|
||||
#else
|
||||
result = (value >> offset) | (value << (64-offset));
|
||||
#endif
|
||||
return result;
|
||||
}
|
||||
|
||||
__device__ __forceinline__ uint64_t ROTR64_32( uint64_t val )
|
||||
{
|
||||
asm("{\n\t"
|
||||
".reg .u32 tl,th; \n\t"
|
||||
"mov.b64 {tl,th},%1; \n\t"
|
||||
"mov.b64 %0,{th,tl}; \n\t"
|
||||
"}"
|
||||
: "=l"(val) : "l"(val));
|
||||
|
||||
return val;
|
||||
}
|
||||
|
||||
__device__ __forceinline__ uint64_t ROTR64_16( uint64_t val )
|
||||
{
|
||||
asm("{\n\t"
|
||||
".reg .u16 b0, b1, b2, b3; \n\t"
|
||||
"mov.b64 { b0, b1, b2, b3 }, %1; \n\t"
|
||||
"mov.b64 %0, {b1, b2, b3, b0}; \n\t"
|
||||
"}"
|
||||
: "=l"(val) : "l"(val));
|
||||
|
||||
return val;
|
||||
}
|
||||
|
||||
#define G(a,b,c,d,e) \
|
||||
v[a] += (m[c_sigma[i][e]] ^ c_u512[c_sigma[i][e+1]]) + v[b]; \
|
||||
v[d] = ROTR64_32(v[d] ^ v[a]); \
|
||||
v[c] += v[d]; \
|
||||
v[b] = ROTR( v[b] ^ v[c],25); \
|
||||
v[a] += (m[c_sigma[i][e+1]] ^ c_u512[c_sigma[i][e]])+v[b]; \
|
||||
v[d] = ROTR64_16(v[d] ^ v[a]); \
|
||||
v[c] += v[d]; \
|
||||
v[b] = ROTR( v[b] ^ v[c],11); \
|
||||
|
||||
|
||||
__device__ void blake_compress( uint64_t *h, const uint64_t *m, const int bits )
|
||||
{
|
||||
uint64_t v[16];
|
||||
|
||||
#pragma unroll 8
|
||||
for( int i = 0; i < 8; ++i ) v[i] = h[i];
|
||||
|
||||
v[ 8] = c_u512[0];
|
||||
v[ 9] = c_u512[1];
|
||||
v[10] = c_u512[2];
|
||||
v[11] = c_u512[3];
|
||||
v[12] = c_u512[4] ^ bits;
|
||||
v[13] = c_u512[5] ^ bits;
|
||||
v[14] = c_u512[6];
|
||||
v[15] = c_u512[7];
|
||||
|
||||
#pragma unroll 2
|
||||
for( int i = 0; i < 16; ++i )
|
||||
{
|
||||
/* column step */
|
||||
G( 0, 4, 8, 12, 0 );
|
||||
G( 1, 5, 9, 13, 2 );
|
||||
G( 2, 6, 10, 14, 4 );
|
||||
G( 3, 7, 11, 15, 6 );
|
||||
/* diagonal step */
|
||||
G( 0, 5, 10, 15, 8 );
|
||||
G( 1, 6, 11, 12, 10 );
|
||||
G( 2, 7, 8, 13, 12 );
|
||||
G( 3, 4, 9, 14, 14 );
|
||||
}
|
||||
|
||||
#pragma unroll 8
|
||||
for( int i = 0; i < 8; ++i ) h[i] ^= v[i] ^ v[i+8];
|
||||
}
|
||||
|
||||
static __device__ uint32_t cuda_swap32(uint32_t x)
|
||||
{
|
||||
return __byte_perm(x, 0, 0x0123);
|
||||
}
|
||||
|
||||
static __constant__ uint64_t d_IV[8];
|
||||
static const uint64_t h_IV[8] = {
|
||||
0x6a09e667f3bcc908ULL,
|
||||
0xbb67ae8584caa73bULL,
|
||||
0x3c6ef372fe94f82bULL,
|
||||
0xa54ff53a5f1d36f1ULL,
|
||||
0x510e527fade682d1ULL,
|
||||
0x9b05688c2b3e6c1fULL,
|
||||
0x1f83d9abfb41bd6bULL,
|
||||
0x5be0cd19137e2179ULL
|
||||
};
|
||||
|
||||
__global__ void blake_gpu_hash_185(uint32_t threads, uint32_t startNonce, uint32_t *outputHash, uint32_t *g_signature, uint32_t *g_hashwholeblock)
|
||||
{
|
||||
const uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
// bestimme den aktuellen Zähler
|
||||
uint32_t nonce = startNonce + thread;
|
||||
uint32_t idx64 = thread >> 6;
|
||||
uint64_t h[8];
|
||||
uint64_t buf[16];
|
||||
uint64_t *hashwholeblock = (uint64_t *)&g_hashwholeblock[idx64 << 3];
|
||||
uint64_t *signature = (uint64_t *)&g_signature[idx64 << 3];
|
||||
|
||||
#pragma unroll 8
|
||||
for(int i=0;i<8;i++)
|
||||
h[i] = d_IV[i];
|
||||
|
||||
#pragma unroll 11
|
||||
for (int i=0; i < 11; ++i) buf[i] = SWAP64(c_PaddedMessage[i]);
|
||||
|
||||
((uint32_t *)buf)[20] = cuda_swap32(nonce);
|
||||
|
||||
#pragma unroll 4
|
||||
for (int i=0; i < 4; ++i) buf[i+11] = SWAP64(hashwholeblock[i]);
|
||||
|
||||
buf[15] = SWAP64(c_PaddedMessage[15]);
|
||||
|
||||
blake_compress( h, buf, 1024 );
|
||||
|
||||
#pragma unroll 16
|
||||
for (int i=0; i < 16; ++i) buf[i] = c_PaddedMessage[i+16];
|
||||
|
||||
#pragma unroll 32
|
||||
for (int i=0; i < 32; ++i) ((unsigned char *)buf)[25+i] = ((unsigned char *)signature)[i];//SWAP64(signature[i]);
|
||||
|
||||
for (int i=0; i < 16; ++i) buf[i] = SWAP64(buf[i]);
|
||||
|
||||
blake_compress( h, buf, 1480 );
|
||||
|
||||
uint32_t *outHash = (uint32_t *)outputHash + 16 * thread;
|
||||
|
||||
#pragma unroll 8
|
||||
for (int i=0; i < 8; ++i) {
|
||||
outHash[2*i+0] = cuda_swap32( HIWORD(h[i]) );
|
||||
outHash[2*i+1] = cuda_swap32( LOWORD(h[i]) );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
__host__
|
||||
void blake_cpu_init(int thr_id, uint32_t threads)
|
||||
{
|
||||
cudaMemcpyToSymbol(c_sigma, host_sigma, sizeof(host_sigma), 0, cudaMemcpyHostToDevice);
|
||||
cudaMemcpyToSymbol(c_u512, host_u512, sizeof(host_u512), 0, cudaMemcpyHostToDevice);
|
||||
cudaMemcpyToSymbol(d_IV, h_IV, sizeof(h_IV), 0, cudaMemcpyHostToDevice);
|
||||
}
|
||||
|
||||
__host__
|
||||
void blake_cpu_setBlock_185(void *pdata)
|
||||
{
|
||||
unsigned char PaddedMessage[256];
|
||||
memcpy(PaddedMessage, pdata, 185);
|
||||
memset(PaddedMessage+185, 0, 71);
|
||||
PaddedMessage[185] = 0x80;
|
||||
PaddedMessage[239] = 1;
|
||||
PaddedMessage[254] = 0x05;
|
||||
PaddedMessage[255] = 0xC8;
|
||||
|
||||
//for( int i = 0; i < 32; i++ ) ((uint64_t *)PaddedMessage)[i] = host_SWAP64(((uint64_t *)PaddedMessage)[i]);
|
||||
|
||||
cudaMemcpyToSymbol(c_PaddedMessage, PaddedMessage, 32*sizeof(uint64_t), 0, cudaMemcpyHostToDevice);
|
||||
}
|
||||
|
||||
__host__
|
||||
void blake_cpu_hash_185(int thr_id, uint32_t threads, uint32_t startNonce, uint32_t *d_outputHash, uint32_t *d_signature, uint32_t *d_hashwholeblock)
|
||||
{
|
||||
const int threadsperblock = 64;
|
||||
|
||||
dim3 grid((threads + threadsperblock-1)/threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
|
||||
size_t shared_size = 0;
|
||||
|
||||
blake_gpu_hash_185<<<grid, block, shared_size>>>(threads, startNonce, d_outputHash, d_signature, d_hashwholeblock);
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
@@ -1,501 +0,0 @@
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <memory.h>
|
||||
|
||||
#include "miner.h"
|
||||
#include "spreadx11.h"
|
||||
|
||||
__constant__ uint32_t c_PaddedMessage88[32]; // padded message, 88 bytes + padding to 128 bytes
|
||||
|
||||
// precalculated state for sha256double_88
|
||||
static __constant__ uint32_t d_state[8];
|
||||
|
||||
// init vector
|
||||
static __constant__ uint32_t d_IV[8];
|
||||
static const uint32_t h_IV[8] = {
|
||||
0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
|
||||
0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
|
||||
};
|
||||
// round constants
|
||||
static __constant__ uint32_t d_K[64];
|
||||
static const uint32_t h_K[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
|
||||
};
|
||||
// padding for 400000 bytes of input data
|
||||
static __constant__ uint32_t padding400000[16] = {
|
||||
0x80000000, 0x00000000, 0x00000000, 0x00000000,
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000,
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000,
|
||||
0x00000000, 0x00000000, 0x00000000, 0x0030d400
|
||||
};
|
||||
|
||||
// padding for 32 bytes of input data
|
||||
static __constant__ uint32_t padding32[16] = {
|
||||
0x80000000, 0x00000000, 0x00000000, 0x00000000,
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000100
|
||||
};
|
||||
|
||||
__device__ __host__ __forceinline__ uint32_t ROTR32( const uint32_t val, const size_t offset )
|
||||
{
|
||||
#if __CUDA_ARCH__ >= 320
|
||||
return __funnelshift_r(val, val, offset);
|
||||
#else
|
||||
return (val >> offset) | (val << (32-offset));
|
||||
#endif
|
||||
}
|
||||
|
||||
static __device__ uint32_t cuda_swab32(uint32_t x)
|
||||
{
|
||||
return __byte_perm(x, x, 0x0123);
|
||||
}
|
||||
|
||||
__host__ uint32_t bswap32( const uint32_t x )
|
||||
{
|
||||
return
|
||||
((x & 0xff000000) >> 24 ) |
|
||||
((x & 0x00ff0000) >> 8 ) |
|
||||
((x & 0x0000ff00) << 8 ) |
|
||||
((x & 0x000000ff) << 24 );
|
||||
}
|
||||
|
||||
__device__ __host__ __forceinline__ uint32_t BSG2_0( const uint32_t x )
|
||||
{
|
||||
return
|
||||
ROTR32(x, 2) ^
|
||||
ROTR32(x, 13) ^
|
||||
ROTR32(x, 22);
|
||||
}
|
||||
|
||||
__device__ __host__ __forceinline__ uint32_t BSG2_1( const uint32_t x )
|
||||
{
|
||||
return
|
||||
ROTR32(x, 6) ^
|
||||
ROTR32(x, 11) ^
|
||||
ROTR32(x, 25);
|
||||
}
|
||||
|
||||
__device__ __host__ __forceinline__ uint32_t SSG2_0( const uint32_t x )
|
||||
{
|
||||
return
|
||||
ROTR32(x, 7) ^
|
||||
ROTR32(x, 18) ^
|
||||
(x >> 3);
|
||||
}
|
||||
|
||||
__device__ __host__ __forceinline__ uint32_t SSG2_1( const uint32_t x )
|
||||
{
|
||||
return
|
||||
ROTR32(x, 17) ^
|
||||
ROTR32(x, 19) ^
|
||||
(x >> 10);
|
||||
}
|
||||
|
||||
__device__ __host__ __forceinline__ uint32_t CH( const uint32_t x, const uint32_t y, const uint32_t z )
|
||||
{
|
||||
return ((y ^ z) & x) ^ z;
|
||||
}
|
||||
|
||||
__device__ __host__ __forceinline__ uint32_t MAJ( const uint32_t x, const uint32_t y, const uint32_t z )
|
||||
{
|
||||
return (x & y) | ((x | y) & z);
|
||||
}
|
||||
|
||||
|
||||
__device__ __host__ __forceinline__ void sha2_step1( uint32_t *W, const uint32_t *K, 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 pc, const uint32_t pcount )
|
||||
{
|
||||
W[pc] = in[pc];
|
||||
uint32_t t1 =
|
||||
h + BSG2_1(e) + CH(e, f, g) +
|
||||
K[pcount + pc] + W[pc];
|
||||
d += t1;
|
||||
h = t1 + BSG2_0(a) + MAJ(a, b, c);
|
||||
}
|
||||
|
||||
__device__ __host__ __forceinline__ void sha2_step2( uint32_t *W, const uint32_t *K, 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 pc, const uint32_t pcount )
|
||||
{
|
||||
uint32_t t1;
|
||||
W[pc] = SSG2_1(W[(pc - 2) & 0x0F])
|
||||
+ W[(pc - 7) & 0x0F]
|
||||
+ SSG2_0(W[(pc - 15) & 0x0F]) + W[pc];
|
||||
t1 = h + BSG2_1(e) + CH(e, f, g)
|
||||
+ K[pcount + (pc)] + W[(pc)];
|
||||
d += t1;
|
||||
h = t1 + BSG2_0(a) + MAJ(a, b, c);
|
||||
}
|
||||
|
||||
__device__
|
||||
void sha2_transform(const uint32_t *in, uint32_t *state)
|
||||
{
|
||||
uint32_t a, b, c, d, e, f, g, h;
|
||||
uint32_t w[16];
|
||||
uint32_t pcount;
|
||||
|
||||
a = state[0];
|
||||
b = state[1];
|
||||
c = state[2];
|
||||
d = state[3];
|
||||
e = state[4];
|
||||
f = state[5];
|
||||
g = state[6];
|
||||
h = state[7];
|
||||
pcount = 0;
|
||||
|
||||
sha2_step1(w, d_K, a, b, c, d, e, f, g, h, in, 0, pcount);
|
||||
sha2_step1(w, d_K, h, a, b, c, d, e, f, g, in, 1, pcount);
|
||||
sha2_step1(w, d_K, g, h, a, b, c, d, e, f, in, 2, pcount);
|
||||
sha2_step1(w, d_K, f, g, h, a, b, c, d, e, in, 3, pcount);
|
||||
sha2_step1(w, d_K, e, f, g, h, a, b, c, d, in, 4, pcount);
|
||||
sha2_step1(w, d_K, d, e, f, g, h, a, b, c, in, 5, pcount);
|
||||
sha2_step1(w, d_K, c, d, e, f, g, h, a, b, in, 6, pcount);
|
||||
sha2_step1(w, d_K, b, c, d, e, f, g, h, a, in, 7, pcount);
|
||||
sha2_step1(w, d_K, a, b, c, d, e, f, g, h, in, 8, pcount);
|
||||
sha2_step1(w, d_K, h, a, b, c, d, e, f, g, in, 9, pcount);
|
||||
sha2_step1(w, d_K, g, h, a, b, c, d, e, f, in, 10, pcount);
|
||||
sha2_step1(w, d_K, f, g, h, a, b, c, d, e, in, 11, pcount);
|
||||
sha2_step1(w, d_K, e, f, g, h, a, b, c, d, in, 12, pcount);
|
||||
sha2_step1(w, d_K, d, e, f, g, h, a, b, c, in, 13, pcount);
|
||||
sha2_step1(w, d_K, c, d, e, f, g, h, a, b, in, 14, pcount);
|
||||
sha2_step1(w, d_K, b, c, d, e, f, g, h, a, in, 15, pcount);
|
||||
|
||||
for (pcount = 16; pcount < 64; pcount += 16) {
|
||||
|
||||
sha2_step2(w, d_K, a, b, c, d, e, f, g, h, in, 0, pcount);
|
||||
sha2_step2(w, d_K, h, a, b, c, d, e, f, g, in, 1, pcount);
|
||||
sha2_step2(w, d_K, g, h, a, b, c, d, e, f, in, 2, pcount);
|
||||
sha2_step2(w, d_K, f, g, h, a, b, c, d, e, in, 3, pcount);
|
||||
sha2_step2(w, d_K, e, f, g, h, a, b, c, d, in, 4, pcount);
|
||||
sha2_step2(w, d_K, d, e, f, g, h, a, b, c, in, 5, pcount);
|
||||
sha2_step2(w, d_K, c, d, e, f, g, h, a, b, in, 6, pcount);
|
||||
sha2_step2(w, d_K, b, c, d, e, f, g, h, a, in, 7, pcount);
|
||||
sha2_step2(w, d_K, a, b, c, d, e, f, g, h, in, 8, pcount);
|
||||
sha2_step2(w, d_K, h, a, b, c, d, e, f, g, in, 9, pcount);
|
||||
sha2_step2(w, d_K, g, h, a, b, c, d, e, f, in, 10, pcount);
|
||||
sha2_step2(w, d_K, f, g, h, a, b, c, d, e, in, 11, pcount);
|
||||
sha2_step2(w, d_K, e, f, g, h, a, b, c, d, in, 12, pcount);
|
||||
sha2_step2(w, d_K, d, e, f, g, h, a, b, c, in, 13, pcount);
|
||||
sha2_step2(w, d_K, c, d, e, f, g, h, a, b, in, 14, pcount);
|
||||
sha2_step2(w, d_K, b, c, d, e, f, g, h, a, in, 15, pcount);
|
||||
}
|
||||
state[0] += a;
|
||||
state[1] += b;
|
||||
state[2] += c;
|
||||
state[3] += d;
|
||||
state[4] += e;
|
||||
state[5] += f;
|
||||
state[6] += g;
|
||||
state[7] += h;
|
||||
}
|
||||
|
||||
__host__
|
||||
void host_sha2_transform(const uint32_t *in, uint32_t *state)
|
||||
{
|
||||
uint32_t a, b, c, d, e, f, g, h;
|
||||
uint32_t w[16];
|
||||
uint32_t pcount;
|
||||
|
||||
a = state[0];
|
||||
b = state[1];
|
||||
c = state[2];
|
||||
d = state[3];
|
||||
e = state[4];
|
||||
f = state[5];
|
||||
g = state[6];
|
||||
h = state[7];
|
||||
pcount = 0;
|
||||
|
||||
sha2_step1(w, h_K, a, b, c, d, e, f, g, h, in, 0, pcount);
|
||||
sha2_step1(w, h_K, h, a, b, c, d, e, f, g, in, 1, pcount);
|
||||
sha2_step1(w, h_K, g, h, a, b, c, d, e, f, in, 2, pcount);
|
||||
sha2_step1(w, h_K, f, g, h, a, b, c, d, e, in, 3, pcount);
|
||||
sha2_step1(w, h_K, e, f, g, h, a, b, c, d, in, 4, pcount);
|
||||
sha2_step1(w, h_K, d, e, f, g, h, a, b, c, in, 5, pcount);
|
||||
sha2_step1(w, h_K, c, d, e, f, g, h, a, b, in, 6, pcount);
|
||||
sha2_step1(w, h_K, b, c, d, e, f, g, h, a, in, 7, pcount);
|
||||
sha2_step1(w, h_K, a, b, c, d, e, f, g, h, in, 8, pcount);
|
||||
sha2_step1(w, h_K, h, a, b, c, d, e, f, g, in, 9, pcount);
|
||||
sha2_step1(w, h_K, g, h, a, b, c, d, e, f, in, 10, pcount);
|
||||
sha2_step1(w, h_K, f, g, h, a, b, c, d, e, in, 11, pcount);
|
||||
sha2_step1(w, h_K, e, f, g, h, a, b, c, d, in, 12, pcount);
|
||||
sha2_step1(w, h_K, d, e, f, g, h, a, b, c, in, 13, pcount);
|
||||
sha2_step1(w, h_K, c, d, e, f, g, h, a, b, in, 14, pcount);
|
||||
sha2_step1(w, h_K, b, c, d, e, f, g, h, a, in, 15, pcount);
|
||||
|
||||
for (pcount = 16; pcount < 64; pcount += 16) {
|
||||
|
||||
sha2_step2(w, h_K, a, b, c, d, e, f, g, h, in, 0, pcount);
|
||||
sha2_step2(w, h_K, h, a, b, c, d, e, f, g, in, 1, pcount);
|
||||
sha2_step2(w, h_K, g, h, a, b, c, d, e, f, in, 2, pcount);
|
||||
sha2_step2(w, h_K, f, g, h, a, b, c, d, e, in, 3, pcount);
|
||||
sha2_step2(w, h_K, e, f, g, h, a, b, c, d, in, 4, pcount);
|
||||
sha2_step2(w, h_K, d, e, f, g, h, a, b, c, in, 5, pcount);
|
||||
sha2_step2(w, h_K, c, d, e, f, g, h, a, b, in, 6, pcount);
|
||||
sha2_step2(w, h_K, b, c, d, e, f, g, h, a, in, 7, pcount);
|
||||
sha2_step2(w, h_K, a, b, c, d, e, f, g, h, in, 8, pcount);
|
||||
sha2_step2(w, h_K, h, a, b, c, d, e, f, g, in, 9, pcount);
|
||||
sha2_step2(w, h_K, g, h, a, b, c, d, e, f, in, 10, pcount);
|
||||
sha2_step2(w, h_K, f, g, h, a, b, c, d, e, in, 11, pcount);
|
||||
sha2_step2(w, h_K, e, f, g, h, a, b, c, d, in, 12, pcount);
|
||||
sha2_step2(w, h_K, d, e, f, g, h, a, b, c, in, 13, pcount);
|
||||
sha2_step2(w, h_K, c, d, e, f, g, h, a, b, in, 14, pcount);
|
||||
sha2_step2(w, h_K, b, c, d, e, f, g, h, a, in, 15, pcount);
|
||||
}
|
||||
state[0] += a;
|
||||
state[1] += b;
|
||||
state[2] += c;
|
||||
state[3] += d;
|
||||
state[4] += e;
|
||||
state[5] += f;
|
||||
state[6] += g;
|
||||
state[7] += h;
|
||||
}
|
||||
|
||||
__global__
|
||||
void spreadx11_sha256_gpu_hash_wholeblock(uint32_t threads, uint32_t startNonce, uint32_t *g_input, uint32_t *g_hash, uint32_t *g_signature)
|
||||
{
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
uint32_t state[8];
|
||||
uint32_t input[16];
|
||||
uint32_t *outputHash = (uint32_t *)&g_hash[thread<<3];
|
||||
uint8_t *signature = (uint8_t *)&g_signature[thread<<3];
|
||||
|
||||
#pragma unroll 8
|
||||
for( int i=0; i < 8; i++ ) state[i] = d_IV[i];
|
||||
|
||||
/*
|
||||
Input is as follows, we need to replace nonce and MinerSignature for each hash.
|
||||
This means the first two blocks need to be handled separately.
|
||||
|
||||
4 bytes (nNonce & ~NONCE_MASK)
|
||||
8 bytes nTime;
|
||||
65 bytes MinerSignature;
|
||||
4 bytes nVersion;
|
||||
and so on....
|
||||
*/
|
||||
|
||||
// we process the same 200000 bytes of data twice
|
||||
for( int round = 0; round < 2; round++ ) {
|
||||
|
||||
// insert nonce
|
||||
input[0] = startNonce + (thread << 6);
|
||||
|
||||
// read the rest of the block
|
||||
#pragma unroll 15
|
||||
for( int i=1; i < 16; i++ ) input[i] = g_input[i];
|
||||
|
||||
// first 19 bytes of signature go into the first block
|
||||
#pragma unroll 19
|
||||
for( int i = 0; i < 19; i++ ) ((uint8_t *)input)[45+i] = signature[i];
|
||||
|
||||
// endian swap the block and transform
|
||||
#pragma unroll 16
|
||||
for( int i=0; i < 16; i++ ) input[i] = cuda_swab32(input[i]);
|
||||
sha2_transform(input, state);
|
||||
|
||||
// read the second block
|
||||
#pragma unroll 16
|
||||
for( int i=0; i < 16; i++ ) input[i] = g_input[i+16];
|
||||
|
||||
// replace in the remaining bytes of the signature
|
||||
#pragma unroll 13
|
||||
for( int i = 0; i < 13; i++ ) ((uint8_t *)input)[i] = signature[i+19];
|
||||
|
||||
// endian swap the second block and transform
|
||||
#pragma unroll 16
|
||||
for( int i=0; i < 16; i++ ) input[i] = cuda_swab32(input[i]);
|
||||
sha2_transform(input, state);
|
||||
|
||||
// transform the remaining blocks as they are
|
||||
for( int block = 2; block < 3125; block++ ) {
|
||||
|
||||
#pragma unroll 16
|
||||
for( int i=0; i < 16; i++ ) input[i] = cuda_swab32(g_input[i+(block << 4)]);
|
||||
|
||||
sha2_transform(input, state);
|
||||
}
|
||||
}
|
||||
|
||||
// load and transform the padding block
|
||||
#pragma unroll 16
|
||||
for( int i = 0; i < 16; i++ ) input[i] = padding400000[i];
|
||||
sha2_transform(input, state);
|
||||
|
||||
#pragma unroll 8
|
||||
for( int i=0; i < 8; i++ ) outputHash[i] = cuda_swab32(state[i]);
|
||||
}
|
||||
}
|
||||
|
||||
__global__
|
||||
void spreadx11_sha256double_gpu_hash_88(uint32_t threads, uint32_t startNonce, uint32_t *g_hash)
|
||||
{
|
||||
uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
if (thread < threads)
|
||||
{
|
||||
uint32_t state[8];
|
||||
uint32_t input[16];
|
||||
uint32_t nonce = startNonce + (thread << 6);
|
||||
uint32_t *outputHash = (uint32_t *)&g_hash[thread<<3];
|
||||
|
||||
// load precalculated state from the first block
|
||||
#pragma unroll 8
|
||||
for( int i = 0; i < 8; i++ ) state[i] = d_state[i];
|
||||
|
||||
#pragma unroll 16
|
||||
for( int i = 0; i < 16; i++ ) input[i] = cuda_swab32(c_PaddedMessage88[i+16]);
|
||||
input[5] = cuda_swab32(nonce);
|
||||
sha2_transform(input, state);
|
||||
|
||||
// finished hashing the input data, next step: hash the first result hash
|
||||
|
||||
#pragma unroll 8
|
||||
for( int i = 0; i < 8; i++ ) {
|
||||
input[i] = state[i];
|
||||
input[i+8] = padding32[i];
|
||||
state[i] = d_IV[i];
|
||||
}
|
||||
|
||||
sha2_transform(input, state);
|
||||
|
||||
#pragma unroll 8
|
||||
for( int i = 0; i < 8; i++ ) outputHash[i] = cuda_swab32(state[i]);
|
||||
}
|
||||
}
|
||||
|
||||
__host__
|
||||
void spreadx11_sha256_cpu_init(int thr_id, uint32_t threads)
|
||||
{
|
||||
cudaMemcpyToSymbol(d_K, h_K, sizeof(h_K), 0, cudaMemcpyHostToDevice);
|
||||
cudaMemcpyToSymbol(d_IV, h_IV, sizeof(h_IV), 0, cudaMemcpyHostToDevice);
|
||||
}
|
||||
|
||||
__host__
|
||||
void spreadx11_sha256double_cpu_hash_88(int thr_id, uint32_t threads, uint32_t startNonce, uint32_t *d_hash)
|
||||
{
|
||||
const uint32_t threadsperblock = 256;
|
||||
|
||||
dim3 grid((threads + threadsperblock-1)/threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
|
||||
spreadx11_sha256double_gpu_hash_88<<<grid, block>>>(threads, startNonce, d_hash);
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
|
||||
__host__
|
||||
void spreadx11_sha256double_setBlock_88(void *data)
|
||||
{
|
||||
unsigned char PaddedMessage[128];
|
||||
uint32_t tmpstate[8], tmpinput[16];
|
||||
|
||||
memcpy(PaddedMessage, data, 88);
|
||||
memset(PaddedMessage+88, 0, 40);
|
||||
PaddedMessage[ 88] = 0x80;
|
||||
PaddedMessage[126] = 0x02;
|
||||
PaddedMessage[127] = 0xC0;
|
||||
|
||||
// we can transform the first block here and start the CUDA kernel with the precalculated state
|
||||
for( int i = 0; i < 8; i++ ) tmpstate[i] = h_IV[i];
|
||||
for( int i = 0; i < 16; i++ ) tmpinput[i] = bswap32(((uint32_t *)PaddedMessage)[i]);
|
||||
host_sha2_transform(tmpinput, tmpstate);
|
||||
|
||||
cudaMemcpyToSymbol(d_state, tmpstate, 8*sizeof(uint32_t), 0, cudaMemcpyHostToDevice);
|
||||
cudaMemcpyToSymbol(c_PaddedMessage88, PaddedMessage, 128, 0, cudaMemcpyHostToDevice);
|
||||
}
|
||||
|
||||
__host__
|
||||
void spreadx11_sha256_setBlock_wholeblock(struct work *work, uint32_t *d_wholeblock)
|
||||
{
|
||||
unsigned char paddedmessage[200000];
|
||||
struct spreadwork *swork = (struct spreadwork *) work->extradata;
|
||||
|
||||
/*
|
||||
We need a hash of:
|
||||
offset size field
|
||||
0 4 nNonce & 0xffffffc0
|
||||
4 8 nTime
|
||||
12 65 MinerSignature
|
||||
77 4 nVersion
|
||||
81 32 hashPrevBlock
|
||||
113 32 hashMerkleRoot
|
||||
145 4 nBits
|
||||
149 4 nHeight
|
||||
153 x transactions, variable length
|
||||
padding calculated backwards from the copy of hashPrevBlock at the end
|
||||
199968 32 hashPrevBlock
|
||||
|
||||
We have in work->data:
|
||||
offset size field data
|
||||
0 4 nVersion 02000000
|
||||
4 32 hashPrevBlock 83ac9d7e96c4bb15d1a9a2fe3dbc81747768125009efc14e3824fbacaec65fad
|
||||
36 32 HashMerkleRoot 4e06a8366a959df705ea34dfe7eafea0d8a9e6fe3ba6b83afddb145b27da2362
|
||||
68 8 nTime ed71585400000000
|
||||
76 4 nBits 19850d1d
|
||||
80 4 nHeight 33d20100
|
||||
84 4 nNonce 00000000
|
||||
88 32 hashWholeBlock 0000000000000000000000000000000000000000000000000000000000000000
|
||||
120 33 MinerSignature1 1cad95a3e3e3598b74a1b8e2e3c013ababf6c45c83534029dbe8b4698916f78255
|
||||
153 32 MinerSignature2 0000000000000000000000000000000000000000000000000000000000000000
|
||||
*/
|
||||
|
||||
memcpy(paddedmessage+0, swork->data+84, 4); // nNonce
|
||||
memcpy(paddedmessage+4, swork->data+68, 8); // nTime
|
||||
memcpy(paddedmessage+12, swork->data+120, 65); // MinerSignature
|
||||
memcpy(paddedmessage+77, swork->data+0, 4); // nVersion
|
||||
memcpy(paddedmessage+81, swork->data+4, 32); // hashPrevBlock
|
||||
memcpy(paddedmessage+113, swork->data+36, 32); // HashMerkleRoot
|
||||
memcpy(paddedmessage+145, swork->data+76, 4); // nBits
|
||||
memcpy(paddedmessage+149, swork->data+80, 4); // nHeight
|
||||
memcpy(paddedmessage+153, swork->tx, swork->txsize); // tx
|
||||
|
||||
// the total amount of bytes in our data
|
||||
int blocksize = 153 + swork->txsize;
|
||||
|
||||
// pad the block with 0x07 bytes to make it a multiple of uint32_t
|
||||
while( blocksize & 3 ) paddedmessage[blocksize++] = 0x07;
|
||||
|
||||
// figure out the offsets for the padding
|
||||
uint32_t *pFillBegin = (uint32_t*)&paddedmessage[blocksize];
|
||||
uint32_t *pFillEnd = (uint32_t*)&paddedmessage[MAX_BLOCK_SIZE]; // FIXME: isn't this out of bounds by one... but it seems to work out...
|
||||
uint32_t *pFillFooter = pFillBegin > pFillEnd - 8 ? pFillBegin : pFillEnd - 8;
|
||||
|
||||
memcpy(pFillFooter, swork->data+4, (pFillEnd - pFillFooter)*4);
|
||||
for (uint32_t *pI = pFillFooter; pI < pFillEnd; pI++)
|
||||
*pI |= 1;
|
||||
|
||||
for (uint32_t *pI = pFillFooter - 1; pI >= pFillBegin; pI--)
|
||||
pI[0] = pI[3]*pI[7];
|
||||
|
||||
// copy the whole monstrosity into device memory for processing
|
||||
cudaMemcpy(d_wholeblock, paddedmessage, 200000, cudaMemcpyHostToDevice);
|
||||
}
|
||||
|
||||
__host__
|
||||
void spreadx11_sha256_cpu_hash_wholeblock(int thr_id, uint32_t threads, uint32_t startNonce, uint32_t *d_hash, uint32_t *d_signature, uint32_t *d_wholeblock)
|
||||
{
|
||||
const uint32_t threadsperblock = 256;
|
||||
|
||||
dim3 grid((threads + threadsperblock-1)/threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
|
||||
spreadx11_sha256_gpu_hash_wholeblock<<<grid, block>>>(threads, startNonce, d_wholeblock, d_hash, d_signature);
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
@@ -1,97 +0,0 @@
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <memory.h>
|
||||
|
||||
#include "miner.h"
|
||||
#include "bignum_fp.h"
|
||||
#include "spreadx11.h"
|
||||
|
||||
__constant__ uint32_t d_privkey_data[8]; // 32 bytes
|
||||
__constant__ uint32_t d_kinv_data[8]; // 32 bytes
|
||||
|
||||
__constant__ uint32_t d_m_data[8] = {
|
||||
0xd0364141, 0xbfd25e8c, 0xaf48a03b, 0xbaaedce6,
|
||||
0xfffffffe, 0xffffffff, 0xffffffff, 0xffffffff
|
||||
};
|
||||
|
||||
__constant__ uint32_t d_mu_data[9] = {
|
||||
0x2fc9bec0, 0x402da173, 0x50b75fc4, 0x45512319,
|
||||
0x00000001, 0x00000000, 0x00000000, 0x00000000,
|
||||
0x00000001
|
||||
};
|
||||
|
||||
__global__
|
||||
void spreadx11_sign_gpu(uint32_t threads, uint32_t startNonce, uint32_t *g_sha256hash, uint32_t *g_signature )
|
||||
{
|
||||
const uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x);
|
||||
|
||||
if (thread < threads)
|
||||
{
|
||||
fp_int hash, result, m, mu, privkey, kinv;
|
||||
unsigned char *sha256hash = (unsigned char *)&g_sha256hash[thread<<3];
|
||||
uint32_t *signature = (uint32_t *)&g_signature[thread<<3];
|
||||
|
||||
fp_zero(&result);
|
||||
fp_read_unsigned_bin(&hash, sha256hash, 32);
|
||||
|
||||
privkey.used = 8;
|
||||
kinv.used = 8;
|
||||
m.used = 8;
|
||||
mu.used = 9;
|
||||
|
||||
#pragma unroll 8
|
||||
for( int i = 0; i < 8; i++ ) {
|
||||
privkey.dp[i] = d_privkey_data[i];
|
||||
kinv.dp[i] = d_kinv_data[i];
|
||||
m.dp[i] = d_m_data[i];
|
||||
mu.dp[i] = d_mu_data[i];
|
||||
signature[i] = 0;
|
||||
}
|
||||
mu.dp[8] = d_mu_data[8];
|
||||
m.dp[8] = 0;
|
||||
|
||||
#pragma unroll
|
||||
for( int i = 9; i < FP_SIZE; i++ ) {
|
||||
|
||||
m.dp[i] = 0;
|
||||
mu.dp[i] = 0;
|
||||
}
|
||||
|
||||
fp_add(&hash, &privkey, &result);
|
||||
fp_mul(&result, &kinv, &result);
|
||||
fp_reduce(&result, &m, &mu);
|
||||
fp_to_unsigned_bin(&result, &((unsigned char *)signature)[32-(fp_count_bits(&result)+7)/8]);
|
||||
}
|
||||
}
|
||||
|
||||
__host__
|
||||
void spreadx11_sign_cpu_init(int thr_id, uint32_t throughput)
|
||||
{
|
||||
}
|
||||
|
||||
__host__
|
||||
void spreadx11_sign_cpu_setInput(struct work *work)
|
||||
{
|
||||
fp_int fp_privkey, fp_kinv;
|
||||
struct spreadwork* swork = (struct spreadwork*) work->extradata;
|
||||
|
||||
fp_read_unsigned_bin(&fp_privkey, swork->privkey, 32);
|
||||
fp_read_unsigned_bin(&fp_kinv, swork->kinv, 32);
|
||||
|
||||
cudaMemcpyToSymbol(d_privkey_data, fp_privkey.dp, 32, 0, cudaMemcpyHostToDevice);
|
||||
cudaMemcpyToSymbol(d_kinv_data, fp_kinv.dp, 32, 0, cudaMemcpyHostToDevice);
|
||||
}
|
||||
|
||||
__host__
|
||||
void spreadx11_sign_cpu(int thr_id, uint32_t threads, uint32_t startNonce, uint32_t *d_hash, uint32_t *d_signature)
|
||||
{
|
||||
const uint32_t threadsperblock = 256;
|
||||
|
||||
dim3 grid((threads + threadsperblock-1)/threadsperblock);
|
||||
dim3 block(threadsperblock);
|
||||
|
||||
spreadx11_sign_gpu<<<grid, block>>>(threads, startNonce, d_hash, d_signature);
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
|
||||
Loaded 100 of 129 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user