Queue.Queue-like class without the busy-wait

[Nick Craig-Wood]

Paul Rubin <http> wrote:
>  Antoon Pardon <apardon at forel.vub.ac.be> writes:
> > I'm not sure that this would be an acceptable approach. I did the man
> > semop and it indicates this is part of system V IPC. This makes me
> > fear that semaphores will use file descriptors or other resources
> > that are only available in a limited amount. Not usefull if you are
> > talking about thousands of threads.
> 
>  That would be terrible, if semaphores are as heavy as file descriptors.
>  I'd like to hope the OS's are better designed than that.

I believe futex is the thing you want for a modern linux.  Not
very portable though.

>From futex(4)

       The  Linux  kernel  provides  futexes  ('Fast  Userspace muTexes') as a
       building block for fast userspace locking and semaphores.  Futexes  are
       very  basic  and lend themselves well for building higher level locking
       abstractions such as POSIX mutexes.

       This page does not  set  out  to  document  all  design  decisions  but
       restricts  itself to issues relevant for application and library devel-
       opment. Most programmers will in fact not be using futexes directly but
       instead  rely  on  system  libraries  built  on  them, such as the NPTL
       pthreads implementation.

       A futex is identified by a piece of memory which can be shared  between
       different  processes.  In  these  different processes, it need not have
       identical addresses. In its bare form, a futex has semaphore semantics;
       it  is  a  counter  that can be incremented and decremented atomically;
       processes can wait for the value to become positive.

       Futex operation is entirely userspace for the non-contended  case.  The
       kernel  is  only  involved to arbitrate the contended case. As any sane
       design will strive for non-contension, futexes are also  optimised  for
       this situation.

       In  its  bare form, a futex is an aligned integer which is only touched
       by atomic assembler instructions. Processes can share this integer over
       mmap,  via shared segments or because they share memory space, in which
       case the application is commonly called multithreaded.

-- 
Nick Craig-Wood <nick at craig-wood.com> -- http://www.craig-wood.com/nick