sysio::subjective_billing Class Reference

#include <subjective_billing.hpp>

Public Member Functions
void	remove_subjective_billing (const transaction_id_type &trx_id, uint32_t time_ordinal)
void	disable ()
void	disable_account (chain::account_name a)
bool	is_account_disabled (const account_name &a) const
void	subjective_bill (const transaction_id_type &id, const fc::time_point &expire, const account_name &first_auth, const fc::microseconds &elapsed, bool in_pending_block)
void	subjective_bill_failure (const account_name &first_auth, const fc::microseconds &elapsed, const fc::time_point &now)
int64_t	get_subjective_bill (const account_name &first_auth, const fc::time_point &now) const
void	abort_block ()
void	on_block (fc::logger &log, const block_state_ptr &bsp, const fc::time_point &now)
template<typename Yield >
bool	remove_expired (fc::logger &log, const fc::time_point &pending_block_time, const fc::time_point &now, Yield &&yield)
uint32_t	get_expired_accumulator_average_window () const
void	set_expired_accumulator_average_window (fc::microseconds subjective_account_decay_time)

Static Public Attributes
static constexpr uint32_t	subjective_time_interval_ms = 5'000

Detailed Description

Definition at line 25 of file subjective_billing.hpp.

Member Function Documentation

abort_block()

void sysio::subjective_billing::abort_block ( )

inline

Definition at line 171 of file subjective_billing.hpp.

                      {
      _block_subjective_bill_cache.clear();
   }

Here is the caller graph for this function:

disable()

void sysio::subjective_billing::disable ( )

inline

Definition at line 115 of file subjective_billing.hpp.

{ _disabled = true; }

disable_account()

void sysio::subjective_billing::disable_account ( chain::account_name a )

inline

Definition at line 116 of file subjective_billing.hpp.

{ _disabled_accounts.emplace( a ); }

get_expired_accumulator_average_window()

uint32_t sysio::subjective_billing::get_expired_accumulator_average_window ( ) const

inline

Definition at line 210 of file subjective_billing.hpp.

                                                           {
      return _expired_accumulator_average_window;
   }

get_subjective_bill()

int64_t sysio::subjective_billing::get_subjective_bill ( const account_name & first_auth, const fc::time_point & now ) const

inline

Definition at line 148 of file subjective_billing.hpp.

                                                                                                {
      if( _disabled || _disabled_accounts.count( first_auth ) ) return 0;
      const auto time_ordinal = time_ordinal_for(now);
      const subjective_billing_info* sub_bill_info = nullptr;
      auto aitr = _account_subjective_bill_cache.find( first_auth );
      if( aitr != _account_subjective_bill_cache.end() ) {
         sub_bill_info = &aitr->second;
      }
      uint64_t in_block_pending_cpu_us = 0;
      auto bitr = _block_subjective_bill_cache.find( first_auth );
      if( bitr != _block_subjective_bill_cache.end() ) {
         in_block_pending_cpu_us = bitr->second;
      }
 
      if (sub_bill_info) {
         SYS_ASSERT(sub_bill_info->pending_cpu_us >= in_block_pending_cpu_us, chain::tx_resource_exhaustion, "Logic error subjective billing ${a}", ("a", first_auth) );
         int64_t sub_bill = sub_bill_info->pending_cpu_us - in_block_pending_cpu_us + sub_bill_info->expired_accumulator.value_at(time_ordinal, _expired_accumulator_average_window );
         return sub_bill;
      } else {
         return 0;
      }
   }

Here is the call graph for this function:

is_account_disabled()

bool sysio::subjective_billing::is_account_disabled ( const account_name & a ) const

inline

Definition at line 117 of file subjective_billing.hpp.

{ return _disabled || _disabled_accounts.count( a ); }

Here is the caller graph for this function:

on_block()

void sysio::subjective_billing::on_block ( fc::logger & log, const block_state_ptr & bsp, const fc::time_point & now )

inline

