feat():initial version

install/boost_1_75_0/include/boost/fiber/algo/algorithm.hpp

@@ -0,0 +1,162 @@
+//          Copyright Oliver Kowalke 2013.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_FIBERS_ALGO_ALGORITHM_H
+#define BOOST_FIBERS_ALGO_ALGORITHM_H
+
+#include <atomic>
+#include <chrono>
+#include <cstddef>
+
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
+#include <boost/intrusive_ptr.hpp>
+
+#include <boost/fiber/properties.hpp>
+#include <boost/fiber/detail/config.hpp>
+
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+
+namespace boost {
+namespace fibers {
+
+class context;
+
+namespace algo {
+
+class BOOST_FIBERS_DECL algorithm {
+private:
+    std::atomic< std::size_t >    use_count_{ 0 };
+
+public:
+    typedef intrusive_ptr< algorithm >  ptr_t;
+
+    virtual ~algorithm() = default;
+
+    virtual void awakened( context *) noexcept = 0;
+
+    virtual context * pick_next() noexcept = 0;
+
+    virtual bool has_ready_fibers() const noexcept = 0;
+
+    virtual void suspend_until( std::chrono::steady_clock::time_point const&) noexcept = 0;
+
+    virtual void notify() noexcept = 0;
+
+    #if !defined(BOOST_EMBTC)
+      
+    friend void intrusive_ptr_add_ref( algorithm * algo) noexcept {
+        BOOST_ASSERT( nullptr != algo);
+        algo->use_count_.fetch_add( 1, std::memory_order_relaxed);
+    }
+
+    friend void intrusive_ptr_release( algorithm * algo) noexcept {
+        BOOST_ASSERT( nullptr != algo);
+        if ( 1 == algo->use_count_.fetch_sub( 1, std::memory_order_release) ) {
+            std::atomic_thread_fence( std::memory_order_acquire);
+            delete algo;
+        }
+    }
+    
+    #else
+      
+    friend void intrusive_ptr_add_ref( algorithm * algo) noexcept;
+    friend void intrusive_ptr_release( algorithm * algo) noexcept;
+    
+    #endif
+      
+};
+
+#if defined(BOOST_EMBTC)
+
+    inline void intrusive_ptr_add_ref( algorithm * algo) noexcept {
+        BOOST_ASSERT( nullptr != algo);
+        algo->use_count_.fetch_add( 1, std::memory_order_relaxed);
+    }
+
+    inline void intrusive_ptr_release( algorithm * algo) noexcept {
+        BOOST_ASSERT( nullptr != algo);
+        if ( 1 == algo->use_count_.fetch_sub( 1, std::memory_order_release) ) {
+            std::atomic_thread_fence( std::memory_order_acquire);
+            delete algo;
+        }
+    }
+    
+#endif
+    
+class BOOST_FIBERS_DECL algorithm_with_properties_base : public algorithm {
+public:
+    // called by fiber_properties::notify() -- don't directly call
+    virtual void property_change_( context * ctx, fiber_properties * props) noexcept = 0;
+
+protected:
+    static fiber_properties* get_properties( context * ctx) noexcept;
+    static void set_properties( context * ctx, fiber_properties * p) noexcept;
+};
+
+template< typename PROPS >
+struct algorithm_with_properties : public algorithm_with_properties_base {
+    typedef algorithm_with_properties_base super;
+
+    // Mark this override 'final': algorithm_with_properties subclasses
+    // must override awakened() with properties parameter instead. Otherwise
+    // you'd have to remember to start every subclass awakened() override
+    // with: algorithm_with_properties<PROPS>::awakened(fb);
+    void awakened( context * ctx) noexcept final {
+        fiber_properties * props = super::get_properties( ctx);
+        if ( BOOST_LIKELY( nullptr == props) ) {
+            // TODO: would be great if PROPS could be allocated on the new
+            // fiber's stack somehow
+            props = new_properties( ctx);
+            // It is not good for new_properties() to return 0.
+            BOOST_ASSERT_MSG( props, "new_properties() must return non-NULL");
+            // new_properties() must return instance of (a subclass of) PROPS
+            BOOST_ASSERT_MSG( dynamic_cast< PROPS * >( props),
+                              "new_properties() must return properties class");
+            super::set_properties( ctx, props);
+        }
+        // Set algo_ again every time this fiber becomes READY. That
+        // handles the case of a fiber migrating to a new thread with a new
+        // algorithm subclass instance.
+        props->set_algorithm( this);
+
+        // Okay, now forward the call to subclass override.
+        awakened( ctx, properties( ctx) );
+    }
+
+    // subclasses override this method instead of the original awakened()
+    virtual void awakened( context *, PROPS &) noexcept = 0;
+
+    // used for all internal calls
+    PROPS & properties( context * ctx) noexcept {
+        return static_cast< PROPS & >( * super::get_properties( ctx) );
+    }
+
+    // override this to be notified by PROPS::notify()
+    virtual void property_change( context * /* ctx */, PROPS & /* props */) noexcept {
+    }
+
+    // implementation for algorithm_with_properties_base method
+    void property_change_( context * ctx, fiber_properties * props) noexcept final {
+        property_change( ctx, * static_cast< PROPS * >( props) );
+    }
+
+    // Override this to customize instantiation of PROPS, e.g. use a different
+    // allocator. Each PROPS instance is associated with a particular
+    // context.
+    virtual fiber_properties * new_properties( context * ctx) {
+        return new PROPS( ctx);
+    }
+};
+
+}}}
+
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+
+#endif // BOOST_FIBERS_ALGO_ALGORITHM_H

