Switch to boost fiber

libraries/chain/db_block.cpp

@@ -39,6 +39,7 @@
 
 #include <graphene/protocol/fee_schedule.hpp>
 
+#include <fc/asio.hpp>
 #include <fc/io/raw.hpp>
 #include <fc/thread/parallel.hpp>
 
@@ -822,9 +823,9 @@ void database::_precompute_parallel( const Trx* trx, const size_t count, const u
    }
 }
 
-fc::future<void> database::precompute_parallel( const signed_block& block, const uint32_t skip )const
+boost::fibers::future<void> database::precompute_parallel( const signed_block& block, const uint32_t skip )const
 { try {
-   std::vector<fc::future<void>> workers;
+   std::vector<boost::fibers::future<void>> workers;
    if( !block.transactions.empty() )
    {
       if( (skip & skip_expensive) == skip_expensive )
@@ -850,16 +851,20 @@ fc::future<void> database::precompute_parallel( const signed_block& block, const
    block.id();
 
    if( workers.empty() )
-      return fc::future< void >( fc::promise< void >::create( true ) );
+   {
+      boost::fibers::promise< void > done;
+      done.set_value();
+      return done.get_future();
+   }
 
    auto first = workers.begin();
    auto worker = first;
    while( ++worker != workers.end() )
       worker->wait();
-   return *first;
+   return std::move( *first );
 } FC_LOG_AND_RETHROW() }
 
-fc::future<void> database::precompute_parallel( const precomputable_transaction& trx )const
+boost::fibers::future<void> database::precompute_parallel( const precomputable_transaction& trx )const
 {
    return fc::do_parallel([this,&trx] () {
       _precompute_parallel( &trx, 1, skip_nothing );

libraries/chain/db_management.cpp

@@ -80,7 +80,7 @@ void database::reindex( fc::path data_dir )
 
    size_t total_block_size = _block_id_to_block.total_block_size();
    const auto& gpo = get_global_properties();
-   std::queue< std::tuple< size_t, signed_block, fc::future< void > > > blocks;
+   std::queue< std::tuple< size_t, signed_block, boost::fibers::future< void > > > blocks;
    uint32_t next_block_num = head_block_num() + 1;
    uint32_t i = next_block_num;
    while( next_block_num <= last_block_num || !blocks.empty() )
@@ -93,7 +93,7 @@ void database::reindex( fc::path data_dir )
          {
             if( block->timestamp >= last_block->timestamp - gpo.parameters.maximum_time_until_expiration )
                skip &= ~skip_transaction_dupe_check;
-            blocks.emplace( processed_block_size, std::move(*block), fc::future<void>() );
+            blocks.emplace( processed_block_size, std::move(*block), boost::fibers::future<void>() );
             std::get<2>(blocks.back()) = precompute_parallel( std::get<1>(blocks.back()), skip );
          }
          else

libraries/chain/include/graphene/chain/database.hpp

@@ -37,10 +37,12 @@
 #include <graphene/db/object_database.hpp>
 #include <graphene/db/object.hpp>
 #include <graphene/db/simple_index.hpp>
-#include <fc/signals.hpp>
 
+#include <fc/signals.hpp>
 #include <fc/log/logger.hpp>
 
+#include <boost/fiber/future.hpp>
+
 #include <map>
 
 namespace graphene { namespace chain {
@@ -453,7 +455,8 @@ namespace graphene { namespace chain {
           * @return a future that will resolve to the input block with
           *         precomputations applied
           */
-         fc::future<void> precompute_parallel( const signed_block& block, const uint32_t skip = skip_nothing )const;
+         boost::fibers::future<void> precompute_parallel( const signed_block& block,
+                                                          const uint32_t skip = skip_nothing )const;
 
          /** Precomputes digests, signatures and operation validations.
           *  "Expensive" computations may be done in a parallel thread.
@@ -462,7 +465,7 @@ namespace graphene { namespace chain {
           * @return a future that will resolve to the input transaction with
           *         precomputations applied
           */
-         fc::future<void> precompute_parallel( const precomputable_transaction& trx )const;
+         boost::fibers::future<void> precompute_parallel( const precomputable_transaction& trx )const;
    private:
          template<typename Trx>
          void _precompute_parallel( const Trx* trx, const size_t count, const uint32_t skip )const;

libraries/db/object_database.cpp

@@ -72,7 +72,7 @@ void object_database::flush()
 {
 //   ilog("Save object_database in ${d}", ("d", _data_dir));
    fc::create_directories( _data_dir / "object_database.tmp" / "lock" );
-   std::vector<fc::future<void>> tasks;
+   std::vector<boost::fibers::future<void>> tasks;
    tasks.reserve(200);
    for( uint32_t space = 0; space < _index.size(); ++space )
    {
@@ -109,7 +109,7 @@ void object_database::open(const fc::path& data_dir)
        wlog("Ignoring locked object_database");
        return;
    }
-   std::vector<fc::future<void>> tasks;
+   std::vector<boost::fibers::future<void>> tasks;
    tasks.reserve(200);
    ilog("Opening object database from ${d} ...", ("d", data_dir));
    for( uint32_t space = 0; space < _index.size(); ++space )

libraries/net/CMakeLists.txt

@@ -12,7 +12,7 @@ set(SOURCES node.cpp
 add_library( graphene_net ${SOURCES} ${HEADERS} )
 
 target_link_libraries( graphene_net 
-  PUBLIC fc graphene_db graphene_protocol )
+  PUBLIC fc graphene_db graphene_protocol graphene_utilities )
 target_include_directories( graphene_net 
   PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include"
   PRIVATE "${CMAKE_SOURCE_DIR}/libraries/chain/include"

libraries/net/include/graphene/net/node.hpp

@@ -30,6 +30,7 @@
 #include <graphene/protocol/types.hpp>
 
 #include <list>
+#include <thread>
 
 namespace graphene { namespace net {
 
@@ -293,35 +294,10 @@ namespace graphene { namespace net {
         void disable_peer_advertising();
         fc::variant_object get_call_statistics() const;
       private:
-        std::unique_ptr<detail::node_impl, detail::node_impl_deleter> my;
+        std::unique_ptr<detail::node_impl> my;
    };
 
-    class simulated_network : public node
-    {
-    public:
-      ~simulated_network();
-      simulated_network(const std::string& user_agent) : node(user_agent) {}
-      void      listen_to_p2p_network() override {}
-      void      connect_to_p2p_network() override {}
-      void      connect_to_endpoint(const fc::ip::endpoint& ep) override {}
-
-      fc::ip::endpoint get_actual_listening_endpoint() const override { return fc::ip::endpoint(); }
-
-      void      sync_from(const item_id& current_head_block, const std::vector<uint32_t>& hard_fork_block_numbers) override {}
-      void      broadcast(const message& item_to_broadcast) override;
-      void      add_node_delegate(node_delegate* node_delegate_to_add);
-
-      virtual uint32_t get_connection_count() const override { return 8; }
-    private:
-      struct node_info;
-      void message_sender(node_info* destination_node);
-      std::list<node_info*> network_nodes;
-    };
-
-
    typedef std::shared_ptr<node> node_ptr;
-   typedef std::shared_ptr<simulated_network> simulated_network_ptr;
-
 } } // graphene::net
 
 FC_REFLECT(graphene::net::message_propagation_data, (received_time)(validated_time)(originating_peer));

libraries/net/include/graphene/net/peer_connection.hpp

@@ -39,7 +39,6 @@
 
 #include <queue>
 #include <boost/container/deque.hpp>
-#include <fc/thread/future.hpp>
 
 namespace graphene { namespace net
   {
@@ -166,7 +165,7 @@ namespace graphene { namespace net
 
       size_t _total_queued_messages_size = 0;
       std::queue<std::unique_ptr<queued_message>, std::list<std::unique_ptr<queued_message> > > _queued_messages;
-      fc::future<void> _send_queued_messages_done;
+      boost::fibers::future<void> _send_queued_messages_done;
     public:
       fc::time_point connection_initiation_time;
       fc::time_point connection_closed_time;
@@ -260,7 +259,7 @@ namespace graphene { namespace net
 
       uint32_t last_known_fork_block_number = 0;
 
-      fc::future<void> accept_or_connect_task_done;
+      boost::fibers::future<void> accept_or_connect_task_done;
 
       firewall_check_state_data *firewall_check_state = nullptr;
     private: