Concurrent ML

Concurrent ML (CML) is a concurrent extension of the Standard ML programming language characterized by its ability to allow programmers to create composable communication abstractions that are first class rather than built into the language. The design of CML and its primitive operations have been adopted in several other programming languages such as GNU Guile,^[1] Racket,^[2] and Manticore.^[3]

Concepts

Many programming languages that support concurrency offer communication channels that allow the exchange of values between processes or threads running concurrently in a system. Communications established between processes may follow a specific protocol, requiring the programmer to write functions to establish the required pattern of communication. Meanwhile, a communicating system often requires establishing multiple channels, such as to multiple servers, and then choosing between the available channels when new data is available. This can be accomplished using polling, such as with the select operation on Unix systems.

Combining both application-specific protocols and multi-party communication may be complicated, due to the need to introduce polling and checking for blocking within a pre-existing protocol. Concurrent ML solves this problem by reducing this coupling of programming concepts by introducing synchronizable events.^[4] Events are a first-class abstraction that can used with a synchronization operation (called sync in CML and Racket) in order to potentially block, and then produce some value resulting from communication (for example, data transmitted on a channel).

In CML, events can be combined or manipulated using a number of primitive operations. Each primitive operation constructs a new event rather than modifying the event in-place, which allows the construction of compound events that represent a desired communication pattern. For example, CML allows the programmer to combine several sub-events in order to create a compound event that non-deterministically chooses one of the sub-events. Another primitive creates a new event that will modify the value resulting from synchronization on the original event. These events embody patterns of communication that, in a non-CML language, would typically be handled using a polling loop or function with handlers for each kind of event.

Sample Code

Here is sample code to print "hello, world" to the console. It spawns a thread which creates a channel for strings. This thread then spawns another thread which prints the first string that is received on the channel. The former thread then sends the "hello, world\n" string on the channel. It uses SML/NJ and CML (note that the heap name will be different on non linux-x86 platforms; you may need to change the line with "cml_test.x86-linux" to something different):

cml_test.cm

   Library
       structure Hello
   is
       $cml/basis.cm
       $cml/cml.cm
       cml_test.sml

cml_test.sml

   structure Hello =
   struct
       open CML
           
       fun hello () =
           let val c : string chan = channel ()
           in
               spawn (fn () => TextIO.print (recv c));
               send (c, "hello, world\n");
               exit ()
           end
           
       fun main (name, argv) =
           RunCML.doit (fn () => ignore (spawn hello), NONE)
   end

Running

$ ml-build cml_test.cm Hello.main
Standard ML of New Jersey v110.60 [built: Mon Nov 27 14:19:21 2006]
[scanning cml_test.cm]
[library $cml/basis.cm is stable]
[library $cml/cml.cm is stable]
[parsing (cml_test.cm):cml_test.sml]
[creating directory .cm/SKEL]
[library $cml/cml-internal.cm is stable]
[library $cml/core-cml.cm is stable]
[library $SMLNJ-BASIS/basis.cm is stable]
[compiling (cml_test.cm):cml_test.sml]
[creating directory .cm/GUID]
[creating directory .cm/x86-unix]
[code: 2170, data: 42, env: 2561 bytes]
[scanning 18518-export.cm]
[scanning (18518-export.cm):cml_test.cm]
[parsing (18518-export.cm):18518-export.sml]
[compiling (18518-export.cm):18518-export.sml]
[code: 309, data: 37, env: 42 bytes]
$ heap2exec cml_test.x86-linux cml_test
$ ./cml_test
hello, world

External links

• The language homepage

References