Context Navigation

-              r627dc41
+              ra95e75e
 #define LIBCPP_BITS_THREAD_FUTURE
-#include <__bits/functional/function.hpp>
-#include <__bits/functional/invoke.hpp>
-#include <__bits/refcount_obj.hpp>
-#include <__bits/thread/threading.hpp>
 #include <cassert>
 #include <memory>
 …
     };
-    enum class launch
+    {
-        async,
-        deferred
-    };
     enum class future_status
+    {
 …
     /**
+     * 30.6.4, shared state:
+     */
+    namespace aux
+    {
+        template<class R>
+        class shared_state: public aux::refcount_obj
+        {
+            public:
+                shared_state()
+                    : mutex_{}, condvar_{}, value_{}, value_set_{false},
+                      exception_{}, has_exception_{false}
+                {
+                    threading::mutex::init(mutex_);
+                    threading::condvar::init(condvar_);
+                }
+                void destroy() override
+                {
+                    /**
+                     * Note: No need to act in this case, async shared
+                     *       state is the object that needs to sometimes
+                     *       invoke its payload.
+                     */
+                }
+                void set_value(const R& val, bool set)
+                {
+                    /**
+                     * Note: This is the 'mark ready' move described
+                     *       in 30.6.4 (6).
+                     */
+                    aux::threading::mutex::lock(mutex_);
+                    value_ = val;
+                    value_set_ = set;
+                    aux::threading::mutex::unlock(mutex_);
+                    aux::threading::condvar::broadcast(condvar_);
+                }
+                void set_value(R&& val, bool set = true)
+                {
+                    aux::threading::mutex::lock(mutex_);
+                    value_ = std::move(val);
+                    value_set_ = set;
+                    aux::threading::mutex::unlock(mutex_);
+                    aux::threading::condvar::broadcast(condvar_);
+                }
+                void mark_set(bool set = true) noexcept
+                {
+                    value_set_ = set;
+                }
+                bool is_set() const noexcept
+                {
+                    return value_set_;
+                }
+                R& get()
+                {
+                    return value_;
+                }
+                void set_exception(exception_ptr ptr)
+                {
+                    exception_ = ptr;
+                    has_exception_ = true;
+                }
+                bool has_exception() const noexcept
+                {
+                    return has_exception_;
+                }
+                void throw_stored_exception() const
+                {
+                    // TODO: implement
+                }
+                /**
+                 * TODO: This member function is supposed to be marked
+                 *       as 'const'. In such a case, however, we cannot
+                 *       use the underlying fibril API because these
+                 *       references get converted to pointers and the API
+                 *       does not accept e.g. 'const fibril_condvar_t*'.
+                 *
+                 *       The same applies to the wait_for and wait_until
+                 *       functions.
+                 */
+                virtual void wait()
+                {
+                    aux::threading::mutex::lock(mutex_);
+                    while (!value_set_)
+                        aux::threading::condvar::wait(condvar_, mutex_);
+                    aux::threading::mutex::unlock(mutex_);
+                }
+                template<class Rep, class Period>
+                bool wait_for(const chrono::duration<Rep, Period>& rel_time)
+                {
+                    aux::threading::mutex::lock(mutex_);
+                    aux::threading::condvar::wait_for(
+                        condvar_, mutex_,
+                        aux::threading::time::convert(rel_time)
+                    );
+                    aux::threading::mutex::unlock(mutex_);
+                    return value_set_;
+                }
+                template<class Clock, class Duration>
+                bool wait_until(const chrono::time_point<Clock, Duration>& abs_time)
+                {
+                    aux::threading::mutex::lock(mutex_);
+                    aux::threading::condvar::wait_for(
+                        condvar_, mutex_,
+                        aux::threading::time::convert(abs_time - Clock::now())
+                    );
+                    aux::threading::mutex::unlock(mutex_);
+                    return value_set_;
+                }
+                ~shared_state() override = default;
+            private:
+                aux::mutex_t mutex_;
+                aux::condvar_t condvar_;
+                R value_;
+                bool value_set_;
+                exception_ptr exception_;
+                bool has_exception_;
+        };
+        /**
+         * We could make one state for both async and
+         * deferred policies, but then we would be wasting
+         * memory and the only benefit would be the ability
+         * for additional implementation defined policies done
+         * directly in that state (as opposed to making new
+         * states for them).
+         *
+         * But since we have no plan (nor need) to make those,
+         * this approach seems to be the best one.
+         * TODO: Override wait_for and wait_until in both!
+         */
+        template<class R, class F, class... Args>
+        class async_shared_state: public shared_state<R>
+        {
+            public:
+                async_shared_state(F&& f, Args&&... args)
+                    : shared_state<R>{}, thread_{}
+                {
+                    thread_ = thread{
+                        [=](){
+                            try
+                            {
+                                this->set_value(invoke(f, args...));
+                            }
+                            catch(...) // TODO: Any exception.
+                            {
+                                // TODO: Store it.
+                            }
+                        }
+                    };
+                }
+                void destroy() override
+                {
+                    if (!this->is_set())
+                        thread_.join();
+                }
+                void wait() override
+                {
+                    if (!this->is_set())
+                        thread_.join();
+                }
+                ~async_shared_state() override
+                {
+                    destroy();
+                }
+            private:
+                thread thread_;
+        };
+        template<class R, class F, class... Args>
+        class deferred_shared_state: public shared_state<R>
+        {
+            public:
+                template<class G>
+                deferred_shared_state(G&& f, Args&&... args)
+                    : shared_state<R>{}, func_{forward<F>(f)},
+                      args_{forward<Args>(args)...}
+                { /* DUMMY BODY */ }
+                void destroy() override
+                {
+                    if (!this->is_set())
+                        invoke_(make_index_sequence<sizeof...(Args)>{});
+                }
+                void wait() override
+                {
+                    // TODO: Should these be synchronized for async?
+                    if (!this->is_set())
+                        invoke_(make_index_sequence<sizeof...(Args)>{});
+                }
+                ~deferred_shared_state() override
+                {
+                    destroy();
+                }
+            private:
+                function<R(decay_t<Args>...)> func_;
+                tuple<decay_t<Args>...> args_;
+                template<size_t... Is>
+                void invoke_(index_sequence<Is...>)
+                {
+                    try
+                    {
+                        this->set_value(invoke(move(func_), get<Is>(move(args_))...));
+                    }
+                    catch(...)
+                    {
+                        // TODO: Store it.
+                    }
+                }
+        };
+    }
+    template<class R>
+    class future;
+    template<class R>
+    class promise
+    {
+        public:
+            promise()
+                : state_{new aux::shared_state<R>{}}
+            { /* DUMMY BODY */ }
+            template<class Allocator>
+            promise(allocator_arg_t, const Allocator& a)
+                : promise{}
+            {
+                // TODO: Use the allocator.
+            }
+            promise(promise&& rhs) noexcept
+                : state_{}
+            {
+                state_ = rhs.state_;
+                rhs.state_ = nullptr;
+            }
+            promise(const promise&) = delete;
+            ~promise()
+            {
+                abandon_state_();
+            }
+            promise& operator=(promise&& rhs) noexcept
+            {
+                abandon_state_();
+                promise{std::move(rhs)}.swap(*this);
+            }
+            promise& operator=(const promise&) = delete;
+            void swap(promise& other) noexcept
+            {
+                std::swap(state_, other.state_);
+            }
+            future<R> get_future()
+            {
+                return future<R>{state_};
+            }
+            void set_value(const R& val)
+            {
+                if (!state_)
+                    throw future_error{make_error_code(future_errc::no_state)};
+                if (state_->is_set())
+                {
+                    throw future_error{
+                        make_error_code(future_errc::promise_already_satisfied)
+                    };
+                }
+                state_->set_value(val, true);
+            }
+            void set_value(R&& val)
+            {
+                if (!state_)
+                    throw future_error{make_error_code(future_errc::no_state)};
+                if (state_->is_set())
+                {
+                    throw future_error{
+                        make_error_code(future_errc::promise_already_satisfied)
+                    };
+                }
+                state_->set_value(std::forward<R>(val), true);
+            }
+            void set_exception(exception_ptr ptr)
+            {
+                assert(state_);
+                state_->set_exception(ptr);
+            }
+            void set_value_at_thread_exit(const R& val)
+            {
+                if (!state_)
+                    throw future_error{make_error_code(future_errc::no_state)};
+                if (state_->is_set())
+                {
+                    throw future_error{
+                        make_error_code(future_errc::promise_already_satisfied)
+                    };
+                }
+                state_->set_value(val, false);
+                // TODO: schedule it to be set as ready when thread exits
+            }
+            void set_value_at_thread_exit(R&& val)
+            {
+                if (!state_)
+                    throw future_error{make_error_code(future_errc::no_state)};
+                if (state_->is_set())
+                {
+                    throw future_error{
+                        make_error_code(future_errc::promise_already_satisfied)
+                    };
+                }
+                state_->set_value(std::forward<R>(val), false);
+                // TODO: schedule it to be set as ready when thread exits
+            }
+            void set_exception_at_thread_exit(exception_ptr)
+            {
+                // TODO: No exception handling, no-op at this time.
+            }
+        private:
+            void abandon_state_()
+            {
+                /**
+                 * Note: This is the 'abandon' move described in
+                 *       30.6.4 (7).
+                 * 1) If state is not ready:
+                 *   a) Store exception of type future_error with
+                 *      error condition broken_promise.
+                 *   b) Mark state as ready.
+                 * 2) Rekease the state.
+                 */
+            }
+            aux::shared_state<R>* state_;
+    };
+    template<class R>
+    class promise<R&>
+    {
+        // TODO: Copy & modify once promise is done.
+    };
+    template<>
+    class promise<void>
+    {
+        // TODO: Copy & modify once promise is done.
+    };
+    template<class R>
+    void swap(promise<R>& lhs, promise<R>& rhs) noexcept
+    {
+        lhs.swap(rhs);
+    }
+    template<class R, class Alloc>
+    struct uses_allocator<promise<R>, Alloc>: true_type
+    { /* DUMMY BODY */ };
+     * 30.6.6, class template future:
+     */
     template<class R>
 …
+            {
                 assert(state_);
+                if (state_->is_deffered_function)
+                    return future_status::deferred;
+                auto res = state_->wait_for(rel_time);
+                if (res)
+                    return future_status::ready;
+                else
+                    return future_status::timeout;
+                return state_->wait_for(rel_time);
+            }
 …
+            {
                 assert(state_);
+                if (state_->is_deffered_function)
+                    return future_status::deferred;
+                auto res = state_->wait_until(abs_time);
+                if (res)
+                    return future_status::ready;
+                else
+                    return future_status::timeout;
+                return state_->wait_until(abs_time);
+            }
 …
         // TODO: Copy & modify once future is done.
     };
