C level mutices and condition variables

C level mutices and condition variables

[Marius Vollmer]

Hi,

currently, we support the scm_t_mutex and scm_t_cond types, along with
some functions.  You can declare a variable of type scm_t_mutex and
initialize it with scm_mute_init, for example.

This makes it hard to have SCM data in a scm_t_mutex since you have to
protect it without the help from the user of the mutex.  Also, this is
not 'astract' enough when we make thread package support a run-time
option (which we should).

Dirk did some work in this direction in the dirk-thread-factorization
branch.  I propose something simpler:

Let's just remove C level support for mutex and condition variable
objects and tell them to use the Scheme level mutices, which are also
available to C.  (With deprecation.)

Ok?

-- 
GPG: D5D4E405 - 2F9B BCCC 8527 692A 04E3  331E FAF8 226A D5D4 E405


_______________________________________________
Guile-devel mailing list
Guile-devel@gnu.org
http://mail.gnu.org/mailman/listinfo/guile-devel

Re: C level mutices and condition variables

[Neil Jerram]

>>>>> "Marius" == Marius Vollmer <mvo@zagadka.ping.de> writes:

    Marius> Hi,
    Marius> currently, we support the scm_t_mutex and scm_t_cond types, along with
    Marius> some functions.  You can declare a variable of type scm_t_mutex and
    Marius> initialize it with scm_mute_init, for example.

    Marius> This makes it hard to have SCM data in a scm_t_mutex since you have to
    Marius> protect it without the help from the user of the mutex.  Also, this is
    Marius> not 'astract' enough when we make thread package support a run-time
    Marius> option (which we should).

    Marius> Dirk did some work in this direction in the dirk-thread-factorization
    Marius> branch.  I propose something simpler:

    Marius> Let's just remove C level support for mutex and condition variable
    Marius> objects and tell them to use the Scheme level mutices, which are also
    Marius> available to C.  (With deprecation.)

    Marius> Ok?

I don't understand, I'm afraid.

- Why would you want "to have SCM data in a scm_t_mutex"? - isn't the
  data that you are protecting access to normally a separate variable
  (or set of variables) from the mutex itself?

- What do you mean by not abstract enough?

- In "tell them to use the Scheme level mutices", who is "them", and
  would it be possible for them to use Scheme mutexes from C code, or
  are you saying that people who need mutexes must code in Scheme?

Regards,
        Neil



_______________________________________________
Guile-devel mailing list
Guile-devel@gnu.org
http://mail.gnu.org/mailman/listinfo/guile-devel

Re: C level mutices and condition variables

[Marius Vollmer]

Neil Jerram <neil@ossau.uklinux.net> writes:

> - Why would you want "to have SCM data in a scm_t_mutex"? - isn't the
>   data that you are protecting access to normally a separate variable
>   (or set of variables) from the mutex itself?

I was thinking about data that is needed to implement the mutex
itself.  It would be nice to be able to use SCM values, I'd say, just
because a SCM string as the mutex name is nicer than a C string.

Concretely, I wanted to use SCM lists to implement the waiting queue
(to add fairness to POSIX mutices), mostly because SCM lists are
already there and why shouldn't I use them then?

> - What do you mean by not abstract enough?

You will declare scm_t_mutex variables and thus the size of the
scm_t_mutex structure can not change.  When we want to select mutex
implementations at run-time, that might be a (small) problem.  In any
case, I think it is better to hide mutices behind SCM values, just as
other data structures.

> - In "tell them to use the Scheme level mutices", who is "them", and

The people who use scm_t_mutex etc now.

>   would it be possible for them to use Scheme mutexes from C code, or
>   are you saying that people who need mutexes must code in Scheme?

They can code in C.  Instead of

   scm_t_mutex my_mutex;
   scm_mutex_init (&my_mutex);
   scm_mutex_lock (&my_mutex);

it would be

   SCM my_mutex = scm_make_mutex ();
   scm_lock_mutex (my_mutex);

-- 
GPG: D5D4E405 - 2F9B BCCC 8527 692A 04E3  331E FAF8 226A D5D4 E405


_______________________________________________
Guile-devel mailing list
Guile-devel@gnu.org
http://mail.gnu.org/mailman/listinfo/guile-devel

