Re: [Caml-list] Thread behaviour

[Goswin von Brederlow <goswin-v-b@web.de>]

On Sat, Sep 28, 2013 at 08:09:12PM +0100, Tom Ridge wrote:
> Would it be fair to say that OCaml does not currently support
> pre-emptively scheduled threads?
> 
> I have read the lecture from Xavier archived here:
> 
> http://alan.petitepomme.net/cwn/2002.11.26.html#8
> 
> I would like to implement a library to handle messaging between
> possibly-distributed OCaml processes. Alas, my design naively requires
> pre-emptively scheduled threads (although it may be possible to change
> the design e.g. to work with Lwt) - each message queue is accompanied
> by a thread which reinitializes connections when connections go down
> etc., hiding this complexity from the user.
> 
> Quoting Xavier:
> 
> "Scheduling I/O and computation concurrently, and managing process
> stacks, is the job of the operating system."
> 
> But what if you want to implement a messaging library in OCaml? It
> seems unlikely that all operating systems would fix on a standard
> implementation of distributed message passing (or, even more funky,
> distributed persistent message queues).

Why do you need pre-emptively scheduled threads? That would mean you
have threads that are more important than others. Ocaml has no
priorities in its threads for that.

If you want to do I/O and computation concurrently then you probably
need to offload the computation into seperate processes (with their
own runtime). Otherwise, because you can't give the I/O thread a
higher priority, the computation threads will block the I/O a lot of
the time.

One way around that is to do the computations in C, without the
runtime lock. That way the I/O thread can run in parallel with
computations and computations can run on multiple cores.

> On 27 September 2013 11:51, Benedikt Grundmann
> <bgrundmann@janestreet.com> wrote:
> > The ticker thread will cause yields which will be honored on the next
> > allocation of the thread that currently has the caml lock.  That said we
> > have seen that sometimes the lock is reacquired by the same thread again.
> > So there are some fairness issues.
> >
> >
> > On Fri, Sep 27, 2013 at 11:27 AM, Romain Bardou <romain.bardou@inria.fr>
> > wrote:
> >>
> >> Le 27/09/2013 12:10, Tom Ridge a écrit :
> >> > Dear caml-list,
> >> >
> >> > I have a little program which creates a thread, and then sits in a loop:
> >> >
> >> > --
> >> >
> >> > let f () =
> >> >   let _ = ignore (print_endline "3") in
> >> >   let _ = ignore (print_endline "hello") in
> >> >   let _ = ignore (print_endline "4") in
> >> >   ()
> >> >
> >> > let main () =
> >> >   let _ = ignore (print_endline "1") in
> >> >   let t = Thread.create f () in
> >> >   (* let _ = Thread.join t in *)
> >> >   let _ = ignore (print_endline "2") in
> >> >   while true do
> >> >     flush stdout;
> >> >   done

Never ever do that. You have a busy loop there that just eats up 100%
cpu time. All while holding the global runtime lock. So the thread
will be blocked trying to aquire the lock.

> >> >
> >> > let _ = main ()
> >> >
> >> > --
> >> >
> >> > I compile the program with the following Makefile clause:
> >> >
> >> > test.byte: test.ml FORCE
> >> > ocamlc -o $@ -thread unix.cma threads.cma $<
> >> >
> >> > When I run the program I get the output:
> >> >
> >> > 1
> >> > 2
> >> >
> >> > and the program then sits in the loop. I was expecting the output from
> >> > f to show up as well. If you wait a while, it does. But you have to
> >> > wait quite a while.
> >> >
> >> > What am I doing wrong here? I notice that if I put Thread.yield in the
> >> > while loop then f's output gets printed pretty quickly. But why should
> >> > the while loop affect scheduling of f's thread?
> >> >
> >> > Thanks
> >> >
> >>
> >> OCaml's thread, unfortunately, are kind of cooperative: you need to
> >> yield explicitly. Note that you will obtain an even different (worse)
> >> result with a native program. I observed this myself without looking at
> >> the thread code itself so maybe there is actually a way to
> >> "automatically yield" but as far as I know there is no way to obtain the
> >> behavior you want without using either yields or processes instead of
> >> threads. This is the reason for the Procord library I am developing
> >> (first version to be released before the next OUPS meeting).
> >>
> >> Also, you don't need to ignore the result of print_endline, as
> >> print_endline returns unit. And using let _ = ... in is the same as
> >> using ignore, so using both is not needed.

"let _ = ..." and "ignore" are dangerous since they don't type check.
Better would be:

let () = print_endline "3" in

> >> Cheers,
> >>
> >> --
> >> Romain Bardou

MfG
	Goswin