Peerplays_Blockchain/peerplays_migrated
1
0
Fork 0
Code Issues 35 Pull requests 4 Projects Releases 20 Packages Wiki Activity Actions

Replace fc::uint128 with boost::multiprecision::uint128_t

Browse source
This commit is contained in:
Peter Conrad 2019-05-07 08:27:57 +02:00 committed by Nathan Hourt
parent 6514f8fadd
commit f25c4f6ae6
No known key found for this signature in database
GPG key ID: B4344309A110851E
29 changed files with 58 additions and 66 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
libraries/app/api.cpp
View file

@ -37,6 +37,7 @@
#include <graphene/chain/worker_object.hpp>
#include <graphene/chain/tournament_object.hpp>
#include <fc/crypto/base64.hpp>
#include <fc/crypto/hex.hpp>
#include <fc/smart_ref_impl.hpp>
#include <fc/rpc/api_connection.hpp>

1
libraries/app/database_api.cpp
View file

@ -38,7 +38,6 @@
#include <boost/range/iterator_range.hpp>
#include <boost/rational.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <cctype>

4
libraries/chain/account_object.cpp
View file

@ -36,10 +36,10 @@ share_type cut_fee(share_type a, uint16_t p)
if( p == GRAPHENE_100_PERCENT )
return a;
fc::uint128 r(a.value);
fc::uint128_t r = a.value;
r *= p;
r /= GRAPHENE_100_PERCENT;
return r.to_uint64();
return r.convert_to<uint64_t>();
}
void account_balance_object::adjust_balance(const asset& delta)

5
libraries/chain/asset_object.cpp
View file

@ -38,10 +38,11 @@ share_type asset_bitasset_data_object::max_force_settlement_volume(share_type cu
if( options.maximum_force_settlement_volume == GRAPHENE_100_PERCENT )
return current_supply + force_settled_volume;
fc::uint128 volume = current_supply.value + force_settled_volume.value;
fc::uint128_t volume = current_supply.value;
volume += force_settled_volume.value;
volume *= options.maximum_force_settlement_volume;
volume /= GRAPHENE_100_PERCENT;
return volume.to_uint64();
return volume.convert_to<uint64_t>();
}
void asset_bitasset_data_object::update_median_feeds(time_point_sec current_time)

5
libraries/chain/db_init.cpp
View file