Re: C level mutices and condition variables

[Neil Jerram]

>>>>> "Marius" == Marius Vollmer <mvo@zagadka.ping.de> writes:

    [ answers to my questions about mutex implementation ]

Thanks, I understand much better now.  I think that your proposal
makes excellent sense, and look forward to seeing it.

        Neil



_______________________________________________
Guile-devel mailing list
Guile-devel@gnu.org
http://mail.gnu.org/mailman/listinfo/guile-devel

Re: C level mutices and condition variables

[Marius Vollmer]

Neil Jerram <neil@ossau.uklinux.net> writes:

> Thanks, I understand much better now.  I think that your proposal
> makes excellent sense, and look forward to seeing it.

Ok!  I hope to have it committed this weekend.


_______________________________________________
Guile-devel mailing list
Guile-devel@gnu.org
http://mail.gnu.org/mailman/listinfo/guile-devel

Thread interface issues (was Re: C level mutices and condition variables)

[Mikael Djurfeldt]

I've talked a little with Marius about this over telephone.  He asked
me to give a summary of our discussion on the list.  I'll try to
do that, but don't promise to be fair and will probably miss a lot.
(Also, Marius, there is an additional argument regarding the
"combinatorial explosion" which I've marked with ***.)

NOTE: Unfortunately, I'm *very* short of time right now, so I don't
promise to continue discussing this issue.  Therefore it's important
that those of you who support my view don't expect me to defend it (if
it needs fruther defence) but instead do that yourselves.

We talked over four connected issues:

Q1. How are we going to choose whether to use threads and which thread
    package to use?  Compile-time, link-time or run-time?

Q2. Should Guile have a "plug-in" thread interface a la glib or should
    we have multiple versions of libguile installed on the system?

Q3. Should Guile have a C level thread API?  (The present guile-devel
    news-thread arrived at the answer "no", but in my opinion the
    issue needs further thought.)

Q4. How should the C level API be implemented?  Scheme level
    implemented on top of C level or the reverse?

----------------------------------------------------------------------

Q1. How are we going to choose whether to use threads and which thread
    package to use?  Compile-time, link-time or run-time?

