int scanhash_X(int thr_id, uint32_t *pdata, const uint32_t *ptarget, uint32_t max_nonce, unsigned long *hashes_done){ uint32_t n = pdata[19] - 1; const uint32_t first_nonce = pdata[19]; const uint32_t Htarg = ptarget[7]; uint32_t hash64[8] __attribute__((aligned(32))); uint32_t endiandata[32]; int kk=0; #pragma unroll for (; kk < 32; kk++){ be32enc(&endiandata[kk], ((uint32_t*)pdata)[kk]); }; if (ptarget[7]==0) { do { pdata[19] = ++n; be32enc(&endiandata[19], n); Xhash(hash64, &endiandata); if (((hash64[7]&0xFFFFFFFF)==0) && fulltest(hash64, ptarget)) { *hashes_done = n - first_nonce + 1; return true; } } while (n < max_nonce && !work_restart[thr_id].restart); } else if (ptarget[7]<=0xF) { do { pdata[19] = ++n; be32enc(&endiandata[19], n); Xhash(hash64, &endiandata); if (((hash64[7]&0xFFFFFFF0)==0) && fulltest(hash64, ptarget)) { *hashes_done = n - first_nonce + 1; return true; } } while (n < max_nonce && !work_restart[thr_id].restart); } else if (ptarget[7]<=0xFF) { do { pdata[19] = ++n; be32enc(&endiandata[19], n); Xhash(hash64, &endiandata); if (((hash64[7]&0xFFFFFF00)==0) && fulltest(hash64, ptarget)) { *hashes_done = n - first_nonce + 1; return true; } } while (n < max_nonce && !work_restart[thr_id].restart); } else if (ptarget[7]<=0xFFF) { do { pdata[19] = ++n; be32enc(&endiandata[19], n); Xhash(hash64, &endiandata); if (((hash64[7]&0xFFFFF000)==0) && fulltest(hash64, ptarget)) { *hashes_done = n - first_nonce + 1; return true; } } while (n < max_nonce && !work_restart[thr_id].restart); } else if (ptarget[7]<=0xFFFF) { do { pdata[19] = ++n; be32enc(&endiandata[19], n); Xhash(hash64, &endiandata); if (((hash64[7]&0xFFFF0000)==0) && fulltest(hash64, ptarget)) { *hashes_done = n - first_nonce + 1; return true; } } while (n < max_nonce && !work_restart[thr_id].restart); } else { do { pdata[19] = ++n; be32enc(&endiandata[19], n); Xhash(hash64, &endiandata); if (fulltest(hash64, ptarget)) { *hashes_done = n - first_nonce + 1; return true; } } while (n < max_nonce && !work_restart[thr_id].restart); } *hashes_done = n - first_nonce + 1; pdata[19] = n; return 0; }
bool scanhash_sse2_32(struct thr_info*thr, const unsigned char *pmidstate, unsigned char *pdata, unsigned char *phash1, unsigned char *phash, const unsigned char *ptarget, uint32_t max_nonce, uint32_t *last_nonce, uint32_t nonce) { uint32_t *nNonce_p = (uint32_t *)(pdata + 76); uint32_t m_midstate[8], m_w[16], m_w1[16]; __m128i m_4w[64] __attribute__ ((aligned (0x100))); __m128i m_4hash[64] __attribute__ ((aligned (0x100))); __m128i m_4hash1[64] __attribute__ ((aligned (0x100))); __m128i offset; int i; pdata += 64; /* Message expansion */ memcpy(m_midstate, pmidstate, sizeof(m_midstate)); memcpy(m_w, pdata, sizeof(m_w)); /* The 2nd half of the data */ memcpy(m_w1, phash1, sizeof(m_w1)); memset(m_4hash, 0, sizeof(m_4hash)); /* Transmongrify */ for (i = 0; i < 16; i++) m_4w[i] = _mm_set1_epi32(m_w[i]); for (i = 0; i < 16; i++) m_4hash1[i] = _mm_set1_epi32(m_w1[i]); for (i = 0; i < 64; i++) sha256_consts_m128i[i] = _mm_set1_epi32(g_sha256_k[i]); offset = _mm_set_epi32(0x3, 0x2, 0x1, 0x0); for (;;) { int j; m_4w[3] = _mm_add_epi32(offset, _mm_set1_epi32(nonce)); /* Some optimization can be done here W.R.T. precalculating some hash */ CalcSha256_x86 (m_4hash1, m_4w, m_midstate); CalcSha256_x86 (m_4hash, m_4hash1, sha256_32init); for (j = 0; j < 4; j++) { if (unlikely(((uint32_t *)&(m_4hash[7]))[j] == 0)) { /* We found a hit...so check it */ /* Use the C version for a check... */ for (i = 0; i < 8; i++) { *(uint32_t *)&(phash)[i<<2] = ((uint32_t *)&(m_4hash[i]))[j]; } if (fulltest(phash, ptarget)) { nonce += j; *last_nonce = nonce; *nNonce_p = nonce; return true; } } } if (unlikely((nonce >= max_nonce) || thr->work_restart)) { *last_nonce = nonce; return false; } nonce += 4; } }
int scanhash_scryptjane( int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done) { scrypt_aligned_alloc YX, V; uint8_t *X, *Y; uint32_t N, chunk_bytes; const uint32_t r = SCRYPT_R; const uint32_t p = SCRYPT_P; uint32_t *pdata = work->data; uint32_t *ptarget = work->target; uint32_t _ALIGN(64) endiandata[20]; const uint32_t first_nonce = pdata[19]; uint32_t nonce = first_nonce; if (opt_benchmark) ptarget[7] = 0x00ff; for (int k = 0; k < 19; k++) be32enc(&endiandata[k], pdata[k]); //Nfactor = GetNfactor(data[17], ntime); //if (Nfactor > scrypt_maxN) { // return 1; // //scrypt_fatal_error("scrypt: N out of range"); //} N = (1 << ( opt_scrypt_n + 1)); chunk_bytes = SCRYPT_BLOCK_BYTES * r * 2; if (!scrypt_alloc((uint64_t)N * chunk_bytes, &V)) return 1; if (!scrypt_alloc((p + 1) * chunk_bytes, &YX)) { scrypt_free(&V); return 1; } Y = YX.ptr; X = Y + chunk_bytes; do { const uint32_t Htarg = ptarget[7]; uint32_t hash[8]; be32enc(&endiandata[19], nonce); scrypt_N_1_1((unsigned char *)endiandata, 80, (unsigned char *)endiandata, 80, N, (unsigned char *)hash, 32, X, Y, V.ptr); if (hash[7] <= Htarg && fulltest(hash, ptarget)) { pdata[19] = nonce; *hashes_done = pdata[19] - first_nonce; scrypt_free(&V); scrypt_free(&YX); return 1; } nonce++; } while (nonce < max_nonce && !work_restart[thr_id].restart); pdata[19] = nonce; *hashes_done = pdata[19] - first_nonce + 1; scrypt_free(&V); scrypt_free(&YX); return 0; }
int scanhash_luffa(int thr_id, uint32_t *pdata, const uint32_t *ptarget, uint32_t max_nonce, unsigned long *hashes_done) { uint32_t n = pdata[19] - 1; const uint32_t first_nonce = pdata[19]; const uint32_t Htarg = ptarget[7]; uint32_t hash64[8] __attribute__((aligned(32))); uint32_t endiandata[32]; //char testdata[] = {"\x70\x00\x00\x00\x5d\x38\x5b\xa1\x14\xd0\x79\x97\x0b\x29\xa9\x41\x8f\xd0\x54\x9e\x7d\x68\xa9\x5c\x7f\x16\x86\x21\xa3\x14\x20\x10\x00\x00\x00\x00\x57\x85\x86\xd1\x49\xfd\x07\xb2\x2f\x3a\x8a\x34\x7c\x51\x6d\xe7\x05\x2f\x03\x4d\x2b\x76\xff\x68\xe0\xd6\xec\xff\x9b\x77\xa4\x54\x89\xe3\xfd\x51\x17\x32\x01\x1d\xf0\x73\x10\x00"}; //we need bigendian data... //lessons learned: do NOT endianchange directly in pdata, this will all proof-of-works be considered as stale from minerd.... int kk=0; for (; kk < 32; kk++) { be32enc(&endiandata[kk], ((uint32_t*)pdata)[kk]); }; // if (opt_debug) // { // applog(LOG_DEBUG, "Thr: %02d, firstN: %08x, maxN: %08x, ToDo: %d", thr_id, first_nonce, max_nonce, max_nonce-first_nonce); // } /* I'm to lazy to put the loop in an inline function... so dirty copy'n'paste.... */ /* i know that i could set a variable, but i don't know how the compiler will optimize it, not that then the cpu needs to load the value *everytime* in a register */ if (ptarget[7]==0) { do { pdata[19] = ++n; be32enc(&endiandata[19], n); luffahash(hash64, &endiandata); if (((hash64[7]&0xFFFFFFFF)==0) && fulltest(hash64, ptarget)) { *hashes_done = n - first_nonce + 1; return true; } } while (n < max_nonce && !work_restart[thr_id].restart); } else if (ptarget[7]<=0xF) { do { pdata[19] = ++n; be32enc(&endiandata[19], n); luffahash(hash64, &endiandata); if (((hash64[7]&0xFFFFFFF0)==0) && fulltest(hash64, ptarget)) { *hashes_done = n - first_nonce + 1; return true; } } while (n < max_nonce && !work_restart[thr_id].restart); } else if (ptarget[7]<=0xFF) { do { pdata[19] = ++n; be32enc(&endiandata[19], n); luffahash(hash64, &endiandata); if (((hash64[7]&0xFFFFFF00)==0) && fulltest(hash64, ptarget)) { *hashes_done = n - first_nonce + 1; return true; } } while (n < max_nonce && !work_restart[thr_id].restart); } else if (ptarget[7]<=0xFFF) { do { pdata[19] = ++n; be32enc(&endiandata[19], n); luffahash(hash64, &endiandata); if (((hash64[7]&0xFFFFF000)==0) && fulltest(hash64, ptarget)) { *hashes_done = n - first_nonce + 1; return true; } } while (n < max_nonce && !work_restart[thr_id].restart); } else if (ptarget[7]<=0xFFFF) { do { pdata[19] = ++n; be32enc(&endiandata[19], n); luffahash(hash64, &endiandata); if (((hash64[7]&0xFFFF0000)==0) && fulltest(hash64, ptarget)) { *hashes_done = n - first_nonce + 1; return true; } } while (n < max_nonce && !work_restart[thr_id].restart); } else { do { pdata[19] = ++n; be32enc(&endiandata[19], n); luffahash(hash64, &endiandata); if (fulltest(hash64, ptarget)) { *hashes_done = n - first_nonce + 1; return true; } } while (n < max_nonce && !work_restart[thr_id].restart); } *hashes_done = n - first_nonce + 1; pdata[19] = n; return 0; }