{"id":1901,"date":"2014-02-10T13:00:26","date_gmt":"2014-02-10T13:00:26","guid":{"rendered":"http:\/\/writeasync.net\/?p=1901"},"modified":"2014-02-10T10:00:36","modified_gmt":"2014-02-10T10:00:36","slug":"async-in-c-with-the-ppl","status":"publish","type":"post","link":"http:\/\/writeasync.net\/?p=1901","title":{"rendered":"Async in C++ with the PPL"},"content":{"rendered":"

The Parallel Patterns Library (PPL)<\/a> provides C++ developers with some very useful concurrency primitives along similar lines as Task parallelism in .NET. Having been introduced in Visual Studio 2010<\/a>, the PPL is not new by any means. However, it remains relatively obscure to many who dabble in native code.<\/p>\n

Similar to .NET, task<T><\/code><\/a> is the main star of the native async show. In contrast to C#, C++ allows the use of void<\/code> as a template parameter, so you can pass around task<void><\/code> instances.<\/p>\n

\r\n\/\/ MyAsyncWorker.h\r\n#include <ppltasks.h>\r\n\r\nclass MyAsyncWorker\r\n{\r\npublic:\r\n\/\/ ...\r\n    concurrency::task<void> DoWorkAsync();\r\n    concurrency::task<int> DoWorkWithResultAsync();\r\n};\r\n\r\n\/\/ Main.cpp\r\n#include "MyAsyncWorker.h"\r\n\r\nusing namespace concurrency;\r\n\r\n\/\/ ...\r\nMyAsyncWorker w;\r\ntask<void> t1 = w.DoWorkAsync();\r\n\r\n\/\/ does not return anything, but will throw if task has failed.\r\nt1.get();\r\n\r\ntask<int> t2 = w.DoWorkWithResultAsync();\r\n\r\n\/\/ Returns value or throws if task has failed.\r\nint v = t2.get();\r\n\r\n\/\/ ...\r\n<\/pre>\n
The PPL equivalent to TaskCompletionSource<\/code><\/a> is task_completion_event<\/code><\/a>. The API should look reasonably familiar, though note that there are no Try...<\/code> methods — instead the set...<\/code> methods all return bool<\/code> to indicate status. To set an exception, std::exception_ptr<\/code><\/a> is used; see the MSDN article “Transporting Exceptions Between Threads”<\/a> for more details.<\/p>\n
\r\n\/\/ MyAsyncWorker.cpp\r\ntask<void> MyAsyncWorker::DoWorkAsync()\r\n{\r\n    task_completion_event<void> tce;\r\n\r\n    \/\/ schedule some background work somehow...\r\n    StartBackgroundWork(tce);\r\n\r\n    \/\/ There is no 'get_task' method; instead create a task from the TCE instance\r\n    return task<void>(tce);\r\n}\r\n\r\n\/\/ ...\r\nvoid OnWorkCompleted(task_completion_event<void> tce)\r\n{\r\n    \/\/ Note that the set method for <void> takes no params\r\n    tce.set();\r\n}\r\n\r\nvoid OnWorkFailed(task_completion_event<void> tce, int errorCode)\r\n{\r\n    \/\/ Make an exception_ptr from our custom exception instance\r\n    tce.set_exception(make_exception_ptr(worker_error(errorCode)));\r\n}\r\n<\/pre>\n
As far as continuations go, the PPL is about on par with .NET 4.0 — that is, you won’t get much compiler code generation help or the niceties of async<\/code>\/await<\/code>. You’ll have to make do with then<\/code><\/a>, the ContinueWith<\/code><\/a> equivalent. Here is an example of a multi-step async method using an imaginary pipe\/buffer API. Note the use of std::shared_ptr<\/code><\/a> to manage heap objects so that they don’t go out of scope prematurely.<\/p>\n
\r\ntask<bool> ReadAndWriteAsync(Pipe & input, Pipe & output)\r\n{\r\n    shared_ptr<Buffer> buffer = make_shared<Buffer>();\r\n    return input.ReadAsync(*buffer).then([buffer, &output](task<unsigned int> t1)\r\n    {\r\n        unsigned int bytesRead = t1.get();\r\n        if (bytesRead == 0)\r\n        {\r\n            return task_from_result(false);\r\n        }\r\n\r\n        return output.WriteAsync(*buffer).then([](task<unsigned int> t2)\r\n        {\r\n            unsigned int bytesWritten = t2.get();\r\n            return bytesWritten > 0;\r\n        });\r\n    });\r\n}\r\n<\/pre>\n
There is no Task.Delay<\/code><\/a> in the PPL. Instead, you need to use timer<\/code><\/a> to set a task_completion_event<\/code> after a certain timeout. There is a sample covering this on MSDN<\/a>, but it is far easier to pick up the PPL Asynchronous Sample Pack<\/a> which includes a readymade implementation (create_delayed_task<\/code>) in the ppltasks_extra.h<\/code> header.<\/p>\n
\r\n#include "ppltasks_extra.h"\r\n\r\nusing namespace concurrency;\r\nusing namespace concurrency::extras;\r\n\/\/ ...\r\n\r\ntask<int> DelayForOneMillisecondAsync()\r\n{\r\n    return create_delayed_task(std::chrono::milliseconds(1), []()\r\n    {\r\n        return 42;\r\n    });\r\n}\r\n<\/pre>\n
To join on a group of tasks, PPL gives you when_all<\/code><\/a> and when_any<\/code><\/a> which are analogous to their .NET<\/a> namesakes<\/a> — with a C++ twist.<\/p>\n
\r\nvector<task<void>> tasks;\r\ntasks.push_back(Do1Async());\r\ntasks.push_back(Do2Async());\r\n\r\n\/\/ Need to pass begin\/end iterators\r\nwhen_all(tasks.begin(), tasks.end()).get();\r\n<\/pre>\n
Cooperative cancellation<\/a> is achieved with cancellation_token<\/code><\/a> and cancellation_token_source<\/code><\/a> which are, as expected, quite similar to their .NET<\/a> counterparts<\/a>.<\/p>\n
\r\ncancellation_token_source cts;\r\ntask<void> task = LoopForeverAsync(cts.get_token());\r\n\r\nwcout << L"Press ENTER to cancel." << endl;\r\nwstring line;\r\ngetline(wcin, line);\r\n\r\n\/\/ Request cancellation\r\ncts.cancel();\r\n\r\n\/\/ Task may complete with task_canceled exception\r\ntry\r\n{\r\n    task.get();\r\n}\r\ncatch (task_canceled const &)\r\n{\r\n}\r\n<\/pre>\n
Perhaps the most surprising aspect to those accustomed to async in .NET is that the default task scheduler<\/a> in the PPL does not support explicit synchronous continuations<\/strong>. Keep this in mind, especially when you are writing async unit tests — you may encounter unexpected thread switches.<\/p>\n
Overall, the PPL is a boon to C++ programmers who want to explore the wild world of async. In an upcoming post, I will show a more complete native async sample using the PPL.<\/p>\n","protected":false},"excerpt":{"rendered":"
The Parallel Patterns Library (PPL) provides C++ developers with some very useful concurrency primitives along similar lines as Task parallelism in .NET. Having been introduced in Visual Studio 2010, the PPL is not new by any means. However, it remains… <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[21,101],"tags":[],"class_list":["post-1901","post","type-post","status-publish","format-standard","hentry","category-async","category-native"],"_links":{"self":[{"href":"http:\/\/writeasync.net\/index.php?rest_route=\/wp\/v2\/posts\/1901","targetHints":{"allow":["GET"]}}],"collection":[{"href":"http:\/\/writeasync.net\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/writeasync.net\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/writeasync.net\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/writeasync.net\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=1901"}],"version-history":[{"count":0,"href":"http:\/\/writeasync.net\/index.php?rest_route=\/wp\/v2\/posts\/1901\/revisions"}],"wp:attachment":[{"href":"http:\/\/writeasync.net\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=1901"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/writeasync.net\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=1901"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/writeasync.net\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=1901"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}