Auto merge of #1146 - str4d:1143-equihash-solution-callback, r=ebfull
Equihash: Pass each obtained solution to a callback for immediate checking Closes #1143
This commit is contained in:
commit
4714ea145b
|
@ -193,7 +193,9 @@ std::shared_ptr<eh_trunc> TruncatedStepRow<WIDTH>::GetTruncatedIndices(size_t le
|
|||
}
|
||||
|
||||
template<unsigned int N, unsigned int K>
|
||||
std::set<std::vector<eh_index>> Equihash<N,K>::BasicSolve(const eh_HashState& base_state, const std::function<bool(EhSolverCancelCheck)> cancelled)
|
||||
bool Equihash<N,K>::BasicSolve(const eh_HashState& base_state,
|
||||
const std::function<bool(std::vector<eh_index>)> validBlock,
|
||||
const std::function<bool(EhSolverCancelCheck)> cancelled)
|
||||
{
|
||||
eh_index init_size { 1 << (CollisionBitLength + 1) };
|
||||
|
||||
|
@ -269,7 +271,6 @@ std::set<std::vector<eh_index>> Equihash<N,K>::BasicSolve(const eh_HashState& ba
|
|||
|
||||
// k+1) Find a collision on last 2n(k+1) bits
|
||||
LogPrint("pow", "Final round:\n");
|
||||
std::set<std::vector<eh_index>> solns;
|
||||
if (X.size() > 1) {
|
||||
LogPrint("pow", "- Sorting list\n");
|
||||
std::sort(X.begin(), X.end(), CompareSR(hashLen));
|
||||
|
@ -286,8 +287,9 @@ std::set<std::vector<eh_index>> Equihash<N,K>::BasicSolve(const eh_HashState& ba
|
|||
for (int l = 0; l < j - 1; l++) {
|
||||
for (int m = l + 1; m < j; m++) {
|
||||
FullStepRow<FinalFullWidth> res(X[i+l], X[i+m], hashLen, lenIndices, 0);
|
||||
if (DistinctIndices(X[i+l], X[i+m], hashLen, lenIndices)) {
|
||||
solns.insert(res.GetIndices(hashLen, 2*lenIndices));
|
||||
if (DistinctIndices(X[i+l], X[i+m], hashLen, lenIndices) &&
|
||||
validBlock(res.GetIndices(hashLen, 2*lenIndices))) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -298,7 +300,7 @@ std::set<std::vector<eh_index>> Equihash<N,K>::BasicSolve(const eh_HashState& ba
|
|||
} else
|
||||
LogPrint("pow", "- List is empty\n");
|
||||
|
||||
return solns;
|
||||
return false;
|
||||
}
|
||||
|
||||
template<size_t WIDTH>
|
||||
|
@ -354,7 +356,9 @@ void CollideBranches(std::vector<FullStepRow<WIDTH>>& X, const size_t hlen, cons
|
|||
}
|
||||
|
||||
template<unsigned int N, unsigned int K>
|
||||
std::set<std::vector<eh_index>> Equihash<N,K>::OptimisedSolve(const eh_HashState& base_state, const std::function<bool(EhSolverCancelCheck)> cancelled)
|
||||
bool Equihash<N,K>::OptimisedSolve(const eh_HashState& base_state,
|
||||
const std::function<bool(std::vector<eh_index>)> validBlock,
|
||||
const std::function<bool(EhSolverCancelCheck)> cancelled)
|
||||
{
|
||||
eh_index init_size { 1 << (CollisionBitLength + 1) };
|
||||
eh_index recreate_size { UntruncateIndex(1, 0, CollisionBitLength + 1) };
|
||||
|
@ -363,7 +367,6 @@ std::set<std::vector<eh_index>> Equihash<N,K>::OptimisedSolve(const eh_HashState
|
|||
|
||||
eh_index soln_size { 1 << K };
|
||||
std::vector<std::shared_ptr<eh_trunc>> partialSolns;
|
||||
std::set<std::vector<eh_index>> solns;
|
||||
int invalidCount = 0;
|
||||
{
|
||||
|
||||
|
@ -531,7 +534,8 @@ std::set<std::vector<eh_index>> Equihash<N,K>::OptimisedSolve(const eh_HashState
|
|||
// We are at the top of the tree
|
||||
assert(X.size() == K+1);
|
||||
for (FullStepRow<FinalFullWidth> row : *X[K]) {
|
||||
solns.insert(row.GetIndices(hashLen, lenIndices));
|
||||
if (validBlock(row.GetIndices(hashLen, lenIndices)))
|
||||
return true;
|
||||
}
|
||||
if (cancelled(PartialEnd)) throw solver_cancelled;
|
||||
continue;
|
||||
|
@ -541,7 +545,7 @@ invalidsolution:
|
|||
}
|
||||
LogPrint("pow", "- Number of invalid solutions found: %d\n", invalidCount);
|
||||
|
||||
return solns;
|
||||
return false;
|
||||
}
|
||||
|
||||
template<unsigned int N, unsigned int K>
|
||||
|
@ -591,18 +595,30 @@ bool Equihash<N,K>::IsValidSolution(const eh_HashState& base_state, std::vector<
|
|||
|
||||
// Explicit instantiations for Equihash<96,3>
|
||||
template int Equihash<96,3>::InitialiseState(eh_HashState& base_state);
|
||||
template std::set<std::vector<eh_index>> Equihash<96,3>::BasicSolve(const eh_HashState& base_state, const std::function<bool(EhSolverCancelCheck)> cancelled);
|
||||
template std::set<std::vector<eh_index>> Equihash<96,3>::OptimisedSolve(const eh_HashState& base_state, const std::function<bool(EhSolverCancelCheck)> cancelled);
|
||||
template bool Equihash<96,3>::BasicSolve(const eh_HashState& base_state,
|
||||
const std::function<bool(std::vector<eh_index>)> validBlock,
|
||||
const std::function<bool(EhSolverCancelCheck)> cancelled);
|
||||
template bool Equihash<96,3>::OptimisedSolve(const eh_HashState& base_state,
|
||||
const std::function<bool(std::vector<eh_index>)> validBlock,
|
||||
const std::function<bool(EhSolverCancelCheck)> cancelled);
|
||||
template bool Equihash<96,3>::IsValidSolution(const eh_HashState& base_state, std::vector<eh_index> soln);
|
||||
|
||||
// Explicit instantiations for Equihash<96,5>
|
||||
template int Equihash<96,5>::InitialiseState(eh_HashState& base_state);
|
||||
template std::set<std::vector<eh_index>> Equihash<96,5>::BasicSolve(const eh_HashState& base_state, const std::function<bool(EhSolverCancelCheck)> cancelled);
|
||||
template std::set<std::vector<eh_index>> Equihash<96,5>::OptimisedSolve(const eh_HashState& base_state, const std::function<bool(EhSolverCancelCheck)> cancelled);
|
||||
template bool Equihash<96,5>::BasicSolve(const eh_HashState& base_state,
|
||||
const std::function<bool(std::vector<eh_index>)> validBlock,
|
||||
const std::function<bool(EhSolverCancelCheck)> cancelled);
|
||||
template bool Equihash<96,5>::OptimisedSolve(const eh_HashState& base_state,
|
||||
const std::function<bool(std::vector<eh_index>)> validBlock,
|
||||
const std::function<bool(EhSolverCancelCheck)> cancelled);
|
||||
template bool Equihash<96,5>::IsValidSolution(const eh_HashState& base_state, std::vector<eh_index> soln);
|
||||
|
||||
// Explicit instantiations for Equihash<48,5>
|
||||
template int Equihash<48,5>::InitialiseState(eh_HashState& base_state);
|
||||
template std::set<std::vector<eh_index>> Equihash<48,5>::BasicSolve(const eh_HashState& base_state, const std::function<bool(EhSolverCancelCheck)> cancelled);
|
||||
template std::set<std::vector<eh_index>> Equihash<48,5>::OptimisedSolve(const eh_HashState& base_state, const std::function<bool(EhSolverCancelCheck)> cancelled);
|
||||
template bool Equihash<48,5>::BasicSolve(const eh_HashState& base_state,
|
||||
const std::function<bool(std::vector<eh_index>)> validBlock,
|
||||
const std::function<bool(EhSolverCancelCheck)> cancelled);
|
||||
template bool Equihash<48,5>::OptimisedSolve(const eh_HashState& base_state,
|
||||
const std::function<bool(std::vector<eh_index>)> validBlock,
|
||||
const std::function<bool(EhSolverCancelCheck)> cancelled);
|
||||
template bool Equihash<48,5>::IsValidSolution(const eh_HashState& base_state, std::vector<eh_index> soln);
|
||||
|
|
|
@ -155,8 +155,12 @@ public:
|
|||
Equihash() { }
|
||||
|
||||
int InitialiseState(eh_HashState& base_state);
|
||||
std::set<std::vector<eh_index>> BasicSolve(const eh_HashState& base_state, const std::function<bool(EhSolverCancelCheck)> cancelled);
|
||||
std::set<std::vector<eh_index>> OptimisedSolve(const eh_HashState& base_state, const std::function<bool(EhSolverCancelCheck)> cancelled);
|
||||
bool BasicSolve(const eh_HashState& base_state,
|
||||
const std::function<bool(std::vector<eh_index>)> validBlock,
|
||||
const std::function<bool(EhSolverCancelCheck)> cancelled);
|
||||
bool OptimisedSolve(const eh_HashState& base_state,
|
||||
const std::function<bool(std::vector<eh_index>)> validBlock,
|
||||
const std::function<bool(EhSolverCancelCheck)> cancelled);
|
||||
bool IsValidSolution(const eh_HashState& base_state, std::vector<eh_index> soln);
|
||||
};
|
||||
|
||||
|
@ -177,31 +181,49 @@ static Equihash<48,5> Eh48_5;
|
|||
throw std::invalid_argument("Unsupported Equihash parameters"); \
|
||||
}
|
||||
|
||||
#define EhBasicSolve(n, k, base_state, solns, cancelled) \
|
||||
if (n == 96 && k == 3) { \
|
||||
solns = Eh96_3.BasicSolve(base_state, cancelled); \
|
||||
} else if (n == 96 && k == 5) { \
|
||||
solns = Eh96_5.BasicSolve(base_state, cancelled); \
|
||||
} else if (n == 48 && k == 5) { \
|
||||
solns = Eh48_5.BasicSolve(base_state, cancelled); \
|
||||
} else { \
|
||||
throw std::invalid_argument("Unsupported Equihash parameters"); \
|
||||
inline bool EhBasicSolve(unsigned int n, unsigned int k, const eh_HashState& base_state,
|
||||
const std::function<bool(std::vector<eh_index>)> validBlock,
|
||||
const std::function<bool(EhSolverCancelCheck)> cancelled)
|
||||
{
|
||||
if (n == 96 && k == 3) {
|
||||
return Eh96_3.BasicSolve(base_state, validBlock, cancelled);
|
||||
} else if (n == 96 && k == 5) {
|
||||
return Eh96_5.BasicSolve(base_state, validBlock, cancelled);
|
||||
} else if (n == 48 && k == 5) {
|
||||
return Eh48_5.BasicSolve(base_state, validBlock, cancelled);
|
||||
} else {
|
||||
throw std::invalid_argument("Unsupported Equihash parameters");
|
||||
}
|
||||
#define EhBasicSolveUncancellable(n, k, base_state, solns) \
|
||||
EhBasicSolve(n, k, base_state, solns, [](EhSolverCancelCheck pos) { return false; })
|
||||
}
|
||||
|
||||
#define EhOptimisedSolve(n, k, base_state, solns, cancelled) \
|
||||
if (n == 96 && k == 3) { \
|
||||
solns = Eh96_3.OptimisedSolve(base_state, cancelled); \
|
||||
} else if (n == 96 && k == 5) { \
|
||||
solns = Eh96_5.OptimisedSolve(base_state, cancelled); \
|
||||
} else if (n == 48 && k == 5) { \
|
||||
solns = Eh48_5.OptimisedSolve(base_state, cancelled); \
|
||||
} else { \
|
||||
throw std::invalid_argument("Unsupported Equihash parameters"); \
|
||||
inline bool EhBasicSolveUncancellable(unsigned int n, unsigned int k, const eh_HashState& base_state,
|
||||
const std::function<bool(std::vector<eh_index>)> validBlock)
|
||||
{
|
||||
return EhBasicSolve(n, k, base_state, validBlock,
|
||||
[](EhSolverCancelCheck pos) { return false; });
|
||||
}
|
||||
|
||||
inline bool EhOptimisedSolve(unsigned int n, unsigned int k, const eh_HashState& base_state,
|
||||
const std::function<bool(std::vector<eh_index>)> validBlock,
|
||||
const std::function<bool(EhSolverCancelCheck)> cancelled)
|
||||
{
|
||||
if (n == 96 && k == 3) {
|
||||
return Eh96_3.OptimisedSolve(base_state, validBlock, cancelled);
|
||||
} else if (n == 96 && k == 5) {
|
||||
return Eh96_5.OptimisedSolve(base_state, validBlock, cancelled);
|
||||
} else if (n == 48 && k == 5) {
|
||||
return Eh48_5.OptimisedSolve(base_state, validBlock, cancelled);
|
||||
} else {
|
||||
throw std::invalid_argument("Unsupported Equihash parameters");
|
||||
}
|
||||
#define EhOptimisedSolveUncancellable(n, k, base_state, solns) \
|
||||
EhOptimisedSolve(n, k, base_state, solns, [](EhSolverCancelCheck pos) { return false; })
|
||||
}
|
||||
|
||||
inline bool EhOptimisedSolveUncancellable(unsigned int n, unsigned int k, const eh_HashState& base_state,
|
||||
const std::function<bool(std::vector<eh_index>)> validBlock)
|
||||
{
|
||||
return EhOptimisedSolve(n, k, base_state, validBlock,
|
||||
[](EhSolverCancelCheck pos) { return false; });
|
||||
}
|
||||
|
||||
#define EhIsValidSolution(n, k, base_state, soln, ret) \
|
||||
if (n == 96 && k == 3) { \
|
||||
|
|
|
@ -7,76 +7,99 @@ TEST(equihash_tests, check_basic_solver_cancelled) {
|
|||
Equihash<48,5> Eh48_5;
|
||||
crypto_generichash_blake2b_state state;
|
||||
Eh48_5.InitialiseState(state);
|
||||
std::set<std::vector<unsigned int>> solns;
|
||||
|
||||
{
|
||||
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return false;
|
||||
}));
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_THROW(Eh48_5.BasicSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == ListGeneration;
|
||||
}), EhSolverCancelledException);
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_THROW(Eh48_5.BasicSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == ListSorting;
|
||||
}), EhSolverCancelledException);
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_THROW(Eh48_5.BasicSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == ListColliding;
|
||||
}), EhSolverCancelledException);
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_THROW(Eh48_5.BasicSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == RoundEnd;
|
||||
}), EhSolverCancelledException);
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_THROW(Eh48_5.BasicSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == FinalSorting;
|
||||
}), EhSolverCancelledException);
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_THROW(Eh48_5.BasicSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == FinalColliding;
|
||||
}), EhSolverCancelledException);
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == PartialGeneration;
|
||||
}));
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == PartialSorting;
|
||||
}));
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == PartialSubtreeEnd;
|
||||
}));
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == PartialIndexEnd;
|
||||
}));
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == PartialEnd;
|
||||
}));
|
||||
}
|
||||
|
@ -86,76 +109,99 @@ TEST(equihash_tests, check_optimised_solver_cancelled) {
|
|||
Equihash<48,5> Eh48_5;
|
||||
crypto_generichash_blake2b_state state;
|
||||
Eh48_5.InitialiseState(state);
|
||||
std::set<std::vector<unsigned int>> solns;
|
||||
|
||||
{
|
||||
ASSERT_NO_THROW(Eh48_5.OptimisedSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_NO_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return false;
|
||||
}));
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == ListGeneration;
|
||||
}), EhSolverCancelledException);
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == ListSorting;
|
||||
}), EhSolverCancelledException);
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == ListColliding;
|
||||
}), EhSolverCancelledException);
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == RoundEnd;
|
||||
}), EhSolverCancelledException);
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == FinalSorting;
|
||||
}), EhSolverCancelledException);
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == FinalColliding;
|
||||
}), EhSolverCancelledException);
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == PartialGeneration;
|
||||
}), EhSolverCancelledException);
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == PartialSorting;
|
||||
}), EhSolverCancelledException);
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == PartialSubtreeEnd;
|
||||
}), EhSolverCancelledException);
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == PartialIndexEnd;
|
||||
}), EhSolverCancelledException);
|
||||
}
|
||||
|
||||
{
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](EhSolverCancelCheck pos) {
|
||||
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
||||
return false;
|
||||
}, [](EhSolverCancelCheck pos) {
|
||||
return pos == PartialEnd;
|
||||
}), EhSolverCancelledException);
|
||||
}
|
||||
|
|
|
@ -529,26 +529,16 @@ void static BitcoinMiner(CWallet *pwallet)
|
|||
// (x_1, x_2, ...) = A(I, V, n, k)
|
||||
LogPrint("pow", "Running Equihash solver with nNonce = %s\n",
|
||||
pblock->nNonce.ToString());
|
||||
std::set<std::vector<unsigned int>> solns;
|
||||
try {
|
||||
std::function<bool(EhSolverCancelCheck)> cancelled = [&m_cs, &cancelSolver](EhSolverCancelCheck pos) {
|
||||
std::lock_guard<std::mutex> lock{m_cs};
|
||||
return cancelSolver;
|
||||
};
|
||||
EhOptimisedSolve(n, k, curr_state, solns, cancelled);
|
||||
} catch (EhSolverCancelledException&) {
|
||||
LogPrint("pow", "Equihash solver cancelled\n");
|
||||
std::lock_guard<std::mutex> lock{m_cs};
|
||||
cancelSolver = false;
|
||||
}
|
||||
LogPrint("pow", "Solutions: %d\n", solns.size());
|
||||
|
||||
// Write the solution to the hash and compute the result.
|
||||
for (auto soln : solns) {
|
||||
std::function<bool(std::vector<eh_index>)> validBlock =
|
||||
[&pblock, &hashTarget, &pwallet, &reservekey, &m_cs, &cancelSolver, &chainparams]
|
||||
(std::vector<eh_index> soln) {
|
||||
// Write the solution to the hash and compute the result.
|
||||
LogPrint("pow", "- Checking solution against target\n");
|
||||
pblock->nSolution = soln;
|
||||
|
||||
if (UintToArith256(pblock->GetHash()) > hashTarget) {
|
||||
continue;
|
||||
return false;
|
||||
}
|
||||
|
||||
// Found a solution
|
||||
|
@ -566,7 +556,20 @@ void static BitcoinMiner(CWallet *pwallet)
|
|||
if (chainparams.MineBlocksOnDemand())
|
||||
throw boost::thread_interrupted();
|
||||
|
||||
break;
|
||||
return true;
|
||||
};
|
||||
std::function<bool(EhSolverCancelCheck)> cancelled = [&m_cs, &cancelSolver](EhSolverCancelCheck pos) {
|
||||
std::lock_guard<std::mutex> lock{m_cs};
|
||||
return cancelSolver;
|
||||
};
|
||||
try {
|
||||
// If we find a valid block, we rebuild
|
||||
if (EhOptimisedSolve(n, k, curr_state, validBlock, cancelled))
|
||||
break;
|
||||
} catch (EhSolverCancelledException&) {
|
||||
LogPrint("pow", "Equihash solver cancelled\n");
|
||||
std::lock_guard<std::mutex> lock{m_cs};
|
||||
cancelSolver = false;
|
||||
}
|
||||
|
||||
// Check for stop or if block needs to be rebuilt
|
||||
|
|
|
@ -188,19 +188,13 @@ Value generate(const Array& params, bool fHelp)
|
|||
pblock->nNonce.size());
|
||||
|
||||
// (x_1, x_2, ...) = A(I, V, n, k)
|
||||
std::set<std::vector<unsigned int>> solns;
|
||||
EhBasicSolveUncancellable(n, k, curr_state, solns);
|
||||
|
||||
for (auto soln : solns) {
|
||||
bool isValid;
|
||||
EhIsValidSolution(n, k, curr_state, soln, isValid);
|
||||
assert(isValid);
|
||||
std::function<bool(std::vector<eh_index>)> validBlock =
|
||||
[&pblock](std::vector<eh_index> soln) {
|
||||
pblock->nSolution = soln;
|
||||
|
||||
if (CheckProofOfWork(pblock->GetHash(), pblock->nBits, Params().GetConsensus())) {
|
||||
goto endloop;
|
||||
}
|
||||
}
|
||||
return CheckProofOfWork(pblock->GetHash(), pblock->nBits, Params().GetConsensus());
|
||||
};
|
||||
if (EhBasicSolveUncancellable(n, k, curr_state, validBlock))
|
||||
goto endloop;
|
||||
}
|
||||
endloop:
|
||||
CValidationState state;
|
||||
|
|
|
@ -50,7 +50,12 @@ void TestEquihashSolvers(unsigned int n, unsigned int k, const std::string &I, c
|
|||
|
||||
// First test the basic solver
|
||||
std::set<std::vector<uint32_t>> ret;
|
||||
EhBasicSolveUncancellable(n, k, state, ret);
|
||||
std::function<bool(std::vector<eh_index>)> validBlock =
|
||||
[&ret](std::vector<eh_index> soln) {
|
||||
ret.insert(soln);
|
||||
return false;
|
||||
};
|
||||
EhBasicSolveUncancellable(n, k, state, validBlock);
|
||||
BOOST_TEST_MESSAGE("[Basic] Number of solutions: " << ret.size());
|
||||
std::stringstream strm;
|
||||
PrintSolutions(strm, ret);
|
||||
|
@ -59,7 +64,12 @@ void TestEquihashSolvers(unsigned int n, unsigned int k, const std::string &I, c
|
|||
|
||||
// The optimised solver should have the exact same result
|
||||
std::set<std::vector<uint32_t>> retOpt;
|
||||
EhOptimisedSolveUncancellable(n, k, state, retOpt);
|
||||
std::function<bool(std::vector<eh_index>)> validBlockOpt =
|
||||
[&retOpt](std::vector<eh_index> soln) {
|
||||
retOpt.insert(soln);
|
||||
return false;
|
||||
};
|
||||
EhOptimisedSolveUncancellable(n, k, state, validBlockOpt);
|
||||
BOOST_TEST_MESSAGE("[Optimised] Number of solutions: " << retOpt.size());
|
||||
strm.str("");
|
||||
PrintSolutions(strm, retOpt);
|
||||
|
|
|
@ -118,7 +118,8 @@ double benchmark_solve_equihash()
|
|||
|
||||
timer_start();
|
||||
std::set<std::vector<unsigned int>> solns;
|
||||
EhOptimisedSolveUncancellable(n, k, eh_state, solns);
|
||||
EhOptimisedSolveUncancellable(n, k, eh_state,
|
||||
[](std::vector<eh_index> soln) { return false; });
|
||||
return timer_stop();
|
||||
}
|
||||
|
||||
|
|
Loading…
Reference in New Issue