Merge pull request #4118 from taokayan/producerlag

Producerlag

plugins/producer_plugin/include/eosio/producer_plugin/producer_plugin.hpp

@@ -21,6 +21,8 @@ public:
    struct runtime_options {
       fc::optional<int32_t> max_transaction_time;
       fc::optional<int32_t> max_irreversible_block_age;
+      fc::optional<int32_t> produce_time_offset_us;
+      fc::optional<int32_t> last_block_time_offset_us;
    };
 
    producer_plugin();
@@ -51,4 +53,4 @@ private:
 
 } //eosio
 
-FC_REFLECT(eosio::producer_plugin::runtime_options, (max_transaction_time)(max_irreversible_block_age));
+FC_REFLECT(eosio::producer_plugin::runtime_options, (max_transaction_time)(max_irreversible_block_age)(produce_time_offset_us)(last_block_time_offset_us));

plugins/producer_plugin/producer_plugin.cpp

@@ -131,6 +131,8 @@ class producer_plugin_impl : public std::enable_shared_from_this<producer_plugin
 
       int32_t                                                   _max_transaction_time_ms;
       fc::microseconds                                          _max_irreversible_block_age_us;
+      int32_t                                                   _produce_time_offset_us = 0;
+      int32_t                                                   _last_block_time_offset_us = 0;
       fc::time_point                                            _irreversible_block_time;
       fc::microseconds                                          _keosd_provider_timeout_us;
 
@@ -371,7 +373,7 @@ class producer_plugin_impl : public std::enable_shared_from_this<producer_plugin
          exhausted
       };
 
-      start_block_result start_block();
+      start_block_result start_block(bool &last_block);
 };
 
 void new_chain_banner(const eosio::chain::controller& db)
@@ -433,6 +435,10 @@ void producer_plugin::set_program_options(
           "   KEOSD:<data>    \tis the URL where keosd is available and the approptiate wallet(s) are unlocked")
          ("keosd-provider-timeout", boost::program_options::value<int32_t>()->default_value(5),
           "Limits the maximum time (in milliseconds) that is allowd for sending blocks to a keosd provider for signing")
+         ("produce-time-offset-us", boost::program_options::value<int32_t>()->default_value(0),
+          "offset of non last block producing time in micro second. Negative number results in blocks to go out sooner, and positive number results in blocks to go out later")
+         ("last-block-time-offset-us", boost::program_options::value<int32_t>()->default_value(0),
+          "offset of last block producing time in micro second. Negative number results in blocks to go out sooner, and positive number results in blocks to go out later")
          ;
    config_file_options.add(producer_options);
 }
@@ -545,6 +551,10 @@ void producer_plugin::plugin_initialize(const boost::program_options::variables_
 
    my->_keosd_provider_timeout_us = fc::milliseconds(options.at("keosd-provider-timeout").as<int32_t>());
 
+   my->_produce_time_offset_us = options.at("produce-time-offset-us").as<int32_t>();
+
+   my->_last_block_time_offset_us = options.at("last-block-time-offset-us").as<int32_t>();
+
    my->_max_transaction_time_ms = options.at("max-transaction-time").as<int32_t>();
 
    my->_max_irreversible_block_age_us = fc::seconds(options.at("max-irreversible-block-age").as<int32_t>());
@@ -653,6 +663,14 @@ void producer_plugin::update_runtime_options(const runtime_options& options) {
       check_speculating = true;
    }
 
+   if (options.produce_time_offset_us) {
+      my->_produce_time_offset_us = *options.produce_time_offset_us;
+   }
+
+   if (options.last_block_time_offset_us) {
+      my->_last_block_time_offset_us = *options.last_block_time_offset_us;
+   }
+
    if (check_speculating && my->_pending_block_mode == pending_block_mode::speculating) {
       chain::controller& chain = app().get_plugin<chain_plugin>().chain();
       chain.abort_block();
@@ -663,7 +681,9 @@ void producer_plugin::update_runtime_options(const runtime_options& options) {
 producer_plugin::runtime_options producer_plugin::get_runtime_options() const {
    return {
       my->_max_transaction_time_ms,
-      my->_max_irreversible_block_age_us.count() < 0 ? -1 : my->_max_irreversible_block_age_us.count() / 1'000'000
+      my->_max_irreversible_block_age_us.count() < 0 ? -1 : my->_max_irreversible_block_age_us.count() / 1'000'000,
+      my->_produce_time_offset_us,
+      my->_last_block_time_offset_us
    };
 }
 
@@ -722,7 +742,7 @@ optional<fc::time_point> producer_plugin_impl::calculate_next_block_time(const a
    }
 }
 
-producer_plugin_impl::start_block_result producer_plugin_impl::start_block() {
+producer_plugin_impl::start_block_result producer_plugin_impl::start_block(bool &last_block) {
    chain::controller& chain = app().get_plugin<chain_plugin>().chain();
    const auto& hbs = chain.head_block_state();
 
@@ -743,6 +763,7 @@ producer_plugin_impl::start_block_result producer_plugin_impl::start_block() {
    _pending_block_mode = pending_block_mode::producing;
 
    // Not our turn
+   last_block = ((block_timestamp_type(block_time).slot % config::producer_repetitions) == config::producer_repetitions - 1);
    const auto& scheduled_producer = hbs->get_scheduled_producer(block_time);
    auto currrent_watermark_itr = _producer_watermarks.find(scheduled_producer.producer_name);
    auto signature_provider_itr = _signature_providers.find(scheduled_producer.block_signing_key);
@@ -940,7 +961,8 @@ void producer_plugin_impl::schedule_production_loop() {
    _timer.cancel();
    std::weak_ptr<producer_plugin_impl> weak_this = shared_from_this();
 
-   auto result = start_block();
+   bool last_block;
+   auto result = start_block(last_block);
 
    if (result == start_block_result::failed) {
       elog("Failed to start a pending block, will try again later");
@@ -959,7 +981,7 @@ void producer_plugin_impl::schedule_production_loop() {
       if (result == start_block_result::succeeded) {
          // ship this block off no later than its deadline
          static const boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
-         _timer.expires_at(epoch + boost::posix_time::microseconds(chain.pending_block_time().time_since_epoch().count()));
+         _timer.expires_at(epoch + boost::posix_time::microseconds(chain.pending_block_time().time_since_epoch().count() + (last_block ? _last_block_time_offset_us : _produce_time_offset_us)));
          fc_dlog(_log, "Scheduling Block Production on Normal Block #${num} for ${time}", ("num", chain.pending_block_state()->block_num)("time",chain.pending_block_time()));
       } else {
          // ship this block off immediately
@@ -1043,6 +1065,7 @@ static auto maybe_make_debug_time_logger() -> fc::optional<decltype(make_debug_t
 }
 
 void producer_plugin_impl::produce_block() {
+   //ilog("produce_block ${t}", ("t", fc::time_point::now())); // for testing _produce_time_offset_us
    FC_ASSERT(_pending_block_mode == pending_block_mode::producing, "called produce_block while not actually producing");
 
    chain::controller& chain = app().get_plugin<chain_plugin>().chain();