-    // TODO: Make sure the move-future constructor of shared_future
-    //       invalidates the state (i.e. sets to nullptr).
-    template<class R>
-    class shared_future
+    {
-        // TODO: Copy & modify once future is done.
-    };
-    template<class R>
-    class shared_future<R&>
+    {
-        // TODO: Copy & modify once future is done.
-    };
-    template<>
-    class shared_future<void>
+    {
-        // TODO: Copy & modify once future is done.
-    };
-    template<class>
-    class packaged_task; // undefined
-    template<class R, class... Args>
-    class packaged_task<R(Args...)>
+    {
-        packaged_task() noexcept
-        {}
-        template<class F>
-        explicit packaged_task(F&& f)
-        {}
-        template<class F, class Allocator>
-        explicit packaged_task(allocator_arg_t, const Allocator& a, F&& f)
-        {}
-        ~packaged_task()
-        {}
-        packaged_task(const packaged_task&) = delete;
-        packaged_task& operator=(const packaged_task&) = delete;
-        packaged_task(packaged_task&& rhs)
-        {}
-        packaged_task& operator=(packaged_task&& rhs)
-        {}
-        void swap(packaged_task& other) noexcept
-        {}
-        bool valid() const noexcept
-        {}
-        future<R> get_future()
-        {}
-        void operator()(Args...)
-        {}
-        void make_ready_at_thread_exit(Args...)
-        {}
-        void reset()
-        {}
-    };
-    template<class R, class... Args>
-    void swap(packaged_task<R(Args...)>& lhs, packaged_task<R(Args...)>& rhs) noexcept
+    {
-        lhs.swap(rhs);
-    };
-    template<class R, class Alloc>
-    struct uses_allocator<packaged_task<R>, Alloc>: true_type
-    { /* DUMMY BODY */ };
-    namespace aux
+    {
-        /**
-         * Note: The reason we keep the actual function
-         *       within the aux namespace is that were the non-policy
-         *       version of the function call the other one in the std
-         *       namespace, we'd get resolution conflicts. This way
-         *       aux::async is properly called even if std::async is
-         *       called either with or without a launch policy.
-         */
-        template<class F, class... Args>
-        future<result_of_t<decay_t<F>(decay_t<Args>...)>>
-        async(launch policy, F&& f, Args&&... args)
+        {
-            using result_t = result_of_t<decay_t<F>(decay_t<Args>...)>;
-            bool async = (static_cast<int>(policy) &
-                          static_cast<int>(launch::async)) != 0;
-            bool deferred = (static_cast<int>(policy) &
-                             static_cast<int>(launch::deferred)) != 0;
-            /**
-             * Note: The case when async | deferred is set in policy
-             *       is implementation defined, feel free to change.
-             */
-            if (async && deferred)
+            {
-                return future<result_t>{
-                    new aux::deferred_shared_state<
-                        result_t, F, Args...
-                    >{forward<F>(f), forward<Args>(args)...}
-                };
+            }
-            else if (async)
+            {
-                return future<result_t>{
-                    new aux::async_shared_state<
-                        result_t, F, Args...
-                    >{forward<F>(f), forward<Args>(args)...}
-                };
+            }
-            else if (deferred)
+            {
-               /**
-                * Duplicated on purpose because of the default.
-                * Do not remove!
-                */
-                return future<result_t>{
-                    new aux::deferred_shared_state<
-                        result_t, F, Args...
-                    >{forward<F>(f), forward<Args>(args)...}
-                };
+            }
-            /**
-             * This is undefined behaviour, let's be nice though ;)
-             */
-            return future<result_t>{
-                new aux::deferred_shared_state<
-                    result_t, F, Args...
-                >{forward<F>(f), forward<Args>(args)...}
-            };
+        }
+    }
-    template<class F>
-    decltype(auto) async(F&& f)
+    {
-        launch policy = static_cast<launch>(
-            static_cast<int>(launch::async) |
-            static_cast<int>(launch::deferred)
-        );
-        return aux::async(policy, forward<F>(f));
+    }
-    /**
-     * The async(launch, F, Args...) and async(F, Args...)
-     * overloards must not collide, so we check the first template
-     * argument and handle the special case of just a functor
-     * above.
-     */
-    template<class F, class Arg, class... Args>
-    decltype(auto) async(F&& f, Arg&& arg, Args&&... args)
+    {
-        if constexpr (is_same_v<decay_t<F>, launch>)
-            return aux::async(f, forward<Arg>(arg), forward<Args>(args)...);
-        else
+        {
-            launch policy = static_cast<launch>(
-                static_cast<int>(launch::async) |
-                static_cast<int>(launch::deferred)
-            );
-            return aux::async(policy, forward<F>(f), forward<Arg>(arg), forward<Args>(args)...);
+        }
+    }
+}

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset a95e75e in mainline

Legend:

uspace/lib/cpp/include/__bits/thread/future.hpp

Download in other formats: