I'm trying a program:
#include <iostream>
#include <thread>
#include <future>
int foo() {
return 0;
}
int main(int argc, char* argv[]) {
for (auto i = 0L; i < 10000; ++i) {
auto f = std::async(foo);
f.get();
}
return 0;
}
Compiler VS11 x64.
Build:
cl /EHsc /Zi async.cpp && async
For me this program crashes. I suspect, there is a limit in the number of futures physically running at the same time. If I reduce the number of iterations to a couple of orders, it works.
So, two questions:
Is there a limit of actually running futures in C++11?
Why does this code crash at all? If I explicitly do "get()" immediately after "async()", it must complete the future before the next iteration, which means only one future runs at a time.
UPDATE
I've simplified the code to:
#include <future>
int main(int argc, char* argv[]) {
for (auto i = 0L; i < 1000000; ++i) {
auto f = std::async([](){ return 0; });
f.get();
}
return 0;
}
And it still crashes for me. It doesn't throw, I've checked that. But now I have a visible stack trace:
async.exe!_Mtx_unlock(_Mtx_internal_imp_t * * mtx) Line 229 C++
async.exe!std::_Mtx_unlockX(_Mtx_internal_imp_t * * _Mtx) Line 84 C++
async.exe!std::_Mutex_base::unlock() Line 47 C++
async.exe!std::unique_lock<std::mutex>::~unique_lock<std::mutex>() Line 284 C++
async.exe!std::_Associated_state<int>::_Set_value(int && _Val, bool _At_thread_exit) Line 358 C++
async.exe!std::_Packaged_state<int __cdecl(void)>::_Call_immediate() Line 569 C++
async.exe!std::_Async_state<int>::`std::U_Nil::ain::ain'::`3'::<lambda_A200A86DFF9A63A1>::operator()() Line 700 C++
async.exe!??$_ApplyX@X@?$_Callable_obj@V<lambda_A200A86DFF9A63A1>@?2???$?0V?$_Bind@$0A@XV<lambda_23AC5A2FBB53FD4D>@?5?main@U_Nil@std@@U23@U23@U23@U23@U23@U23@@std@@@?$_Async_state@H@std@@QEAA@$$QEAV?$_Bind@$0A@XV<lambda_23AC5A2FBB53FD4D>@?5?main@U_Nil@std@@U23@U23@U23@U23@U23@U23@@3@@Z@$0A@@std@@QEAAXXZ() Line 420 C++
async.exe!?_Do_call@?$_Func_impl@U?$_Callable_obj@V<lambda_A200A86DFF9A63A1>@?2???$?0V?$_Bind@$0A@XV<lambda_23AC5A2FBB53FD4D>@?5?main@U_Nil@std@@U23@U23@U23@U23@U23@U23@@std@@@?$_Async_state@H@std@@QEAA@$$QEAV?$_Bind@$0A@XV<lambda_23AC5A2FBB53FD4D>@?5?main@U_Nil@std@@U23@U23@U23@U23@U23@U23@@3@@Z@$0A@@std@@V?$allocator@V?$_Func_class@XU_Nil@std@@U12@U12@U12@U12@U12@U12@@std@@@2@XU_Nil@2@U42@U42@U42@U42@U42@U42@@std@@UEAAXXZ() Line 217 C++
async.exe!std::_Func_class<void,std::_Nil,std::_Nil,std::_Nil,std::_Nil,std::_Nil,std::_Nil,std::_Nil>::operator()() Line 486 C++
async.exe!`Concurrency::details::_MakeVoidToUnitFunc'::`3'::<lambda_25D33530A43E1C90>::operator()() Line 1056 C++
async.exe!std::_Callable_obj<`Concurrency::details::_MakeVoidToUnitFunc'::`3'::<lambda_25D33530A43E1C90>,0>::_ApplyX<Concurrency::details::_Unit_type>() Line 420 C++
async.exe!std::_Func_impl<std::_Callable_obj<`Concurrency::details::_MakeVoidToUnitFunc'::`3'::<lambda_25D33530A43E1C90>,0>,std::allocator<std::_Func_class<Concurrency::details::_Unit_type,std::_Nil,std::_Nil,std::_Nil,std::_Nil,std::_Nil,std::_Nil,std::_Nil> >,Concurrency::details::_Unit_type,std::_Nil,std::_Nil,std::_Nil,std::_Nil,std::_Nil,std::_Nil,std::_Nil>::_Do_call() Line 217 C++
async.exe!std::_Func_class<Concurrency::details::_Unit_type,std::_Nil,std::_Nil,std::_Nil,std::_Nil,std::_Nil,std::_Nil,std::_Nil>::operator()() Line 486 C++
async.exe!`Concurrency::details::_Task_impl<Concurrency::details::_Unit_type>::_ScheduleTask'::`3'::<lambda_7D9BCD859405C05B>::operator()() Line 325 C++
async.exe!Concurrency::details::_PPLTaskHandle<`Concurrency::details::_Task_impl<Concurrency::details::_Unit_type>::_ScheduleTask'::`3'::<lambda_7D9BCD859405C05B> >::operator()() Line 72 C++
async.exe!Concurrency::details::_UnrealizedChore::_InvokeBridge<Concurrency::details::_PPLTaskHandle<`Concurrency::details::_Task_impl<Concurrency::details::_Unit_type>::_ScheduleTask'::`3'::<lambda_7D9BCD859405C05B> > >(Concurrency::details::_PPLTaskHandle<`Concurrency::details::_Task_impl<Concurrency::details::_Unit_type>::_ScheduleTask'::`3'::<lambda_7D9BCD859405C05B> > * _PChore) Line 4190 C++
async.exe!Concurrency::details::_UnrealizedChore::_UnstructuredChoreWrapper(Concurrency::details::_UnrealizedChore * pChore) Line 275 C++
async.exe!Concurrency::details::_PPLTaskChore::_DeletingChoreWrapper(Concurrency::details::_UnrealizedChore * pChore) Line 78 C++
async.exe!Concurrency::details::InternalContextBase::ExecuteChoreInline(Concurrency::details::WorkItem * pWork) Line 1600 C++
async.exe!Concurrency::details::InternalContextBase::Dispatch(Concurrency::DispatchState * pDispatchState) Line 1704 C++
async.exe!Concurrency::details::FreeThreadProxy::Dispatch() Line 191 C++
async.exe!Concurrency::details::ThreadProxy::ThreadProxyMain(void * lpParameter) Line 173 C++
kernel32.dll!0000000076df652d() Unknown
ntdll.dll!0000000076f2c521() Unknown
and threads:
Unflagged 1864 0 Worker Thread ntdll.dll thread ntdll.dll!0000000076f518ca Normal
Unflagged 10964 0 Main Thread Main Thread async.exe!do_signal Normal
Unflagged 7436 0 Worker Thread ntdll.dll thread ntdll.dll!0000000076f52c1a Normal
Unflagged 10232 0 Worker Thread async.exe!Concurrency::details::ThreadProxy::ThreadProxyMain async.exe!Concurrency::details::ThreadProxy::SuspendExecution Normal
Unflagged > 10624 0 Worker Thread async.exe!Concurrency::details::ThreadProxy::ThreadProxyMain async.exe!_Mtx_unlock Normal
Unflagged 4756 0 Worker Thread async.exe!Concurrency::details::ThreadProxy::ThreadProxyMain async.exe!Concurrency::details::ThreadProxy::SuspendExecution Normal
Unflagged 11100 0 Worker Thread async.exe!Concurrency::details::ThreadProxy::ThreadProxyMain async.exe!Concurrency::details::InternalContextBase::WaitForWork Normal
Unflagged 6440 0 Worker Thread async.exe!Concurrency::details::ThreadProxy::ThreadProxyMain async.exe!std::vector<std::pair<void (__cdecl*)(void * __ptr64),void * __ptr64>,std::allocator<std::pair<void (__cdecl*)(void * __ptr64),void * __ptr64> > >::_Tidy Normal
I'm using VS 11.0.40825.2 PREREL.
As the name indicates, C++ async is a function template fn, which takes functions or function objects as arguments (basically called callbacks) and runs them asynchronously. It returns the std:: the future object which is used to keep the result of the above function.
The function template async runs the function f asynchronously (potentially in a separate thread which might be a part of a thread pool) and returns a std::future that will eventually hold the result of that function call. 1) Behaves as if (2) is called with policy being std::launch::async | std::launch::deferred.
For now, we know that if no policy is specified, then std::async launches a callable function in a separate thread. However, the C++ standard does not specify whether the thread is a new one or reused from a thread pool. Let us see how each of the three implementations launches a callable function.
The class template std::future provides a mechanism to access the result of asynchronous operations: An asynchronous operation (created via std::async, std::packaged_task, or std::promise) can provide a std::future object to the creator of that asynchronous operation.
Obviously there are implementation limits, just like there's a limit to how big an array can be. std::async can signal an error 'resource_unavailable_try_again' if the launch policy is lauch::async and the system couldn't start a new thread. But you're not getting this error.
The program shouldn't crash and doesn't for me (VS11 x64, release build, same source and command line).
I believe that even without .get()
the program would not have more than one asynchronous operation going at once. You assign the future to a local variable the future is destroyed each loop iteration, forcing the asynchronous operation to complete before you start another one in the next loop iteration.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With