Currently, we make a compile-time choice of one of three thread
packages:

  I. null-threads (on systems which don't support threads or where the
     sysadmin don't want threads in Guile)

 II. coop-threads (a qthreads based cooperative thread package)

III. coop-pthreads (a pthreads based cooperative thread package)

Is it right to make this choice at libguile compile-time or should it
be at application link time or even run-time?  If run-time, should
individual Guile modules be able to independently choose which thread
library to use?

Our answer should be arrived at under consideration of our vision for
future development, which Marius and I both think is full concurrency
using pthreads.  We basically have the Stalinist view that it would be
good for the whole world to use the pthreads interface (arguments
similar to those for using libc: portability, the possibility to get
kernel-level optimizations etc).  So, it might be that we in the
future drop II and III in favour of (or keep II and III and add):

 IV. pthreads (a preemptive thread package)

Arguments for/against compile-time choice:

+ Simple.

+ Enables compile-time optimizations.  In a pthreads version, we could
  remove logic required for cooperative threading while cooperative
  thread libraries don't require mutecis for protection of common
  resources.

- The sysadmin and application developer might be different people.
  If the sysadmin has installed Guile without thread support, an
  application developer (or user for that matter!) will be in deep
  trouble if the application needs thread support.  This situation is
  unreasonable but could be resolved if we install multiple versions
  of libguile, one for each thread package.

Arguments for link-time choice:

(Link-time in this context means deciding which thread package to use
once, at initialization of libguile.)

+ Moves the choice of thread library to the application developer
  where it should be.

+ Reasonably simple.  Additional requirements are only:

   1. a plug-in interface (a struct with pointers to the thread
      library functions)

   2. glue code

Arguments against run-time choice:

- Unreasonably complex.

- Would require multiple types of mutecis and condition variables or
  overly complex united forms.  In this way the complexity intrudes
  also semantically.

I think both Marius and I agree that the only reasonable answers to Q1
are:

* link-time choice with one libguile

or

* compile-time choice with multiple libguiles (libguile,
  libguile-coop, libguile-copt etc)

This results in Q2:

----------------------------------------------------------------------

Q2. Should Guile have a "plug-in" thread interface a la glib or should
    we have multiple versions of libguile installed on the system?

An example of such a plug-in interface is included below.

Arguments for/against plug-in interface:

+ Gives true modularity by decoupling libguile from the thread
  library.

+ Gives the application developer the freedom to use other thread
  packages with Guile, including experimenting with new thread
  libraries.

  Apart from choosing between COOP threads, COOP-pthreads and
  pthreads, there might be other thread packages out there which the
  application developer might prefer.  For example, the Debian
  distribution provides State threads (libst1), LWP threads
  (liblwp2) and GNU Portable Threads (libpth; a cooperative thread
  library).

  The reason why this is a significant point is that it can be
  difficult to make different thread libraries play well together in
  the same application.  If Guile uses X-threads, the application
  usually runs into trouble if it uses Y-threads.

- (Probably insignificant) overhead due to one pointer indirection.

- Puts a restriction on the thread library capabilities that we can
  use.  (We can't continue to extend this API ad infinitum but must
  decide on a basic set of calls that we think most thread libraries
  can implement.  But we may also use the strategy of GLib: that some
  of the calls are optional and can be initialized to NULL.)

- Requires dynamic linking with an additional glue-code library if the
  thread package isn't directly written for Guile.  Such a glue-code
  library initializes the plug-in interface and provides possibly
  required extra support code.

Arguments for/against multiple versions of libguile:

+ Allows for compile-time optimizations (see Q1: compile-time choice).

- Risk for combinatorial explosion of libguile versions due to
  compilation options.

- *** Risk for combinatorial explosion of libguile support library
  versions.

  Note that we can't just draw the distinction between libguile on one
  hand which supports the application on the other hand.  We also have
  libraries like libguile-gtk which have the double role of being
  application of libguile and providing application framework for user
  applications.  While having multiple version of libguile may be
  reasonable, having, in addition, multiple versions of libguile-gtk
  et al is unreasonable.

  A partial solution is to introduce an abstraction which separates
  guile code + semi-guile code like libguile-gtk from the particular
  thread library being used so that, for example, a single
  libguile-gtk can support all versions of libguile.

  The Scheme-level thread interface provides such an abstraction so
  that Guile scheme modules are independent of the particular thread
  packages being used.  The subset of primitive functions in this
  interface can provide a C level abstraction for loadable C-level
  Guile extensions, but we could also provide a C level thread API.
  In fact, such a C level thread API has been in place since
  1998-01-30 (guile-1.2) but has just been deprecated.

  This brings us to Q3:

----------------------------------------------------------------------

Q3. Should Guile have a C level thread API?

While an application should be free to use whatever thread package it
wants by direct calls to its API, points discussed above shows that
Guile Scheme and C modules should use an abstraction in order be
independent of the thread package being used.  The C level could
either use the Scheme primitives, like this:

   SCM my_mutex = scm_make_mutex ();
   scm_lock_mutex (my_mutex);

However, for thread creation, we would still probably want to use
scm_spawn_thread, so this alterntive is rather a _partial_ C level
thread API.

In a full C level thread API, one would be able to:

   scm_t_mutex my_mutex;
   scm_mutex_init (&my_mutex);
   scm_mutex_lock (&my_mutex);

(Although, as Marius has pointed out, scm_t_mutex is a bit rigid,
since it requires knowledge of mutex size at compile-time.  In the
Glib thread interface and in the plug-in interface proposed below,
scm_mutex_init is replaced with a mutex constructor function.)

Arguments for/against C level thread API:

+ Easy programming in C.

  A major goal of Guile is to be an extension language for
  applications written in C.  Because of this, we try to provide a
  nice environment not only for Scheme but also for C programmers.

  If we do provide a C API, it should be similar to the pthread API.
  In this case, the C programmer will feel very familiar with the
  interface and it's easy to convert code written for the pthread
  API.

  If we don't provide a C API, the code needs to deal with GC issues.
  For example, it is fairly common to store mutecis in dynamic
  application datastructures.  If we go with Scheme API only, the
  application needs to make sure the mutex is GC protected.

+ Efficiency.

  In some cases, a thread package needs to be very efficient.  Thread
  package developers make great efforts to reduce overhead.  Even the
  need to switch from user space to system space is sometimes
  considered as causing significant overhead, so there are alternative
  thread libraries which run entirely in user space.

  For such applications where this matters, it seems wasteful to go by
  the indirections of the SCM data type and do unnecessary type checks
  when calling Scheme primitives from C.  Note that the C level
  interface is not only intended for the direct cooperation with
  Scheme code, in which overhead may be of less significance, but is
  also intended for time-critical C code in a loadable Guile extension
  module.

  (This point is only valid together with the Scheme on top of C
   alternative in Q4 below.)

+ Deprecation will break applications.

  The current C level thread API has been in place since 1998-01-30
  (guile-1.2) but has just been deprecated.

  Maybe only I have been using this API in several of my applications,
  but it doesn't seem nice towards application developers to remove
  such a useful feature when there is no simple replacement,
  especially when it's been in place for so long.

- Demands extra work for Guile developers to maintain it.

(Missing some - points?  They might rather belong to Q2 or Q4 and
 could be listen there.)

----------------------------------------------------------------------

Q4. How should the C level API be implemented?  Scheme level
    implemented on top of C level or reverse?

Scheme level on top of C level means that Scheme primitives call the C
level API for core thread functionality.

C level on top of Scheme level means that the Scheme primitives
implement the core thread library functionality directly and that the
C level interface is an adapter on top of this to facilitate coding
for C programmers.  (An example is provided by the currently
deprecated C level API for coop-pthreads.)

Just as regarding Q3, this may be a matter of coding philosophy:

Either one aims for a slim C level solution or one wants to take
advantage of the advanced facilities of a dynamically typed language
and is prepared to pay for it.

Arguments for Scheme level implemented on top of C level:

+ More "natural"

  Results in a natural layering of the code.  The reverse will, in
  fact, be C - Scheme - C.

Arguments for C level implemented on top of Scheme level:

+ Easier to use Scheme level facilities when implementing the thread
  packages.  For example, we might decide, at a later stage, to add
  some debugging facilities to the thread support.  We might prefer to
  write this in Scheme code.  With C implemented on top of Scheme
  level this seems easier than for the reverse.  Also, in implementing
  certain thread functionality, we might want to use Scheme facilities
  such as SCM lists.  If we have an SCM list in a mutex, how will it
  be GC protected if the mutex resides under the C API?

- We won't want to do that anyway in the envisioned pthreads
  implementation

  Since we're envisioning Guile using pthreads with full concurrency
  as a future standard thread package for Guile, it is likely that
  we won't need to implement much core thread functionality.  It's
  more likely that we just want to wrap pthreads as Scheme primitives
  which seems to harmonize better with the Scheme on top of C
  alternatives.

- Overhead

  Overhead problems will be even greater than those we'd have if we
  don't provide a C API at all.

----------------------------------------------------------------------

OK, was it difficult to figure out what I want to see in Guile? ;-)

