Yes it can be done without a problem. All you need is a little assembly code to move the call stack to a newly allocated stack on the heap. I would look at the boost::coroutine library. The one thing that you should watch out for is a stack overflow. On most operating systems overflowing the … Read more
First, thank you for taking a look at CO2 🙂 The Boost.Coroutine doc describes the advantage of stackful coroutine well: stackfulness In contrast to a stackless coroutine a stackful coroutine can be suspended from within a nested stackframe. Execution resumes at exactly the same point in the code where it was suspended before. With a … Read more
I’ll start with generators, seeing as they’re the simplest case. As @zvolkov mentioned, they’re functions/objects that can be repeatedly called without returning, but when called will return (yield) a value and then suspend their execution. When they’re called again, they will start up from where they last suspended execution and do their thing again. A … Read more
Javaflow is a continuation implementation, it will probably let you do that. It uses bytecode manipulation though. Anyway, it feels like you’re trying to do OOP with plain C. It’s doable but it doesn’t mean you should do it.
First read: Concurrency vs Parallelism – What is the difference? Concurrency is the separation of tasks to provide interleaved execution. Parallelism is the simultaneous execution of multiple pieces of work in order to increase speed. —https://github.com/servo/servo/wiki/Design Short answer: With threads, the operating system switches running threads preemptively according to its scheduler, which is an algorithm … Read more
As pointed in the comments, you could do it in a new thread, using Queue. The drawback is that you’d still need some way to access the final result (what fmin returns at the end). My example below uses an optional callback to do something with it (another option would be to just yield it … Read more
Generators exist in C++, just under another name: Input Iterators. For example, reading from std::cin is similar to having a generator of char. You simply need to understand what a generator does: there is a blob of data: the local variables define a state there is an init method there is a “next” method there … Read more
Actual info: Starting from Python 3.7 asyncio.create_task(coro) high-level function was added for this purpose. You should use it instead other ways of creating tasks from coroutimes. However if you need to create task from arbitrary awaitable, you should use asyncio.ensure_future(obj). Old info: ensure_future vs create_task ensure_future is a method to create Task from coroutine. It … Read more
When the server closes the connection, sock_recv returns an empty bytearray (b”), indicating end of file. Since you don’t handle that condition, your code ends up stuck in an infinite loop processing the same buffer. To correct it, add something like: if data == b”: break …after the data = await loop.sock_recv(…) line. But the … Read more
Coroutines and concurrency are largely orthogonal. Coroutines are a general control structure whereby flow control is cooperatively passed between two different routines without returning. The ‘yield’ statement in Python is a good example. It creates a coroutine. When the ‘yield ‘ is encountered the current state of the function is saved and control is returned … Read more