Based on the following it looks like coroutines in C++20 will be stackless. 

https://en.cppreference.com/w/cpp/language/coroutines

I&#39;m concerned for many reasons:

 1. On embedded systems heap allocation is often not acceptable.
 2. When in low level code, nesting of co_await would be useful (I don&#39;t believe stackless co-routines allow this).

&gt; With a stackless coroutine, only the top-level routine may be
&gt; suspended. Any routine called by that top-level routine may not itself
&gt; suspend. This prohibits providing suspend/resume operations in
&gt; routines within a general-purpose library.

https://www.boost.org/doc/libs/1_57_0/libs/coroutine/doc/html/coroutine/intro.html#coroutine.intro.stackfulness

 3. More verbose code because of the need for custom allocators and memory pooling.

 4. Slower if the task waits for the operating system to allocate it some memory (without memory pooling).

Given these reasons, I&#39;m really hoping I&#39;m very wrong about what the current coroutines are.

The question has three parts:

 1. Why would C++ choose to use stackless coroutines?
 2. Regarding allocations to save state in stackless coroutines. Can I use alloca() to avoid any heap allocations that would normally be used for the coroutine creation. 

&gt; coroutine state is allocated on the heap via non-array
&gt; operator new.
https://en.cppreference.com/w/cpp/language/coroutines

 3. Are my assumptions about the c++ coroutines wrong, why?

EDIT:

I&#39;m going through the cppcon talks for the coroutines now, if I find any answers to my own question I&#39;ll post it (nothing so far).

*CppCon 2014: Gor Nishanov &quot;await 2.0: Stackless Resumable Functions&quot;*

https://www.youtube.com/watch?v=KUhSjfSbINE

*CppCon 2016: James McNellis “Introduction to C++ Coroutines&quot;*

https://www.youtube.com/watch?v=ZTqHjjm86Bw


All C++ Coroutine Solutions on Gang of Coders

Total of 1 C++ Coroutine Solutions

Are stackless C++20 coroutines a problem?