Minecon724/dncurrency
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions 1

Cache cemented count (#2259)

Browse source
This commit is contained in:
Wesley Shillingford 2019-08-29 15:42:09 +01:00 • committed by Guilherme Lawless
commit e3abade132
20 changed files with 189 additions and 143 deletions
Download patch file Download diff file Expand all files Collapse all files

51
nano/core_test/block_store.cpp
View file

@ -259,8 +259,9 @@ TEST (block_store, genesis)
nano::genesis genesis;
auto hash (genesis.hash ());
nano::rep_weights rep_weights;
std::atomic<uint64_t> cemented_count{ 0 };
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, rep_weights);
store->initialize (transaction, genesis, rep_weights, cemented_count);
nano::account_info info;
ASSERT_FALSE (store->account_get (transaction, nano::genesis_account, info));
ASSERT_EQ (hash, info.head);
@ -733,17 +734,17 @@ TEST (block_store, account_count)
ASSERT_EQ (1, store->account_count (transaction));
}
TEST (block_store, cemented_count)
TEST (block_store, cemented_count_cache)
{
nano::logger_mt logger;
auto store = nano::make_store (logger, nano::unique_path ());
ASSERT_TRUE (!store->init_error ());
auto transaction (store->tx_begin_write ());
ASSERT_EQ (0, store->cemented_count (transaction));
nano::genesis genesis;
nano::rep_weights rep_weights;
store->initialize (transaction, genesis, rep_weights);
ASSERT_EQ (1, store->cemented_count (transaction));
std::atomic<uint64_t> cemented_count{ 0 };
store->initialize (transaction, genesis, rep_weights, cemented_count);
ASSERT_EQ (1, cemented_count);
}
TEST (block_store, sequence_increment)
@ -790,7 +791,7 @@ TEST (mdb_block_store, upgrade_v2_v3)
auto hash (genesis.hash ());
nano::stat stats;
nano::ledger ledger (store, stats);
store.initialize (transaction, genesis, ledger.rep_weights);
store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::change_block change (hash, key1.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (hash));
change_hash = change.hash ();
@ -870,7 +871,7 @@ TEST (mdb_block_store, upgrade_v4_v5)
nano::genesis genesis;
nano::stat stats;
nano::ledger ledger (store, stats);
store.initialize (transaction, genesis, ledger.rep_weights);
store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
store.version_put (transaction, 4);
nano::account_info info;
ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info));
@ -900,8 +901,9 @@ TEST (block_store, block_random)
nano::genesis genesis;
{
nano::rep_weights rep_weights;
std::atomic<uint64_t> cemented_count{ 0 };
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, rep_weights);
store->initialize (transaction, genesis, rep_weights, cemented_count);
}
auto transaction (store->tx_begin_read ());
auto block (store->block_random (transaction));
@ -919,7 +921,8 @@ TEST (mdb_block_store, upgrade_v5_v6)
auto transaction (store.tx_begin_write ());
nano::genesis genesis;
nano::rep_weights rep_weights;
store.initialize (transaction, genesis, rep_weights);
std::atomic<uint64_t> cemented_count{ 0 };
store.initialize (transaction, genesis, rep_weights, cemented_count);
store.version_put (transaction, 5);
modify_genesis_account_info_to_v5 (store, transaction);
}
@ -942,7 +945,8 @@ TEST (mdb_block_store, upgrade_v6_v7)
auto transaction (store.tx_begin_write ());
nano::genesis genesis;
nano::rep_weights rep_weights;
store.initialize (transaction, genesis, rep_weights);
std::atomic<uint64_t> cemented_count{ 0 };
store.initialize (transaction, genesis, rep_weights, cemented_count);
store.version_put (transaction, 6);
modify_account_info_to_v13 (store, transaction, nano::genesis_account);
auto send1 (std::make_shared<nano::send_block> (0, 0, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0));
@ -1104,7 +1108,8 @@ TEST (block_store, state_block)
{
auto transaction (store->tx_begin_write ());
nano::rep_weights rep_weights;
store->initialize (transaction, genesis, rep_weights);
std::atomic<uint64_t> cemented_count{ 0 };
store->initialize (transaction, genesis, rep_weights, cemented_count);
ASSERT_EQ (nano::block_type::state, block1.type ());
nano::block_sideband sideband1 (nano::block_type::state, 0, 0, 0, 0, 0);
store->block_put (transaction, block1.hash (), block1, sideband1);
@ -1159,7 +1164,8 @@ TEST (mdb_block_store, upgrade_sideband_genesis)
auto transaction (store.tx_begin_write ());
store.version_put (transaction, 11);
nano::rep_weights rep_weights;
store.initialize (transaction, genesis, rep_weights);
std::atomic<uint64_t> cemented_count{ 0 };
store.initialize (transaction, genesis, rep_weights, cemented_count);
modify_account_info_to_v13 (store, transaction, nano::genesis_account);
nano::block_sideband sideband;
auto genesis_block (store.block_get (transaction, genesis.hash (), &sideband));
@ -1194,7 +1200,7 @@ TEST (mdb_block_store, upgrade_sideband_two_blocks)
nano::ledger ledger (store, stat);
auto transaction (store.tx_begin_write ());
store.version_put (transaction, 11);
store.initialize (transaction, genesis, ledger.rep_weights);
store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::state_block block (nano::test_genesis_key.pub, genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
hash2 = block.hash ();
@ -1232,7 +1238,7 @@ TEST (mdb_block_store, upgrade_sideband_two_accounts)
nano::ledger ledger (store, stat);
auto transaction (store.tx_begin_write ());
store.version_put (transaction, 11);
store.initialize (transaction, genesis, ledger.rep_weights);
store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::state_block block1 (nano::test_genesis_key.pub, genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
hash2 = block1.hash ();
@ -1275,7 +1281,7 @@ TEST (mdb_block_store, insert_after_legacy)
nano::ledger ledger (store, stat);
auto transaction (store.tx_begin_write ());
store.version_put (transaction, 11);
store.initialize (transaction, genesis, ledger.rep_weights);
store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
write_legacy_sideband (store, transaction, *genesis.open, 0, store.open_blocks);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::state_block block (nano::test_genesis_key.pub, genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1292,7 +1298,7 @@ TEST (mdb_block_store, legacy_account_computed)
nano::ledger ledger (store, stats);
nano::genesis genesis;
auto transaction (store.tx_begin_write ());
store.initialize (transaction, genesis, ledger.rep_weights);
store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
store.version_put (transaction, 11);
write_legacy_sideband (store, transaction, *genesis.open, 0, store.open_blocks);
ASSERT_EQ (nano::genesis_account, ledger.account (transaction, genesis.hash ()));
@ -1313,7 +1319,7 @@ TEST (mdb_block_store, upgrade_sideband_epoch)
nano::ledger ledger (store, stat, 42, nano::test_genesis_key.pub);
auto transaction (store.tx_begin_write ());
store.version_put (transaction, 11);
store.initialize (transaction, genesis, ledger.rep_weights);
store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::state_block block1 (nano::test_genesis_key.pub, genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount, 42, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
hash2 = block1.hash ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code);
@ -1352,7 +1358,7 @@ TEST (mdb_block_store, sideband_height)
nano::ledger ledger (store, stat);
ledger.epoch_signer = epoch_key.pub;
auto transaction (store.tx_begin_write ());
store.initialize (transaction, genesis, ledger.rep_weights);
store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::send_block send (genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code);
@ -1551,7 +1557,8 @@ TEST (mdb_block_store, upgrade_v13_v14)
nano::mdb_store store (logger, path);
auto transaction (store.tx_begin_write ());
nano::rep_weights rep_weights;
store.initialize (transaction, genesis, rep_weights);
std::atomic<uint64_t> cemented_count{ 0 };
store.initialize (transaction, genesis, rep_weights, cemented_count);
nano::account_info account_info;
ASSERT_FALSE (store.account_get (transaction, nano::genesis_account, account_info));
uint64_t confirmation_height;
@ -1604,7 +1611,8 @@ TEST (mdb_block_store, upgrade_v14_v15)
nano::mdb_store store (logger, path);
auto transaction (store.tx_begin_write ());
nano::rep_weights rep_weights;
store.initialize (transaction, genesis, rep_weights);
std::atomic<uint64_t> cemented_count{ 0 };
store.initialize (transaction, genesis, rep_weights, cemented_count);
nano::account_info account_info;
ASSERT_FALSE (store.account_get (transaction, nano::genesis_account, account_info));
uint64_t confirmation_height;
@ -1745,7 +1753,8 @@ TEST (block_store, upgrade_confirmation_height_many)
auto transaction (store.tx_begin_write ());
store.version_put (transaction, 13);
nano::rep_weights rep_weights;
store.initialize (transaction, genesis, rep_weights);
std::atomic<uint64_t> cemented_count{ 0 };
store.initialize (transaction, genesis, rep_weights, cemented_count);
modify_account_info_to_v13 (store, transaction, nano::genesis_account);
// Add many accounts

150
nano/core_test/ledger.cpp
View file

@ -44,7 +44,7 @@ TEST (ledger, genesis_balance)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
auto balance (ledger.account_balance (transaction, nano::genesis_account));
ASSERT_EQ (nano::genesis_amount, balance);
auto amount (ledger.amount (transaction, nano::genesis_account));
@ -81,7 +81,7 @@ TEST (ledger, process_send)
nano::ledger ledger (*store, stats);
auto transaction (store->tx_begin_write ());
nano::genesis genesis;
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::account_info info1;
ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1));
@ -175,7 +175,7 @@ TEST (ledger, process_receive)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::account_info info1;
ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1));
@ -233,7 +233,7 @@ TEST (ledger, rollback_receiver)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::account_info info1;
ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1));
@ -272,7 +272,7 @@ TEST (ledger, rollback_representation)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key5;
nano::change_block change1 (genesis.hash (), key5.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -326,7 +326,7 @@ TEST (ledger, receive_rollback)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::send_block send (genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code);
@ -344,7 +344,7 @@ TEST (ledger, process_duplicate)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::account_info info1;
ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1));
@ -367,7 +367,7 @@ TEST (ledger, representative_genesis)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
auto latest (ledger.latest (transaction, nano::test_genesis_key.pub));
ASSERT_FALSE (latest.is_zero ());
ASSERT_EQ (genesis.open->hash (), ledger.representative (transaction, latest));
@ -382,7 +382,7 @@ TEST (ledger, weight)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account));
}
@ -396,7 +396,7 @@ TEST (ledger, representative_change)
nano::keypair key2;
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::test_genesis_key.pub));
ASSERT_EQ (0, ledger.weight (transaction, key2.pub));
@ -436,7 +436,7 @@ TEST (ledger, send_fork)
nano::keypair key3;
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::account_info info1;
ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1));
@ -457,7 +457,7 @@ TEST (ledger, receive_fork)
nano::keypair key3;
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::account_info info1;
ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1));
@ -484,7 +484,7 @@ TEST (ledger, open_fork)
nano::keypair key3;
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::account_info info1;
ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1));
@ -614,7 +614,7 @@ TEST (ledger, representation)
auto & rep_weights = ledger.rep_weights;
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, rep_weights);
store->initialize (transaction, genesis, rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
ASSERT_EQ (nano::genesis_amount, rep_weights.representation_get (nano::test_genesis_key.pub));
nano::keypair key2;
@ -688,7 +688,7 @@ TEST (ledger, double_open)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key2;
nano::send_block send1 (genesis.hash (), key2.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -708,7 +708,7 @@ TEST (ledger, double_receive)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key2;
nano::send_block send1 (genesis.hash (), key2.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -981,7 +981,7 @@ TEST (ledger, fail_change_old)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::change_block block (genesis.hash (), key1.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1000,7 +1000,7 @@ TEST (ledger, fail_change_gap_previous)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::change_block block (1, key1.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (1));
@ -1017,7 +1017,7 @@ TEST (ledger, fail_change_bad_signature)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::change_block block (genesis.hash (), key1.pub, nano::keypair ().prv, 0, pool.generate (genesis.hash ()));
@ -1034,7 +1034,7 @@ TEST (ledger, fail_change_fork)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::change_block block1 (genesis.hash (), key1.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1055,7 +1055,7 @@ TEST (ledger, fail_send_old)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::send_block block (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1074,7 +1074,7 @@ TEST (ledger, fail_send_gap_previous)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::send_block block (1, key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (1));
@ -1091,7 +1091,7 @@ TEST (ledger, fail_send_bad_signature)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::send_block block (genesis.hash (), key1.pub, 1, nano::keypair ().prv, 0, pool.generate (genesis.hash ()));
@ -1108,7 +1108,7 @@ TEST (ledger, fail_send_negative_spend)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1127,7 +1127,7 @@ TEST (ledger, fail_send_fork)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1146,7 +1146,7 @@ TEST (ledger, fail_open_old)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1165,7 +1165,7 @@ TEST (ledger, fail_open_gap_source)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::open_block block2 (1, 1, key1.pub, key1.prv, key1.pub, pool.generate (key1.pub));
@ -1182,7 +1182,7 @@ TEST (ledger, fail_open_bad_signature)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1201,7 +1201,7 @@ TEST (ledger, fail_open_fork_previous)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1223,7 +1223,7 @@ TEST (ledger, fail_open_account_mismatch)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1242,7 +1242,7 @@ TEST (ledger, fail_receive_old)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1265,7 +1265,7 @@ TEST (ledger, fail_receive_gap_source)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1291,7 +1291,7 @@ TEST (ledger, fail_receive_overreceive)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1314,7 +1314,7 @@ TEST (ledger, fail_receive_bad_signature)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1340,7 +1340,7 @@ TEST (ledger, fail_receive_gap_previous_opened)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1366,7 +1366,7 @@ TEST (ledger, fail_receive_gap_previous_unopened)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1389,7 +1389,7 @@ TEST (ledger, fail_receive_fork_previous)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1419,7 +1419,7 @@ TEST (ledger, fail_receive_received_source)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
nano::send_block block1 (genesis.hash (), key1.pub, 2, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1468,7 +1468,7 @@ TEST (ledger, latest_root)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key;
ASSERT_EQ (key.pub, ledger.latest_root (transaction, key.pub));
@ -1488,7 +1488,7 @@ TEST (ledger, change_representative_move_representation)
nano::keypair key1;
auto transaction (store->tx_begin_write ());
nano::genesis genesis;
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
auto hash1 (genesis.hash ());
ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::test_genesis_key.pub));
@ -1513,7 +1513,7 @@ TEST (ledger, send_open_receive_rollback)
nano::ledger ledger (*store, stats);
auto transaction (store->tx_begin_write ());
nano::genesis genesis;
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::account_info info1;
ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1));
@ -1576,7 +1576,7 @@ TEST (ledger, bootstrap_rep_weight)
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
{
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1));
nano::send_block send (info1.head, key2.pub, std::numeric_limits<nano::uint128_t>::max () - 50, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (info1.head));
ledger.process (transaction, send);
@ -1608,7 +1608,7 @@ TEST (ledger, block_destination_source)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair dest;
nano::uint128_t balance (nano::genesis_amount);
@ -1654,7 +1654,7 @@ TEST (ledger, state_account)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code);
@ -1670,7 +1670,7 @@ TEST (ledger, state_send_receive)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code);
@ -1703,7 +1703,7 @@ TEST (ledger, state_receive)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::send_block send1 (genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code);
@ -1734,7 +1734,7 @@ TEST (ledger, state_rep_change)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair rep;
nano::state_block change1 (nano::genesis_account, genesis.hash (), rep.pub, nano::genesis_amount, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1758,7 +1758,7 @@ TEST (ledger, state_open)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair destination;
nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1793,7 +1793,7 @@ TEST (ledger, send_after_state_fail)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code);
@ -1811,7 +1811,7 @@ TEST (ledger, receive_after_state_fail)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code);
@ -1829,7 +1829,7 @@ TEST (ledger, change_after_state_fail)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code);
@ -1847,7 +1847,7 @@ TEST (ledger, state_unreceivable_fail)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::send_block send1 (genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code);
@ -1871,7 +1871,7 @@ TEST (ledger, state_receive_bad_amount_fail)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::send_block send1 (genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code);
@ -1895,7 +1895,7 @@ TEST (ledger, state_no_link_amount_fail)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code);
@ -1913,7 +1913,7 @@ TEST (ledger, state_receive_wrong_account_fail)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code);
@ -1938,7 +1938,7 @@ TEST (ledger, state_open_state_fork)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair destination;
nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1959,7 +1959,7 @@ TEST (ledger, state_state_open_fork)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair destination;
nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1980,7 +1980,7 @@ TEST (ledger, state_open_previous_fail)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair destination;
nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -1998,7 +1998,7 @@ TEST (ledger, state_open_source_fail)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair destination;
nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -2016,7 +2016,7 @@ TEST (ledger, state_send_change)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair rep;
nano::state_block send1 (nano::genesis_account, genesis.hash (), rep.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -2040,7 +2040,7 @@ TEST (ledger, state_receive_change)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code);
@ -2073,7 +2073,7 @@ TEST (ledger, state_open_old)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair destination;
nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -2094,7 +2094,7 @@ TEST (ledger, state_receive_old)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair destination;
nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -2119,7 +2119,7 @@ TEST (ledger, state_rollback_send)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code);
@ -2150,7 +2150,7 @@ TEST (ledger, state_rollback_receive)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code);
@ -2176,7 +2176,7 @@ TEST (ledger, state_rollback_received_send)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key;
nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -2203,7 +2203,7 @@ TEST (ledger, state_rep_change_rollback)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair rep;
nano::state_block change1 (nano::genesis_account, genesis.hash (), rep.pub, nano::genesis_amount, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -2224,7 +2224,7 @@ TEST (ledger, state_open_rollback)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair destination;
nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -2250,7 +2250,7 @@ TEST (ledger, state_send_change_rollback)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair rep;
nano::state_block send1 (nano::genesis_account, genesis.hash (), rep.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -2271,7 +2271,7 @@ TEST (ledger, state_receive_change_rollback)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code);
@ -2295,7 +2295,7 @@ TEST (ledger, epoch_blocks_general)
nano::ledger ledger (*store, stats, 123, epoch_key.pub);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair destination;
nano::state_block epoch1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount, 123, epoch_key.prv, epoch_key.pub, pool.generate (genesis.hash ()));
@ -2342,7 +2342,7 @@ TEST (ledger, epoch_blocks_receive_upgrade)
nano::ledger ledger (*store, stats, 123, epoch_key.pub);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair destination;
nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -2383,7 +2383,7 @@ TEST (ledger, epoch_blocks_fork)
nano::ledger ledger (*store, stats, 123, epoch_key.pub);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair destination;
nano::send_block send1 (genesis.hash (), nano::account (0), nano::genesis_amount, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ()));
@ -2514,7 +2514,7 @@ TEST (ledger, could_fit)
ledger.epoch_signer = epoch_signer.pub;
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair destination;
// Test legacy and state change blocks could_fit
@ -2738,7 +2738,7 @@ TEST (ledger, confirmation_height_not_updated)
nano::ledger ledger (*store, stats);
auto transaction (store->tx_begin_write ());
nano::genesis genesis;
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::account_info account_info;
ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, account_info));

