Notice: Function _load_textdomain_just_in_time was called incorrectly. Translation loading for the ga-google-analytics domain was triggered too early. This is usually an indicator for some code in the plugin or theme running too early. Translations should be loaded at the init action or later. Please see Debugging in WordPress for more information. (This message was added in version 6.7.0.) in /home/posttrau/public_html/mdtWordpress/wp-includes/functions.php on line 6121
Notice: Function _load_textdomain_just_in_time was called incorrectly. Translation loading for the themeisle-companion domain was triggered too early. This is usually an indicator for some code in the plugin or theme running too early. Translations should be loaded at the init action or later. Please see Debugging in WordPress for more information. (This message was added in version 6.7.0.) in /home/posttrau/public_html/mdtWordpress/wp-includes/functions.php on line 6121
Notice: Function _load_textdomain_just_in_time was called incorrectly. Translation loading for the foxiz-core domain was triggered too early. This is usually an indicator for some code in the plugin or theme running too early. Translations should be loaded at the init action or later. Please see Debugging in WordPress for more information. (This message was added in version 6.7.0.) in /home/posttrau/public_html/mdtWordpress/wp-includes/functions.php on line 6121
Notice: Function _load_textdomain_just_in_time was called incorrectly. Translation loading for the hestia domain was triggered too early. This is usually an indicator for some code in the plugin or theme running too early. Translations should be loaded at the init action or later. Please see Debugging in WordPress for more information. (This message was added in version 6.7.0.) in /home/posttrau/public_html/mdtWordpress/wp-includes/functions.php on line 6121 Async programming with C++11 - My Day To-Do
Asynchronous programming is a wonderfull thing is it not? Async programming with C++11 even more so. However that only applies if it is used in a controlled manner. Given the advantages that it offers it can potentially be very easy to get into the swing of it all and make an entire application async and ending up in debugging hell in the event of unexpected application behaviour.
So why am i talking about aync? ok so let me get one thing clear, when i say async i strictly mean non-blocking, because you can make an async call and have your program wait on the function to finish doing its task, however in that case you are no longer doing what you set out to do. Ok i guess am just dragging this out, well i get the point , enough foreplay, now on to business!Since my research work is mostly all C++, i reached a stage in my research where i had to adopt an asynchronous (non-blocking) approach at solving one of my research problems. Which had me to go on the hunt for the best possible means to accomplish this in C++. So given my self-made rules to minimize dependencies, i started looking into the Async model which is part of the new C++ standard.
Believe me i was very very tempted to go down the third-party library pathway i.e. Asio which provides you with both boost and non-boost options.
http://think-async.com/
However in the interest of confirming to my self-made rules i decided to give the new C++ libraries a spin and surprisingly it is very very simple. I cant believe i am saying this but it is almost as simple (if not simpler) to do async with C++ as it is with Java.
Problem
So this is what i wanted to accomplish,
write 2 functions A and B
Function A goes on for a long long time
Function B performs a short simple task
Start executing function A
Invoke B from A
A keeps on running while B doing its job
at some point when B finishes A acknowledges it and continues doing its processing
Sounds complicated? bear with me a little longer and i will make things clearer
Equipment used
Ubuntu 10.04 to 12.04: i have tried it on most of the Ubuntu versions
g++ 4.6: this is the only compiler that i have tried this on, 10.04 comes with g++4.4 by default in which case you need to install the new version using apt-get install g++-4.6.
A text editor
While this implementation was done under Linux i am sure it can be ported accross to any OS with a compiler that supports c++0x
Async programming with C++11
#include <future>
#include <iostream>
using namespace std;
bool finito = false;//this is the shared variable which will pass messages between the 2 functions
int value;
mutex m; // mutex is simply a way to enforce locking on a shared piece of data
bool countToTen()//think of this as the function B
{
/*lets do something so we can demonstrate that the function takes
time to finish*/
for(int counter=0;counter<10;counter++)
{
/ /cout<<"counter from(async):"<<(i+1)<<endl;
}
/*lets acquire a lock on the finito variable
we do not need to worry about unlocking it
as the lock_guard already takes care of that for us
*/
lock_guard<std::mutex> lk(m);
finito = true;
return finito;
}
int main()//think of this as the function A
{
/*the launch policies are launch::async and launch::sync
which are both self-explanatory.
*/
future<bool> done = async(std::launch::async,countToTen);
cout<<"Now we are going to start counting...."<<endl;
for(int counter=0;counter<100000;counter++)
{
/*do something meaningfull....
In my case i was looping through frames of a video
*/
/* Instead of accessing finito directly we can also access it via the future
done.get(), the future is a neat little thing that holds the return value of your
function, so when the function is done you can access it via the get method
*/
if(finito)
{
value+=counter;
cout<<"ok so we have finished the function"<<endl;
cout<<"this is where we got upto:"<<value<<" before countToTen finished";
cout<<endl;
break;//ok we are done so lets get out of here
}
}
}
Compiling the code above
So you need to keep a few steps in mind since the new threading functionality is still experimental and you need to specify that use of these new functions when compiling the code. It can be compiled using the following commands
g++ -std=c++0x –pthread -o yourasyncdemo yourasyncdemo.cpp-std: c++0x, so you are using the extensions to the standard library which are part of c++0x-pthread: so we are including the thread library
If you find any of my posts useful and want to support me, you can buy me a coffee 🙂https://www.buymeacoffee.com/bhumansoniOr you can buying or even try one of my apps on the App Store.
About pointers and references…. about two and a half years ago, i would have never imagined myself writing anything about pointers or let alone be at a stage where i am no longer intimidated by Read more…
In one of my projects, I had the need to call a Java function from a C++ class and somewhat surprisingly it was more complicated than I initially expected it to be. Arguably there are Read more…
0 Comments