Hacker Read

Rochus · 2022-08-27 05:51:29

Because of pjmlp's hint I just looked into the repositories https://github.com/btreut/a2 and https://github.com/metacore/A2OS, but didn't find a coroutines module. I'm aware that Active Oberon (Patrik Reali, 2004) includes concurrency, but this is a different language than the one used for System 3.

dpratt | karma 696 | avg karma 4.3 · | 2015-10-24 00:14:09+00:00

As an interesting aside, Avian has native support for coroutines through stack de/re-hydration. I have yet to use it, but it looks quite interesting.

XtalJ | karma 103 | avg karma 1.69 · | 2016-12-09 14:17:35+00:00

If you like coroutines, also have a look at libmill (http://libmill.org).

danappelxx | karma 476 | avg karma 2.99 · | 2016-10-31 02:29:54+00:00

Have you seen libmill[0]? Single-threaded coroutines - no mutexes, semaphores, etc. We're using it in Zewo[1] with great success.

[0]: http://libmill.org [1]: https://github.com/Zewo/Zewo

reply

mikewarot | karma 10851 | avg karma 2.02 · | 2023-03-18 14:02:23

I did coroutines under Turbo Pascal wayyyyy back in the 1980s[1]. It's really just a matter of copying the stack and some book-keeping.

Free Pascal has threads.

[1] https://www.pcorner.com/list/PASCAL/TASKER4.ZIP/TASKER.PAS/

reply

girvo | karma 11277 | avg karma 2.24 · | 2013-11-19 17:25:59

No coroutines per se, but it does have really nice native threading support, and I'm nearly certain that coroutines could be easily put in userspace. It's a powerful language in that regard.

Ask the guys and gals in #Nimrod on freenode, they're super Super helpful -- I'm not well versed enough in parallelism and concurrency to answer your question, but they are!

reply

waydegg | karma 26 | avg karma 1.37 · | 2023-07-06 00:39:22

It's a shame there isn't any support for coroutines. I'm really hoping some profiling tool that comes along to handle them + threads/processes.

okeuro49 | karma 2123 | avg karma 10.26 · | 2023-06-05 05:35:16

For coroutines look at structured concurrency https://openjdk.org/jeps/437

jcelerier | karma 10788 | avg karma 2.29 · | 2021-02-22 11:34:43+00:00

it'd be very trivial with something such as ASIO's io_context as your coroutine event loop: https://dens.website/tutorials/cpp-asio/multithreading

klibertp | karma 4682 | avg karma 1.75 · | 2016-02-18 13:34:40+00:00

There is some support for coroutines with async/await (http://nim-lang.org/docs/asyncdispatch.html), but I don't know how mature or functional it is, never tested it. As mentioned, for anything involving concurrency I'd rather use Erlang or Elixir; but it may be a good idea to see how well Nim does in this area.

pjmlp | karma 109153 | avg karma 1.76 · | 2019-01-27 09:18:32

Are you not mixing it up with Concurrent Pascal?

I don't remember Turbo Pascal ever having similar to coroutines and I used all versions up to Turbo Pascal for Windows.

reply

elcritch | karma 3737 | avg karma 1.99 · | 2020-08-16 17:13:52+00:00

All of the above. Though the coroutine library looks out of date. Most network libraries use async. Threads are possible, but weave looks promising: https://github.com/mratsim/weave

vlovich123 | karma 10600 | avg karma 2.26 · | 2021-11-01 14:06:59

A coworker added coroutines to KJ [1] so for our purposes it’s “made it”. It’ll be more broadly useful obviously with library support in the standard. I think that’s targeted for c++23

[1] https://github.com/capnproto/capnproto/blob/master/kjdoc/tou...

reply

rajman187 | karma 292 | avg karma 1.97 · | 2022-03-10 15:37:40

Worth sharing also is the async implementation that works with C++20 coroutines https://github.com/pcwalton/cxx-async

zzzcpan | karma 4245 | avg karma 1.44 · | 2013-08-20 15:56:40+00:00

If you are interested in coroutines, take a look at GNU Portable Threads http://www.gnu.org/software/pth/ and this paper: http://www.gnu.org/software/pth/rse-pmt.ps

trebecks | karma 13 | avg karma 1.0 · | 2024-04-09 22:03:52

yeah i like this model. then you can use whatever synchronization junk you prefer to share state between the threads, if you have any.

your library looks well written and clean. thanks for sharing.

if anyone else wants to go coroutine spelunking, these were interesting to me:

https://github.com/higan-emu/libco/tree/master

https://github.com/Tencent/libco

https://github.com/hnes/libaco

https://kernel.googlesource.com/pub/scm/virt/kvm/qemu-kvm/+/...

https://tia.mat.br/posts/2012/09/29/asynchronous_i_o_in_c_wi...

https://www.cs.uml.edu/~bill/cs516/context_paper_rse-pmt.pdf

reply

Rochus | karma 2890 | avg karma 1.31 · | 2022-08-26 17:26:10

Thanks. I don't know the Ulm compiler, and I unfortunately don't have System 3 (can you please provide a link with the source code and/or a working Linux binary?), but I have the source code of V2 and V4 (both ETH and Linz versions, from 1992 to Linz 1.7) where there are no coroutines.

ajasmin | karma 253 | avg karma 1.51 · | 2013-02-27 00:45:52

Boost Coroutines perhaps? http://www.boost.org/doc/libs/1_53_0/libs/coroutine/doc/html...

weberc2 | karma 4751 | avg karma 1.26 · | 2016-11-10 17:55:24

Efficient concurrent programming. I'm not aware of any cross-platform C/C++ or Python libraries that give you async I/O + multi-threaded coroutines. Such a library exists for the Java ecosystem (quasar), but IIRC, it's enabled by clever bytecode tricks, so it's not built with vanilla Java. Further, you still have to take care not to use any libraries that are incompatible with this concurrency model (e.g., anything that does sync I/O).

halayli | karma 2473 | avg karma 2.69 · | 2014-11-17 01:50:11+00:00

For those interested in coroutines, check out lthread & lthread cpp bindings (disclaimer: author)

Code:

https://github.com/halayli/lthread

https://github.com/halayli/lthread_cpp

Docs:

http://lthread.readthedocs.org/en/latest/

http://lthread-cpp.readthedocs.org/en/latest/

reply