Ref #19: Progress on producer voting and race

Begin defining objects and contract handlers for tracking producer votes
and the "race" to select runner-up producers

libraries/chain/CMakeLists.txt

@@ -5,7 +5,6 @@ add_library( eos_chain
              chain_controller.cpp
              fork_database.cpp
 
-             producer_object.cpp
              transaction.cpp
              block.cpp
 

libraries/chain/include/eos/chain/config.hpp

@@ -51,7 +51,7 @@ const static UInt32 DefaultMaxTrxLifetime = 60*60;
 const static int ProducerCount = 21;
 const static int IrreversibleThresholdPercent = 70 * Percent1;
 
-const static UInt128 ProducerScheduleLapLength = std::numeric_limits<UInt128>::max();
+const static UInt128 ProducerRaceLapLength = std::numeric_limits<UInt128>::max();
 } } // namespace eos::config
 
 template<typename Number>

libraries/chain/include/eos/chain/producer_object.hpp

@@ -40,49 +40,6 @@ class producer_object : public chainbase::object<producer_object_type, producer_
 
    /// The blockchain configuration values this producer recommends
    BlockchainConfiguration configuration;
-
-   /**
-    * @brief Update the tally of votes for the producer, while maintaining virtual time accounting
-    *
-    * This function will update @ref votes to @ref new_votes, while also updating all of the @ref virtual_time
-    * accounting as well.
-    *
-    * @param new_votes The new tally of votes for this producer
-    * @param current_virtual_time The current virtual time (see @ref virtual_time)
-    */
-   void update_votes(ShareType new_votes, UInt128 current_virtual_time);
-
-   /// The total votes for this producer
-   /// @warning Do not update this value directly; use @ref update_votes instead!
-   ShareType votes;
-
-   /**
-    * These fields are used for the producer scheduling algorithm which uses virtual time to ensure that all producers
-    * are given proportional time for producing blocks.
-    *
-    * @ref votes is used to determine speed. The @ref virtual_scheduled_time is the expected time at which this
-    * producer should complete a virtual lap which is defined as the position equal to
-    * config::ProducerScheduleLapLength
-    *
-    * virtual_scheduled_time = virtual_last_update + (config::ProducerScheduleLapLength - virtual_position) / votes
-    *
-    * Every time the number of votes changes the virtual_position and virtual_scheduled_time must update. There is a
-    * global current virtual_scheduled_time which gets updated every time a producer is scheduled. To update the
-    * virtual_position the following math is performed.
-    *
-    * virtual_position       = virtual_position + votes * (virtual_current_time - virtual_last_update)
-    * virtual_last_update    = virtual_current_time
-    * votes                  += delta_vote
-    * virtual_scheduled_time = virtual_last_update + (config::ProducerScheduleLapLength - virtual_position) / votes
-    *
-    */
-   ///@defgroup virtual_time Virtual Time Scheduling
-   /// @warning Do not update these values directly; use @ref update_votes instead!
-   ///@{
-   UInt128 virtual_last_update_time;
-   UInt128 virtual_position;
-   UInt128 virtual_scheduled_time = std::numeric_limits<UInt128>::max();
-   ///@}
 };
 
 struct by_key;
@@ -101,4 +58,4 @@ using producer_multi_index = chainbase::shared_multi_index_container<
 CHAINBASE_SET_INDEX_TYPE(eos::chain::producer_object, eos::chain::producer_multi_index)
 
 FC_REFLECT(eos::chain::producer_object, (id)(owner)(last_aslot)(signing_key)(total_missed)(last_confirmed_block_num)
-           (configuration)(virtual_last_update_time)(virtual_position)(virtual_scheduled_time))
+           (configuration))

libraries/chain/include/eos/chain/types.hpp

