monero-project/monero
monero-project/monero
1
0
Fork 0
mirror of https://github.com/monero-project/monero.git synced 2024-12-23 03:59:33 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Build fixes for some platforms

Browse source
This commit is contained in:
moneromooo-monero 2019-02-14 15:36:13 +00:00
parent 3ac3366a6e
commit 0b0fb709c3
No known key found for this signature in database
GPG key ID: 686F07454D6CEFC3
5 changed files with 17 additions and 17 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
src/crypto/slow-hash.c
View file

@ -143,8 +143,8 @@ extern void aesb_pseudo_round(const uint8_t *in, uint8_t *out, const uint8_t *ex
if (variant >= 4) \ if (variant >= 4) \
{ \ { \
chunk1 = veorq_u64(chunk1, chunk2); \ chunk1 = veorq_u64(chunk1, chunk2); \
_c = veorq_u64(_c, chunk3); \ _c = vreinterpretq_u8_u64(veorq_u64(vreinterpretq_u64_u8(_c), chunk3)); \
_c = veorq_u64(_c, chunk1); \ _c = vreinterpretq_u8_u64(veorq_u64(vreinterpretq_u64_u8(_c), chunk1)); \
} \ } \
} while (0) } while (0)
@ -1425,10 +1425,10 @@ void cn_slow_hash(const void *data, size_t length, char *hash, int variant, int
// Iteration 1 // Iteration 1
j = state_index(a); j = state_index(a);
p = &long_state[j]; p = &long_state[j];
aesb_single_round(p, p, a); aesb_single_round(p, c1, a);
copy_block(c1, p);
VARIANT2_PORTABLE_SHUFFLE_ADD(c1, a, long_state, j); VARIANT2_PORTABLE_SHUFFLE_ADD(c1, a, long_state, j);
copy_block(p, c1);
xor_blocks(p, b); xor_blocks(p, b);
VARIANT1_1(p); VARIANT1_1(p);
@ -1439,13 +1439,13 @@ void cn_slow_hash(const void *data, size_t length, char *hash, int variant, int
copy_block(a1, a); copy_block(a1, a);
VARIANT2_PORTABLE_INTEGER_MATH(c, c1); VARIANT2_PORTABLE_INTEGER_MATH(c, c1);
VARIANT4_RANDOM_MATH(a, c, r, b, b + AES_BLOCK_SIZE); VARIANT4_RANDOM_MATH(a1, c, r, b, b + AES_BLOCK_SIZE);
mul(c1, c, d); mul(c1, c, d);
VARIANT2_2_PORTABLE(); VARIANT2_2_PORTABLE();
VARIANT2_PORTABLE_SHUFFLE_ADD(c1, a1, long_state, j); VARIANT2_PORTABLE_SHUFFLE_ADD(c1, a, long_state, j);
sum_half_blocks(a, d); sum_half_blocks(a1, d);
swap_blocks(a, c); swap_blocks(a1, c);
xor_blocks(a, c); xor_blocks(a1, c);
VARIANT1_2(U64(c) + 1); VARIANT1_2(U64(c) + 1);
copy_block(p, c); copy_block(p, c);
@ -1453,6 +1453,7 @@ void cn_slow_hash(const void *data, size_t length, char *hash, int variant, int
copy_block(b + AES_BLOCK_SIZE, b); copy_block(b + AES_BLOCK_SIZE, b);
} }
copy_block(b, c1); copy_block(b, c1);
copy_block(a, a1);
} }
memcpy(text, state.init, INIT_SIZE_BYTE); memcpy(text, state.init, INIT_SIZE_BYTE);
@ -1636,7 +1637,6 @@ void cn_slow_hash(const void *data, size_t length, char *hash, int variant, int
xor_blocks(a1, c2); xor_blocks(a1, c2);
VARIANT1_2(c2 + 8); VARIANT1_2(c2 + 8);
copy_block(&long_state[j], c2); copy_block(&long_state[j], c2);
assert(j == e2i(a, MEMORY / AES_BLOCK_SIZE) * AES_BLOCK_SIZE);
if (variant >= 2) { if (variant >= 2) {
copy_block(b + AES_BLOCK_SIZE, b); copy_block(b + AES_BLOCK_SIZE, b);
} }

8
src/cryptonote_core/blockchain.cpp
View file

@ -1178,7 +1178,7 @@ bool Blockchain::validate_miner_transaction(const block& b, size_t cumulative_bl
} }
} }
std::vector<size_t> last_blocks_weights; std::vector<uint64_t> last_blocks_weights;
get_last_n_blocks_weights(last_blocks_weights, CRYPTONOTE_REWARD_BLOCKS_WINDOW); get_last_n_blocks_weights(last_blocks_weights, CRYPTONOTE_REWARD_BLOCKS_WINDOW);
if (!get_block_reward(epee::misc_utils::median(last_blocks_weights), cumulative_block_weight, already_generated_coins, base_reward, version)) if (!get_block_reward(epee::misc_utils::median(last_blocks_weights), cumulative_block_weight, already_generated_coins, base_reward, version))
{ {
@ -1213,7 +1213,7 @@ bool Blockchain::validate_miner_transaction(const block& b, size_t cumulative_bl
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
// get the block weights of the last <count> blocks, and return by reference <sz>. // get the block weights of the last <count> blocks, and return by reference <sz>.
void Blockchain::get_last_n_blocks_weights(std::vector<size_t>& weights, size_t count) const void Blockchain::get_last_n_blocks_weights(std::vector<uint64_t>& weights, size_t count) const
{ {
LOG_PRINT_L3("Blockchain::" << __func__); LOG_PRINT_L3("Blockchain::" << __func__);
CRITICAL_REGION_LOCAL(m_blockchain_lock); CRITICAL_REGION_LOCAL(m_blockchain_lock);
@ -3043,7 +3043,7 @@ uint64_t Blockchain::get_dynamic_base_fee_estimate(uint64_t grace_blocks) const
grace_blocks = CRYPTONOTE_REWARD_BLOCKS_WINDOW - 1; grace_blocks = CRYPTONOTE_REWARD_BLOCKS_WINDOW - 1;
const uint64_t min_block_weight = get_min_block_weight(version); const uint64_t min_block_weight = get_min_block_weight(version);
std::vector<size_t> weights; std::vector<uint64_t> weights;
get_last_n_blocks_weights(weights, CRYPTONOTE_REWARD_BLOCKS_WINDOW - grace_blocks); get_last_n_blocks_weights(weights, CRYPTONOTE_REWARD_BLOCKS_WINDOW - grace_blocks);
weights.reserve(grace_blocks); weights.reserve(grace_blocks);
for (size_t i = 0; i < grace_blocks; ++i) for (size_t i = 0; i < grace_blocks; ++i)
@ -3673,7 +3673,7 @@ bool Blockchain::update_next_cumulative_weight_limit(uint64_t *long_term_effecti
if (hf_version < HF_VERSION_LONG_TERM_BLOCK_WEIGHT) if (hf_version < HF_VERSION_LONG_TERM_BLOCK_WEIGHT)
{ {
std::vector<size_t> weights; std::vector<uint64_t> weights;
get_last_n_blocks_weights(weights, CRYPTONOTE_REWARD_BLOCKS_WINDOW); get_last_n_blocks_weights(weights, CRYPTONOTE_REWARD_BLOCKS_WINDOW);
m_current_block_cumul_weight_median = epee::misc_utils::median(weights); m_current_block_cumul_weight_median = epee::misc_utils::median(weights);
long_term_block_weight = weights.back(); long_term_block_weight = weights.back();

2
src/cryptonote_core/blockchain.h
View file

@ -1262,7 +1262,7 @@ namespace cryptonote
* @param sz return-by-reference the list of weights * @param sz return-by-reference the list of weights
* @param count the number of blocks to get weights for * @param count the number of blocks to get weights for
*/ */
void get_last_n_blocks_weights(std::vector<size_t>& weights, size_t count) const; void get_last_n_blocks_weights(std::vector<uint64_t>& weights, size_t count) const;
/** /**
* @brief checks if a transaction is unlocked (its outputs spendable) * @brief checks if a transaction is unlocked (its outputs spendable)

2
src/cryptonote_core/cryptonote_core.cpp
View file

@ -1760,7 +1760,7 @@ namespace cryptonote
for (size_t n = 0; n < sizeof(seconds)/sizeof(seconds[0]); ++n) for (size_t n = 0; n < sizeof(seconds)/sizeof(seconds[0]); ++n)
{ {
unsigned int b = 0; unsigned int b = 0;
for (time_t ts: timestamps) b += ts >= now - seconds[n]; for (time_t ts: timestamps) b += ts >= (time_t)(now - seconds[n]);
const double p = probability(b, seconds[n] / DIFFICULTY_TARGET_V2); const double p = probability(b, seconds[n] / DIFFICULTY_TARGET_V2);
MDEBUG("blocks in the last " << seconds[n] / 60 << " minutes: " << b << " (probability " << p << ")"); MDEBUG("blocks in the last " << seconds[n] / 60 << " minutes: " << b << " (probability " << p << ")");
if (p < threshold) if (p < threshold)

2
tests/core_tests/v2_tests.h
View file

@ -81,7 +81,7 @@ template<>
struct get_test_options<gen_v2_tx_validation_base> { struct get_test_options<gen_v2_tx_validation_base> {
const std::pair<uint8_t, uint64_t> hard_forks[3] = {std::make_pair(1, 0), std::make_pair(2, 1), std::make_pair(0, 0)}; const std::pair<uint8_t, uint64_t> hard_forks[3] = {std::make_pair(1, 0), std::make_pair(2, 1), std::make_pair(0, 0)};
const cryptonote::test_options test_options = { const cryptonote::test_options test_options = {
hard_forks hard_forks, 0
}; };
}; };