Skip to content


Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

105 lines (80 sloc) 3.03 kb
* Concurrent - Generic interface for concurrent operations
* Copyright (C) 2008 David Teller, LIFO, Universite d'Orleans
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version,
* with the special exception on linking described in file LICENSE.
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* Lesser General Public License for more details.
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Definition of concurrency primitives.
@author David Teller
type lock
(** The light-weight type of a lock, i.e. a construction which may be
used to guarantee that a section will not be interrupted by
another thread.
This light-weight type is independent of the underlying locking
mechanism and can be used if you do not know whether your code
will run with vmthreads, Posix threads, coThreads, etc.
val create: enter:(unit -> unit) -> leave:(unit -> unit) -> lock
(** Create a lock from a pair of locking/unlocking functions
@param enter Enter critical section.
@param leave Leave critical section.
val nolock : lock
(** A lock which does nothing.*)
val synchronize: (unit -> lock) -> ('a -> 'b) -> 'a -> 'b
[synchronize locker f] returns a function [f'] which behaves as
[f] but whose executions are protected by one lock obtained from
[locker]. The same lock will be reused for all subsequent uses of
For instance,
[synchronize Mutex.make f] is a new function whose executions
will by synchronized by a new lock. Conversely,
[synchronize (const my_lock) f] is a new function whose executions
will be synchronized by an existing lock [my_lock].
val sync:lock -> ('a -> 'b) -> 'a -> 'b
Specialized version of [synchronized].
[sync lock f] behaves as [synchronize (const lock) f] but slightly faster
val compose : lock -> lock -> lock
Compose two lock systems into a third lock system.
(** A signature for modules which implement locking.*)
module type BaseLock =
type t(**The type of a lock.*)
val create:unit -> t
val lock : t -> unit
val unlock:t -> unit
val try_lock:t -> bool
module type Lock =
type t(**The type of a lock.*)
val create: unit -> t
val lock : t -> unit
val unlock: t -> unit
val try_lock:t -> bool
val synchronize: ?lock:t -> ('a -> 'b) -> 'a -> 'b
val make : unit -> lock
module MakeLock(M:BaseLock) : Lock with type t = M.t
module NoLock : Lock
Jump to Line
Something went wrong with that request. Please try again.