install/boost_1_75_0/include/boost/fiber/algo/round_robin.hpp

@@ -0,0 +1,69 @@
+//          Copyright Oliver Kowalke 2013.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_FIBERS_ALGO_ROUND_ROBIN_H
+#define BOOST_FIBERS_ALGO_ROUND_ROBIN_H
+
+#include <condition_variable>
+#include <chrono>
+#include <mutex>
+
+#include <boost/config.hpp>
+
+#include <boost/fiber/algo/algorithm.hpp>
+#include <boost/fiber/context.hpp>
+#include <boost/fiber/detail/config.hpp>
+#include <boost/fiber/scheduler.hpp>
+
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4251)
+#endif
+
+namespace boost {
+namespace fibers {
+namespace algo {
+
+class BOOST_FIBERS_DECL round_robin : public algorithm {
+private:
+    typedef scheduler::ready_queue_type rqueue_type;
+
+    rqueue_type                 rqueue_{};
+    std::mutex                  mtx_{};
+    std::condition_variable     cnd_{};
+    bool                        flag_{ false };
+
+public:
+    round_robin() = default;
+
+    round_robin( round_robin const&) = delete;
+    round_robin & operator=( round_robin const&) = delete;
+
+    void awakened( context *) noexcept override;
+
+    context * pick_next() noexcept override;
+
+    bool has_ready_fibers() const noexcept override;
+
+    void suspend_until( std::chrono::steady_clock::time_point const&) noexcept override;
+
+    void notify() noexcept override;
+};
+
+}}}
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+
+#endif // BOOST_FIBERS_ALGO_ROUND_ROBIN_H

install/boost_1_75_0/include/boost/fiber/algo/shared_work.hpp