4
nano/core_test/network.cpp
View file

@ -1895,6 +1895,7 @@ TEST (confirmation_height, send_receive_between_2_accounts)
ASSERT_EQ (10, node->stats.count (nano::stat::type::confirmation_height, nano::stat::detail::blocks_confirmed, nano::stat::dir::in));
ASSERT_EQ (10, node->stats.count (nano::stat::type::http_callback, nano::stat::detail::http_callback, nano::stat::dir::out));
ASSERT_EQ (11, node->ledger.cemented_count);
}
TEST (confirmation_height, send_receive_self)
@ -1954,6 +1955,7 @@ TEST (confirmation_height, send_receive_self)
ASSERT_EQ (8, account_info.block_count);
ASSERT_EQ (6, node->stats.count (nano::stat::type::confirmation_height, nano::stat::detail::blocks_confirmed, nano::stat::dir::in));
ASSERT_EQ (6, node->stats.count (nano::stat::type::http_callback, nano::stat::detail::http_callback, nano::stat::dir::out));
ASSERT_EQ (confirmation_height, node->ledger.cemented_count);
}
TEST (confirmation_height, all_block_types)
@ -2061,6 +2063,7 @@ TEST (confirmation_height, all_block_types)
ASSERT_EQ (15, node->stats.count (nano::stat::type::confirmation_height, nano::stat::detail::blocks_confirmed, nano::stat::dir::in));
ASSERT_EQ (15, node->stats.count (nano::stat::type::http_callback, nano::stat::detail::http_callback, nano::stat::dir::out));
ASSERT_EQ (16, node->ledger.cemented_count);
}
/* Bulk of the this test was taken from the node.fork_flip test */
@ -2242,6 +2245,7 @@ TEST (confirmation_height, pending_observer_callbacks)
// Confirm the callback is not called under this circumstance
ASSERT_EQ (2, node->stats.count (nano::stat::type::confirmation_height, nano::stat::detail::blocks_confirmed, nano::stat::dir::in));
ASSERT_EQ (0, node->stats.count (nano::stat::type::http_callback, nano::stat::detail::http_callback, nano::stat::dir::out));
ASSERT_EQ (3, node->ledger.cemented_count);
}
}

