C++11/14 how to create async task using function that return type is void or others

Question

I want to write a simple task class that similar to ppltasks.

I want my task class can create task as following:

1.CreateTask([=]{}).then([=]{...});
2.CreateTask([=]{ return X; }).then([=](UnknownType X){...});

But the function I want to run in task may have different type:void, float, string etc. And here is the key point:

auto val = func();    // If func is a void function
prms->set_value(val); // here should be: func(); prms->set_value();

How can I handle void function and other type function using same CreateTask?

Following is my full code of task class:

template
class Task
{
public:
    Task(){};
    std::future mTask;
    template
    auto then(F func)->Task
    {
        Task task;
        auto prms = make_shared>();
        task.mTask = prms->get_future();
        thread th([=]
        {
            auto val = func(mTask.get()); //
            prms->set_value(val);
        });
        th.detach();
        return task;
    });
};

inline void CreateTask(F func) -> Task
{
    Task task;
    auto prms = make_shared>();
    task.mTask = prms->get_future();
    thread th([=] 
    {
        auto val = func();
        prms->set_value(val);
    });
    th.detach();
    return task;
}

Yakk - Adam Nevraumont · Accepted Answer

Lets attack this via separation of concerns.

First, the problem of pipeing the output of one invokable to another:

template
auto get_nth( Index ) {
  return [](auto&&...args)noexcept(true)->decltype(auto) {
    return std::get(
      std::forward_as_tuple( decltype(args)(args)... )
    );
  };
}

template
struct pipeable_t;

template
pipeable_t> make_pipe(F&&);

struct is_pipeable {
    template<
        class Lhs, class Rhs,
        std::enable_if_t< 
            std::is_base_of>{}
            || std::is_base_of>{}
        , int> = 0
    >
    friend
    auto operator|( Lhs&& lhs, Rhs&& rhs ) {
        auto pipe_result=
            [lhs = std::forward(lhs), rhs=std::forward(rhs)]
            (auto&&...args)mutable ->decltype(auto) 
            {
                auto value_is_void = std::is_same< decltype( lhs(decltype(args)(args)...) ), void >{};
                auto pipe_chooser = get_nth( value_is_void );
                auto pipe_execution = pipe_chooser(
                    [&](auto&& lhs, auto&& rhs)->decltype(auto){ return rhs( lhs( decltype(args)(args)... ) ); },
                    [&](auto&& lhs, auto&& rhs)->decltype(auto){ lhs( decltype(args)(args)... ); return rhs(); }
                );
                return pipe_execution( lhs, rhs );
            };
        return make_pipe( std::move(pipe_result) );
    }
};

template
struct pipeable_t:is_pipeable {
    F f;
    pipeable_t( F fin ):f(std::forward(fin)) {}
    template
    auto operator()(Args&&...args) const {
        return f( std::forward(args)... );
    }
    template
    auto operator()(Args&&...args) {
        return f( std::forward(args)... );
    }
};

template
pipeable_t> make_pipe(F&& f) { return {std::forward(f)}; }

template
auto future_to_factory( std::future&& f ) {
    return [f=std::move(f)]() mutable { return f.get(); };
}

template
auto make_pipe( std::future&& f ) {
    return make_pipe( future_to_factory( std::move(f) ) );
}

we can make_pipe( some lambda ) and it can now be fed into more stuff.

A pipe is executable and pipeable itself. We can make anything executable a pipe, and we can make a std::future into a pipe.

Once we have this, we rewrite your Task in terms of it:

struct dispatch_via_async {
    template
    auto operator()(F&& f)const {
        return std::async( std::launch::async, std::forward(f) );
    }
};

template
class Task;

template
using task_type = Task>, D>;

template
task_type CreateTask(F&& func, D&& d={});

template
class Task :
    public is_pipeable, // why not?
    private Dispatch
{
    std::future mTask;

    Dispatch& my_dispatch() { return *this; }
public:
    T operator()() { return mTask.get(); }
    Task(){};
    template
    auto then(F&& func)&&
    {
        return CreateTask(
          make_pipe(std::move(mTask)) | std::forward(func),
          std::move(my_dispatch())
        );
    }

    template
    explicit Task( F&& func, D&& dispatch={} ):
        Dispatch(std::forward(dispatch))
    {
        mTask = my_dispatch()(
            [func = std::forward(func)]() mutable
            -> decltype(func())
            {
                return func();
            }
        );
    }
};

template
task_type CreateTask(F&& func, D&& d)
{
    return task_type( std::forward(func), std::forward(d) );
}

Here we carefully permit the dispatcher (how we get the future) to be passed into a Task if required. The .then'd continuations will use the dispatcher to create the chained futures.

Live example.

As a bonus, you now have a simple streaming chain-of-operations library.

Note that I replaced your thread based implementation with an async based one, because your system failed to properly wait for threads to terminate before program finished, which leads to undefined behavior. You can still replace that Dispatcher with one that uses threads.

In c++2a, Regular Void proposal attempts to get rid of the problem. I don't know how well it does the job.

The above doesn't build in current versions of MSVC because MSVC fails to be a proper c++14 compiler in that its async uses packaged task, its packaged task stores its tasks in a std function, which results in the async incorrectly requiring that the task being called by copyable as std::function type-erases copy.

This breaks the above code because we store a std::future in our async tasks, which cannot be copied.

We can fix this for a modest cost. The minimal most isolated way to do it is to change future_to_factory to:

template
auto future_to_factory( std::future&& f ) {
    return [f=std::make_shared>(std::move(f))]() mutable { return f->get(); };
}

and the code compiles on visual studio.

C++11/14 how to create async task using function that return type is void or others

Answers (1)

Related Questions