The Caml Hump: System :: Distributed and parallel programming

ReactiveML is a programming language dedicated to the implementation of interactive systems as found in graphical user interfaces, video games or simulation problems. ReactiveML is based on the synchronous reactive model of Boussinot embedded in an ML language (here OCaml). The synchronous reactive model provides synchronous parallel composition and dynamic features like the dynamic creation of processes. In ReactiveML, the reactive model is integrated at the language level (not as a library) which leads to safer and more natural programming.

Release is a multi-process Lwt-enabled daemon framework for OCaml, providing facilities for type-safe inter-process communication and privilege-dropping. Its goal is to make it easy to write servers that are released from the calling terminal and to release root privileges when those are not necessary.

JoCaml is Objective Caml plus (&) the join calculus, that is, OCaml extended for concurrent and distributed programming.

Parmap is a minimalistic library allowing to exploit multicore architecture for OCaml programs with minimal modifications.

PEC is a push-based event combinator library for OCaml.

Rtime is an OCaml module implementing timelines for React [1]. It manages time stamp events, delayed events and delayed signals along timelines. The client chooses the concrete timeline by providing an absolute notion of time. Running the timeline at the appropriate pace is left to the client.

React is an OCaml module for functional reactive programming (FRP). It provides support to program with time varying values : applicative events and signals. React doesn't define any primitive event or signal, this lets the client chooses the concrete timeline.

Map/Reduce and distributed filesystem. This package contains two applications: PlasmaFS is a distributed filesystem, Plasma MapReduce is a Map/Reduce framework on top of PlasmaFS.

Lwt is a library for cooperative threads in OCaml. It is using monadic style, which makes it really easy to use. With respect to preemptive threads, cooperative threads are not using a scheduler to distribute processor time between threads. Each thread must instead tell other threads that it wants them to continue. An uncooperative thread will keep other threads blocked until it has completed its work.

ODisco is a library for implementing Disco map-reduce jobs in OCaml. It implements the Disco worker protocol, and provides the plumbing to connect user-specified computations to Disco data sources and results.

Froc is a library for function reactive programming in OCaml. The interface is similar to FrTime and FlapJax, but (of course) typed, implementing a monad of changeable values. The implementation is data-driven, using the dynamic dependency graphs of Acar et al.'s adaptive functional programming. Froc can be used with ocamljs, and with the included Froc-dom library can be used for web browser programming.

OCaml stdlib replacement with a Haskellish flavour.

A functional-reactive approach for developing distributed systems in Objective Caml. In Opis, a protocol description consists of a reactive function (called event function) describing the behavior of a distributed system node. The event functions in Opis are built from pure functions as building blocks, composed using the Arrow combinators. This facilitates reasoning about event functions both informally and using interactive provers. For example, this approach leads to simple termination arguments.

coThreads is a concurrent programming library for OCaml. It enhances the Threads library of the standard OCaml distribution in two dimensions: coThreads implements the same API of the standard Threads library on different execution engines (process, netwoker(todo)), so that a single copy of source code can be compiled and deployed to different environments without modification; coThreads is also a super set of the standard Threads library, with extra components (STM etc.), functions (spawn etc.) and features (object-level compatibility etc.).

This is a user-space implementation of STM (Software Transactional Memory) library for OCaml. It's mainly inspired by the STM library of Haskell, with some exceptions due to the different nature of languages and different strategies of implementation.

OCamlP3l is a compiler for Caml parallel programs. The OCamlP3l programming paradigm is skeleton programming. The skeletons encapsulate basic parallel programming patterns in a well understood and structured approach. Based on P3L, the Pisa Parallel Programming Language, OCamlP3l skeleton algebra is embedded in a full-fledged functional programming language, namely Objective Caml.

A library to help writing distributed programs. The library manages all the details relevant to process launching, channel creation, and network communication so as to let the programmer stick to the core of the problem. This allows to write programs that can be distributed on several machines in a concise way, with all the parallel aspects kept implicit (no synchronisation).

Two small modules that implement extended synchronisations for O'Caml threads.

The ethread library has modules for read/write locks, barriers, and a simple thread-safe message queue that interacts with Unix.select so a thread can wait for I/O or a message at the same time.

A library for Objective Caml allowing SIMD parallel processing on PowerPC G4 processor using the Altivec vector processing unit.

A wrapper for a Spread group communication toolkit, which provides a high performance messaging service that is resilient to faults across external or internal networks.

Library for distributed computing in OCaml.

Scampi (Simple CAml to MPI interface) is small library allowing Caml programs to make calls to MPI-1 communication routines. For now only a few calls are provided (basically, getting communicator size, rank and making synchronous and asynchronous send/receive of polymorphic data plus a couple of collective comm), but it is expected that subsequent versions will enlarge the set of provided bindings. This first version, however, effectivily allows building parallel Caml programs running in SPMD mode on a network of workstations for example.

An interface to the MPI message-passing library.

An interface to the PVM message-passing library.