#include <resource_limits_private.hpp>

Public Member Functions
	exponential_decay_accumulator ()

uint64_t	value_ex_at (uint32_t ordinal, uint32_t window_size) const

uint64_t	value_at (uint32_t ordinal, uint32_t window_size) const

void	add (uint64_t units, uint32_t ordinal, uint32_t window_size)

Public Attributes
uint32_t	last_ordinal
	The ordinal of the last period which has contributed to the accumulator.

uint64_t	value_ex
	The current accumulated value pre-multiplied by Precision.

Static Public Attributes
static constexpr uint64_t	max_raw_value = std::numeric_limits<uint64_t>::max() / Precision

Detailed Description

template<uint64_t Precision = config::rate_limiting_precision>
struct sysio::chain::resource_limits::impl::exponential_decay_accumulator< Precision >

This class accumulates a value that decays over quantums based on inputs The decay is linear between updates and exponential if the set of inputs has no gaps

The value stored is Precision times the sum of the inputs.

Definition at line 131 of file resource_limits_private.hpp.

Constructor & Destructor Documentation

◆ exponential_decay_accumulator()

template<uint64_t Precision = config::rate_limiting_precision>

sysio::chain::resource_limits::impl::exponential_decay_accumulator< Precision >::exponential_decay_accumulator ( )

inline

Definition at line 136 of file resource_limits_private.hpp.

         : last_ordinal(0)
         , value_ex(0)
         {
         }

Member Function Documentation

◆ add()

template<uint64_t Precision = config::rate_limiting_precision>

void sysio::chain::resource_limits::impl::exponential_decay_accumulator< Precision >::add	(	uint64_t	units,
		uint32_t	ordinal,
		uint32_t	window_size )

inline

Definition at line 173 of file resource_limits_private.hpp.

         {
            // check for some numerical limits before doing any state mutations
            SYS_ASSERT(units <= max_raw_value, rate_limiting_state_inconsistent, "Usage exceeds maximum value representable after extending for precision");
 
            uint128_t units_ex = (uint128_t)units * Precision;
            if (last_ordinal < ordinal) {
               value_ex = value_ex_at(ordinal, window_size);
               last_ordinal = ordinal;
            }
 
            // saturate the value
            uint128_t new_value_ex = std::min<uint128_t>(units_ex + (uint128_t)value_ex, std::numeric_limits<uint64_t>::max());
            value_ex = downgrade_cast<uint64_t>(new_value_ex);
         }

Here is the call graph for this function:

◆ value_at()

template<uint64_t Precision = config::rate_limiting_precision>

uint64_t sysio::chain::resource_limits::impl::exponential_decay_accumulator< Precision >::value_at	(	uint32_t	ordinal,
		uint32_t	window_size ) const

inline

return the value at a current or future ordinal

Definition at line 169 of file resource_limits_private.hpp.

                                                                           {
            return integer_divide_ceil(value_ex_at(ordinal, window_size), Precision);
         }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ value_ex_at()

template<uint64_t Precision = config::rate_limiting_precision>

uint64_t sysio::chain::resource_limits::impl::exponential_decay_accumulator< Precision >::value_ex_at	(	uint32_t	ordinal,
		uint32_t	window_size ) const

inline

return the extended value at a current or future ordinal

Definition at line 148 of file resource_limits_private.hpp.

                                                                              {
            if( last_ordinal < ordinal ) {
               if( (uint64_t)last_ordinal + window_size > (uint64_t)ordinal ) {
                  const auto delta = ordinal - last_ordinal; // clearly 0 < delta < window_size
                  const auto decay = make_ratio(
                          (uint128_t)window_size - delta,
                          (uint128_t)window_size
                  );
 
                  return downgrade_cast<uint64_t>((uint128_t)value_ex * decay);
               } else {
                  return 0;
               }
            } else {
               return value_ex;
            }
         }