Question

After receiving answers to a previous question on logging on a different thread, I am currently at the following bit of code (note: the concurrent_queue here is from ppl, but any other concurrent_queue should work):

class concurrentFuncQueue
    {
    private:
        typedef std::function<void()> LambdaFunction;
        mutable concurrency::concurrent_queue<LambdaFunction> functionQueue;
        mutable std::atomic<bool> endcond;
        LambdaFunction function;
        std::thread thd;
    public:
        concurrentFuncQueue() : endcond(false), thd([=]{
            while (endcond != true)
            {
                if (functionQueue.try_pop( function ))
                {
                    function(); //note: I am popping a function and adding () to execute it
                }
            }
        }){}
        ~concurrentFuncQueue() { functionQueue.push([=]{ endcond = true; }); thd.join(); }
        void pushFunction(LambdaFunction function) const { functionQueue.push(function); }
    };

Basically the functions I push are run on a different thread sequentially (ex. a logging function) as to avoid performance issues on the main thread.

Current usage is along the following:

static concurrentFuncQueue Logger;
vector<char> outstring(256);
Logger.pushFunction([=]{ OutputDebugString(debugString.c_str()) });

Great so far. I can push functions on to a concurrent queue that will run my functions sequentially on a separate thread.

One thing I also need to have, but currently don’t are return values so that ex (pseudo-code):

int x = y = 3;
auto intReturn = Logger.pushFunction([=]()->int { return x * y; });

will push x * y on to the concurrent queue, and after the pop and completion of the function (on the other thread), returns the value calculated to the caller thread.

(I understand that I’ll be blocking the caller thread until the pushed function is returned. That is exactly what I want)

I get the feeling that I might have to use something along the line of std::promise, but sadly my current low understanding of them prevent me from formulating something codable.

Any ideas? Thoughts on the above C++ code and any other comments are also much welcome (please just ignore the code completely if you feel another implementation is more appropriate or solves the problem).

Answer 1

You should be able to use something along the lines of:

template<typename Foo>
std::future<typename std::result_of<Foo()>::type> pushFunction(Foo&& f) {
    using result_type = typename std::result_of<Foo()>::type; // change to typedef if using is not supported
    std::packaged_task<result_type()> t(f);
    auto ret_fut = t.get_future();
    functionQueue.push(std::move(t));
    return ret_fut;
}

For this to work you need to make your LambdaFunction a type-erased function handler.