RC costs do not depend on compute time

[holger80]

In the recent steemitblog post it was stated:

The RC system uses three measurements to determine how much an operation should cost in terms of RCs: blockchain size, compute time, and state size.

Let's check the source code, if this is true:
The RC costs are determined by (code):

tx_info.usage.resource_count[i]

where i is one of

enum rc_resource_types
{
   resource_history_bytes,
   resource_new_accounts,
   resource_market_bytes,
   resource_state_bytes,
   resource_execution_time
};

resource_count is set in the count_resources in resource_count.cpp:

void count_resources(
   const signed_transaction& tx,
   count_resources_result& result )
{
   static const state_object_size_info size_info;
   static const operation_exec_info exec_info;
   const int64_t tx_size = int64_t( fc::raw::pack_size( tx ) );
   count_operation_visitor vtor( size_info, exec_info );

   result.resource_count[ resource_history_bytes ] += tx_size;

   for( const operation& op : tx.operations )
   {
      op.visit( vtor );
   }

   result.resource_count[ resource_new_accounts ] += vtor.new_account_op_count;

   if( vtor.market_op_count > 0 )
      result.resource_count[ resource_market_bytes ] += tx_size;

   result.resource_count[ resource_state_bytes ] +=
        size_info.transaction_object_base_size
      + size_info.transaction_object_byte_size * tx_size
      + vtor.state_bytes_count;
}

Wait, there is no resource_execution_time! A search showed that resource_execution_time is not set elsewhere. Something like:

result.resource_count[ resource_execution_time ] += vtor.execution_time_count ;

is missing in count_resources().

Conclusion

The statement in the post should be corrected to (when I'm right):

The RC system uses right now two measurements to determine how much an operation should cost in terms of RCs: blockchain size, and state size. In the next update, we plan to use also compute time to determine the RC costs.

I filled an issue about this: https://github.com/steemit/steem/issues/2972

---

Although I'm familiar with c++, I do not know the entire source code of steem. I could be wrong.

Comments

[sorin.cristescu]

I would upvote this if I had significant voting power after the botched HF20

[indigoocean]

Can you tell us whether the current RC calculations are as intended (meaning stable going forward) or still normalizing? Because right now plankton can barely comment even after their RCs get fully recharged.

Posted using Partiko iOS

[carlgnash]

all signs point to that the RC costs will actually increase as we reach equilibrium with normal network activity. Currently network activity is (dramatically) lower than normal (because everyone's VP and RC were drained) so we are actually seeing lower RC costs than we will see down the road.

[indigoocean]

That's a problem.

If that really winds up being the case, there is going to be a need for some sort of progressive pricing on RC usage, or this ecosystem is not going to possibly be able to keep growing.

[carlgnash]

yup, to put it mildly. To put it more bluntly, not only will Steem not keep growing, it will crash and burn spectacularly

[indigoocean]

Yeah.

[steem-ua]

Hi @holger80!

Your post was upvoted by @steem-ua, new Steem dApp, using UserAuthority for algorithmic post curation!
Your UA account score is currently 6.483 which ranks you at #157 across all Steem accounts.
Your rank has not changed in the last three days.

In our last Algorithmic Curation Round, consisting of 369 contributions, your post is ranked at #18.

Evaluation of your UA score:

• You've built up a nice network.
• The readers appreciate your great work!
• Good user engagement!

Feel free to join our @steem-ua Discord server