Re: Potluck - thread safe event loop with await semantics

[Chris Vine]

On Mon, 22 Feb 2016 13:01:01 +0100
address@hidden (Ludovic Courtès) wrote:
> Chris Vine <address@hidden> skribis:
> 
> > It features an a-sync procedure (in coroutines.scm) which can be
> > used to provide await semantics on asynchronous code (so as to
> > remedy inversion of control), and will work with callbacks for any
> > event loop, including the glib event loop wrapped by guile-gnome.
> > More to the point, it also provides a thread safe event loop for
> > guile (event-loop.scm) with support for watches on ports/file
> > descriptors, and now supports proper timeouts, and permits events
> > to be posted by other tasks.  This includes tasks running on other
> > threads, for which there is a helper procedure
> > a-sync-run-task-in-thread.  
> 
> Interesting.  Have you tried to integrate it with one of the
> object-oriented event loops like in GLib?  (Back in the day I thinking
> about something like that to avoid the callback hell in Guile-Avahi.)
> 
> Thanks for the tasty dish!  :-)
> 
> Ludo’.

This is an example of how you might use a-sync with guile-gnome:

;;;;;;;;

(use-modules (gnome glib) (coroutines))

(define main-loop (g-main-loop-new #f #f))

(a-sync (lambda (await resume)
         ;; launch asynchronous task
         (g-idle-add (lambda ()
                       (display "In first async callback\n")
                       (resume "Hello via async\n")
                       #f))
         (display "About to make first wait\n")
         (display (string-append "Back in waitable procedure, and the callback 
says: " (await)))

         ;; launch another asynchronous task
         (g-idle-add (lambda ()
                       (display "In second async callback\n")
                       (g-main-loop-quit main-loop)
                       (resume)
                       #f))
         (display "About to make second wait\n")
         (await)
         (display "Quitting\n")))

(display "Starting main loop\n")
(g-main-loop-run main-loop)

;;;;;;;;

However, it is more useful with guile-gnome's GTK+ callbacks, or with glib
file watches or timeouts, because although the glib main loop is thread
safe, the guile-gnome wrapper for it is not, and I have had problems
with worker threads posting with g-idle-add.  That was one of the things
that impelled me to write my own thread safe event loop.

I have gone a little further with this and have added more convenience
wrapper procedures which makes a-sync rather easy to use.  I am preparing
a guile-a-sync package which I will put on github.  I have everything
going except that I am finishing off adding a wrapper for clock_gettime()
so that a monotonic clock is available for timeouts.  It also has some
bug fixes for the code I posted.

The other thing that may require further work is the documentation.  I
am used to doxygen or gtk-doc, neither of which I imagine will parse guile
scheme code, so I will have to look into what is available (I don't like
info).

I'll post the URL when I have put it up.

Chris