{"id":4767,"date":"2016-05-26T14:19:08","date_gmt":"2016-05-26T14:19:08","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/asynchronous-function-calls\/"},"modified":"2023-06-26T12:56:05","modified_gmt":"2023-06-26T12:56:05","slug":"asynchronous-function-calls","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/asynchronous-function-calls\/","title":{"rendered":"Asynchronous Function Calls"},"content":{"rendered":"

std:.async<\/span> feels like an asynchronous function call. Under the hood std::async<\/span> is a task.<\/a> One, which is extremely easy to use.<\/p>\n

<\/p>\n

std::async<\/h2>\n

std::async<\/span> gets a callable as a work package. In this example, it’s a function, a function object, or a lambda function. <\/p>\n

<\/p>\n

\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38<\/pre>\n<\/td>\n
\n
\/\/ async.cpp<\/span>\r\n\r\n#include <future><\/span>\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n\r\nstd::string helloFunction(const<\/span> std::string& s){\r\n  return<\/span> \"Hello C++11 from \"<\/span> + s + \".\"<\/span>;\r\n}\r\n\r\nclass<\/span> HelloFunctionObject<\/span>{\r\n  public:\r\n    std::string operator<\/span>()(const<\/span> std::string& s) const<\/span> {\r\n      return<\/span> \"Hello C++11 from \"<\/span> + s + \".\"<\/span>;\r\n    }\r\n};\r\n\r\nint<\/span> main(){\r\n\r\n  std::cout << std::endl;\r\n\r\n  \/\/ future with function<\/span>\r\n  auto<\/span> futureFunction= std::async(helloFunction,\"function\"<\/span>);\r\n\r\n  \/\/ future with function object<\/span>\r\n  HelloFunctionObject helloFunctionObject;\r\n  auto<\/span> futureFunctionObject= std::async(helloFunctionObject,\"function object\"<\/span>);\r\n\r\n  \/\/ future with lambda function<\/span>\r\n  auto<\/span> futureLambda= std::async([](const<\/span> std::string& s ){return<\/span> \"Hello C++11 from \"<\/span> + s + \".\"<\/span>;},\"lambda function\"<\/span>);\r\n\r\n  std::cout << futureFunction.get() << \"\\n\"<\/span> \r\n\t    << futureFunctionObject.get() << \"\\n\"<\/span> \r\n\t    << futureLambda.get() << std::endl;\r\n\r\n  std::cout << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
The program execution is not so exciting.<\/p>\n
 \"async\"<\/p>\n
The future gets a function (line 23), a function object (line 27), and a lambda function (line 30). In the end, each future requests its value (line 32).<\/p>\n
And again, a little bit more formal. The std::async<\/span> calls in lines 23, 27, and 30 create a data channel <\/a>between the two endpoints’ future and promise. The promise immediately starts to execute its work package. But that is only the default behavior. By the get call, the future requests the result of Its work packages.<\/p>\n<\/p>\n
Eager or lazy evaluation<\/h2>\n
Eager or lazy evaluation are two orthogonal strategies to calculate the result of an expression. In the case of eager evaluation<\/a>, the expression will immediately be evaluated; in the case of lazy evaluation<\/a>, the expression will only be evaluated if needed. Often lazy evaluation is called call-by-need. With lazy evaluation, you save time and compute power because there is no evaluation on suspicion. An expression can be a mathematical calculation, a function, or a std::async<\/span> call. <\/p>\n
By default, std::async executed its work package immediately. The C++ runtime decides if the calculation happens in the same or a new thread. With the flag std::launch::async<\/span> std::async<\/span> will run its work package in a new thread. In opposition to that, the flag std::launch::deferred expresses that std::async runs in the same thread. The execution is, in this case, lazy. That implies that the eager evaluations start immediately, but the lazy evaluation with the policy std::launch::deferred<\/span> starts when the future asks for the value with its get call. <\/p>\n
The program shows different behavior.
<\/span><\/span> <\/span> <\/span><\/p>\n
<\/p>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30<\/pre>\n<\/td>\n
\n
\/\/ asyncLazy.cpp<\/span>\r\n\r\n#include <chrono><\/span>\r\n#include <future><\/span>\r\n#include <iostream><\/span>\r\n\r\nint<\/span> main(){\r\n\r\n  std::cout << std::endl;\r\n\r\n  auto<\/span> begin= std::chrono::system_clock::now();\r\n\r\n  auto<\/span> asyncLazy=std::async(std::launch::deferred,[]{ return<\/span>  std::chrono::system_clock::now();});\r\n\r\n  auto<\/span> asyncEager=std::async( std::launch::async,[]{ return<\/span>  std::chrono::system_clock::now();});\r\n\r\n  std::this_thread::sleep_for(std::chrono::seconds(1));\r\n\r\n  auto<\/span> lazyStart= asyncLazy.get() - begin;\r\n  auto<\/span> eagerStart= asyncEager.get() - begin;\r\n\r\n  auto<\/span> lazyDuration= std::chrono::duration<double<\/span>>(lazyStart).count();\r\n  auto<\/span> eagerDuration=  std::chrono::duration<double<\/span>>(eagerStart).count();\r\n\r\n  std::cout << \"asyncLazy evaluated after : \"<\/span> << lazyDuration << \" seconds.\"<\/span> << std::endl;\r\n  std::cout << \"asyncEager evaluated after: \"<\/span> << eagerDuration << \" seconds.\"<\/span> << std::endl;\r\n\r\n  std::cout << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
Both std::async<\/span> calls (lines 13 and 15) return the current time point. But the first call is lazy, the second greedy. The short sleep of one second in line 17 makes that obvious. By the call asyncLazy.get()<\/span> in line 19, the result will be available after a short nap.  This is not true for asyncEager. asyncEager.get()<\/span> gets the result from the immediately executed work package.<\/p>\n
\"asyncLazy\"<\/p>\n
A bigger computing job<\/h2>\n
std::async<\/span> is quite convenient to put a bigger compute job on more shoulders. So, the scalar product is calculated in the program with four asynchronous function calls.<\/p>\n
<\/p>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45\r\n46\r\n47\r\n48\r\n49\r\n50\r\n51\r\n52\r\n53<\/pre>\n<\/td>\n
\n
\/\/ dotProductAsync.cpp<\/span>\r\n\r\n#include <chrono><\/span>\r\n#include <iostream><\/span>\r\n#include <future><\/span>\r\n#include <random><\/span>\r\n#include <vector><\/span>\r\n#include <numeric><\/span>\r\n\r\nstatic<\/span> const<\/span> int<\/span> NUM= 100000000;\r\n\r\nlong<\/span> long<\/span> getDotProduct(std::vector<int<\/span>>& v, std::vector<int<\/span>>& w){\r\n\r\n  auto<\/span> future1= std::async([&]{return<\/span> std::inner_product(&v[0],&v[v.size()\/4],&w[0],0LL);});\r\n  auto<\/span> future2= std::async([&]{return<\/span> std::inner_product(&v[v.size()\/4],&v[v.size()\/2],&w[v.size()\/4],0LL);});\r\n  auto<\/span> future3= std::async([&]{return<\/span> std::inner_product(&v[v.size()\/2],&v[v.size()*3\/4],&w[v.size()\/2],0LL);});\r\n  auto<\/span> future4= std::async([&]{return<\/span> std::inner_product(&v[v.size()*3\/4],&v[v.size()],&w[v.size()*3\/4],0LL);});\r\n\r\n  return<\/span> future1.get() + future2.get() + future3.get() + future4.get();\r\n}\r\n\r\n\r\nint<\/span> main(){\r\n\r\n  std::cout << std::endl;\r\n\r\n  \/\/ get NUM random numbers from 0 .. 100<\/span>\r\n  std::random_device seed;\r\n\r\n  \/\/ generator<\/span>\r\n  std::mt19937 engine(seed());\r\n\r\n  \/\/ distribution<\/span>\r\n  std::uniform_int_distribution<int<\/span>> dist(0,100);\r\n\r\n  \/\/ fill the vectors<\/span>\r\n  std::vector<int<\/span>> v, w;\r\n  v.reserve(NUM);\r\n  w.reserve(NUM);\r\n  for<\/span> (int<\/span> i=0; i< NUM; ++i){\r\n    v.push_back(dist(engine));\r\n    w.push_back(dist(engine));\r\n  }\r\n\r\n  \/\/ measure the execution time<\/span>\r\n  std::chrono::system_clock::time_point start = std::chrono::system_clock::now();\r\n  std::cout << \"getDotProduct(v,w): \"<\/span> << getDotProduct(v,w) << std::endl;\r\n  std::chrono::duration<double<\/span>> dur  = std::chrono::system_clock::now() - start;\r\n  std::cout << \"Parallel Execution: \"<\/span><< dur.count() << std::endl;\r\n\r\n  std::cout << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
The program uses the functionality of the random and time library. Both libraries are part of C++11. The vectors v and w are created and filled with a random number in lines 27 – 43.  Each vector gets (lines 40 – 43) a hundred million elements. dist(engine)<\/span> in lines 41 and 42 generated random numbers uniformly distributed from 0 to 100. The current calculation of the scalar product takes place in the function getDotProduct<\/span> (lines 12 – 20). std::async<\/span> uses the standard template library algorithm std::inner_product internally. <\/span>The return statement sums up the results of the futures.<\/p>\n
It takes about 0.4 seconds to calculate the result on my PC.<\/p>\n
\"dotProductAsync\"<\/p>\n
But now the question is. How fast is the program if I executed it on one core? A slight modification of the function getDotProduct<\/span>, and we know the truth.<\/p>\n
\n

long<\/span> long<\/span> getDotProduct(std::vector<int<\/span>>& v,std::vector<int<\/span>>& w){\r\n  return<\/span> std::inner_product(v.begin(),v.end(),w.begin(),0LL);\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The execution of the program is four times slower.<\/p>\n
 <\/p>\n
\"dotProduct\"<\/p>\n
Optimization<\/h3>\n
But, if I compile the program with maximal optimization level O3 with my GCC, the performance difference is nearly gone. The parallel execution is about 10 percent faster.<\/p>\n
 <\/p>\n
\"dotProductComparisonOptimization\"<\/p>\n
What’s next?<\/h2>\n
In the next post, <\/a>I will show you how to parallelize a big compute job by using std::packaged_task. (Proofreader Alexey <\/strong>Elymanov<\/strong>)<\/span><\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n<\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
std:.async feels like an asynchronous function call. Under the hood std::async is a task. One, which is extremely easy to use.<\/p>\n","protected":false},"author":21,"featured_media":4762,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[366],"tags":[524,446],"class_list":["post-4767","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-multithreading","tag-async","tag-tasks"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4767","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=4767"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4767\/revisions"}],"predecessor-version":[{"id":6977,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4767\/revisions\/6977"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/4762"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=4767"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=4767"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=4767"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}