Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
tpruvot
GitHub Repository: tpruvot/cpuminer-multi
 Path: blob/linux/algo/sonoa.c
1201 views
1
#include "miner.h"

2


3
#include <stdlib.h>

4
#include <stdint.h>

5
#include <string.h>

6
#include <stdio.h>

7


8
#include <sha3/sph_blake.h>

9
#include <sha3/sph_bmw.h>

10
#include <sha3/sph_groestl.h>

11
#include <sha3/sph_jh.h>

12
#include <sha3/sph_keccak.h>

13
#include <sha3/sph_skein.h>

14
#include <sha3/sph_luffa.h>

15
#include <sha3/sph_cubehash.h>

16
#include <sha3/sph_shavite.h>

17
#include <sha3/sph_simd.h>

18
#include <sha3/sph_echo.h>

19
#include <sha3/sph_hamsi.h>

20
#include <sha3/sph_fugue.h>

21
#include <sha3/sph_shabal.h>

22
#include <sha3/sph_whirlpool.h>

23
#include <sha3/sph_sha2.h>

24
#include <sha3/sph_haval.h>

25


26
void sonoa_hash(void *state, const void *input)

27
{

28
	uint8_t _ALIGN(128) hash[64];

29


30
	sph_blake512_context     ctx_blake;

31
	sph_bmw512_context       ctx_bmw;

32
	sph_groestl512_context   ctx_groestl;

33
	sph_jh512_context        ctx_jh;

34
	sph_keccak512_context    ctx_keccak;

35
	sph_skein512_context     ctx_skein;

36
	sph_luffa512_context     ctx_luffa;

37
	sph_cubehash512_context  ctx_cubehash;

38
	sph_shavite512_context   ctx_shavite;

39
	sph_simd512_context      ctx_simd;

40
	sph_echo512_context      ctx_echo;

41
	sph_hamsi512_context     ctx_hamsi;

42
	sph_fugue512_context     ctx_fugue;

43
	sph_shabal512_context    ctx_shabal;

44
	sph_whirlpool_context    ctx_whirlpool;

45
	sph_sha512_context       ctx_sha512;

46
	sph_haval256_5_context   ctx_haval;

47


48


49
	sph_blake512_init(&ctx_blake);

50
	sph_blake512(&ctx_blake, input, 80);

51
	sph_blake512_close(&ctx_blake, hash);

52


53
	sph_bmw512_init(&ctx_bmw);

54
	sph_bmw512(&ctx_bmw, hash, 64);

55
	sph_bmw512_close(&ctx_bmw, hash);

56


57
	sph_groestl512_init(&ctx_groestl);

58
	sph_groestl512(&ctx_groestl, hash, 64);

59
	sph_groestl512_close(&ctx_groestl, hash);

60


61
	sph_skein512_init(&ctx_skein);

62
	sph_skein512(&ctx_skein, hash, 64);

63
	sph_skein512_close(&ctx_skein, hash);

64


65
	sph_jh512_init(&ctx_jh);

66
	sph_jh512(&ctx_jh, hash, 64);

67
	sph_jh512_close(&ctx_jh, hash);

68


69
	sph_keccak512_init(&ctx_keccak);

70
	sph_keccak512(&ctx_keccak, hash, 64);

71
	sph_keccak512_close(&ctx_keccak, hash);

72


73
	sph_luffa512_init(&ctx_luffa);

74
	sph_luffa512(&ctx_luffa, hash, 64);

75
	sph_luffa512_close(&ctx_luffa, hash);

76


77
	sph_cubehash512_init(&ctx_cubehash);

78
	sph_cubehash512(&ctx_cubehash, hash, 64);

79
	sph_cubehash512_close(&ctx_cubehash, hash);

80


81
	sph_shavite512_init(&ctx_shavite);

82
	sph_shavite512(&ctx_shavite, hash, 64);

83
	sph_shavite512_close(&ctx_shavite, hash);

84


85
	sph_simd512_init(&ctx_simd);

86
	sph_simd512(&ctx_simd, hash, 64);

87
	sph_simd512_close(&ctx_simd, hash);

88


89
	sph_echo512_init(&ctx_echo);

90
	sph_echo512(&ctx_echo, hash, 64);

91
	sph_echo512_close(&ctx_echo, hash);

92


93


94
	sph_bmw512(&ctx_bmw, hash, 64);

95
	sph_bmw512_close(&ctx_bmw, hash);

96


97
	sph_groestl512(&ctx_groestl, hash, 64);

98
	sph_groestl512_close(&ctx_groestl, hash);

99


100
	sph_skein512(&ctx_skein, hash, 64);

101
	sph_skein512_close(&ctx_skein, hash);

102


103
	sph_jh512(&ctx_jh, hash, 64);

104
	sph_jh512_close(&ctx_jh, hash);

105


106
	sph_keccak512(&ctx_keccak, hash, 64);

107
	sph_keccak512_close(&ctx_keccak, hash);

108


109
	sph_luffa512(&ctx_luffa, hash, 64);

110
	sph_luffa512_close(&ctx_luffa, hash);

111


112
	sph_cubehash512(&ctx_cubehash, hash, 64);

113
	sph_cubehash512_close(&ctx_cubehash, hash);

114


115
	sph_shavite512(&ctx_shavite, hash, 64);

116
	sph_shavite512_close(&ctx_shavite, hash);

117


118
	sph_simd512(&ctx_simd, hash, 64);

119
	sph_simd512_close(&ctx_simd, hash);

120


121
	sph_echo512(&ctx_echo, hash, 64);

122
	sph_echo512_close(&ctx_echo, hash);

123


124
	sph_hamsi512_init(&ctx_hamsi);

125
	sph_hamsi512(&ctx_hamsi, hash, 64);

126
	sph_hamsi512_close(&ctx_hamsi, hash);

127


128


129
	sph_bmw512(&ctx_bmw, hash, 64);

130
	sph_bmw512_close(&ctx_bmw, hash);

131


132
	sph_groestl512(&ctx_groestl, hash, 64);

133
	sph_groestl512_close(&ctx_groestl, hash);

134


135
	sph_skein512(&ctx_skein, hash, 64);

136
	sph_skein512_close(&ctx_skein, hash);

137


138
	sph_jh512(&ctx_jh, hash, 64);

139
	sph_jh512_close(&ctx_jh, hash);

140


141
	sph_keccak512(&ctx_keccak, hash, 64);

142
	sph_keccak512_close(&ctx_keccak, hash);

143


144
	sph_luffa512(&ctx_luffa, hash, 64);

145
	sph_luffa512_close(&ctx_luffa, hash);

146


147
	sph_cubehash512(&ctx_cubehash, hash, 64);

148
	sph_cubehash512_close(&ctx_cubehash, hash);

149


150
	sph_shavite512(&ctx_shavite, hash, 64);

151
	sph_shavite512_close(&ctx_shavite, hash);

152


153
	sph_simd512(&ctx_simd, hash, 64);

154
	sph_simd512_close(&ctx_simd, hash);

155


156
	sph_echo512(&ctx_echo, hash, 64);

157
	sph_echo512_close(&ctx_echo, hash);

158


159
	sph_hamsi512(&ctx_hamsi, hash, 64);

160
	sph_hamsi512_close(&ctx_hamsi, hash);

161


162
	sph_fugue512_init(&ctx_fugue);

163
	sph_fugue512(&ctx_fugue, hash, 64);

164
	sph_fugue512_close(&ctx_fugue, hash);

165


166


167
	sph_bmw512(&ctx_bmw, hash, 64);

168
	sph_bmw512_close(&ctx_bmw, hash);

169


170
	sph_groestl512(&ctx_groestl, hash, 64);

171
	sph_groestl512_close(&ctx_groestl, hash);

172


173
	sph_skein512(&ctx_skein, hash, 64);

174
	sph_skein512_close(&ctx_skein, hash);

175


176
	sph_jh512(&ctx_jh, hash, 64);

177
	sph_jh512_close(&ctx_jh, hash);

178


179
	sph_keccak512(&ctx_keccak, hash, 64);

180
	sph_keccak512_close(&ctx_keccak, hash);

181


182
	sph_luffa512(&ctx_luffa, hash, 64);

183
	sph_luffa512_close(&ctx_luffa, hash);

184


185
	sph_cubehash512(&ctx_cubehash, hash, 64);

186
	sph_cubehash512_close(&ctx_cubehash, hash);

187


188
	sph_shavite512(&ctx_shavite, hash, 64);

189
	sph_shavite512_close(&ctx_shavite, hash);

190


191
	sph_simd512(&ctx_simd, hash, 64);

192
	sph_simd512_close(&ctx_simd, hash);

193


194
	sph_echo512(&ctx_echo, hash, 64);

195
	sph_echo512_close(&ctx_echo, hash);

196


197
	sph_hamsi512(&ctx_hamsi, hash, 64);

198
	sph_hamsi512_close(&ctx_hamsi, hash);

199


200
	sph_fugue512(&ctx_fugue, hash, 64);

201
	sph_fugue512_close(&ctx_fugue, hash);

202


203
	sph_shabal512_init(&ctx_shabal);

204
	sph_shabal512(&ctx_shabal, hash, 64);

205
	sph_shabal512_close(&ctx_shabal, hash);

206


207
	sph_hamsi512(&ctx_hamsi, hash, 64);

208
	sph_hamsi512_close(&ctx_hamsi, hash);

209


210
	sph_echo512(&ctx_echo, hash, 64);

211
	sph_echo512_close(&ctx_echo, hash);

212


213
	sph_shavite512(&ctx_shavite, hash, 64);

214
	sph_shavite512_close(&ctx_shavite, hash);

215


216


217
	sph_bmw512(&ctx_bmw, hash, 64);

218
	sph_bmw512_close(&ctx_bmw, hash);

219


220
	sph_shabal512(&ctx_shabal, hash, 64);

221
	sph_shabal512_close(&ctx_shabal, hash);

222


223
	sph_groestl512(&ctx_groestl, hash, 64);

224
	sph_groestl512_close(&ctx_groestl, hash);

225


226
	sph_skein512(&ctx_skein, hash, 64);

227
	sph_skein512_close(&ctx_skein, hash);

228


229
	sph_jh512(&ctx_jh, hash, 64);

230
	sph_jh512_close(&ctx_jh, hash);

231


232
	sph_keccak512(&ctx_keccak, hash, 64);

233
	sph_keccak512_close(&ctx_keccak, hash);

234


235
	sph_luffa512(&ctx_luffa, hash, 64);

236
	sph_luffa512_close(&ctx_luffa, hash);

237


238
	sph_cubehash512(&ctx_cubehash, hash, 64);

239
	sph_cubehash512_close(&ctx_cubehash, hash);

240


241
	sph_shavite512(&ctx_shavite, hash, 64);

242
	sph_shavite512_close(&ctx_shavite, hash);

243


244
	sph_simd512(&ctx_simd, hash, 64);

245
	sph_simd512_close(&ctx_simd, hash);

246


247
	sph_echo512(&ctx_echo, hash, 64);

248
	sph_echo512_close(&ctx_echo, hash);

249


250
	sph_hamsi512(&ctx_hamsi, hash, 64);

251
	sph_hamsi512_close(&ctx_hamsi, hash);

252


253
	sph_fugue512(&ctx_fugue, hash, 64);

254
	sph_fugue512_close(&ctx_fugue, hash);

255


256
	sph_shabal512(&ctx_shabal, hash, 64);

257
	sph_shabal512_close(&ctx_shabal, hash);

258


259
	sph_whirlpool_init(&ctx_whirlpool);

260
	sph_whirlpool(&ctx_whirlpool, hash, 64);

261
	sph_whirlpool_close(&ctx_whirlpool, hash);

262


263


264
	sph_bmw512(&ctx_bmw, hash, 64);

265
	sph_bmw512_close(&ctx_bmw, hash);

266


267
	sph_groestl512(&ctx_groestl, hash, 64);

268
	sph_groestl512_close(&ctx_groestl, hash);

269


270
	sph_skein512(&ctx_skein, hash, 64);

271
	sph_skein512_close(&ctx_skein, hash);

272


273
	sph_jh512(&ctx_jh, hash, 64);

274
	sph_jh512_close(&ctx_jh, hash);

275


276
	sph_keccak512(&ctx_keccak, hash, 64);

277
	sph_keccak512_close(&ctx_keccak, hash);

278


279
	sph_luffa512(&ctx_luffa, hash, 64);

280
	sph_luffa512_close(&ctx_luffa, hash);

281


282
	sph_cubehash512(&ctx_cubehash, hash, 64);

283
	sph_cubehash512_close(&ctx_cubehash, hash);

284


285
	sph_shavite512(&ctx_shavite, hash, 64);

286
	sph_shavite512_close(&ctx_shavite, hash);

287


288
	sph_simd512(&ctx_simd, hash, 64);

289
	sph_simd512_close(&ctx_simd, hash);

290


291
	sph_echo512(&ctx_echo, hash, 64);

292
	sph_echo512_close(&ctx_echo, hash);

293


294
	sph_hamsi512(&ctx_hamsi, hash, 64);

295
	sph_hamsi512_close(&ctx_hamsi, hash);

296


297
	sph_fugue512(&ctx_fugue, hash, 64);

298
	sph_fugue512_close(&ctx_fugue, hash);

299


300
	sph_shabal512(&ctx_shabal, hash, 64);

301
	sph_shabal512_close(&ctx_shabal, hash);

302


303
	sph_whirlpool(&ctx_whirlpool, hash, 64);

304
	sph_whirlpool_close(&ctx_whirlpool, hash);

305


306
	sph_sha512_init(&ctx_sha512);

307
	sph_sha512(&ctx_sha512,(const void*) hash, 64);

308
	sph_sha512_close(&ctx_sha512,(void*) hash);

309


310
	sph_whirlpool(&ctx_whirlpool, hash, 64);

311
	sph_whirlpool_close(&ctx_whirlpool, hash);

312


313


314
	sph_bmw512(&ctx_bmw, hash, 64);

315
	sph_bmw512_close(&ctx_bmw, hash);

316


317
	sph_groestl512(&ctx_groestl, hash, 64);

318
	sph_groestl512_close(&ctx_groestl, hash);

319


320
	sph_skein512(&ctx_skein, hash, 64);

321
	sph_skein512_close(&ctx_skein, hash);

322


323
	sph_jh512(&ctx_jh, hash, 64);

324
	sph_jh512_close(&ctx_jh, hash);

325


326
	sph_keccak512(&ctx_keccak, hash, 64);

327
	sph_keccak512_close(&ctx_keccak, hash);

328


329
	sph_luffa512(&ctx_luffa, hash, 64);

330
	sph_luffa512_close(&ctx_luffa, hash);

331


332
	sph_cubehash512(&ctx_cubehash, hash, 64);

333
	sph_cubehash512_close(&ctx_cubehash, hash);

334


335
	sph_shavite512(&ctx_shavite, hash, 64);

336
	sph_shavite512_close(&ctx_shavite, hash);

337


338
	sph_simd512(&ctx_simd, hash, 64);

339
	sph_simd512_close(&ctx_simd, hash);

340


341
	sph_echo512(&ctx_echo, hash, 64);

342
	sph_echo512_close(&ctx_echo, hash);

343


344
	sph_hamsi512(&ctx_hamsi, hash, 64);

345
	sph_hamsi512_close(&ctx_hamsi, hash);

346


347
	sph_fugue512(&ctx_fugue, hash, 64);

348
	sph_fugue512_close(&ctx_fugue, hash);

349


350
	sph_shabal512(&ctx_shabal, hash, 64);

351
	sph_shabal512_close(&ctx_shabal, hash);

352


353
	sph_whirlpool(&ctx_whirlpool, hash, 64);

354
	sph_whirlpool_close(&ctx_whirlpool, hash);

355


356
	sph_sha512(&ctx_sha512,(const void*) hash, 64);

357
	sph_sha512_close(&ctx_sha512,(void*) hash);

358


359
	sph_haval256_5_init(&ctx_haval);

360
	sph_haval256_5(&ctx_haval,(const void*) hash, 64);

361
	sph_haval256_5_close(&ctx_haval, hash);

362


363
	memcpy(state, hash, 32);

364
}

