from Hacker News

Show HN: Libconcurrent – Coroutines in C

by mitghi on 1/12/16, 12:50 PM with 24 comments

by david-given on 1/13/16, 7:36 PM
I wrote a networking daemon (SMTP greylisting proxy; now unmaintained, but <plug> http://spey.sf.net </plug>) using coroutines once.
Non-preemptive multitasking made reasoning about the problem way easier, because I had no concurrency to worry about, while still allowing inversion of control flow which meant that the SMTP state machines were small and simple. It worked really well.
...until I started getting bug reports from users about weird irreproducable crashes. After a very, very long time I eventually figured out that if spey was built on a system where sqlite had been compiled with pthread support, then it automatically linked in a thread-safe malloc, which tried to fetch the current thread ID, which on some versions of pthreads on some Linux architectures on some glibc versions with some kernel versions, was stored at the top of the stack. It used alignment tricks to find this.
So, every time something called malloc(), the libc was doing the equivalent of:
```
    threadid = *(int*) (alignup(sp, 16MB) - sizeof(int))
```
Except my stacks weren't allocated through pthreads, so threadid ended up being garbage. Hilarity ensued.
I eventually rebuild the coroutine library to be a wrapper around pthreads with a big lock to ensure that only one would run at a time. Which was kind of evil, but much more reliable. (Previously I was using my own coroutine implementation based on getcontext/setcontext.)
So, uh. I can't remember if I had a point any more; but the pain remains.
by brudgers on 1/12/16, 1:57 PM
The links to other projects with similar goals at the bottom of the Readme is brilliant. It helps developers solve their problems irrespective of whether this particular solution works...and solving problems not stars and forks is the measure of utility for a library.
by halayli on 1/13/16, 5:55 PM
You might also want to look at lthread. It has some interesting functions like lthread_compute_begin()/end() to run expensive computations inside a coroutine. the compute methods move the coroutine into an actual pthread and resume until compute_end() is called. It also has c++11 bindings called lthread-cpp which allows you to launch coroutines with variable arguments & types and comes with nice socket wrappers.
```
  void MyMethod(std::vector<int> my_vec) {}
  std::vector<int> v{1,2,3,4};
  Lthread t1{&MyMethod, v};
  t1.detach()

  void my_coroutine()
  {
     lthread_compute_begin();
       ret = fibonacci(55);
     lthread_compute_end();
  }
```
by stepanhruda on 1/13/16, 5:47 PM
How does this compare to http://libmill.org?
by geofft on 1/13/16, 4:06 PM
Cool!
A co-TA and I ported the concurrency library in JOS, MIT's teaching operating system, to regular UNIX:
https://github.com/geofft/vireo
It uses the standard-ish library functions setcontext and getcontext to avoid an assembly dependency. ("POSIX.1-2008 removes the specification of getcontext(), citing portability issues, and recommending that applications be rewritten to use POSIX threads instead.")
by evmar on 1/13/16, 5:46 PM
It would be helpful if the README explained how this is different than the many other coroutine libraries.
by delinka on 1/13/16, 4:48 PM
How does this compare to Apple's GCD [1]?
1 - https://en.wikipedia.org/wiki/Grand_Central_Dispatch
by ghrifter on 1/13/16, 4:26 PM
I got a silly question:
Is this statement basically a do while/while(true) infinite loop?
```
    for (;;) {
         ...
    }
```
by pantalaimon on 1/13/16, 6:33 PM
Are the Coroutines scheduled across multiple CPUs?