// Copyright (c) 2012-2013 The PPCoin developers
+// Copyright (c) 2013-2015 The Novacoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <boost/assign/list_of.hpp>
#include "kernel.h"
+#include "kernel_worker.h"
#include "txdb.h"
extern unsigned int nStakeMaxAge;
(149000, 0x48f2bdc4u )
(160000, 0x789df0f0u )
(200000, 0x01ec1503u )
+ (221047, 0x0b39ef50u )
+ (243100, 0xe928d83au )
;
// Hard checkpoints of stake modifiers to ensure they are deterministic (testNet)
if (fSelected && hashSelection < hashBest)
{
hashBest = hashSelection;
- *pindexSelected = (const CBlockIndex*) pindex;
+ *pindexSelected = pindex;
}
else if (!fSelected)
{
fSelected = true;
hashBest = hashSelection;
- *pindexSelected = (const CBlockIndex*) pindex;
+ *pindexSelected = pindex;
}
}
if (fDebug && GetBoolArg("-printstakemodifier"))
return true;
}
-
-#ifdef USE_YASM
-
-// SHA256 initial state
-static const uint32_t init[8] = { 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 };
-
-// 8000000000000000000000000000000000000000000000000000000000000000000000e0
-static const uint32_t block1_suffix[9] = { 0x00000080, 0, 0, 0, 0, 0, 0, 0, 0xe0000000 };
-
-// 8000000000000000000000000000000000000000000000000000000000000100
-static const uint32_t block2_suffix[8] = { 0x00000080, 0, 0, 0, 0, 0, 0, 0x00010000 };
-
-// TODO: cpuid detection of supported instruction sets
-
-extern "C" void sha256_avx(void *input_data, uint32_t digest[8], uint64_t num_blks);
-extern "C" void sha256_avx_swap(void *input_data, uint32_t digest[8], uint64_t num_blks);
-
-// Not used yet
-extern "C" void sha256_sse4(void *input_data, uint32_t digest[8], uint64_t num_blks);
-extern "C" void sha256_sse4_swap(void *input_data, uint32_t digest[8], uint64_t num_blks);
-
-class ScanMidstateWorker
-{
-public:
- ScanMidstateWorker()
- { }
- ScanMidstateWorker(unsigned char *kernel, uint32_t nBits, uint32_t nInputTxTime, int64_t nValueIn, uint32_t nIntervalBegin, uint32_t nIntervalEnd)
- : kernel(kernel), nBits(nBits), nInputTxTime(nInputTxTime), bnValueIn(nValueIn), nIntervalBegin(nIntervalBegin), nIntervalEnd(nIntervalEnd)
- {
- solutions = vector<std::pair<uint256,uint32_t> >();
- }
-
- void Do()
- {
- SetThreadPriority(THREAD_PRIORITY_LOWEST);
-
- // Sha256 result buffer
- uint32_t hashProofOfStake[8];
-
- // Compute maximum possible target to filter out majority of obviously insufficient hashes
- CBigNum bnTargetPerCoinDay;
- bnTargetPerCoinDay.SetCompact(nBits);
-
- uint256 nMaxTarget = (bnTargetPerCoinDay * bnValueIn * nStakeMaxAge / COIN / nOneDay).getuint256(),
- *pnHashProofOfStake = (uint256 *)&hashProofOfStake;
-
- uint8_t data_block[64];
- uint8_t data_block2[64];
-
- // Copy static part of kernel
- memcpy(&data_block[0], kernel, 24);
-
- memcpy(&data_block[28], &block1_suffix[0], 9 * sizeof(uint32_t));
- memcpy(&data_block2[32], &block2_suffix[0], 8 * sizeof(uint32_t));
-
- // Search forward in time from the given timestamp
- // Stopping search in case of shutting down
- for (uint32_t nTimeTx=nIntervalBegin, nMaxTarget32 = nMaxTarget.Get32(7); nTimeTx<nIntervalEnd && !fShutdown; nTimeTx++)
- {
- memcpy(&data_block[24], &nTimeTx, 4); // Timestamp
-
- memcpy(&data_block2[0], &init[0], 8 * sizeof(uint32_t));
- sha256_avx_swap(&data_block[0], (uint32_t *) &data_block2[0], 1);
- memcpy(&hashProofOfStake[0], &init[0], 8 * sizeof(uint32_t));
- sha256_avx(&data_block2[0], &hashProofOfStake[0], 1);
-
- // Skip if hash doesn't satisfy the maximum target
- if (__builtin_bswap32(hashProofOfStake[7]) > nMaxTarget32)
- continue;
-
- // Swap byte order
- for(int i = 0; i < 8; i++)
- hashProofOfStake[i] = __builtin_bswap32(hashProofOfStake[i]);
-
- CBigNum bnCoinDayWeight = bnValueIn * GetWeight((int64_t)nInputTxTime, (int64_t)nTimeTx) / COIN / nOneDay;
- CBigNum bnTargetProofOfStake = bnCoinDayWeight * bnTargetPerCoinDay;
-
- if (bnTargetProofOfStake >= CBigNum(*pnHashProofOfStake))
- solutions.push_back(std::pair<uint256,uint32_t>(*pnHashProofOfStake, nTimeTx));
- }
- }
-
- vector<std::pair<uint256,uint32_t> >& GetSolutions()
- {
- return solutions;
- }
-
-private:
- std::vector<std::pair<uint256,uint32_t> > solutions;
-
- uint8_t *kernel;
- uint32_t nBits;
- uint32_t nInputTxTime;
- CBigNum bnValueIn;
- uint32_t nIntervalBegin;
- uint32_t nIntervalEnd;
-};
-
-#else
-class ScanMidstateWorker
-{
-public:
- ScanMidstateWorker()
- { }
- ScanMidstateWorker(unsigned char *kernel, uint32_t nBits, uint32_t nInputTxTime, int64_t nValueIn, uint32_t nIntervalBegin, uint32_t nIntervalEnd)
- : nBits(nBits), nInputTxTime(nInputTxTime), bnValueIn(nValueIn), nIntervalBegin(nIntervalBegin), nIntervalEnd(nIntervalEnd)
- {
- // Init new sha256 context and update it
- // with first 24 bytes of kernel
- SHA256_Init(&workerCtx);
- SHA256_Update(&workerCtx, kernel, 8 + 16);
- solutions = vector<std::pair<uint256,uint32_t> >();
- }
-
- void Do()
- {
- SetThreadPriority(THREAD_PRIORITY_LOWEST);
- SHA256_CTX ctx = workerCtx;
-
- // Sha256 result buffer
- uint32_t hashProofOfStake[8];
-
- // Compute maximum possible target to filter out majority of obviously insufficient hashes
- CBigNum bnTargetPerCoinDay;
- bnTargetPerCoinDay.SetCompact(nBits);
-
- uint256 nMaxTarget = (bnTargetPerCoinDay * bnValueIn * nStakeMaxAge / COIN / nOneDay).getuint256(),
- *pnHashProofOfStake = (uint256 *)&hashProofOfStake;
-
- // Search forward in time from the given timestamp
- // Stopping search in case of shutting down
- for (uint32_t nTimeTx=nIntervalBegin, nMaxTarget32 = nMaxTarget.Get32(7); nTimeTx<nIntervalEnd && !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
- SHA256((unsigned char*)&hash1, sizeof(hashProofOfStake), (unsigned char*)&hashProofOfStake);
-
- // Skip if hash doesn't satisfy the maximum target
- if (hashProofOfStake[7] > nMaxTarget32)
- continue;
-
- CBigNum bnCoinDayWeight = bnValueIn * GetWeight((int64_t)nInputTxTime, (int64_t)nTimeTx) / COIN / nOneDay;
- CBigNum bnTargetProofOfStake = bnCoinDayWeight * bnTargetPerCoinDay;
-
- if (bnTargetProofOfStake >= CBigNum(*pnHashProofOfStake))
- solutions.push_back(std::pair<uint256,uint32_t>(*pnHashProofOfStake, nTimeTx));
- }
- }
-
- vector<std::pair<uint256,uint32_t> >& GetSolutions()
- {
- return solutions;
- }
-
-private:
- SHA256_CTX workerCtx;
- std::vector<std::pair<uint256,uint32_t> > solutions;
-
- uint32_t nBits;
- uint32_t nInputTxTime;
- CBigNum bnValueIn;
- uint32_t nIntervalBegin;
- uint32_t nIntervalEnd;
-};
-
-#endif
// Scan given kernel for solution
bool ScanKernelForward(unsigned char *kernel, uint32_t nBits, uint32_t nInputTxTime, int64_t nValueIn, std::pair<uint32_t, uint32_t> &SearchInterval, std::vector<std::pair<uint256, uint32_t> > &solutions)
{
// TODO: custom threads amount
uint32_t nThreads = boost::thread::hardware_concurrency();
+ if (nThreads == 0)
+ {
+ nThreads = 1;
+ printf("Warning: hardware_concurrency() failed in %s:%d\n", __FILE__, __LINE__);
+ }
uint32_t nPart = (SearchInterval.second - SearchInterval.first) / nThreads;
-
- ScanMidstateWorker *workers = new ScanMidstateWorker[nThreads];
+ KernelWorker *workers = new KernelWorker[nThreads];
boost::thread_group group;
for(size_t i = 0; i < nThreads; i++)
{
uint32_t nBegin = SearchInterval.first + nPart * i;
uint32_t nEnd = SearchInterval.first + nPart * (i + 1);
- workers[i] = ScanMidstateWorker(kernel, nBits, nInputTxTime, nValueIn, nBegin, nEnd);
- boost::function<void()> workerFnc = boost::bind(&ScanMidstateWorker::Do, &workers[i]);
+ workers[i] = KernelWorker(kernel, nBits, nInputTxTime, nValueIn, nBegin, nEnd);
+ boost::function<void()> workerFnc = boost::bind(&KernelWorker::Do, &workers[i]);
group.create_thread(workerFnc);
}
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)
{
git://git.novaco.in / novacoin.git / blobdiff