Definition at line 175 of file subjective_billing.hpp.

                                                                                       {
      if( bsp == nullptr || _disabled ) return;
      const auto time_ordinal = time_ordinal_for(now);
      const auto orig_count = _account_subjective_bill_cache.size();
      remove_subjective_billing( bsp, time_ordinal );
      fc_dlog( log, "Subjective billed accounts ${n} removed ${r}", ("n", orig_count)("r", orig_count - _account_subjective_bill_cache.size()) );
   }

Here is the caller graph for this function:

remove_expired()

template<typename Yield >

bool sysio::subjective_billing::remove_expired ( fc::logger & log, const fc::time_point & pending_block_time, const fc::time_point & now, Yield && yield )

inline

Definition at line 184 of file subjective_billing.hpp.

                                                                                                                        {
      bool exhausted = false;
      auto& idx = _trx_cache_index.get<by_expiry>();
      if( !idx.empty() ) {
         const auto time_ordinal = time_ordinal_for(now);
         const auto orig_count = _trx_cache_index.size();
         uint32_t num_expired = 0;
 
         while( !idx.empty() ) {
            if( yield() ) {
               exhausted = true;
               break;
            }
            auto b = idx.begin();
            if( b->expiry > pending_block_time ) break;
            transition_to_expired( *b, time_ordinal );
            idx.erase( b );
            num_expired++;
         }
 
         fc_dlog( log, "Processed ${n} subjective billed transactions, Expired ${expired}",
                  ("n", orig_count)( "expired", num_expired ) );
      }
      return !exhausted;
   }

Here is the caller graph for this function:

remove_subjective_billing()

void sysio::subjective_billing::remove_subjective_billing ( const transaction_id_type & trx_id, uint32_t time_ordinal )

inline

Definition at line 105 of file subjective_billing.hpp.

                                                                                              {
      auto& idx = _trx_cache_index.get<by_id>();
      auto itr = idx.find( trx_id );
      if( itr != idx.end() ) {
         remove_subjective_billing( *itr, time_ordinal );
         idx.erase( itr );
      }
   }

set_expired_accumulator_average_window()

void sysio::subjective_billing::set_expired_accumulator_average_window ( fc::microseconds subjective_account_decay_time )

inline

Definition at line 214 of file subjective_billing.hpp.

                                                                                               {
      _expired_accumulator_average_window =
        subjective_account_decay_time.count() / 1000 / subjective_time_interval_ms;
   }

Here is the call graph for this function:

subjective_bill()

void sysio::subjective_billing::subjective_bill ( const transaction_id_type & id, const fc::time_point & expire, const account_name & first_auth, const fc::microseconds & elapsed, bool in_pending_block )

inline

Parameters

in_pending_block

pass true if pt's bill time is accounted for in the pending block

Definition at line 120 of file subjective_billing.hpp.

   {
      if( !_disabled && !_disabled_accounts.count( first_auth ) ) {
         int64_t bill = std::max<int64_t>( 0, elapsed.count() );
         auto p = _trx_cache_index.emplace(
               trx_cache_entry{id,
                               first_auth,
                               bill,
                               expire} );
         if( p.second ) {
            _account_subjective_bill_cache[first_auth].pending_cpu_us += bill;
            if( in_pending_block ) {
               _block_subjective_bill_cache[first_auth] += bill;
            }
         }
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

subjective_bill_failure()

void sysio::subjective_billing::subjective_bill_failure ( const account_name & first_auth, const fc::microseconds & elapsed, const fc::time_point & now )

inline

Definition at line 139 of file subjective_billing.hpp.

   {
      if( !_disabled && !_disabled_accounts.count( first_auth ) ) {
         int64_t bill = std::max<int64_t>( 0, elapsed.count() );
         const auto time_ordinal = time_ordinal_for(now);
         _account_subjective_bill_cache[first_auth].expired_accumulator.add(bill, time_ordinal, _expired_accumulator_average_window);
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

subjective_time_interval_ms

uint32_t sysio::subjective_billing::subjective_time_interval_ms = 5'000

staticconstexpr

Definition at line 103 of file subjective_billing.hpp.

---

The documentation for this class was generated from the following file:

• plugins/producer_plugin/include/sysio/producer_plugin/subjective_billing.hpp