@@ -157,6 +157,7 @@ namespace eos { namespace chain {
       transaction_object_type,
       producer_object_type,
       chain_property_object_type,
+      producer_votes_object_type, ///< Defined by native_system_contract_plugin
       OBJECT_TYPE_COUNT ///< Sentry value which contains the number of different object types
    };
 
@@ -195,6 +196,7 @@ FC_REFLECT_ENUM( eos::chain::object_type,
                  (transaction_object_type)
                  (producer_object_type)
                  (chain_property_object_type)
+                 (producer_votes_object_type)
                  (OBJECT_TYPE_COUNT)
                )
 FC_REFLECT( eos::chain::void_t, )

plugins/native_system_contract_plugin/CMakeLists.txt

@@ -2,6 +2,8 @@ file(GLOB HEADERS "include/eos/native_system_contract_plugin/*.hpp")
 add_library( native_system_contract_plugin
              native_system_contract_plugin.cpp
              staked_balance_contract.cpp
+             staked_balance_objects.hpp
+             staked_balance_objects.cpp
              system_contract.cpp
              eos_contract.cpp
              ${HEADERS} )

plugins/native_system_contract_plugin/include/eos/native_system_contract_plugin/staked_balance_contract.hpp

@@ -18,4 +18,10 @@ struct UpdateProducer {
    static void apply(chain::apply_context& context);
 };
 
+struct ApproveProducer {
+   static void validate(chain::message_validate_context& context);
+   static void validate_preconditions(chain::precondition_validate_context& context);
+   static void apply(chain::apply_context& context);
+};
+
 } // namespace eos

plugins/native_system_contract_plugin/staked_balance_contract.cpp

@@ -4,6 +4,7 @@
 #include <eos/chain/account_object.hpp>
 #include <eos/chain/exceptions.hpp>
 
+
 namespace eos {
 using namespace chain;
 
@@ -55,4 +56,16 @@ void UpdateProducer::apply(apply_context& context) {
    });
 }
 
+void ApproveProducer::validate(message_validate_context& context) {
+
+}
+
+void ApproveProducer::validate_preconditions(precondition_validate_context& context) {
+
+}
+
+void ApproveProducer::apply(apply_context& context) {
+
+}
+
 } // namespace eos

plugins/native_system_contract_plugin/staked_balance_objects.cpp

@@ -0,0 +1,19 @@
+#include "staked_balance_objects.hpp"
+
+namespace eos {
+using namespace chain;
+using namespace types;
+
+void ProducerVotesObject::updateVotes(ShareType deltaVotes, UInt128 currentRaceTime) {
+   auto timeSinceLastUpdate = currentRaceTime - race.positionUpdateTime;
+   race.position += race.speed * timeSinceLastUpdate;
+   race.positionUpdateTime = currentRaceTime;
+
+   race.speed += deltaVotes;
+   auto distanceRemaining = config::ProducerRaceLapLength - race.position;
+   auto projectedTimeToFinish = distanceRemaining / race.speed;
+
+   race.projectedFinishTime = currentRaceTime + projectedTimeToFinish;
+}
+
+} // namespace eos

plugins/native_system_contract_plugin/staked_balance_objects.hpp