If so, I want:

* A plug-in interface which decouples libguile from the thread
  library and allows the application developer to choose which thread
  library to use with Guile.  Preferably it should support both
  cooperative and preemptive scheduling.

* An efficient and pthreads-like C level API.  The plug-in interface
  could serve this role in addition to the decoupling role.

* Scheme primitives implemented using the low-level C API.

If you've read this far you have my respect!

Good luck with decisions and implementation,

Mikael

----------------------------------------------------------------------

Proposed plug-in interface structure:

struct scm_threads {
  /* Threads */
  scm_thread_t (*make_thread) (scm_threadattr_t *attr,
			       void * (*start_routine) (void *),
			       void *arg);
  void (*exit) (void *retval);
  int (*cancel) (scm_thread_t thread);
  int (*join) (scm_thread_t thread, void **retval);
  size_t (*free) (scm_thread_t thread); /* returns freed amount of memory */
  
  /* Cooperative threads */
  void (*yield) (void); /* optional */
  
  /* Mutices */
  scm_mutex_t * (*make_mutex) (const scm_mutexattr_t *mutexattr);
  int (*mutex_lock) (scm_mutex_t *mutex);
  int (*mutex_trylock) (scm_mutex_t *mutex);
  int (*mutex_unlock) (scm_mutex_t *mutex);
  size_t (*mutex_free) (scm_mutex_t *mutex); /* returns freed amount of memory */
  
