threading_module.h

Go to the documentation of this file.

#pragma once
 
#include <future>
#include <utility>
#include "../api_status.h"
#include "init_threading_params.h"
#include "type_aliases.h"
#include "async_task.h"
 
namespace cl::threading {
    template <typename T> class async_result;
    template <typename T> async_result<T> schedule_work(const typed_work<T>& work);
 
    namespace internal {
        template<typename T>
        async_handler create_task_handler(const cl::threading::typed_work<T>& work);
 
        async_handler create_task_handler(const cl::threading::typed_work<void>& work);
    }
 
    scheduler* get_scheduler();
 
    api_status init(const init_threading_params& p);
 
    api_status shutdown();
 
    template <typename TIn>
    class async_result {
    private:
        std::shared_future<TIn> future;
 
    public:
        explicit async_result(const std::shared_future<TIn>& future)
            : future{future} {}
 
        template <typename TOut>
        async_result<TOut> then(typed_callback<TIn, TOut> f) const {
            return schedule_work<TOut>([fut=future, f]() {
                const auto value = fut.get();
                return f(value);
            });
        }
 
        TIn wait() const {
            return future.get();
        }
    };
 
    template <>
    class async_result<void> {
    private:
        std::shared_future<void> future;
 
    public:
        explicit async_result(std::shared_future<void>  future)
                : future{std::move(future)} {}
 
        template <typename TOut>
        async_result<TOut> then(typed_void_callback<TOut> f) const {
            return schedule_work<TOut>([fut=future, f]() {
                fut.wait();
                return f();
            });
        }
 
        void wait() const {
            future.wait();
        }
    };
 
    template <typename T>
    async_handler internal::create_task_handler(const cl::threading::typed_work<T>& work) {
        return [work](async_task* t) {
            auto value = work();
            ((async_task_t<T>*)t)->promise.set_value(value);
        };
    }
 
    template<typename T>
    async_result<T> schedule_work(const cl::threading::typed_work<T>& work) {
        using typed_task = async_task_t<T>;
        auto task = std::make_unique<typed_task>();
        auto future = task->promise.get_future();
 
        // Set the work to be run on a separate thread
        task->exec = internal::create_task_handler(work);
 
        // Schedule the task on the next available thread
        async_worker* w{nullptr};
        const auto sched = get_scheduler();
        sched->next(&w);
        w->schedule(std::move(task));
 
        return async_result<T>(future.share());
    }
}