@@ -0,0 +1,106 @@
+#pragma once
+
+#include <eos/chain/types.hpp>
+#include <eos/chain/multi_index_includes.hpp>
+
+#include <eos/types/types.hpp>
+
+#include <boost/multi_index/mem_fun.hpp>
+
+namespace eos {
+
+/**
+ * @brief The ProducerVotesObject class tracks all votes for and by the block producers
+ *
+ * This class tracks the voting for block producers, as well as the virtual time 'race' to select the runner-up block
+ * producer.
+ *
+ * This class also tracks the votes cast by block producers on various chain configuration options and key documents.
+ */
+class ProducerVotesObject : public chainbase::object<chain::producer_votes_object_type, ProducerVotesObject> {
+   OBJECT_CTOR(ProducerVotesObject)
+
+   id_type id;
+   types::AccountName ownerName;
+
+   /**
+    * @brief Update the tally of votes for the producer, while maintaining virtual time accounting
+    *
+    * This function will update the producer's position in the race
+    *
+    * @param deltaVotes The change in votes since the last update
+    * @param currentRaceTime The current "race time"
+    */
+   void updateVotes(types::ShareType deltaVotes, types::UInt128 currentRaceTime);
+   /// @brief Get the number of votes this producer has received
+   types::ShareType getVotes() const { return race.speed; }
+
+   /**
+    * These fields are used for the producer scheduling algorithm which uses a virtual race to ensure that runner-up
+    * producers are given proportional time for producing blocks. Producers are constantly running a racetrack of
+    * length config::ProducerRaceLapLength, at a speed equal to the number of votes they have received. Runner-up
+    * producers, who lack sufficient votes to get in as a top-N voted producer, get scheduled to produce a block every
+    * time they finish the race. The race algorithm ensures that runner-up producers are scheduled with a frequency
+    * proportional to their relative vote tallies; i.e. a runner-up with more votes is scheduled more often than one
+    * with fewer votes, but all runners-up with any votes will theoretically be scheduled eventually.
+    *
+    * Whenever a runner-up producer needs to be scheduled, the one projected to finish the race next is taken, with the
+    * caveat that any producers already scheduled for other reasons (such as being a top-N voted producer) cannot be
+    * scheduled a second time in the same round, and thus they are skipped/ignored when looking for the producer
+    * projected to finish next. After selecting the runner-up for scheduling, the global current race time is updated
+    * to the point at which the winner crossed the finish line (i.e. his position is zero: he is now beginning his next
+    * lap). Furthermore, all producers which crossed the finish line ahead of the winner, but were ineligible to win as
+    * they were already scheduled in the next round, are effectively held at the finish line until the winner crosses,
+    * so their positions are all also set to zero.
+    *
+    * Every time the number of votes for a given producer changes, the producer's speed in the race changes and thus
+    * his projected finishing time changes. In this event, the stats must be updated: first, the producer's position is
+    * updated to reflect his progress since the last stats update to the current race time; second, the producer's
+    * projected finishing time based on his new position and speed are updated so we know where he shakes out in the
+    * new projected finish times.
+    *
+    * @warning Do not update these values directly; use @ref updateVotes instead!
+    */
+   struct {
+      /// The current speed for this producer (which is actually the total votes for the producer)
+      types::ShareType speed;
+      /// The position of this producer when we last updated the records
+      types::UInt128 position;
+      /// The "race time" when we last updated the records
+      types::UInt128 positionUpdateTime;
+      /// The projected "race time" at which this producer will finish the race
+      types::UInt128 projectedFinishTime = std::numeric_limits<types::UInt128>::max();
+   } race;
+
+   types::UInt128 projectedRaceFinishTime() const { return race.projectedFinishTime; }
+};
+
+using boost::multi_index::const_mem_fun;
+
+/// Index producers by their owner account's name
+struct byOwnerName;
+/// Index producers by projected race finishing time, from soonest to latest
+struct byProjectedRaceFinishTime;
+/// Index producers by votes, from greatest to least
+struct byVotes;
+
+using ProducerMultiIndex = chainbase::shared_multi_index_container<
+   ProducerVotesObject,
+   indexed_by<
+      ordered_unique<tag<by_id>,
+         member<ProducerVotesObject, ProducerVotesObject::id_type, &ProducerVotesObject::id>
+      >,
+      ordered_unique<tag<byOwnerName>,
+         member<ProducerVotesObject, types::AccountName, &ProducerVotesObject::ownerName>
+      >,
+      ordered_non_unique<tag<byVotes>,
+         const_mem_fun<ProducerVotesObject, types::ShareType, &ProducerVotesObject::getVotes>,
+         std::greater<types::ShareType>
+      >,
+      ordered_non_unique<tag<byProjectedRaceFinishTime>,
+         const_mem_fun<ProducerVotesObject, types::UInt128, &ProducerVotesObject::projectedRaceFinishTime>
+      >
+   >
+>;
+
+} // namespace eos