  /* Condition variables */
  scm_cond_t * (*make_cond) (scm_condattr_t *cond_attr);
  int (*cond_signal) (scm_cond_t *cond);
  int (*cond_broadcast) (scm_cond_t *cond);
  int (*cond_wait) (scm_cond_t *cond, scm_mutex_t *mutex);
  int (*cond_timedwait) (scm_cond_t *cond,
			 scm_mutex_t *mutex,
			 const struct timespec *abstime);
  size_t (*cond_free) (scm_cond_t *cond); /* returns freed amount of memory */
  
  /* Keys */
  int (*key_create) (scm_key_t *key, void (*destr_function) (void *));
  int (*key_delete) (scm_key_t key);
  int (*setspecific) (scm_key_t key, const void *pointer);
  void * (*getspecific) (scm_key_t key);

  /* Local data
     
     This is used by Guile to store the root structure.
     It could be a custom data field in the thread data structure
     or a dedicated key.
  */
  void (*set_data) (void *data);
  void * (*data) (void);
  
  /* GC */
  void (*mark_stacks) (void);
  
  /* Parameters */
  void (*set_stack_size) (size_t size);
};


_______________________________________________
Guile-devel mailing list
Guile-devel@gnu.org
http://mail.gnu.org/mailman/listinfo/guile-devel

GC & threads (was: Thread interface issues)

[Han-Wen Nienhuys]

mdj@kvast.blakulla.net writes:
>[threads]

This reminds me: there is a huge bottleneck. .. (Well actually, I
didn't measure it, but it's my hunch anyway... let me call it
inelegancy instead), in the current GC code. SCM cells are processed
nicely in page sized chunks. Unfortunately, almost every object except
for cells require malloc() calls during allocation, and free() calls
during the sweep. For small objects, I would guess that the double
memory administration of free memory has a sizable overhead. Second,
if two threads alloc arrays or strings concurrently, there will be a
lot of wasted mutexing going on.

Any thoughts... is this a real problem?

(I'm too busy right now for any Real Work on GUILE, Sorry.)

-- 

Han-Wen Nienhuys   |   hanwen@cs.uu.nl   |   http://www.cs.uu.nl/~hanwen 


_______________________________________________
Guile-devel mailing list
Guile-devel@gnu.org
http://mail.gnu.org/mailman/listinfo/guile-devel

Re: Thread interface issues (was Re: C level mutices and condition variables)

[Neil Jerram]

>>>>> "Mikael" == Mikael Djurfeldt <mdj@kvast.blakulla.net> writes:

    [summary of thread issues and why he wants a C thread API :-)]

Oh dear.  Having supported Marius' proposal earlier, I now find
Mikael's arguments quite persuasive.  So I will try to help by
summarizing the point of disagreement, then revisit the earlier
conversation where Marius persuaded me of his proposal.

(FWIW, I did have a few second thoughts about removing scm_t_mutex
even before Mikael raised questions, when something that ttn said on
guile-user reminded me of past arguments ...)

So, the gist.  MDJ wants a C API (with a Scheme API on top of it) for
- back compatibility
- performance
- similarity to pthreads interface.
MVO prefers a Scheme API that is callable from C for
- ability to put SCM data inside mutexes etc. without worrying about GC
- because static declaration of scm_t_mutex needs to change anyway.

Revised notes on our earlier conversation:

>> Neil Jerram <neil@ossau.uklinux.net> writes:
>> 
>> > - Why would you want "to have SCM data in a scm_t_mutex"? - isn't the
>> > data that you are protecting access to normally a separate variable
>> > (or set of variables) from the mutex itself?
>> 
>> I was thinking about data that is needed to implement the mutex
>> itself.  It would be nice to be able to use SCM values, I'd say, just
>> because a SCM string as the mutex name is nicer than a C string.

2nd thoughts: why does a mutex need a name?  Didn't we recently remove
names from variables because they were unSchemely?

