return true;
}
-// Scan given midstate for solution
-bool ScanContextBackward(SHA256_CTX &ctx, uint32_t nBits, uint32_t nInputTxTime, int64_t nValueIn, std::pair<uint32_t, uint32_t> &SearchInterval, std::pair<uint256, uint32_t> &solution)
-{
- CBigNum bnTargetPerCoinDay;
- bnTargetPerCoinDay.SetCompact(nBits);
-
- // Get maximum possible target to filter out the majority of obviously insufficient hashes
- CBigNum bnMaxTargetPerCoinDay = bnTargetPerCoinDay * CBigNum(nValueIn) * nStakeMaxAge / COIN / nOneDay;
- uint256 maxTarget = bnMaxTargetPerCoinDay.getuint256();
-
- SHA256_CTX ctxCopy = ctx;
-
- // 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(&ctxCopy, (unsigned char*)&nTimeTx, 4);
- SHA256_Final((unsigned char*)&hash1, &ctxCopy);
-
- // Restore context
- ctxCopy = ctx;
-
- // 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 > maxTarget)
- continue;
-
- CBigNum bnCoinDayWeight = CBigNum(nValueIn) * 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;
-}
-
// Check kernel hash target and coinstake signature
bool CheckProofOfStake(const CTransaction& tx, unsigned int nBits, uint256& hashProofOfStake, uint256& targetProofOfStake)
{
return solutions;
}
+// Scan given kernel for solutions
+bool ScanKernelBackward(unsigned char *kernel, uint32_t nBits, uint32_t nInputTxTime, int64_t nValueIn, std::pair<uint32_t, uint32_t> &SearchInterval, std::pair<uint256, uint32_t> &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 USE_ASM
+
+#ifdef __x86_64__
+ if (false && fUse8Way) // AVX2 CPU
+ {
+ uint32_t blocks1[8 * 16] __attribute__((aligned(16)));
+ uint32_t blocks2[8 * 16] __attribute__((aligned(16)));
+ uint32_t candidates[8 * 8] __attribute__((aligned(16)));
+
+ vector<uint32_t> vRow = vector<uint32_t>(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;
+ }
+ }
+ }
+ }
+ }
+ else
+#endif
+ if (fUse4Way) // SSE2 or Neon CPU
+ {
+ uint32_t blocks1[4 * 16] __attribute__((aligned(16)));
+ uint32_t blocks2[4 * 16] __attribute__((aligned(16)));
+ uint32_t candidates[4 * 8] __attribute__((aligned(16)));
+
+ vector<uint32_t> vRow = vector<uint32_t>(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;
+ }
+ }
+ }
+ }
+ }
+ else // Other CPU
+ {
+#endif
+
+#if !defined(USE_ASM) || defined(__i386__)
+ 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 = CBigNum(nValueIn) * 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;
+ }
+ }
+#else
+ uint32_t block1[16] __attribute__((aligned(16)));
+ uint32_t block2[16] __attribute__((aligned(16)));
+ uint32_t candidate[8] __attribute__((aligned(16)));
+
+ memcpy(&block1[7], &block1_suffix[0], 36); // sha256 padding
+ memcpy(&block2[8], &block2_suffix[0], 32);
+
+ uint32_t *pnKernel = (uint32_t *) kernel;
+
+ for (int i = 0; i < 6; i++)
+ block1[i] = __builtin_bswap32(pnKernel[i]);
+
+ // 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--)
+ {
+ memcpy(&block2[0], &sha256_initial[0], 32);
+ memcpy(&candidate[0], &sha256_initial[0], 32);
+
+ block1[6] = __builtin_bswap32(nTimeTx);
+
+ sha256_transform(&block2[0], &block1[0], 0); // first hashing
+ sha256_transform(&candidate[0], &block2[0], 0); // second hashing
+
+ uint32_t nHash7 = __builtin_bswap32(candidate[7]);
+
+ // Skip if hash doesn't satisfy the maximum target
+ if (nHash7 > nMaxTarget32)
+ continue;
+
+ uint256 nHashProofOfStake;
+ uint32_t *pnHashProofOfStake = (uint32_t *) &nHashProofOfStake;
+
+ for (int i = 0; i < 7; i++)
+ pnHashProofOfStake[i] = __builtin_bswap32(candidate[i]);
+ pnHashProofOfStake[7] = nHash7;
+
+ CBigNum bnCoinDayWeight = bnValueIn * GetWeight((int64_t)nInputTxTime, (int64_t)nTimeTx) / COIN / nOneDay;
+ CBigNum bnTargetProofOfStake = bnCoinDayWeight * bnTargetPerCoinDay;
+
+ if (bnTargetProofOfStake >= CBigNum(nHashProofOfStake))
+ {
+ solution.first = nHashProofOfStake;
+ solution.second = nTimeTx;
+
+ return true;
+ }
+ }
+#endif
+#ifdef USE_ASM
+ }
+#endif
+
+ return false;
+}
#include "txdb.h"
#include "miner.h"
#include "kernel.h"
+#include "kernel_worker.h"
using namespace std;
}
// Precalculated SHA256 contexts and metadata
-// (txid, vout.n) => (SHA256_CTX, (tx.nTime, nAmount))
-typedef std::map<std::pair<uint256, unsigned int>, std::pair<SHA256_CTX, std::pair<uint32_t, uint64_t> > > MidstateMap;
+// (txid, vout.n) => (kernel, (tx.nTime, nAmount))
+typedef std::map<std::pair<uint256, unsigned int>, std::pair<std::vector<unsigned char>, std::pair<uint32_t, uint64_t> > > MidstateMap;
// Fill the inputs map with precalculated contexts and metadata
bool FillMap(CWallet *pwallet, uint32_t nUpperTime, MidstateMap &inputsMap)
CDataStream ssKernel(SER_GETHASH, 0);
ssKernel << nStakeModifier;
ssKernel << block.nTime << (txindex.pos.nTxPos - txindex.pos.nBlockPos) << pcoin->first->nTime << pcoin->second;
- CDataStream::const_iterator itK = ssKernel.begin();
- // Init new sha256 context and update it
- // with first 24 bytes of kernel
- SHA256_CTX ctx;
- SHA256_Init(&ctx);
- SHA256_Update(&ctx, (unsigned char*)&itK[0], 8 + 16);
-
- // (txid, vout.n) => (SHA256_CTX, (tx.nTime, nAmount))
- inputsMap[key] = make_pair(ctx, make_pair(pcoin->first->nTime, pcoin->first->vout[pcoin->second].nValue));
+ // (txid, vout.n) => (kernel, (tx.nTime, nAmount))
+ inputsMap[key] = make_pair(std::vector<unsigned char>(ssKernel.begin(), ssKernel.end()), make_pair(pcoin->first->nTime, pcoin->first->vout[pcoin->second].nValue));
}
nStakeInputsMapSize = inputsMap.size();
interval.first = nSearchTime;
interval.second = nSearchTime - min(nSearchTime-nLastCoinStakeSearchTime, nMaxStakeSearchInterval);
- // (txid, nout) => (SHA256_CTX, (tx.nTime, nAmount))
+ // (txid, nout) => (kernel, (tx.nTime, nAmount))
for(MidstateMap::const_iterator input = inputsMap.begin(); input != inputsMap.end(); input++)
{
- SHA256_CTX ctx = input->second.first;
+ unsigned char *kernel = (unsigned char *) &input->second.first[0];
// scan(State, Bits, Time, Amount, ...)
- if (ScanContextBackward(ctx, nBits, input->second.second.first, input->second.second.second, interval, solution))
+ if (ScanKernelBackward(kernel, nBits, input->second.second.first, input->second.second.second, interval, solution))
{
// Solution found
LuckyInput = input->first; // (txid, nout)