X-Git-Url: https://git.novaco.in/?a=blobdiff_plain;f=src%2Fkernel_worker.cpp;h=2980952072963412684e182090ca352a8a7a11e1;hb=5b098a8ec26ef68b65dd42a04246418a871e9cd9;hp=0c3b9d3765ca4cee383386e8220a95ed00f0d6b1;hpb=5d466098ff30f0dece5d7e64e1b8b701aa088649;p=novacoin.git diff --git a/src/kernel_worker.cpp b/src/kernel_worker.cpp index 0c3b9d3..2980952 100644 --- a/src/kernel_worker.cpp +++ b/src/kernel_worker.cpp @@ -10,6 +10,11 @@ using namespace std; #ifdef USE_ASM +#ifdef _MSC_VER +#include +#define __builtin_bswap32 _byteswap_ulong +#endif + #if defined(__i386__) || defined(__x86_64__) #include #endif @@ -139,9 +144,15 @@ void KernelWorker::Do_8way() bnTargetPerCoinDay.SetCompact(nBits); uint256 nMaxTarget = (bnTargetPerCoinDay * bnValueIn * nStakeMaxAge / COIN / nOneDay).getuint256(); +#ifdef _MSC_VER + __declspec(align(16)) uint32_t blocks1[8 * 16]; + __declspec(align(16)) uint32_t blocks2[8 * 16]; + __declspec(align(16)) uint32_t candidates[8 * 8]; +#else uint32_t blocks1[8 * 16] __attribute__((aligned(16))); uint32_t blocks2[8 * 16] __attribute__((aligned(16))); uint32_t candidates[8 * 8] __attribute__((aligned(16))); +#endif vector vRow = vector(8); uint32_t *pnKernel = (uint32_t *) kernel; @@ -210,9 +221,15 @@ void KernelWorker::Do_4way() bnTargetPerCoinDay.SetCompact(nBits); uint256 nMaxTarget = (bnTargetPerCoinDay * bnValueIn * nStakeMaxAge / COIN / nOneDay).getuint256(); +#ifdef _MSC_VER + __declspec(align(16)) uint32_t blocks1[4 * 16]; + __declspec(align(16)) uint32_t blocks2[4 * 16]; + __declspec(align(16)) uint32_t candidates[4 * 8]; +#else uint32_t blocks1[4 * 16] __attribute__((aligned(16))); uint32_t blocks2[4 * 16] __attribute__((aligned(16))); uint32_t candidates[4 * 8] __attribute__((aligned(16))); +#endif vector vRow = vector(4); uint32_t *pnKernel = (uint32_t *) kernel; @@ -315,9 +332,16 @@ void KernelWorker::Do_generic() solutions.push_back(std::pair(*pnHashProofOfStake, nTimeTx)); } #else + +#ifdef _MSC_VER + __declspec(align(16)) uint32_t block1[16]; + __declspec(align(16)) uint32_t block2[16]; + __declspec(align(16)) uint32_t candidate[8]; +#else uint32_t block1[16] __attribute__((aligned(16))); uint32_t block2[16] __attribute__((aligned(16))); uint32_t candidate[8] __attribute__((aligned(16))); +#endif memcpy(&block1[7], &block1_suffix[0], 36); // sha256 padding memcpy(&block2[8], &block2_suffix[0], 32); @@ -386,3 +410,237 @@ vector >& KernelWorker::GetSolutions() return solutions; } +// Scan given kernel for solutions +#ifdef USE_ASM + +#ifdef __x86_64__ +bool ScanKernelBackward_8Way(unsigned char *kernel, uint32_t nBits, uint32_t nInputTxTime, int64_t nValueIn, std::pair &SearchInterval, std::pair &solution) +{ + CBigNum bnTargetPerCoinDay; + bnTargetPerCoinDay.SetCompact(nBits); + + CBigNum bnValueIn(nValueIn); + + // Get maximum possible target to filter out the majority of obviously insufficient hashes + uint256 nMaxTarget = (bnTargetPerCoinDay * bnValueIn * nStakeMaxAge / COIN / nOneDay).getuint256(); + +#ifdef _MSC_VER + __declspec(align(16)) uint32_t blocks1[8 * 16]; + __declspec(align(16)) uint32_t blocks2[8 * 16]; + __declspec(align(16)) uint32_t candidates[8 * 8]; +#else + uint32_t blocks1[8 * 16] __attribute__((aligned(16))); + uint32_t blocks2[8 * 16] __attribute__((aligned(16))); + uint32_t candidates[8 * 8] __attribute__((aligned(16))); +#endif + + vector vRow = vector(8); + uint32_t *pnKernel = (uint32_t *) kernel; + + for(int i = 0; i < 7; i++) + { + fill(vRow.begin(), vRow.end(), pnKernel[i]); + copyrow8_swap32(&blocks1[i*8], &vRow[0]); + } + + memcpy(&blocks1[56], &block1_suffix_8way[0], 36*8); // sha256 padding + memcpy(&blocks2[64], &block2_suffix_8way[0], 32*8); + + uint32_t nHashes[8]; + uint32_t nTimeStamps[8]; + + // Search forward in time from the given timestamp + // Stopping search in case of shutting down + for (uint32_t nTimeTx=SearchInterval.first, nMaxTarget32 = nMaxTarget.Get32(7); nTimeTx>SearchInterval.second && !fShutdown; nTimeTx -=8) + { + sha256_init_8way(blocks2); + sha256_init_8way(candidates); + + nTimeStamps[0] = nTimeTx; + nTimeStamps[1] = nTimeTx-1; + nTimeStamps[2] = nTimeTx-2; + nTimeStamps[3] = nTimeTx-3; + nTimeStamps[4] = nTimeTx-4; + nTimeStamps[5] = nTimeTx-5; + nTimeStamps[6] = nTimeTx-6; + nTimeStamps[7] = nTimeTx-7; + + copyrow8_swap32(&blocks1[24], &nTimeStamps[0]); // Kernel timestamps + sha256_transform_8way(&blocks2[0], &blocks1[0], 0); // first hashing + sha256_transform_8way(&candidates[0], &blocks2[0], 0); // second hashing + copyrow8_swap32(&nHashes[0], &candidates[56]); + + for(int nResult = 0; nResult < 8; nResult++) + { + if (nHashes[nResult] <= nMaxTarget32) // Possible hit + { + uint256 nHashProofOfStake = 0; + uint32_t *pnHashProofOfStake = (uint32_t *) &nHashProofOfStake; + + for (int i = 0; i < 7; i++) + pnHashProofOfStake[i] = __builtin_bswap32(candidates[(i*8) + nResult]); + pnHashProofOfStake[7] = nHashes[nResult]; + + CBigNum bnCoinDayWeight = bnValueIn * GetWeight((int64_t)nInputTxTime, (int64_t)nTimeStamps[nResult]) / COIN / nOneDay; + CBigNum bnTargetProofOfStake = bnCoinDayWeight * bnTargetPerCoinDay; + + if (bnTargetProofOfStake >= CBigNum(nHashProofOfStake)) + { + solution.first = nHashProofOfStake; + solution.second = nTimeStamps[nResult]; + + return true; + } + } + } + } + + return false; +} +#endif + +bool ScanKernelBackward_4Way(unsigned char *kernel, uint32_t nBits, uint32_t nInputTxTime, int64_t nValueIn, std::pair &SearchInterval, std::pair &solution) +{ + CBigNum bnTargetPerCoinDay; + bnTargetPerCoinDay.SetCompact(nBits); + + CBigNum bnValueIn(nValueIn); + + // Get maximum possible target to filter out the majority of obviously insufficient hashes + uint256 nMaxTarget = (bnTargetPerCoinDay * bnValueIn * nStakeMaxAge / COIN / nOneDay).getuint256(); + +#ifdef _MSC_VER + __declspec(align(16)) uint32_t blocks1[4 * 16]; + __declspec(align(16)) uint32_t blocks2[4 * 16]; + __declspec(align(16)) uint32_t candidates[4 * 8]; +#else + uint32_t blocks1[4 * 16] __attribute__((aligned(16))); + uint32_t blocks2[4 * 16] __attribute__((aligned(16))); + uint32_t candidates[4 * 8] __attribute__((aligned(16))); +#endif + + vector vRow = vector(4); + uint32_t *pnKernel = (uint32_t *) kernel; + + for(int i = 0; i < 7; i++) + { + fill(vRow.begin(), vRow.end(), pnKernel[i]); + copyrow4_swap32(&blocks1[i*4], &vRow[0]); + } + + memcpy(&blocks1[28], &block1_suffix_4way[0], 36*4); // sha256 padding + memcpy(&blocks2[32], &block2_suffix_4way[0], 32*4); + + uint32_t nHashes[4]; + uint32_t nTimeStamps[4]; + + // Search forward in time from the given timestamp + // Stopping search in case of shutting down + for (uint32_t nTimeTx=SearchInterval.first, nMaxTarget32 = nMaxTarget.Get32(7); nTimeTx>SearchInterval.second && !fShutdown; nTimeTx -=4) + { + sha256_init_4way(blocks2); + sha256_init_4way(candidates); + + nTimeStamps[0] = nTimeTx; + nTimeStamps[1] = nTimeTx-1; + nTimeStamps[2] = nTimeTx-2; + nTimeStamps[3] = nTimeTx-3; + + copyrow4_swap32(&blocks1[24], &nTimeStamps[0]); // Kernel timestamps + sha256_transform_4way(&blocks2[0], &blocks1[0], 0); // first hashing + sha256_transform_4way(&candidates[0], &blocks2[0], 0); // second hashing + copyrow4_swap32(&nHashes[0], &candidates[28]); + + for(int nResult = 0; nResult < 4; nResult++) + { + if (nHashes[nResult] <= nMaxTarget32) // Possible hit + { + uint256 nHashProofOfStake = 0; + uint32_t *pnHashProofOfStake = (uint32_t *) &nHashProofOfStake; + + for (int i = 0; i < 7; i++) + pnHashProofOfStake[i] = __builtin_bswap32(candidates[(i*4) + nResult]); + pnHashProofOfStake[7] = nHashes[nResult]; + + CBigNum bnCoinDayWeight = bnValueIn * GetWeight((int64_t)nInputTxTime, (int64_t)nTimeStamps[nResult]) / COIN / nOneDay; + CBigNum bnTargetProofOfStake = bnCoinDayWeight * bnTargetPerCoinDay; + + if (bnTargetProofOfStake >= CBigNum(nHashProofOfStake)) + { + solution.first = nHashProofOfStake; + solution.second = nTimeStamps[nResult]; + + return true; + } + } + } + } + + return false; +} +#endif + +bool ScanKernelBackward(unsigned char *kernel, uint32_t nBits, uint32_t nInputTxTime, int64_t nValueIn, std::pair &SearchInterval, std::pair &solution) +{ +#ifdef USE_ASM +#ifdef __x86_64__ + if (false && fUse8Way) // disable for now + { + return ScanKernelBackward_8Way(kernel, nBits, nInputTxTime, nValueIn, SearchInterval, solution); + } +#endif + if (fUse4Way) + { + return ScanKernelBackward_4Way(kernel, nBits, nInputTxTime, nValueIn, SearchInterval, solution); + } +#endif + + CBigNum bnTargetPerCoinDay; + bnTargetPerCoinDay.SetCompact(nBits); + + CBigNum bnValueIn(nValueIn); + + // Get maximum possible target to filter out the majority of obviously insufficient hashes + uint256 nMaxTarget = (bnTargetPerCoinDay * bnValueIn * nStakeMaxAge / COIN / nOneDay).getuint256(); + + SHA256_CTX ctx, workerCtx; + // Init new sha256 context and update it + // with first 24 bytes of kernel + SHA256_Init(&ctx); + SHA256_Update(&ctx, kernel, 8 + 16); + workerCtx = ctx; // save context + + // Search backward in time from the given timestamp + // Stopping search in case of shutting down + for (uint32_t nTimeTx=SearchInterval.first; nTimeTx>SearchInterval.second && !fShutdown; nTimeTx--) + { + // Complete first hashing iteration + uint256 hash1; + SHA256_Update(&ctx, (unsigned char*)&nTimeTx, 4); + SHA256_Final((unsigned char*)&hash1, &ctx); + + // Restore context + ctx = workerCtx; + + // Finally, calculate kernel hash + uint256 hashProofOfStake; + SHA256((unsigned char*)&hash1, sizeof(hashProofOfStake), (unsigned char*)&hashProofOfStake); + + // Skip if hash doesn't satisfy the maximum target + if (hashProofOfStake > nMaxTarget) + continue; + + CBigNum bnCoinDayWeight = bnValueIn * GetWeight((int64_t)nInputTxTime, (int64_t)nTimeTx) / COIN / nOneDay; + CBigNum bnTargetProofOfStake = bnCoinDayWeight * bnTargetPerCoinDay; + + if (bnTargetProofOfStake >= CBigNum(hashProofOfStake)) + { + solution.first = hashProofOfStake; + solution.second = nTimeTx; + + return true; + } + } + + return false; +}