@ -89,7 +89,6 @@
#include <graphene/chain/protocol/fee_schedule.hpp>
#include <fc/smart_ref_impl.hpp>
#include <fc/uint128.hpp>
#include <fc/crypto/digest.hpp>
#include <boost/algorithm/string.hpp>
@ -614,7 +613,7 @@ void database::init_genesis(const genesis_state_type& genesis_state)
p.time = genesis_state.initial_timestamp;
p.dynamic_flags = 0;
p.witness_budget = 0;
p.recent_slots_filled = fc::uint128::max_value();
p.recent_slots_filled = std::numeric_limits<fc::uint128_t>::max();
});
create<global_betting_statistics_object>([&](global_betting_statistics_object& betting_statistics) {
betting_statistics.number_of_active_events = 0;
@ -989,7 +988,7 @@ void database::init_genesis(const genesis_state_type& genesis_state)
_wso.last_scheduling_block = 0;
_wso.recent_slots_filled = fc::uint128::max_value();
_wso.recent_slots_filled = fc::uint128_t::max_value();
// for shuffled
for( const witness_id_type& wid : get_global_properties().active_witnesses )

14
libraries/chain/db_maint.cpp
View file

@ -22,8 +22,6 @@
* THE SOFTWARE.
*/
#include <boost/multiprecision/integer.hpp>
#include <fc/smart_ref_impl.hpp>
#include <fc/uint128.hpp>
@ -184,10 +182,10 @@ void database::pay_workers( share_type& budget )
// Note: if there is a good chance that passed_time_count == day_count,
// for better performance, can avoid the 128 bit calculation by adding a check.
// Since it's not the case on BitShares mainnet, we're not using a check here.
fc::uint128 pay(requested_pay.value);
fc::uint128_t pay = requested_pay.value;
pay *= passed_time_count;
pay /= day_count;
requested_pay = pay.to_uint64();
requested_pay = pay.convert_to<uint64_t>();
share_type actual_pay = std::min(budget, requested_pay);
//ilog(" ==> Paying ${a} to worker ${w}", ("w", active_worker.id)("a", actual_pay));
@ -436,7 +434,7 @@ void database::initialize_budget_record( fc::time_point_sec now, budget_record&
budget_u128 >>= GRAPHENE_CORE_ASSET_CYCLE_RATE_BITS;
share_type budget;
if( budget_u128 < reserve.value )
rec.total_budget = share_type(budget_u128.to_uint64());
rec.total_budget = share_type(budget_u128.convert_to<uint64_t>());
else
rec.total_budget = reserve;
@ -491,7 +489,7 @@ void database::process_budget()
if( worker_budget_u128 >= available_funds.value )
worker_budget = available_funds;
else
worker_budget = worker_budget_u128.to_uint64();
worker_budget = worker_budget_u128.convert_to<uint64_t>();
rec.worker_budget = worker_budget;
available_funds -= worker_budget;
@ -631,12 +629,12 @@ void split_fba_balance(
fc::uint128_t buyback_amount_128 = fba.accumulated_fba_fees.value;
buyback_amount_128 *= designated_asset_buyback_pct;
buyback_amount_128 /= GRAPHENE_100_PERCENT;
share_type buyback_amount = buyback_amount_128.to_uint64();
share_type buyback_amount = buyback_amount_128.convert_to<uint64_t>();
fc::uint128_t issuer_amount_128 = fba.accumulated_fba_fees.value;
issuer_amount_128 *= designated_asset_issuer_pct;
issuer_amount_128 /= GRAPHENE_100_PERCENT;
share_type issuer_amount = issuer_amount_128.to_uint64();
share_type issuer_amount = issuer_amount_128.convert_to<uint64_t>();
// this assert should never fail
FC_ASSERT( buyback_amount + issuer_amount <= fba.accumulated_fba_fees );

2
libraries/chain/db_market.cpp
View file

@ -575,7 +575,7 @@ asset database::calculate_market_fee( const asset_object& trade_asset, const ass
if( trade_asset.options.market_fee_percent == 0 )
return trade_asset.amount(0);
fc::uint128 a(trade_amount.amount.value);
fc::uint128_t a(trade_amount.amount.value);
a *= trade_asset.options.market_fee_percent;
a /= GRAPHENE_100_PERCENT;
asset percent_fee = trade_asset.amount(a.to_uint64());

2
libraries/chain/db_update.cpp
View file

@ -39,8 +39,6 @@
#include <graphene/chain/protocol/fee_schedule.hpp>
#include <fc/uint128.hpp>
namespace graphene { namespace chain {
void database::update_global_dynamic_data( const signed_block& b, const uint32_t missed_blocks )

2
libraries/chain/db_witness_schedule.cpp
View file

@ -27,6 +27,8 @@
#include <graphene/chain/witness_object.hpp>
#include <graphene/chain/witness_schedule_object.hpp>
#include <fc/popcount.hpp>
namespace graphene { namespace chain {
using boost::container::flat_set;

2
libraries/chain/evaluator.cpp
View file

@ -35,8 +35,6 @@
#include <graphene/chain/market_evaluator.hpp>
#include <graphene/chain/protocol/fee_schedule.hpp>
#include <fc/uint128.hpp>
namespace graphene { namespace chain {
database& generic_evaluator::db()const { return trx_state->db(); }

2
libraries/chain/genesis_state.cpp
View file

@ -28,6 +28,8 @@
#include <fc/smart_ref_impl.hpp> // required for gcc in release mode
#include <graphene/chain/protocol/fee_schedule.hpp>
#include <fc/io/raw.hpp>
namespace graphene { namespace chain {
chain_id_type genesis_state_type::compute_chain_id() const

2
libraries/chain/include/graphene/chain/global_property_object.hpp
View file

@ -84,8 +84,6 @@ namespace graphene { namespace chain {
* every time a block is found it decreases by
* RECENTLY_MISSED_COUNT_DECREMENT. It is
* never less than 0.
*
* If the recently_missed_count hits 2*UNDO_HISTORY then no new blocks may be pushed.
*/
uint32_t recently_missed_count = 0;

1
libraries/chain/include/graphene/chain/protocol/types.hpp
View file

@ -36,7 +36,6 @@
#include <fc/string.hpp>
#include <fc/io/datastream.hpp>
#include <fc/io/raw_fwd.hpp>
#include <fc/uint128.hpp>
#include <fc/static_variant.hpp>
#include <fc/smart_ref_fwd.hpp>

8
libraries/chain/include/graphene/chain/vesting_balance_object.hpp
View file

@ -89,11 +89,11 @@ namespace graphene { namespace chain {
*/
struct cdd_vesting_policy
{
uint32_t vesting_seconds = 0;
fc::uint128_t coin_seconds_earned;
uint32_t vesting_seconds = 0;
fc::uint128_t coin_seconds_earned;
/** while coindays may accrue over time, none may be claimed before first_claim date */
fc::time_point_sec start_claim;
fc::time_point_sec coin_seconds_earned_last_update;
fc::time_point_sec start_claim;
fc::time_point_sec coin_seconds_earned_last_update;
/**
* Compute coin_seconds_earned. Used to

1
libraries/chain/market_evaluator.cpp
View file

@ -34,7 +34,6 @@
#include <graphene/chain/protocol/market.hpp>
#include <fc/uint128.hpp>
#include <fc/smart_ref_impl.hpp>
namespace graphene { namespace chain {

1
libraries/chain/protocol/asset.cpp
View file

@ -25,6 +25,7 @@
#include <boost/rational.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <fc/io/raw.hpp>
#include <fc/uint128.hpp>
namespace graphene { namespace chain {
typedef boost::multiprecision::uint128_t uint128_t;

3
libraries/chain/protocol/fee_schedule.cpp
View file

@ -36,6 +36,7 @@ namespace fc
}
#include <fc/io/raw.hpp>
#include <fc/uint128.hpp>
#define MAX_FEE_STABILIZATION_ITERATION 4
@ -131,7 +132,7 @@ namespace graphene { namespace chain {
auto itr = parameters.find(params);
if( itr != parameters.end() ) params = *itr;
auto base_value = op.visit( calc_fee_visitor( params ) );
auto scaled = fc::uint128(base_value) * scale;
auto scaled = fc::uint128_t(base_value) * scale;
scaled /= GRAPHENE_100_PERCENT;
FC_ASSERT( scaled <= GRAPHENE_MAX_SHARE_SUPPLY );
//idump( (base_value)(scaled)(core_exchange_rate) );

5
libraries/chain/protocol/operations.cpp
View file

@ -25,14 +25,15 @@
#include <graphene/chain/protocol/operations.hpp>
#include <graphene/chain/protocol/fee_schedule.hpp>
#include <fc/io/raw.hpp>
#include <fc/uint128.hpp>
namespace graphene { namespace chain {
uint64_t base_operation::calculate_data_fee( uint64_t bytes, uint64_t price_per_kbyte )
{
auto result = (fc::uint128(bytes) * price_per_kbyte) / 1024;
auto result = (fc::uint128_t(bytes) * price_per_kbyte) / 1024;
FC_ASSERT( result <= GRAPHENE_MAX_SHARE_SUPPLY );
return result.to_uint64();
return result.convert_to<uint64_t>();
}
void balance_claim_operation::validate()const

2
libraries/chain/vesting_balance_object.cpp
View file

@ -127,7 +127,7 @@ asset cdd_vesting_policy::get_allowed_withdraw(const vesting_policy_context& ctx
fc::uint128_t cs_earned = compute_coin_seconds_earned(ctx);
fc::uint128_t withdraw_available = cs_earned / std::max(vesting_seconds, 1u);
assert(withdraw_available <= ctx.balance.amount.value);
return asset(withdraw_available.to_uint64(), ctx.balance.asset_id);
return asset(static_cast<uint64_t>(withdraw_available), ctx.balance.asset_id);
}
void cdd_vesting_policy::on_deposit(const vesting_policy_context& ctx)

13
libraries/db/include/graphene/db/generic_index.hpp
View file

@ -33,7 +33,7 @@ namespace graphene { namespace chain {
using boost::multi_index_container;
using namespace boost::multi_index;
struct by_id{};
struct by_id;
/**
* Almost all objects can be tracked and managed via a boost::multi_index container that uses
* an unordered_unique key on the object ID. This template class adapts the generic index interface
@ -112,18 +112,7 @@ namespace graphene { namespace chain {
const index_type& indices()const { return _indices; }
virtual fc::uint128 hash()const override {
fc::uint128 result;
for( const auto& ptr : _indices )
{
result += ptr.hash();
}
return result;
}
private:
fc::uint128 _current_hash;
index_type _indices;
};

1
libraries/db/include/graphene/db/index.hpp
View file

@ -129,7 +129,6 @@ namespace graphene { namespace db {
}
virtual void inspect_all_objects(std::function<void(const object&)> inspector)const = 0;
virtual fc::uint128 hash()const = 0;
virtual void add_observer( const shared_ptr<index_observer>& ) = 0;
virtual void object_from_variant( const fc::variant& var, object& obj, uint32_t max_depth )const = 0;

14
libraries/db/include/graphene/db/object.hpp
View file

@ -23,9 +23,9 @@
*/
#pragma once
#include <graphene/db/object_id.hpp>
#include <boost/multiprecision/integer.hpp>
#include <fc/io/raw.hpp>
#include <fc/crypto/city.hpp>
#include <fc/uint128.hpp>
#define MAX_NESTING (200)
@ -77,7 +77,6 @@ namespace graphene { namespace db {
virtual void move_from( object& obj ) = 0;
virtual variant to_variant()const = 0;
virtual vector<char> pack()const = 0;
virtual fc::uint128 hash()const = 0;
};
/**
@ -102,10 +101,6 @@ namespace graphene { namespace db {
}
virtual variant to_variant()const { return variant( static_cast<const DerivedClass&>(*this), MAX_NESTING ); }
virtual vector<char> pack()const { return fc::raw::pack( static_cast<const DerivedClass&>(*this) ); }
virtual fc::uint128 hash()const {
auto tmp = this->pack();
return fc::city_hash_crc_128( tmp.data(), tmp.size() );
}
};
typedef flat_map<uint8_t, object_id_type> annotation_map;
@ -139,6 +134,13 @@ namespace graphene { namespace db {
} } // graphene::db
// Without this, pack(object_id) tries to match the template for
// pack(boost::multiprecision::uint128_t). No idea why. :-(
namespace boost { namespace multiprecision { namespace detail {
template<typename To>
struct is_restricted_conversion<graphene::db::object,To> : public mpl::true_ {};
}}}
FC_REFLECT_TYPENAME( graphene::db::annotation_map )
FC_REFLECT( graphene::db::object, (id) )
FC_REFLECT_DERIVED_TEMPLATE( (typename Derived), graphene::db::annotated_object<Derived>, (graphene::db::object), (annotations) )

7
libraries/db/include/graphene/db/simple_index.hpp
View file

@ -98,13 +98,6 @@ namespace graphene { namespace db {
}
} FC_CAPTURE_AND_RETHROW()
}
virtual fc::uint128 hash()const override {
fc::uint128 result;
for( const auto& ptr : _objects )
result += ptr->hash();
return result;
}
class const_iterator
{

1
libraries/db/object_database.cpp
View file

@ -25,7 +25,6 @@
#include <fc/io/raw.hpp>
#include <fc/container/flat.hpp>
#include <fc/uint128.hpp>
namespace graphene { namespace db {

2
libraries/fc

@ -1 +1 @@
Subproject commit 9fa98d9a93ada3e84f48812b5c42b053b0dbf9da
Subproject commit 69ebbf4ba490482956de0e331b22f1018747d789

1
libraries/plugins/market_history/include/graphene/market_history/market_history_plugin.hpp
View file

@ -123,7 +123,6 @@ typedef multi_index_container<
>
> order_history_multi_index_type;
typedef generic_index<bucket_object, bucket_object_multi_index_type> bucket_index;
typedef generic_index<order_history_object, order_history_multi_index_type> history_index;

12
libraries/wallet/wallet.cpp
View file

@ -62,7 +62,13 @@
#include <fc/crypto/hex.hpp>
#include <fc/thread/mutex.hpp>
#include <fc/thread/scoped_lock.hpp>
<<<<<<< HEAD
#include <fc/crypto/rand.hpp>
=======
#include <fc/rpc/api_connection.hpp>
#include <fc/crypto/base58.hpp>
#include <fc/popcount.hpp>
>>>>>>> 8f1eca14... Replace fc::uint128 with boost::multiprecision::uint128_t
#include <graphene/app/api.hpp>
#include <graphene/chain/asset_object.hpp>
@ -680,7 +686,13 @@ public:
" old");
result["next_maintenance_time"] = fc::get_approximate_relative_time_string(dynamic_props.next_maintenance_time);
result["chain_id"] = chain_props.chain_id;
<<<<<<< HEAD
result["participation"] = (100*dynamic_props.recent_slots_filled.popcount()) / 128.0;
=======
stringstream participation;
participation << fixed << std::setprecision(2) << (100.0*fc::popcount(dynamic_props.recent_slots_filled)) / 128.0;
result["participation"] = participation.str();
>>>>>>> 8f1eca14... Replace fc::uint128 with boost::multiprecision::uint128_t
result["active_witnesses"] = fc::variant(global_props.active_witnesses, GRAPHENE_MAX_NESTED_OBJECTS);
result["active_committee_members"] = fc::variant(global_props.active_committee_members, GRAPHENE_MAX_NESTED_OBJECTS);
result["entropy"] = fc::variant(dynamic_props.random, GRAPHENE_MAX_NESTED_OBJECTS);

6
tests/tests/block_tests.cpp
View file

@ -1030,9 +1030,9 @@ BOOST_FIXTURE_TEST_CASE( rsf_missed_blocks, database_fixture )
{
generate_block();
auto rsf = [&]() -> string
auto rsf = [this]() -> string
{
fc::uint128 rsf;
fc::uint128_t rsf;
if (db.get_global_properties().parameters.witness_schedule_algorithm == GRAPHENE_WITNESS_SCHEDULED_ALGORITHM)
rsf = db.get(witness_schedule_id_type()).recent_slots_filled;
else
@ -1041,7 +1041,7 @@ BOOST_FIXTURE_TEST_CASE( rsf_missed_blocks, database_fixture )
result.reserve(128);
for( int i=0; i<128; i++ )
{
result += ((rsf.lo & 1) == 0) ? '0' : '1';
result += rsf & 1 ? '1' : '0';
rsf >>= 1;
}
return result;

4
tests/tests/fee_tests.cpp
View file

@ -35,6 +35,8 @@
#include <graphene/chain/vesting_balance_object.hpp>
#include <graphene/chain/exceptions.hpp>
#include <fc/uint128.hpp>
#include <boost/test/unit_test.hpp>
#include "../common/database_fixture.hpp"
@ -245,7 +247,7 @@ uint64_t pct( uint64_t percentage, uint64_t val )
fc::uint128_t x = percentage;
x *= val;
x /= GRAPHENE_100_PERCENT;
return x.to_uint64();
return static_cast<uint64_t>(x);
}
uint64_t pct( uint64_t percentage0, uint64_t percentage1, uint64_t val )