365


366
int scanhash_sonoa(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done)

367
{

368
	uint32_t _ALIGN(128) hash32[8];

369
	uint32_t _ALIGN(128) endiandata[20];

370
	uint32_t *pdata = work->data;

371
	uint32_t *ptarget = work->target;

372
	const uint32_t first_nonce = pdata[19];

373
	const uint32_t Htarg = ptarget[7];

374
	uint32_t n = pdata[19] - 1;

375


376
	uint64_t htmax[] = {

377
		0,

378
		0xF,

379
		0xFF,

380
		0xFFF,

381
		0xFFFF,

382
		0x10000000

383
	};

384
	uint32_t masks[] = {

385
		0xFFFFFFFF,

386
		0xFFFFFFF0,

387
		0xFFFFFF00,

388
		0xFFFFF000,

389
		0xFFFF0000,

390
		0

391
	};

392


393
	// we need bigendian data...

394
	for (int i=0; i < 19; i++) {

395
			be32enc(&endiandata[i], pdata[i]);

396
	}

397


398
#ifdef DEBUG_ALGO

399
	printf("[%d] Htarg=%X\n", thr_id, Htarg);

400
#endif

401
	for (int m=0; m < 6; m++) {

402
		if (Htarg <= htmax[m]) {

403
			uint32_t mask = masks[m];

404
			do {

405
				pdata[19] = ++n;

406
				be32enc(&endiandata[19], n);

407
				sonoa_hash(hash32, endiandata);

408
#ifndef DEBUG_ALGO

409
				if ((!(hash32[7] & mask)) && fulltest(hash32, ptarget)) {

410
					work_set_target_ratio(work, hash32);

411
					*hashes_done = n - first_nonce + 1;

412
					return 1;

413
				}

414
#else

415
				if (!(n % 0x1000) && !thr_id) printf(".");

416
				if (!(hash32[7] & mask)) {

417
					printf("[%d]",thr_id);

418
					if (fulltest(hash32, ptarget)) {

419
						work_set_target_ratio(work, hash32);

420
						*hashes_done = n - first_nonce + 1;

421
						return 1;

422
					}

423
				}

424
#endif

425
			} while (n < max_nonce && !work_restart[thr_id].restart);

426
			// see blake.c if else to understand the loop on htmax => mask

427
			break;

428
		}

429
	}

430


431
	*hashes_done = n - first_nonce + 1;

432
	pdata[19] = n;

433
	return 0;

434
}

435


436