mirror of
https://github.com/monero-project/monero.git
synced 2024-10-01 11:49:47 -04:00
112 lines
3.5 KiB
C++
112 lines
3.5 KiB
C++
// Copyright (c) 2012-2013 The Cryptonote developers
|
|
// Distributed under the MIT/X11 software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include <algorithm>
|
|
#include <cassert>
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <vector>
|
|
|
|
#include "common/int-util.h"
|
|
#include "crypto/hash.h"
|
|
#include "cryptonote_config.h"
|
|
#include "difficulty.h"
|
|
|
|
namespace cryptonote {
|
|
|
|
using std::size_t;
|
|
using std::uint64_t;
|
|
using std::vector;
|
|
|
|
#if defined(_MSC_VER)
|
|
#include <windows.h>
|
|
#include <winnt.h>
|
|
|
|
static inline void mul(uint64_t a, uint64_t b, uint64_t &low, uint64_t &high) {
|
|
low = UnsignedMultiply128(a, b, &high);
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void mul(uint64_t a, uint64_t b, uint64_t &low, uint64_t &high) {
|
|
typedef unsigned __int128 uint128_t;
|
|
uint128_t res = (uint128_t) a * (uint128_t) b;
|
|
low = (uint64_t) res;
|
|
high = (uint64_t) (res >> 64);
|
|
}
|
|
|
|
#endif
|
|
|
|
static inline bool cadd(uint64_t a, uint64_t b) {
|
|
return a + b < a;
|
|
}
|
|
|
|
static inline bool cadc(uint64_t a, uint64_t b, bool c) {
|
|
return a + b < a || (c && a + b == (uint64_t) -1);
|
|
}
|
|
|
|
bool check_hash(const crypto::hash &hash, difficulty_type difficulty) {
|
|
uint64_t low, high, top, cur;
|
|
// First check the highest word, this will most likely fail for a random hash.
|
|
mul(swap64le(((const uint64_t *) &hash)[3]), difficulty, top, high);
|
|
if (high != 0) {
|
|
return false;
|
|
}
|
|
mul(swap64le(((const uint64_t *) &hash)[0]), difficulty, low, cur);
|
|
mul(swap64le(((const uint64_t *) &hash)[1]), difficulty, low, high);
|
|
bool carry = cadd(cur, low);
|
|
cur = high;
|
|
mul(swap64le(((const uint64_t *) &hash)[2]), difficulty, low, high);
|
|
carry = cadc(cur, low, carry);
|
|
carry = cadc(high, top, carry);
|
|
return !carry;
|
|
}
|
|
|
|
difficulty_type next_difficulty(vector<uint64_t> timestamps, vector<difficulty_type> cumulative_difficulties, size_t target_seconds) {
|
|
//cutoff DIFFICULTY_LAG
|
|
if(timestamps.size() > DIFFICULTY_WINDOW)
|
|
{
|
|
timestamps.resize(DIFFICULTY_WINDOW);
|
|
cumulative_difficulties.resize(DIFFICULTY_WINDOW);
|
|
}
|
|
|
|
|
|
size_t length = timestamps.size();
|
|
assert(length == cumulative_difficulties.size());
|
|
if (length <= 1) {
|
|
return 1;
|
|
}
|
|
static_assert(DIFFICULTY_WINDOW >= 2, "Window is too small");
|
|
assert(length <= DIFFICULTY_WINDOW);
|
|
sort(timestamps.begin(), timestamps.end());
|
|
size_t cut_begin, cut_end;
|
|
static_assert(2 * DIFFICULTY_CUT <= DIFFICULTY_WINDOW - 2, "Cut length is too large");
|
|
if (length <= DIFFICULTY_WINDOW - 2 * DIFFICULTY_CUT) {
|
|
cut_begin = 0;
|
|
cut_end = length;
|
|
} else {
|
|
cut_begin = (length - (DIFFICULTY_WINDOW - 2 * DIFFICULTY_CUT) + 1) / 2;
|
|
cut_end = cut_begin + (DIFFICULTY_WINDOW - 2 * DIFFICULTY_CUT);
|
|
}
|
|
assert(/*cut_begin >= 0 &&*/ cut_begin + 2 <= cut_end && cut_end <= length);
|
|
uint64_t time_span = timestamps[cut_end - 1] - timestamps[cut_begin];
|
|
if (time_span == 0) {
|
|
time_span = 1;
|
|
}
|
|
difficulty_type total_work = cumulative_difficulties[cut_end - 1] - cumulative_difficulties[cut_begin];
|
|
assert(total_work > 0);
|
|
uint64_t low, high;
|
|
mul(total_work, target_seconds, low, high);
|
|
if (high != 0 || low + time_span - 1 < low) {
|
|
return 0;
|
|
}
|
|
return (low + time_span - 1) / time_span;
|
|
}
|
|
|
|
difficulty_type next_difficulty(vector<uint64_t> timestamps, vector<difficulty_type> cumulative_difficulties)
|
|
{
|
|
return next_difficulty(std::move(timestamps), std::move(cumulative_difficulties), DIFFICULTY_TARGET);
|
|
}
|
|
}
|