3
nano/core_test/node.cpp
View file

@ -3053,8 +3053,9 @@ TEST (node, dont_write_lock_node)
{
nano::genesis genesis;
nano::rep_weights rep_weights;
std::atomic<uint64_t> cemented_count{ 0 };
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, rep_weights);
store->initialize (transaction, genesis, rep_weights, cemented_count);
}
// Hold write lock open until main thread is done needing it

4
nano/core_test/processor_service.cpp
View file

@ -17,7 +17,7 @@ TEST (processor_service, bad_send_signature)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::account_info info1;
ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1));
@ -36,7 +36,7 @@ TEST (processor_service, bad_receive_signature)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::account_info info1;
ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1));

4
nano/core_test/socket.cpp
View file

@ -10,7 +10,9 @@ using namespace std::chrono_literals;
TEST (socket, concurrent_writes)
{
nano::inactive_node inactivenode (nano::working_path (), 24000, false);
auto node_flags = nano::inactive_node_flag_defaults ();
node_flags.read_only = false;
nano::inactive_node inactivenode (nano::working_path (), 24000, node_flags);
auto node = inactivenode.node;
// This gives more realistic execution than using system#poll, allowing writes to

11
nano/nano_node/entry.cpp
View file

@ -270,7 +270,9 @@ int main (int argc, char * const * argv)
}
else if (vm.count ("debug_dump_representatives"))
{
nano::inactive_node node (data_path, 24000, true);
auto node_flags = nano::inactive_node_flag_defaults ();
node_flags.cache_representative_weights_from_frontiers = true;
nano::inactive_node node (data_path, 24000, node_flags);
auto transaction (node.node->store.tx_begin_read ());
nano::uint128_t total;
auto rep_amounts = node.node->ledger.rep_weights.get_rep_amounts ();
@ -1031,9 +1033,10 @@ int main (int argc, char * const * argv)
}
else if (vm.count ("debug_cemented_block_count"))
{
nano::inactive_node node (data_path);
auto transaction (node.node->store.tx_begin_read ());
std::cout << "Total cemented block count: " << node.node->store.cemented_count (transaction) << std::endl;
auto node_flags = nano::inactive_node_flag_defaults ();
node_flags.cache_cemented_count_from_frontiers = true;
nano::inactive_node node (data_path, 24000, node_flags);
std::cout << "Total cemented block count: " << node.node->ledger.cemented_count << std::endl;
}
else if (vm.count ("debug_sys_logging"))
{

24
nano/node/cli.cpp
View file

@ -83,7 +83,9 @@ bool copy_database (boost::filesystem::path const & data_path, boost::program_op
bool success = false;
bool needs_to_write = vm.count ("unchecked_clear") || vm.count ("clear_send_ids") || vm.count ("online_weight_clear") || vm.count ("peer_clear") || vm.count ("confirmation_height_clear");
nano::inactive_node node (data_path, 24000, !needs_to_write);
auto node_flags = nano::inactive_node_flag_defaults ();
node_flags.read_only = !needs_to_write;
nano::inactive_node node (data_path, 24000, node_flags);
if (!node.node->init_error ())
{
if (vm.count ("unchecked_clear"))
@ -290,7 +292,9 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map
else if (vm.count ("unchecked_clear"))
{
boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as<std::string> ()) : nano::working_path ();
inactive_node node (data_path, 24000, false);
auto node_flags = nano::inactive_node_flag_defaults ();
node_flags.read_only = false;
nano::inactive_node node (data_path, 24000, node_flags);
if (!node.node->init_error ())
{
auto transaction (node.node->store.tx_begin_write ());
@ -305,7 +309,9 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map
else if (vm.count ("clear_send_ids"))
{
boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as<std::string> ()) : nano::working_path ();
inactive_node node (data_path, 24000, false);
auto node_flags = nano::inactive_node_flag_defaults ();
node_flags.read_only = false;
nano::inactive_node node (data_path, 24000, node_flags);
if (!node.node->init_error ())
{
auto transaction (node.node->wallets.tx_begin_write ());
@ -320,7 +326,9 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map
else if (vm.count ("online_weight_clear"))
{
boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as<std::string> ()) : nano::working_path ();
inactive_node node (data_path, 24000, false);
auto node_flags = nano::inactive_node_flag_defaults ();
node_flags.read_only = false;
nano::inactive_node node (data_path, 24000, node_flags);
if (!node.node->init_error ())
{
auto transaction (node.node->store.tx_begin_write ());
@ -335,7 +343,9 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map
else if (vm.count ("peer_clear"))
{
boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as<std::string> ()) : nano::working_path ();
inactive_node node (data_path, 24000, false);
auto node_flags = nano::inactive_node_flag_defaults ();
node_flags.read_only = false;
nano::inactive_node node (data_path, 24000, node_flags);
if (!node.node->init_error ())
{
auto transaction (node.node->store.tx_begin_write ());
@ -350,7 +360,9 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map
else if (vm.count ("confirmation_height_clear"))
{
boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as<std::string> ()) : nano::working_path ();
inactive_node node (data_path, 24000, false);
auto node_flags = nano::inactive_node_flag_defaults ();
node_flags.read_only = false;
nano::inactive_node node (data_path, 24000, node_flags);
if (!node.node->init_error ())
{
auto account_it = vm.find ("account");

4
nano/node/confirmation_height_processor.cpp
View file

@ -13,7 +13,7 @@
#include <cassert>
#include <numeric>
nano::confirmation_height_processor::confirmation_height_processor (nano::pending_confirmation_height & pending_confirmation_height_a, nano::block_store & store_a, nano::stat & stats_a, nano::active_transactions & active_a, nano::block_hash const & epoch_link_a, nano::write_database_queue & write_database_queue_a, std::chrono::milliseconds batch_separate_pending_min_time_a, nano::logger_mt & logger_a) :
nano::confirmation_height_processor::confirmation_height_processor (nano::pending_confirmation_height & pending_confirmation_height_a, nano::block_store & store_a, nano::stat & stats_a, nano::active_transactions & active_a, nano::block_hash const & epoch_link_a, nano::write_database_queue & write_database_queue_a, std::chrono::milliseconds batch_separate_pending_min_time_a, nano::logger_mt & logger_a, std::atomic<uint64_t> & cemented_count_a) :
pending_confirmations (pending_confirmation_height_a),
store (store_a),
stats (stats_a),
@ -22,6 +22,7 @@ epoch_link (epoch_link_a),
logger (logger_a),
write_database_queue (write_database_queue_a),
batch_separate_pending_min_time (batch_separate_pending_min_time_a),
cemented_count (cemented_count_a),
thread ([this]() {
nano::thread_role::set (nano::thread_role::name::confirmation_height_processing);
this->run ();
@ -303,6 +304,7 @@ bool nano::confirmation_height_processor::write_pending (std::deque<conf_height_
stats.add (nano::stat::type::confirmation_height, nano::stat::detail::blocks_confirmed, nano::stat::dir::in, pending.height - confirmation_height);
assert (pending.num_blocks_confirmed == pending.height - confirmation_height);
confirmation_height = pending.height;
cemented_count += pending.num_blocks_confirmed;
store.confirmation_height_put (transaction, pending.account, confirmation_height);
}
total_pending_write_block_count -= pending.num_blocks_confirmed;

3
nano/node/confirmation_height_processor.hpp
View file

@ -38,7 +38,7 @@ std::unique_ptr<seq_con_info_component> collect_seq_con_info (pending_confirmati
class confirmation_height_processor final
{
public:
confirmation_height_processor (pending_confirmation_height &, nano::block_store &, nano::stat &, nano::active_transactions &, nano::block_hash const &, nano::write_database_queue &, std::chrono::milliseconds, nano::logger_mt &);
confirmation_height_processor (pending_confirmation_height &, nano::block_store &, nano::stat &, nano::active_transactions &, nano::block_hash const &, nano::write_database_queue &, std::chrono::milliseconds, nano::logger_mt &, std::atomic<uint64_t> &);
~confirmation_height_processor ();
void add (nano::block_hash const &);
void stop ();
@ -96,6 +96,7 @@ private:
nano::timer<std::chrono::milliseconds> timer;
nano::write_database_queue & write_database_queue;
std::chrono::milliseconds batch_separate_pending_min_time;
std::atomic<uint64_t> & cemented_count;
std::thread thread;
void run ();

2
nano/node/json_handler.cpp
View file

@ -1206,7 +1206,7 @@ void nano::json_handler::block_count ()
auto transaction (node.store.tx_begin_read ());
response_l.put ("count", std::to_string (node.store.block_count (transaction).sum ()));
response_l.put ("unchecked", std::to_string (node.store.unchecked_count (transaction)));
response_l.put ("cemented", std::to_string (node.store.cemented_count (transaction)));
response_l.put ("cemented", std::to_string (node.ledger.cemented_count));
response_errors ();
}

18
nano/node/node.cpp
View file

@ -145,7 +145,7 @@ block_processor_thread ([this]() {
online_reps (*this, config.online_weight_minimum.number ()),
vote_uniquer (block_uniquer),
active (*this),
confirmation_height_processor (pending_confirmation_height, store, ledger.stats, active, ledger.epoch_link, write_database_queue, config.conf_height_processor_batch_min_time, logger),
confirmation_height_processor (pending_confirmation_height, store, ledger.stats, active, ledger.epoch_link, write_database_queue, config.conf_height_processor_batch_min_time, logger, ledger.cemented_count),
payment_observer_processor (observers.blocks),
wallets (wallets_store.init_error (), *this),
startup_time (std::chrono::steady_clock::now ())
@ -391,7 +391,7 @@ startup_time (std::chrono::steady_clock::now ())
release_assert (!flags.read_only);
auto transaction (store.tx_begin_write ());
// Store was empty meaning we just created it, add the genesis block
store.initialize (transaction, genesis, ledger.rep_weights);
store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
}
auto transaction (store.tx_begin_read ());
@ -1639,7 +1639,7 @@ bool nano::node::init_error () const
return store.init_error () || wallets_store.init_error ();
}
nano::inactive_node::inactive_node (boost::filesystem::path const & path_a, uint16_t peering_port_a, bool read_only_a, bool cache_reps_a) :
nano::inactive_node::inactive_node (boost::filesystem::path const & path_a, uint16_t peering_port_a, nano::node_flags const & node_flags) :
path (path_a),
io_context (std::make_shared<boost::asio::io_context> ()),
alarm (*io_context),
@ -1655,9 +1655,6 @@ peering_port (peering_port_a)
nano::set_secure_perm_directory (path, error_chmod);
logging.max_size = std::numeric_limits<std::uintmax_t>::max ();
logging.init (path);
nano::node_flags node_flags;
node_flags.read_only = read_only_a;
node_flags.cache_representative_weights_from_frontiers = cache_reps_a;
node = std::make_shared<nano::node> (*io_context, peering_port, path, alarm, logging, work, node_flags);
node->active.stop ();
}
@ -1667,6 +1664,15 @@ nano::inactive_node::~inactive_node ()
node->stop ();
}
nano::node_flags const & nano::inactive_node_flag_defaults ()
{
static nano::node_flags node_flags;
node_flags.read_only = true;
node_flags.cache_representative_weights_from_frontiers = false;
node_flags.cache_cemented_count_from_frontiers = false;
return node_flags;
}
std::unique_ptr<nano::block_store> nano::make_store (nano::logger_mt & logger, boost::filesystem::path const & path, bool read_only, bool add_db_postfix, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a, int lmdb_max_dbs, bool drop_unchecked, size_t batch_size, bool backup_before_upgrade)
{
#if NANO_ROCKSDB

4
nano/node/node.hpp
View file

@ -186,10 +186,12 @@ public:
std::unique_ptr<seq_con_info_component> collect_seq_con_info (node & node, const std::string & name);
nano::node_flags const & inactive_node_flag_defaults ();
class inactive_node final
{
public:
inactive_node (boost::filesystem::path const & path = nano::working_path (), uint16_t = 24000, bool = true, bool = false);
inactive_node (boost::filesystem::path const & path = nano::working_path (), uint16_t = 24000, nano::node_flags const & = nano::inactive_node_flag_defaults ());
~inactive_node ();
boost::filesystem::path path;
std::shared_ptr<boost::asio::io_context> io_context;

2
nano/node/nodeconfig.hpp
View file

@ -119,6 +119,8 @@ public:
bool read_only{ false };
/** Whether to read all frontiers and construct the representative weights */
bool cache_representative_weights_from_frontiers{ true };
/** Whether to read all frontiers and construct the total cemented count */
bool cache_cemented_count_from_frontiers{ true };
size_t sideband_batch_size{ 512 };
size_t block_processor_batch_size{ 0 };
size_t block_processor_full_size{ 65536 };

2
nano/qt_test/qt.cpp
View file

@ -481,7 +481,7 @@ TEST (history, short_text)
nano::ledger ledger (store, system.nodes[0]->stats);
{
auto transaction (store.tx_begin_write ());
store.initialize (transaction, genesis, ledger.rep_weights);
store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::keypair key;
auto latest (ledger.latest (transaction, nano::test_genesis_key.pub));
nano::send_block send (latest, nano::test_genesis_key.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (latest));

3
nano/secure/blockstore.hpp
View file

@ -574,7 +574,7 @@ class block_store
{
public:
virtual ~block_store () = default;
virtual void initialize (nano::write_transaction const &, nano::genesis const &, nano::rep_weights &) = 0;
virtual void initialize (nano::write_transaction const &, nano::genesis const &, nano::rep_weights &, std::atomic<uint64_t> &) = 0;
virtual void block_put (nano::write_transaction const &, nano::block_hash const &, nano::block const &, nano::block_sideband const &, nano::epoch version = nano::epoch::epoch_0) = 0;
virtual nano::block_hash block_successor (nano::transaction const &, nano::block_hash const &) const = 0;
virtual void block_successor_clear (nano::write_transaction const &, nano::block_hash const &) = 0;
@ -599,7 +599,6 @@ public:
virtual size_t account_count (nano::transaction const &) = 0;
virtual void confirmation_height_clear (nano::write_transaction const &, nano::account const & account, uint64_t existing_confirmation_height) = 0;
virtual void confirmation_height_clear (nano::write_transaction const &) = 0;
virtual uint64_t cemented_count (nano::transaction const &) = 0;
virtual nano::store_iterator<nano::account, nano::account_info> latest_v0_begin (nano::transaction const &, nano::account const &) = 0;
virtual nano::store_iterator<nano::account, nano::account_info> latest_v0_begin (nano::transaction const &) = 0;
virtual nano::store_iterator<nano::account, nano::account_info> latest_v0_end () = 0;

13
nano/secure/blockstore_partial.hpp
View file

@ -24,7 +24,7 @@ public:
* If using a different store version than the latest then you may need
* to modify some of the objects in the store to be appropriate for the version before an upgrade.
*/
void initialize (nano::write_transaction const & transaction_a, nano::genesis const & genesis_a, nano::rep_weights & rep_weights) override
void initialize (nano::write_transaction const & transaction_a, nano::genesis const & genesis_a, nano::rep_weights & rep_weights, std::atomic<uint64_t> & cemented_count) override
{
auto hash_l (genesis_a.hash ());
assert (latest_v0_begin (transaction_a) == latest_v0_end ());
@ -32,6 +32,7 @@ public:
nano::block_sideband sideband (nano::block_type::open, network_params.ledger.genesis_account, 0, network_params.ledger.genesis_amount, 1, nano::seconds_since_epoch ());
block_put (transaction_a, hash_l, *genesis_a.open, sideband);
confirmation_height_put (transaction_a, network_params.ledger.genesis_account, 1);
++cemented_count;
account_put (transaction_a, network_params.ledger.genesis_account, { hash_l, genesis_a.open->hash (), genesis_a.open->hash (), std::numeric_limits<nano::uint128_t>::max (), nano::seconds_since_epoch (), 1, nano::epoch::epoch_0 });
rep_weights.representation_put (network_params.ledger.genesis_account, std::numeric_limits<nano::uint128_t>::max ());
frontier_put (transaction_a, hash_l, network_params.ledger.genesis_account);
@ -244,16 +245,6 @@ public:
block_raw_put (transaction_a, data, type, version, hash_a);
}
uint64_t cemented_count (nano::transaction const & transaction_a) override
{
uint64_t sum = 0;
for (auto i (confirmation_height_begin (transaction_a)), n (confirmation_height_end ()); i != n; ++i)
{
sum += i->second;
}
return sum;
}
void unchecked_put (nano::write_transaction const & transaction_a, nano::block_hash const & hash_a, std::shared_ptr<nano::block> const & block_a) override
{
nano::unchecked_key key (hash_a, block_a->hash ());

25
nano/secure/ledger.cpp
View file

@ -677,22 +677,33 @@ bool nano::shared_ptr_block_hash::operator() (std::shared_ptr<nano::block> const
return lhs->hash () == rhs->hash ();
}
nano::ledger::ledger (nano::block_store & store_a, nano::stat & stat_a, nano::uint256_union const & epoch_link_a, nano::account const & epoch_signer_a, bool cache_reps_a) :
nano::ledger::ledger (nano::block_store & store_a, nano::stat & stat_a, nano::uint256_union const & epoch_link_a, nano::account const & epoch_signer_a, bool cache_reps_a, bool cache_cemented_count_a) :
store (store_a),
stats (stat_a),
check_bootstrap_weights (true),
epoch_link (epoch_link_a),
epoch_signer (epoch_signer_a)
{
if (!store.init_error () && cache_reps_a)
if (!store.init_error ())
{
auto transaction = store.tx_begin_read ();
for (auto i (store.latest_begin (transaction)), n (store.latest_end ()); i != n; ++i)
if (cache_reps_a)
{
nano::account_info const & info (i->second);
auto block (store.block_get (transaction, info.rep_block));
assert (block != nullptr);
rep_weights.representation_add (block->representative (), info.balance.number ());
for (auto i (store.latest_begin (transaction)), n (store.latest_end ()); i != n; ++i)
{
nano::account_info const & info (i->second);
auto block (store.block_get (transaction, info.rep_block));
assert (block != nullptr);
rep_weights.representation_add (block->representative (), info.balance.number ());
}
}
if (cache_cemented_count_a)
{
for (auto i (store.confirmation_height_begin (transaction)), n (store.confirmation_height_end ()); i != n; ++i)
{
cemented_count += i->second;
}
}
}
}

3
nano/secure/ledger.hpp
View file

@ -19,7 +19,7 @@ using tally_t = std::map<nano::uint128_t, std::shared_ptr<nano::block>, std::gre
class ledger final
{
public:
ledger (nano::block_store &, nano::stat &, nano::uint256_union const & = 1, nano::account const & = 0, bool = true);
ledger (nano::block_store &, nano::stat &, nano::uint256_union const & = 1, nano::account const & = 0, bool = true, bool = true);
nano::account account (nano::transaction const &, nano::block_hash const &) const;
nano::uint128_t amount (nano::transaction const &, nano::block_hash const &);
nano::uint128_t balance (nano::transaction const &, nano::block_hash const &) const;
@ -51,6 +51,7 @@ public:
static nano::uint128_t const unit;
nano::network_params network_params;
nano::block_store & store;
std::atomic<uint64_t> cemented_count{ 0 };
nano::rep_weights rep_weights;
nano::stat & stats;
std::unordered_map<nano::account, nano::uint128_t> bootstrap_weights;

2
nano/slow_test/node.cpp
View file

@ -95,7 +95,7 @@ TEST (ledger, deep_account_compute)
nano::ledger ledger (*store, stats);
nano::genesis genesis;
auto transaction (store->tx_begin_write ());
store->initialize (transaction, genesis, ledger.rep_weights);
store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key;
auto balance (nano::genesis_amount - 1);