@@ -0,0 +1,86 @@
+
+//          Copyright Nat Goodspeed + Oliver Kowalke 2015.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_FIBERS_ALGO_SHARED_WORK_H
+#define BOOST_FIBERS_ALGO_SHARED_WORK_H
+
+#include <condition_variable>
+#include <chrono>
+#include <deque>
+#include <mutex>
+
+#include <boost/config.hpp>
+
+#include <boost/fiber/algo/algorithm.hpp>
+#include <boost/fiber/context.hpp>
+#include <boost/fiber/detail/config.hpp>
+#include <boost/fiber/scheduler.hpp>
+
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4251)
+#endif
+
+namespace boost {
+namespace fibers {
+namespace algo {
+
+class BOOST_FIBERS_DECL shared_work : public algorithm {
+private:
+    typedef std::deque< context * >  rqueue_type;
+    typedef scheduler::ready_queue_type lqueue_type;
+
+    static rqueue_type     	rqueue_;
+    static std::mutex   	rqueue_mtx_;
+
+    lqueue_type            	lqueue_{};
+    std::mutex              mtx_{};
+    std::condition_variable cnd_{};
+    bool                    flag_{ false };
+    bool                    suspend_{ false };
+
+public:
+    shared_work() = default;
+
+    shared_work( bool suspend) :
+        suspend_{ suspend } {
+    }
+
+	shared_work( shared_work const&) = delete;
+	shared_work( shared_work &&) = delete;
+
+	shared_work & operator=( shared_work const&) = delete;
+	shared_work & operator=( shared_work &&) = delete;
+
+    void awakened( context * ctx) noexcept override;
+
+    context * pick_next() noexcept override;
+
+    bool has_ready_fibers() const noexcept override {
+        std::unique_lock< std::mutex > lock{ rqueue_mtx_ };
+        return ! rqueue_.empty() || ! lqueue_.empty();
+    }
+
+	void suspend_until( std::chrono::steady_clock::time_point const& time_point) noexcept override;
+
+	void notify() noexcept override;
+};
+
+}}}
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+
+#endif // BOOST_FIBERS_ALGO_SHARED_WORK_H

install/boost_1_75_0/include/boost/fiber/algo/work_stealing.hpp

@@ -0,0 +1,88 @@
+
+//          Copyright Oliver Kowalke 2015.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_FIBERS_ALGO_WORK_STEALING_H
+#define BOOST_FIBERS_ALGO_WORK_STEALING_H
+
+#include <atomic>
+#include <condition_variable>
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <mutex>
+#include <vector>
+
+#include <boost/config.hpp>
+#include <boost/intrusive_ptr.hpp>
+
+#include <boost/fiber/algo/algorithm.hpp>
+#include <boost/fiber/context.hpp>
+#include <boost/fiber/detail/config.hpp>
+#include <boost/fiber/detail/context_spinlock_queue.hpp>
+#include <boost/fiber/detail/context_spmc_queue.hpp>
+#include <boost/fiber/scheduler.hpp>
+
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+
+namespace boost {
+namespace fibers {
+namespace algo {
+
+class BOOST_FIBERS_DECL work_stealing : public algorithm {
+private:
+    static std::atomic< std::uint32_t >                     counter_;
+    static std::vector< intrusive_ptr< work_stealing > >    schedulers_;
+
+    std::uint32_t                                           id_;
+    std::uint32_t                                           thread_count_;
+#ifdef BOOST_FIBERS_USE_SPMC_QUEUE
+    detail::context_spmc_queue                              rqueue_{};
+#else
+    detail::context_spinlock_queue                          rqueue_{};
+#endif
+    std::mutex                                              mtx_{};
+    std::condition_variable                                 cnd_{};
+    bool                                                    flag_{ false };
+    bool                                                    suspend_;
+
+    static void init_( std::uint32_t, std::vector< intrusive_ptr< work_stealing > > &);
+
+public:
+    work_stealing( std::uint32_t, bool = false);
+
+    work_stealing( work_stealing const&) = delete;
+    work_stealing( work_stealing &&) = delete;
+
+    work_stealing & operator=( work_stealing const&) = delete;
+    work_stealing & operator=( work_stealing &&) = delete;
+
+    void awakened( context *) noexcept override;
+
+    context * pick_next() noexcept override;
+
+    virtual context * steal() noexcept {
+        return rqueue_.steal();
+    }
+
+    bool has_ready_fibers() const noexcept override {
+        return ! rqueue_.empty();
+    }
+
+    void suspend_until( std::chrono::steady_clock::time_point const&) noexcept override;
+
+    void notify() noexcept override;
+};
+
+}}}
+
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+
+#endif // BOOST_FIBERS_ALGO_WORK_STEALING_H