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;
|
||||
}
|
||||
+13
-12
@@ -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 \
|
||||
@@ -36,7 +36,8 @@ ccminer_SOURCES = elist.h miner.h compat.h \
|
||||
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,9 +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
|
||||
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 \
|
||||
@@ -76,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\"
|
||||
@@ -112,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 $<
|
||||
|
||||
@@ -154,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.
|
||||
|
||||
+1071
-310
File diff suppressed because it is too large.
Load diff
+40
-25
@@ -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,6 +348,8 @@
|
||||
<ClInclude Include="lyra2\Sponge.h" />
|
||||
<ClInclude Include="quark\groestl_transf_quad.h" />
|
||||
<ClInclude Include="quark\groestl_functions_quad.h" />
|
||||
<ClInclude Include="quark\cuda_quark.h" />
|
||||
<ClInclude Include="x11\cuda_x11.h" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<CudaCompile Include="cuda.cpp" />
|
||||
@@ -396,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" />
|
||||
@@ -454,9 +473,7 @@
|
||||
<CudaCompile Include="cuda_skeincoin.cu">
|
||||
<MaxRegCount>48</MaxRegCount>
|
||||
</CudaCompile>
|
||||
<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>
|
||||
@@ -467,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>
|
||||
@@ -490,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>
|
||||
@@ -511,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">
|
||||
@@ -520,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,10 +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_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);
|
||||
@@ -301,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);
|
||||
@@ -322,10 +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_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);
|
||||
@@ -440,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;
|
||||
@@ -448,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;
|
||||
@@ -481,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"
|
||||
@@ -514,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;
|
||||
@@ -584,7 +620,7 @@ struct tx {
|
||||
};
|
||||
|
||||
struct work {
|
||||
uint32_t data[32];
|
||||
uint32_t data[48];
|
||||
uint32_t target[8];
|
||||
uint32_t maxvote;
|
||||
|
||||
@@ -597,6 +633,8 @@ struct work {
|
||||
uint64_t u64[1];
|
||||
} noncerange;
|
||||
|
||||
uint32_t nonces[2];
|
||||
|
||||
double targetdiff;
|
||||
double shareratio;
|
||||
double sharediff;
|
||||
@@ -609,6 +647,9 @@ struct work {
|
||||
/* pok getwork txs */
|
||||
uint32_t tx_count;
|
||||
struct tx txs[POK_MAX_TXS];
|
||||
|
||||
char *txs2;
|
||||
char *workid;
|
||||
};
|
||||
|
||||
#define POK_BOOL_MASK 0x00008000
|
||||
@@ -628,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
|
||||
@@ -652,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;
|
||||
};
|
||||
|
||||
@@ -663,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);
|
||||
@@ -729,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);
|
||||
@@ -754,9 +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 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
@@ -32,8 +32,8 @@ void stats_remember_speed(int thr_id, uint32_t hashcount, double hashrate, uint8
|
||||
return;
|
||||
|
||||
// first hash rates are often erroneous
|
||||
if (uid < opt_n_threads * 2)
|
||||
return;
|
||||
//if (uid < opt_n_threads * 2)
|
||||
// return;
|
||||
|
||||
memset(&data, 0, sizeof(data));
|
||||
data.uid = (uint32_t) uid;
|
||||
|
||||
@@ -104,10 +104,10 @@ void applog(int prio, const char *fmt, ...)
|
||||
#endif
|
||||
else {
|
||||
const char* color = "";
|
||||
const time_t now = time(NULL);
|
||||
char *f;
|
||||
int len;
|
||||
struct tm tm;
|
||||
time_t now = time(NULL);
|
||||
|
||||
localtime_r(&now, &tm);
|
||||
|
||||
@@ -147,6 +147,37 @@ void applog(int prio, const char *fmt, ...)
|
||||
va_end(ap);
|
||||
}
|
||||
|
||||
extern int gpu_threads;
|
||||
// Use different prefix if multiple cpu threads per gpu
|
||||
// Also, auto hide LOG_DEBUG if --debug (-D) is not used
|
||||
void gpulog(int prio, int thr_id, const char *fmt, ...)
|
||||
{
|
||||
char _ALIGN(128) pfmt[128];
|
||||
char _ALIGN(128) line[256];
|
||||
int len, dev_id = device_map[thr_id % MAX_GPUS];
|
||||
va_list ap;
|
||||
|
||||
if (prio == LOG_DEBUG && !opt_debug)
|
||||
return;
|
||||
|
||||
if (gpu_threads > 1)
|
||||
len = snprintf(pfmt, 128, "GPU T%d: %s", thr_id, fmt);
|
||||
else
|
||||
len = snprintf(pfmt, 128, "GPU #%d: %s", dev_id, fmt);
|
||||
pfmt[sizeof(pfmt)-1]='\0';
|
||||
|
||||
va_start(ap, fmt);
|
||||
|
||||
if (len && vsnprintf(line, sizeof(line), pfmt, ap)) {
|
||||
line[sizeof(line)-1]='\0';
|
||||
applog(prio, "%s", line);
|
||||
} else {
|
||||
fprintf(stderr, "%s OOM!\n", __func__);
|
||||
}
|
||||
|
||||
va_end(ap);
|
||||
}
|
||||
|
||||
/* Get default config.json path (system specific) */
|
||||
void get_defconfig_path(char *out, size_t bufsize, char *argv0)
|
||||
{
|
||||
@@ -411,8 +442,11 @@ static json_t *json_rpc_call(CURL *curl, const char *url,
|
||||
if (opt_protocol)
|
||||
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
|
||||
curl_easy_setopt(curl, CURLOPT_URL, url);
|
||||
if (opt_cert)
|
||||
if (opt_cert) {
|
||||
curl_easy_setopt(curl, CURLOPT_CAINFO, opt_cert);
|
||||
// ignore CN domain name, allow to move cert files
|
||||
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);
|
||||
}
|
||||
curl_easy_setopt(curl, CURLOPT_ENCODING, "");
|
||||
curl_easy_setopt(curl, CURLOPT_FAILONERROR, 0);
|
||||
curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
|
||||
@@ -525,7 +559,7 @@ static json_t *json_rpc_call(CURL *curl, const char *url,
|
||||
res_val = json_object_get(val, "result");
|
||||
err_val = json_object_get(val, "error");
|
||||
|
||||
if (!res_val || json_is_null(res_val) ||
|
||||
if (!res_val || //json_is_null(res_val) ||
|
||||
(err_val && !json_is_null(err_val))) {
|
||||
char *s = NULL;
|
||||
|
||||
@@ -580,7 +614,7 @@ err_out:
|
||||
json_t *json_rpc_call_pool(CURL *curl, struct pool_infos *pool, const char *req,
|
||||
bool longpoll_scan, bool longpoll, int *curl_err)
|
||||
{
|
||||
char userpass[256];
|
||||
char userpass[512];
|
||||
// todo, malloc and store that in pool array
|
||||
snprintf(userpass, sizeof(userpass), "%s%c%s", pool->user,
|
||||
strlen(pool->pass)?':':'\0', pool->pass);
|
||||
@@ -591,7 +625,7 @@ json_t *json_rpc_call_pool(CURL *curl, struct pool_infos *pool, const char *req,
|
||||
/* called only from longpoll thread, we have the lp_url */
|
||||
json_t *json_rpc_longpoll(CURL *curl, char *lp_url, struct pool_infos *pool, const char *req, int *curl_err)
|
||||
{
|
||||
char userpass[256];
|
||||
char userpass[512];
|
||||
snprintf(userpass, sizeof(userpass), "%s%c%s", pool->user,
|
||||
strlen(pool->pass)?':':'\0', pool->pass);
|
||||
|
||||
@@ -693,9 +727,10 @@ char *bin2hex(const uchar *in, size_t len)
|
||||
return s;
|
||||
}
|
||||
|
||||
bool hex2bin(uchar *p, const char *hexstr, size_t len)
|
||||
bool hex2bin(void *output, const char *hexstr, size_t len)
|
||||
{
|
||||
char hex_byte[3];
|
||||
uchar *p = (uchar *) output;
|
||||
char hex_byte[4];
|
||||
char *ep;
|
||||
|
||||
hex_byte[2] = '\0';
|
||||
@@ -791,14 +826,11 @@ bool fulltest(const uint32_t *hash, const uint32_t *target)
|
||||
}
|
||||
|
||||
// Only used by stratum pools
|
||||
void diff_to_target(struct work* work, double diff)
|
||||
void diff_to_target(uint32_t *target, double diff)
|
||||
{
|
||||
uint32_t *target = work->target;
|
||||
uint64_t m;
|
||||
int k;
|
||||
|
||||
work->targetdiff = diff;
|
||||
|
||||
for (k = 6; k > 0 && diff > 1.0; k--)
|
||||
diff /= 4294967296.0;
|
||||
m = (uint64_t)(4294901760.0 / diff);
|
||||
@@ -811,6 +843,14 @@ void diff_to_target(struct work* work, double diff)
|
||||
}
|
||||
}
|
||||
|
||||
// Only used by stratum pools
|
||||
void work_set_target(struct work* work, double diff)
|
||||
{
|
||||
diff_to_target(work->target, diff);
|
||||
work->targetdiff = diff;
|
||||
}
|
||||
|
||||
|
||||
// Only used by longpoll pools
|
||||
double target_to_diff(uint32_t* target)
|
||||
{
|
||||
@@ -952,7 +992,7 @@ char *stratum_recv_line(struct stratum_ctx *sctx)
|
||||
} while (time(NULL) - rstart < timeout && !strstr(sctx->sockbuf, "\n"));
|
||||
|
||||
if (!ret) {
|
||||
applog(LOG_ERR, "stratum_recv_line failed");
|
||||
if (opt_debug) applog(LOG_ERR, "stratum_recv_line failed");
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
@@ -1492,13 +1532,6 @@ static bool stratum_set_difficulty(struct stratum_ctx *sctx, json_t *params)
|
||||
sctx->next_diff = diff;
|
||||
pthread_mutex_unlock(&stratum_work_lock);
|
||||
|
||||
/* store for api stats */
|
||||
if (diff != stratum_diff) {
|
||||
stratum_diff = diff;
|
||||
applog(LOG_WARNING, "Stratum difficulty set to %g", diff);
|
||||
g_work_time = 0;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -1528,19 +1561,141 @@ static bool stratum_reconnect(struct stratum_ctx *sctx, json_t *params)
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool stratum_get_version(struct stratum_ctx *sctx, json_t *id)
|
||||
static bool stratum_pong(struct stratum_ctx *sctx, json_t *id)
|
||||
{
|
||||
char buf[64];
|
||||
bool ret = false;
|
||||
|
||||
if (!id || json_is_null(id))
|
||||
return ret;
|
||||
|
||||
sprintf(buf, "{\"id\":%d,\"result\":\"pong\",\"error\":null}",
|
||||
(int) json_integer_value(id));
|
||||
ret = stratum_send_line(sctx, buf);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static bool stratum_get_algo(struct stratum_ctx *sctx, json_t *id, json_t *params)
|
||||
{
|
||||
char algo[64] = { 0 };
|
||||
char *s;
|
||||
json_t *val;
|
||||
bool ret = true;
|
||||
|
||||
if (!id || json_is_null(id))
|
||||
return false;
|
||||
|
||||
get_currentalgo(algo, sizeof(algo));
|
||||
|
||||
val = json_object();
|
||||
json_object_set(val, "id", id);
|
||||
json_object_set_new(val, "error", json_null());
|
||||
json_object_set_new(val, "result", json_string(algo));
|
||||
|
||||
s = json_dumps(val, 0);
|
||||
ret = stratum_send_line(sctx, s);
|
||||
json_decref(val);
|
||||
free(s);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
#include "nvml.h"
|
||||
extern char driver_version[32];
|
||||
extern int cuda_arch[MAX_GPUS];
|
||||
|
||||
static bool json_object_set_error(json_t *result, int code, const char *msg)
|
||||
{
|
||||
json_t *val = json_object();
|
||||
json_object_set_new(val, "code", json_integer(code));
|
||||
json_object_set_new(val, "message", json_string(msg));
|
||||
return json_object_set_new(result, "error", val) != -1;
|
||||
}
|
||||
|
||||
/* allow to report algo/device perf to the pool for algo stats */
|
||||
static bool stratum_benchdata(json_t *result, json_t *params, int thr_id)
|
||||
{
|
||||
char algo[64] = { 0 };
|
||||
char vid[32], arch[8], driver[32];
|
||||
char *card;
|
||||
char os[8];
|
||||
uint32_t watts = 0;
|
||||
int dev_id = device_map[thr_id];
|
||||
int cuda_ver = cuda_version();
|
||||
struct cgpu_info *cgpu = &thr_info[thr_id].gpu;
|
||||
json_t *val;
|
||||
|
||||
if (!cgpu || !opt_stratum_stats) return false;
|
||||
|
||||
#if defined(WIN32) && (defined(_M_X64) || defined(__x86_64__))
|
||||
strcpy(os, "win64");
|
||||
#else
|
||||
strcpy(os, is_windows() ? "win32" : "linux");
|
||||
#endif
|
||||
|
||||
#ifdef USE_WRAPNVML
|
||||
cgpu->has_monitoring = true;
|
||||
cgpu->gpu_power = gpu_power(cgpu); // mWatts
|
||||
watts = (cgpu->gpu_power >= 1000) ? cgpu->gpu_power / 1000 : 0; // ignore nvapi %
|
||||
gpu_info(cgpu);
|
||||
#endif
|
||||
cuda_gpu_clocks(cgpu);
|
||||
get_currentalgo(algo, sizeof(algo));
|
||||
|
||||
card = device_name[dev_id];
|
||||
cgpu->khashes = stats_get_speed(thr_id, 0.0) / 1000.0;
|
||||
|
||||
sprintf(vid, "%04hx:%04hx", cgpu->gpu_vid, cgpu->gpu_pid);
|
||||
sprintf(arch, "%d", (int) cgpu->gpu_arch);
|
||||
if (cuda_arch[dev_id] > 0 && cuda_arch[dev_id] != cgpu->gpu_arch) {
|
||||
// if binary was not compiled for the highest cuda arch, add it
|
||||
snprintf(arch, 8, "%d@%d", (int) cgpu->gpu_arch, cuda_arch[dev_id]);
|
||||
}
|
||||
snprintf(driver, 32, "CUDA %d.%d %s", cuda_ver/1000, (cuda_ver%1000) / 10, driver_version);
|
||||
driver[31] = '\0';
|
||||
|
||||
val = json_object();
|
||||
json_object_set_new(val, "algo", json_string(algo));
|
||||
json_object_set_new(val, "type", json_string("gpu"));
|
||||
json_object_set_new(val, "device", json_string(card));
|
||||
json_object_set_new(val, "vendorid", json_string(vid));
|
||||
json_object_set_new(val, "arch", json_string(arch));
|
||||
json_object_set_new(val, "freq", json_integer(cgpu->gpu_clock/1000));
|
||||
json_object_set_new(val, "memf", json_integer(cgpu->gpu_memclock/1000));
|
||||
json_object_set_new(val, "power", json_integer(watts));
|
||||
json_object_set_new(val, "khashes", json_real(cgpu->khashes));
|
||||
json_object_set_new(val, "intensity", json_real(cgpu->intensity));
|
||||
json_object_set_new(val, "throughput", json_integer(cgpu->throughput));
|
||||
json_object_set_new(val, "client", json_string(PACKAGE_NAME "/" PACKAGE_VERSION));
|
||||
json_object_set_new(val, "os", json_string(os));
|
||||
json_object_set_new(val, "driver", json_string(driver));
|
||||
|
||||
json_object_set_new(result, "result", val);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool stratum_get_stats(struct stratum_ctx *sctx, json_t *id, json_t *params)
|
||||
{
|
||||
char *s;
|
||||
json_t *val;
|
||||
bool ret;
|
||||
|
||||
|
||||
if (!id || json_is_null(id))
|
||||
return false;
|
||||
|
||||
val = json_object();
|
||||
json_object_set(val, "id", id);
|
||||
json_object_set_new(val, "error", json_null());
|
||||
json_object_set_new(val, "result", json_string(USER_AGENT));
|
||||
|
||||
ret = stratum_benchdata(val, params, 0);
|
||||
|
||||
if (!ret) {
|
||||
json_object_set_error(val, 1, "disabled"); //EPERM
|
||||
} else {
|
||||
json_object_set_new(val, "error", json_null());
|
||||
}
|
||||
|
||||
s = json_dumps(val, 0);
|
||||
ret = stratum_send_line(sctx, s);
|
||||
json_decref(val);
|
||||
@@ -1549,6 +1704,29 @@ static bool stratum_get_version(struct stratum_ctx *sctx, json_t *id)
|
||||
return ret;
|
||||
}
|
||||
|
||||
static bool stratum_get_version(struct stratum_ctx *sctx, json_t *id, json_t *params)
|
||||
{
|
||||
char *s;
|
||||
json_t *val;
|
||||
bool ret = true;
|
||||
|
||||
if (!id || json_is_null(id))
|
||||
return false;
|
||||
|
||||
val = json_object();
|
||||
json_object_set(val, "id", id);
|
||||
json_object_set_new(val, "result", json_string(USER_AGENT));
|
||||
if (ret) json_object_set_new(val, "error", json_null());
|
||||
|
||||
s = json_dumps(val, 0);
|
||||
ret = stratum_send_line(sctx, s);
|
||||
|
||||
json_decref(val);
|
||||
free(s);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static bool stratum_show_message(struct stratum_ctx *sctx, json_t *id, json_t *params)
|
||||
{
|
||||
char *s;
|
||||
@@ -1574,6 +1752,28 @@ static bool stratum_show_message(struct stratum_ctx *sctx, json_t *id, json_t *p
|
||||
return ret;
|
||||
}
|
||||
|
||||
static bool stratum_unknown_method(struct stratum_ctx *sctx, json_t *id)
|
||||
{
|
||||
char *s;
|
||||
json_t *val;
|
||||
bool ret = false;
|
||||
|
||||
if (!id || json_is_null(id))
|
||||
return ret;
|
||||
|
||||
val = json_object();
|
||||
json_object_set(val, "id", id);
|
||||
json_object_set_new(val, "result", json_false());
|
||||
json_object_set_error(val, 38, "unknown method"); // ENOSYS
|
||||
|
||||
s = json_dumps(val, 0);
|
||||
ret = stratum_send_line(sctx, s);
|
||||
json_decref(val);
|
||||
free(s);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool stratum_handle_method(struct stratum_ctx *sctx, const char *s)
|
||||
{
|
||||
json_t *val, *id, *params;
|
||||
@@ -1597,6 +1797,11 @@ bool stratum_handle_method(struct stratum_ctx *sctx, const char *s)
|
||||
ret = stratum_notify(sctx, params);
|
||||
goto out;
|
||||
}
|
||||
if (!strcasecmp(method, "mining.ping")) { // cgminer 4.7.1+
|
||||
if (opt_debug) applog(LOG_DEBUG, "Pool ping");
|
||||
ret = stratum_pong(sctx, id);
|
||||
goto out;
|
||||
}
|
||||
if (!strcasecmp(method, "mining.set_difficulty")) {
|
||||
ret = stratum_set_difficulty(sctx, params);
|
||||
goto out;
|
||||
@@ -1609,15 +1814,32 @@ bool stratum_handle_method(struct stratum_ctx *sctx, const char *s)
|
||||
ret = stratum_reconnect(sctx, params);
|
||||
goto out;
|
||||
}
|
||||
if (!strcasecmp(method, "client.get_version")) {
|
||||
ret = stratum_get_version(sctx, id);
|
||||
if (!strcasecmp(method, "client.get_algo")) { // ccminer only yet!
|
||||
// will prevent wrong algo parameters on a pool, will be used as test on rejects
|
||||
if (!opt_quiet) applog(LOG_NOTICE, "Pool asked your algo parameter");
|
||||
ret = stratum_get_algo(sctx, id, params);
|
||||
goto out;
|
||||
}
|
||||
if (!strcasecmp(method, "client.show_message")) {
|
||||
if (!strcasecmp(method, "client.get_stats")) { // ccminer/yiimp only yet!
|
||||
// optional to fill device benchmarks
|
||||
ret = stratum_get_stats(sctx, id, params);
|
||||
goto out;
|
||||
}
|
||||
if (!strcasecmp(method, "client.get_version")) { // common
|
||||
ret = stratum_get_version(sctx, id, params);
|
||||
goto out;
|
||||
}
|
||||
if (!strcasecmp(method, "client.show_message")) { // common
|
||||
ret = stratum_show_message(sctx, id, params);
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (!ret) {
|
||||
// don't fail = disconnect stratum on unknown (and optional?) methods
|
||||
if (opt_debug) applog(LOG_WARNING, "unknown stratum method %s!", method);
|
||||
ret = stratum_unknown_method(sctx, id);
|
||||
}
|
||||
|
||||
out:
|
||||
if (val)
|
||||
json_decref(val);
|
||||
@@ -1762,8 +1984,9 @@ char* atime2str(time_t timer)
|
||||
}
|
||||
|
||||
/* sprintf can be used in applog */
|
||||
static char* format_hash(char* buf, uchar *hash)
|
||||
static char* format_hash(char* buf, uint8_t* h)
|
||||
{
|
||||
uchar *hash = (uchar*) h;
|
||||
int len = 0;
|
||||
for (int i=0; i < 32; i += 4) {
|
||||
len += sprintf(buf+len, "%02x%02x%02x%02x ",
|
||||
@@ -1773,23 +1996,39 @@ static char* format_hash(char* buf, uchar *hash)
|
||||
}
|
||||
|
||||
/* to debug diff in data */
|
||||
extern void applog_compare_hash(uchar *hash, uchar *hash2)
|
||||
void applog_compare_hash(void *hash, void *hash_ref)
|
||||
{
|
||||
char s[256] = "";
|
||||
int len = 0;
|
||||
uchar* hash1 = (uchar*)hash;
|
||||
uchar* hash2 = (uchar*)hash_ref;
|
||||
for (int i=0; i < 32; i += 4) {
|
||||
const char *color = memcmp(hash+i, hash2+i, 4) ? CL_WHT : CL_GRY;
|
||||
const char *color = memcmp(hash1+i, hash2+i, 4) ? CL_WHT : CL_GRY;
|
||||
len += sprintf(s+len, "%s%02x%02x%02x%02x " CL_GRY, color,
|
||||
hash[i], hash[i+1], hash[i+2], hash[i+3]);
|
||||
hash1[i], hash1[i+1], hash1[i+2], hash1[i+3]);
|
||||
s[len] = '\0';
|
||||
}
|
||||
applog(LOG_DEBUG, "%s", s);
|
||||
}
|
||||
|
||||
extern void applog_hash(uchar *hash)
|
||||
void applog_hash(void *hash)
|
||||
{
|
||||
char s[128] = {'\0'};
|
||||
applog(LOG_DEBUG, "%s", format_hash(s, hash));
|
||||
applog(LOG_DEBUG, "%s", format_hash(s, (uint8_t*)hash));
|
||||
}
|
||||
|
||||
void applog_hash64(void *hash)
|
||||
{
|
||||
char s[128] = {'\0'};
|
||||
char t[128] = {'\0'};
|
||||
applog(LOG_DEBUG, "%s %s", format_hash(s, (uint8_t*)hash), format_hash(t, &((uint8_t*)hash)[32]));
|
||||
}
|
||||
|
||||
void applog_hex(void *data, int len)
|
||||
{
|
||||
char* hex = bin2hex((uchar*)data, len);
|
||||
applog(LOG_DEBUG, "%s", hex);
|
||||
free(hex);
|
||||
}
|
||||
|
||||
#define printpfx(n,h) \
|
||||
@@ -1823,34 +2062,20 @@ void do_gpu_tests(void)
|
||||
#ifdef _DEBUG
|
||||
unsigned long done;
|
||||
char s[128] = { '\0' };
|
||||
uchar buf[160];
|
||||
uint32_t tgt[8] = { 0 };
|
||||
struct work work;
|
||||
memset(&work, 0, sizeof(work));
|
||||
|
||||
opt_tracegpu = true;
|
||||
work_restart = (struct work_restart*) malloc(sizeof(struct work_restart));
|
||||
work_restart[0].restart = 1;
|
||||
tgt[7] = 0xffff;
|
||||
|
||||
//memset(buf, 0, sizeof buf);
|
||||
//scanhash_skeincoin(0, (uint32_t*)buf, tgt, 1, &done);
|
||||
|
||||
//memset(buf, 0, sizeof buf);
|
||||
//memcpy(buf, zrtest, 80);
|
||||
//scanhash_zr5(0, (uint32_t*)buf, tgt, zrtest[19]+1, &done);
|
||||
work.target[7] = 0xffff;
|
||||
|
||||
//struct timeval tv;
|
||||
//memset(buf, 0, sizeof buf);
|
||||
//scanhash_scrypt_jane(0, (uint32_t*)buf, tgt, NULL, 1, &done, &tv, &tv);
|
||||
//memset(work.data, 0, sizeof(work.data));
|
||||
//scanhash_scrypt_jane(0, &work, NULL, 1, &done, &tv, &tv);
|
||||
|
||||
memset(buf, 0, sizeof buf);
|
||||
scanhash_lyra2(0, (uint32_t*)buf, tgt, 1, &done);
|
||||
|
||||
//memset(buf, 0, sizeof buf);
|
||||
// buf[0] = 1; buf[64] = 2; // for endian tests
|
||||
//scanhash_blake256(0, (uint32_t*)buf, tgt, 1, &done, 14);
|
||||
|
||||
//memset(buf, 0, sizeof buf);
|
||||
//scanhash_heavy(0, (uint32_t*)buf, tgt, 1, &done, 1, 84); // HEAVYCOIN_BLKHDR_SZ=84
|
||||
memset(work.data, 0, sizeof(work.data));
|
||||
scanhash_decred(0, &work, 1, &done);
|
||||
|
||||
free(work_restart);
|
||||
work_restart = NULL;
|
||||
@@ -1863,7 +2088,7 @@ void print_hash_tests(void)
|
||||
uchar *scratchbuf = NULL;
|
||||
char s[128] = {'\0'};
|
||||
uchar hash[128];
|
||||
uchar buf[128];
|
||||
uchar buf[192];
|
||||
|
||||
// work space for scratchpad based algos
|
||||
scratchbuf = (uchar*)calloc(128, 1024);
|
||||
@@ -1879,12 +2104,19 @@ void print_hash_tests(void)
|
||||
blake256hash(&hash[0], &buf[0], 14);
|
||||
printpfx("blake", hash);
|
||||
|
||||
blake2s_hash(&hash[0], &buf[0]);
|
||||
printpfx("blake2s", hash);
|
||||
|
||||
bmw_hash(&hash[0], &buf[0]);
|
||||
printpfx("bmw", hash);
|
||||
|
||||
c11hash(&hash[0], &buf[0]);
|
||||
printpfx("c11", hash);
|
||||
|
||||
memset(buf, 0, 180);
|
||||
decred_hash(&hash[0], &buf[0]);
|
||||
printpfx("decred", hash);
|
||||
|
||||
deephash(&hash[0], &buf[0]);
|
||||
printpfx("deep", hash);
|
||||
|
||||
@@ -1939,6 +2171,9 @@ void print_hash_tests(void)
|
||||
scryptjane_hash(&hash[0], &buf[0]);
|
||||
printpfx("scrypt-jane", hash);
|
||||
|
||||
sibhash(&hash[0], &buf[0]);
|
||||
printpfx("sib", hash);
|
||||
|
||||
skeincoinhash(&hash[0], &buf[0]);
|
||||
printpfx("skein", hash);
|
||||
|
||||
@@ -1948,8 +2183,14 @@ void print_hash_tests(void)
|
||||
s3hash(&hash[0], &buf[0]);
|
||||
printpfx("S3", hash);
|
||||
|
||||
whirlxHash(&hash[0], &buf[0]);
|
||||
printpfx("whirlpoolx", hash);
|
||||
blake256hash(&hash[0], &buf[0], 8);
|
||||
printpfx("vanilla", hash);
|
||||
|
||||
wcoinhash(&hash[0], &buf[0]);
|
||||
printpfx("whirlpool", hash);
|
||||
|
||||
//whirlxHash(&hash[0], &buf[0]);
|
||||
//printpfx("whirlpoolx", hash);
|
||||
|
||||
x11hash(&hash[0], &buf[0]);
|
||||
printpfx("X11", hash);
|
||||
|
||||
+27
-47
@@ -16,49 +16,17 @@ extern "C"
|
||||
|
||||
#include "miner.h"
|
||||
#include "cuda_helper.h"
|
||||
#include "cuda_x11.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <memory.h>
|
||||
|
||||
static uint32_t *d_hash[MAX_GPUS];
|
||||
|
||||
extern void quark_blake512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_blake512_cpu_setBlock_80(int thr_id, uint32_t *pdata);
|
||||
extern void quark_blake512_cpu_hash_80(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_hash);
|
||||
|
||||
extern void quark_bmw512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_bmw512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void quark_groestl512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_groestl512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
extern void quark_doublegroestl512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void quark_skein512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_skein512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void quark_keccak512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_keccak512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void quark_jh512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void quark_jh512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void x11_luffaCubehash512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void x11_luffaCubehash512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t *d_hash, int order);
|
||||
|
||||
extern void x11_shavite512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void x11_shavite512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern int x11_simd512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void x11_simd512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
extern void x11_echo512_cpu_init(int thr_id, uint32_t threads);
|
||||
extern void x11_echo512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
|
||||
|
||||
|
||||
// Flax/C11 CPU Hash
|
||||
// Flax/Chaincoin C11 CPU Hash
|
||||
extern "C" void c11hash(void *output, const void *input)
|
||||
{
|
||||
// blake1-bmw2-grs3-skein4-jh5-keccak6-luffa7-cubehash8-shavite9-simd10-echo11
|
||||
unsigned char hash[128] = { 0 };
|
||||
|
||||
sph_blake512_context ctx_blake;
|
||||
sph_bmw512_context ctx_bmw;
|
||||
@@ -72,9 +40,6 @@ extern "C" void c11hash(void *output, const void *input)
|
||||
sph_simd512_context ctx_simd;
|
||||
sph_echo512_context ctx_echo;
|
||||
|
||||
unsigned char hash[128];
|
||||
memset(hash, 0, sizeof hash);
|
||||
|
||||
sph_blake512_init(&ctx_blake);
|
||||
sph_blake512 (&ctx_blake, input, 80);
|
||||
sph_blake512_close(&ctx_blake, (void*) hash);
|
||||
@@ -145,8 +110,8 @@ extern "C" int scanhash_c11(int thr_id, struct work* work, uint32_t max_nonce, u
|
||||
uint32_t *ptarget = work->target;
|
||||
const uint32_t first_nonce = pdata[19];
|
||||
int intensity = (device_sm[device_map[thr_id]] >= 500 && !is_windows()) ? 20 : 19;
|
||||
uint32_t throughput = device_intensity(thr_id, __func__, 1U << intensity); // 19=256*256*8;
|
||||
throughput = min(throughput, max_nonce - first_nonce);
|
||||
uint32_t throughput = cuda_default_throughput(thr_id, 1U << intensity); // 19=256*256*8;
|
||||
if (init[thr_id]) throughput = min(throughput, max_nonce - first_nonce);
|
||||
|
||||
if (opt_benchmark)
|
||||
((uint32_t*)ptarget)[7] = 0x5;
|
||||
@@ -154,6 +119,12 @@ extern "C" int scanhash_c11(int thr_id, struct work* work, uint32_t max_nonce, u
|
||||
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();
|
||||
}
|
||||
|
||||
quark_blake512_cpu_init(thr_id, throughput);
|
||||
quark_bmw512_cpu_init(thr_id, throughput);
|
||||
@@ -221,28 +192,34 @@ extern "C" int scanhash_c11(int thr_id, struct work* work, uint32_t max_nonce, u
|
||||
int res = 1;
|
||||
// check if there was some other ones...
|
||||
uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1);
|
||||
bn_store_hash_target_ratio(vhash64, ptarget, work);
|
||||
work_set_target_ratio(work, vhash64);
|
||||
if (secNonce != 0) {
|
||||
be32enc(&endiandata[19], secNonce);
|
||||
c11hash(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++;
|
||||
}
|
||||
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] = foundNonce + 1;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
@@ -252,12 +229,15 @@ extern "C" void free_c11(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);
|
||||
x11_simd512_cpu_free(thr_id);
|
||||
|
||||
cuda_check_cpu_free(thr_id);
|
||||
init[thr_id] = false;
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
Loaded 100 of 123 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user