Merge pull request #140 from Wire-Network/feature/WIRE-207-subjective-cpu-payer

Add disable-subjective-payer-billing option

Author: heifner

libraries/chain/include/sysio/chain/subjective_billing.hpp

@@ -51,6 +51,7 @@ class subjective_billing {
    using account_subjective_bill_cache = std::unordered_map<chain::account_name, subjective_billing_info>;
 
    bool                                      _disabled = false;
+   bool                                      _disabled_payer_billing = false;
    fc::microseconds                          _subjective_account_cpu_allowed{config::default_subjective_cpu_us};
    trx_cache_index                           _trx_cache_index;
    account_subjective_bill_cache             _account_subjective_bill_cache;
@@ -120,6 +121,8 @@ class subjective_billing {
    fc::microseconds get_subjective_account_cpu_allowed() const { return _subjective_account_cpu_allowed; }
    void set_disabled(bool disable) { _disabled = disable; }
    bool is_disabled() const { return _disabled; }
+   void disable_payer_billing(bool disable) { _disabled_payer_billing = disable; }
+   bool is_payer_billing_disabled() const { return _disabled_payer_billing; }
    void disable_account( chain::account_name a ) { _disabled_accounts.emplace( a ); }
    bool is_account_disabled(const account_name& a ) const { return _disabled || _disabled_accounts.contains( a ); }
    bool is_any_account_disabled(const action_payers_t& accounts ) const {
@@ -133,10 +136,12 @@ class subjective_billing {
       if (_disabled) return;
       if (_trx_cache_index.contains(id)) return;
       account_subjective_cpu_bill_t account_subjective_cpu_bill;
-      for (const auto& [a, b] : accounts_billing) {
-         if (!_disabled_accounts.contains(a)) {
-            account_subjective_cpu_bill[a] = fc::microseconds(b.cpu_usage_us);
-            _account_subjective_bill_cache[a].pending_cpu_us += b.cpu_usage_us;
+      if (!_disabled_payer_billing) {
+         for (const auto& [a, b] : accounts_billing) {
+            if (!_disabled_accounts.contains(a)) {
+               account_subjective_cpu_bill[a] = fc::microseconds(b.cpu_usage_us);
+               _account_subjective_bill_cache[a].pending_cpu_us += b.cpu_usage_us;
+            }
          }
       }
       for (const auto& [a, b] : auth_cpu) {
@@ -156,9 +161,11 @@ class subjective_billing {
    void subjective_bill_failure( const accounts_billing_t& accounts_billing, const account_subjective_cpu_bill_t& auth_cpu, const fc::time_point& now ) {
       if (_disabled) return;
       const auto time_ordinal = time_ordinal_for(now);
-      for (const auto& [a, b] : accounts_billing) {
-         if (!_disabled_accounts.contains(a)) {
-            _account_subjective_bill_cache[a].expired_accumulator.add(b.cpu_usage_us, time_ordinal, _expired_accumulator_average_window);
+      if (!_disabled_payer_billing) {
+         for (const auto& [a, b] : accounts_billing) {
+            if (!_disabled_accounts.contains(a)) {
+               _account_subjective_bill_cache[a].expired_accumulator.add(b.cpu_usage_us, time_ordinal, _expired_accumulator_average_window);
+            }
          }
       }
       for (const auto& [a, b] : auth_cpu) {

libraries/chain/include/sysio/chain/transaction_context.hpp

@@ -205,7 +205,6 @@ namespace sysio::chain {
          fc::microseconds              leeway = fc::microseconds( config::default_subjective_cpu_leeway_us );
          cpu_usage_t                   billed_cpu_us;
          accounts_billing_t            prev_accounts_billing;
-         account_subjective_cpu_bill_t authorizers_cpu;
          bool                          explicit_billed_cpu_time = false;
 
          transaction_checktime_timer   transaction_timer;

libraries/chain/transaction_context.cpp

@@ -700,11 +700,13 @@ namespace sysio::chain {
       int64_t total_cpu_time_us = std::max( (now - pseudo_start).count(), static_cast<int64_t>(cfg.min_transaction_cpu_usage) );
       SYS_ASSERT(total_cpu_time_us - trace->total_cpu_usage_us >= 0, tx_cpu_usage_exceeded,
                  "Invalid CPU usage calculation ${tt} - ${tu}", ("tt", total_cpu_time_us)("tu", trace->total_cpu_usage_us));
+      account_subjective_cpu_bill_t authorizers_cpu;
       if (!billed_cpu_us.empty()) {
          assert(trace->action_traces.size() >= billed_cpu_us.size());
          // +1 so total is above min_transaction_cpu_usage
          int64_t delta_per_action = (( total_cpu_time_us - trace->total_cpu_usage_us ) / billed_cpu_us.size()) + 1;
          total_cpu_time_us = 0;
+         bool subjectively_bill_payer_disabled = control.get_subjective_billing().is_payer_billing_disabled();
          auto trx_first_authorizer = packed_trx.get_transaction().first_authorizer(); // use if no authorizer
          for (auto&& [i, b] : std::views::enumerate(billed_cpu_us)) {
             // if exception thrown, action_traces may not be the same size as billed_cpu_us
@@ -717,7 +719,7 @@ namespace sysio::chain {
             auto first_auth = act_trace.act.first_authorizer();
             if (first_auth.empty())
                first_auth = trx_first_authorizer;
-            if (first_auth != payer) // don't subjectively bill payer twice
+            if (first_auth != payer || subjectively_bill_payer_disabled) // don't subjectively bill payer twice if billing payer
                authorizers_cpu[first_auth] += fc::microseconds{b.value};
          }
       }
@@ -734,7 +736,7 @@ namespace sysio::chain {
          } else {
             // if producing then trx is in objective cpu account billing. Also no block will be received to remove the billing.
             if (!control.is_producing_block()) {
-               subjective_bill.subjective_bill(packed_trx.id(), packed_trx.expiration(), prev_accounts_billing, authorizers_cpu);
+               subjective_bill.subjective_bill(packed_trx.id(), packed_trx.expiration(), accounts_billing, authorizers_cpu);
             }
          }
       }

plugins/producer_plugin/src/producer_plugin.cpp

@@ -1308,6 +1308,8 @@ void producer_plugin::set_program_options(
           "Maximum size (in MiB) of the incoming transaction queue. Exceeding this value will subjectively drop transaction with resource exhaustion.")
          ("disable-subjective-account-billing", boost::program_options::value<vector<string>>()->composing()->multitoken(),
           "Account which is excluded from subjective CPU billing")
+         ("disable-subjective-payer-billing", bpo::value<bool>()->default_value(false),
+          "Disable subjective CPU billing for all contract payer accounts")
          ("disable-subjective-p2p-billing", bpo::value<bool>()->default_value(true),
           "Disable subjective CPU billing for P2P transactions")
          ("disable-subjective-api-billing", bpo::value<bool>()->default_value(true),
@@ -1431,8 +1433,9 @@ void producer_plugin_impl::plugin_initialize(const boost::program_options::varia
    chain.get_mutable_subjective_billing().set_subjective_account_cpu_allowed(fc::microseconds(options.at("subjective-account-cpu-allowed-us").as<int64_t>()));
    _disable_subjective_p2p_billing = options.at("disable-subjective-p2p-billing").as<bool>();
    _disable_subjective_api_billing = options.at("disable-subjective-api-billing").as<bool>();
-   dlog("disable-subjective-p2p-billing: ${p2p}, disable-subjective-api-billing: ${api}",
-        ("p2p", _disable_subjective_p2p_billing)("api", _disable_subjective_api_billing));
+   chain.get_mutable_subjective_billing().disable_payer_billing(options.at("disable-subjective-payer-billing").as<bool>());
+   dlog("disable-subjective-p2p-billing: ${p2p}, disable-subjective-api-billing: ${api}, disable-subjective-payer-billing: ${payer}",
+        ("p2p", _disable_subjective_p2p_billing)("api", _disable_subjective_api_billing)("payer", chain.get_subjective_billing().is_payer_billing_disabled()));
    if (_disable_subjective_p2p_billing && _disable_subjective_api_billing) {
       chain.get_mutable_subjective_billing().set_disabled(true);
       ilog("Subjective CPU billing disabled");