>> Concretely, I wanted to use SCM lists to implement the waiting queue
>> (to add fairness to POSIX mutices), mostly because SCM lists are
>> already there and why shouldn't I use them then?

Given the renewed discussion, could we not have both

- a low level, implementation-dependent scm_t_mutex, with no fairness
  guarantees, that is as native as possible w.r.t. the thread impl

- fair SCM mutexes built on top of scm_t_mutex.

>> > - What do you mean by not abstract enough?
>> 
>> You will declare scm_t_mutex variables and thus the size of the
>> scm_t_mutex structure can not change.  When we want to select mutex
>> implementations at run-time, that might be a (small) problem.

If we keep scm_t_mutex after all, it would be nice if existing
applications didn't have to change their code.  If it is already a
requirement to call scm_mutex_init, couldn't scm_t_mutex have a
pointer to some other structure that was dynamically allocated by
scm_mutex_init?

>>                                                                In any
>> case, I think it is better to hide mutices behind SCM values, just as
>> other data structures.

This may be the key point.  What other structures in Guile are most
like mutexes for the purposes of this comparison?  Why are mutexes not
like integers, which are represented by both int and SCM?  If mutexes
are most like other SCM types, is it the possibility of multiple
underlying thread implementations that motivates a non-SCM-based C API
for them?  Why don't we have the possibility (or problem) of multiple
XXX implementations for other kinds of XXX in Guile?

(All genuine questions.)

        Neil



_______________________________________________
Guile-devel mailing list
Guile-devel@gnu.org
http://mail.gnu.org/mailman/listinfo/guile-devel

Re: Thread interface issues (was Re: C level mutices and condition variables)

[Marius Vollmer]

Neil Jerram <neil@ossau.uklinux.net> writes:

> Given the renewed discussion, could we not have both
> 
> - a low level, implementation-dependent scm_t_mutex, with no fairness
>   guarantees, that is as native as possible w.r.t. the thread impl
> 
> - fair SCM mutexes built on top of scm_t_mutex.

Yep, I think this is the way to go.  When I find some time, I'll
revert the deprecation of scm_t_mutex etc and document that API in
addition to the Scheme API.  I will make it so that when we use
pthreads, there wont be any overhead whatsoever when using scm_t_mutex
(compared to using pthreads directly).

Mikael, when you want to work on this yourself, that would be great.
Just tell me briefly.

-- 
GPG: D5D4E405 - 2F9B BCCC 8527 692A 04E3  331E FAF8 226A D5D4 E405


_______________________________________________
Guile-devel mailing list
Guile-devel@gnu.org
http://mail.gnu.org/mailman/listinfo/guile-devel

Re: Thread interface issues

[Mikael Djurfeldt]

Marius Vollmer <mvo@zagadka.ping.de> writes:

> Neil Jerram <neil@ossau.uklinux.net> writes:
>
>> Given the renewed discussion, could we not have both
>> 
>> - a low level, implementation-dependent scm_t_mutex, with no fairness
>>   guarantees, that is as native as possible w.r.t. the thread impl
>> 
>> - fair SCM mutexes built on top of scm_t_mutex.
>
> Yep, I think this is the way to go.

I concur.

> Mikael, when you want to work on this yourself, that would be great.
> Just tell me briefly.

Sorry, no time to work now.  But I will tell you if an opportunity to
work comes.  (But don't wait for me!)

Mikael


_______________________________________________
Guile-devel mailing list
Guile-devel@gnu.org
http://mail.gnu.org/mailman/listinfo/guile-devel

Re: Thread interface issues

[Marius Vollmer]

Mikael Djurfeldt <mdj@kvast.blakulla.net> writes:

> > Mikael, when you want to work on this yourself, that would be great.
> > Just tell me briefly.
> 
> Sorry, no time to work now.  But I will tell you if an opportunity to
> work comes.  (But don't wait for me!)

Ok, I hope to get this done this weekend.

-- 
GPG: D5D4E405 - 2F9B BCCC 8527 692A 04E3  331E FAF8 226A D5D4 E405


_______________________________________________
Guile-devel mailing list
Guile-devel@gnu.org
http://mail.gnu.org/mailman/listinfo/guile-devel