Programming Language: Concurrent ML

Matt Defenthaler John Maskasky Vinash Seenath

7/15/2009

Presentation Outline• CML Origins/History• ML in CaML Shell• Features of CML

o TraceCML• CML vs. SML• Dynamic Semantics

o Definitions o Classeso Grammaro Evaluation Contexto Event Matching

• Syntax of CML• Concurrency• Synchronization• Producer/Consumer in CML • File I/O• Conclusions

7/15/2009

7/15/2009

CML Origins

• ML •originally released in the 1980’s•specifically purposed as a meta language

• First CaML implementations came about in the late 1980's.

• O-CaML is an object-oriented, concurrent variation of the ML programming language

• CML was created by Dr. John H. Reppy

http://tunes.org/cliki/ocaml.html

7/15/2009

ML in CaML Shell• Objective Caml version 3.11.0• # 1+2*3;;• - : int = 7• # let rec fib n =• if n < 2 then• n• else• fib(n-1) + fib(n-2)• ;;• val fib : int -> int = <fun>• # fib 10;;• - : int = 55• # fib 2;;• - : int = 1

These are some examples of code run in the Shell of the CaML compiler.

• The first function is a simple addition multiplication problem in which it returned 7

• The second is defined as a function fib. to determine the Fibonacci number. (sequence starting with 1, 1)

7/15/2009

Features of CML

• Inherited from SMLo Functions as first-class valueso Strong static typingo Polymorphismo Datatypes and pattern matchingo Lexical scopingo Exception handlingo State of the art module facility

• Written in SML: should run on anything running SML

7/15/2009

Features of CML

• Those added with CMLo Concurrency with dynamic thread creationo Preemptive scheduling (to prevent processor monopolization)o Automatic reclamation of threads and channelso Synchronous I/O operations o TraceCML

Features of CML: TraceCML

• Provides good debugging support for CML• 3 facilities

o Trace modules: for controlling debugging outputo Thread watching: for detecting thread terminationo Reporting of uncaught exceptions on 'per thread'

basis• Trace modules have been implemented in such a way

that invocation of them can occur regardless of the current running state of CML.

7/15/2009

Features of CML: TraceCML

type trace_moduledatatype trace_to  = TraceToOut  | TraceToErr  | TraceToNull  | TraceToFile of string  | TraceToStream of TextIO.outstreamval setTraceFile : trace_to -> unitval traceRoot : trace_moduleexception NoSuchModuleval traceModule : trace_module * string -> trace_moduleval nameOf : trace_module -> stringval moduleOf : string -> trace_moduleval traceOn : trace_module -> unitval traceOff : trace_module -> unitval traceOnly : trace_module -> unitval amTracing : trace_module -> boolval status : trace_module -> (trace_module * bool) listval trace : trace_module * (unit -> string list) -> unitval watcher : trace_moduleval watch : string * CML.thread_id -> unitval unwatch : CML.thread_id -> unitval setUncaughtFn : (CML.thread_id * exn -> unit) -> unitval setHandleFn : (CML.thread_id * exn -> bool) -> unitval resetUncaughtFn : unit -> unit

TraceCML Interface

7/15/2009http://cml.cs.uchicago.edu/pages/trace-cml.html

7/15/2009

CML vs. SML

• Concurrent ML is embedded in the standard ML language for programming concurrent systems.

• CML supports explicit thread creation.• CML possesses event values for

communications between threads. These event values are an abstraction for synchronous communications.

7/15/2009

CML vs. SML

• Concurrency in ML is achieved mostly via libraries.

• Programs in CML are more likely to spawn processes when they are needed, instead of at the beginning of the program.

• CML like SML supports polymorphism, has user defined variables, and an automatic garbage collector.

Dynamic Semantics of λcv

• λcv is a concurrent extension of λv–calculus

• λcv is useful as it does posses synchronous operations

7/15/2009

Dynamic Semantics - Definitions

• Here we have the foundation of λcv • Channel names are needed to send and

receive information

7/15/2009

Dynamic Semantics - Classes

• 3 Syntactic classes:o Expressionso Values o Event values

7/15/2009

Dynamic Semantics - Classes

• e can be:

7/15/2009

Dynamic Semantics - Classes

• v can be:

7/15/2009

Dynamic Semantics - Grammar

• Of note are o Channel outputo Channel inputo Wrapper o Choice

7/15/2009

Dynamic Semantics – Evaluation Context

• Similar to the production rules of denotational semantics

• Spawn E creates a new process• Sync E synchronizes a channel after a

non-deterministic choice is offered

7/15/2009

Dynamic Semantics – Event Matching

• Key concept in semantics of concurrent evaluation

• The semantic of rendezvous• By synchronizing on matching events,

values can be exchanged

7/15/2009

Dynamic Semantics – Event Matching

• Read as:ev1 matches ev2 on channel k with results e1 and e2

7/15/2009

Dynamic Semantics – Event Matching

• Recall that k is the channel name

7/15/2009

Dynamic Semantics – Event Matching

• ev1 and ev2 can be

7/15/2009

Dynamic Semantics – Event Matching

• And e1 e1 are :

7/15/2009

Dynamic Semantics – Event Matching

• An example is show to illustrate an event matching situation

7/15/2009

Syntax of CMLBold text denotes elements found in CML and not in SML

http://www.cs.cornell.edu/Courses/cs312/2005sp/lectures/lec02.html7/15/2009

7/15/2009

Concurrency

• To achieve concurrency in ML we need to create and run multiple threads simultaneously.

• We may have to force the threads to synchronize in order to protect the integrity of the data.

7/15/2009

Synchronization

• CML has various ways in which threads can synchronize with each other.o Events

Threads can Synchronize on an evento Communication channels

Send/Recv functions -- Blocking Events SendPoll/RecvPoll functions -- Non-Blocking Events SendEvt/RecvEvt – will create an event associated with

sending or receiving a message. Multicasting -- this is where a message can be transmitted to

multiple threads simultaneously.o SyncVars – variables that can be filled or emptied

Processes will synchronize on reading from an emptied variable

7/15/2009

Synchronization

• MailBoxes are a combination of SyncVars and Communication channels. o A producer may put objects in a mailbox where a

consumer will retrieve them. o Events Associated with a MailBox

Send - non-blocking Recv - blocking RecvPoll – non-blocking

Buffered Producer/Consumer in CMLdatatype 'a buffer = BUF of {insCh : 'a chan,remCh : 'a chan}fun buffer () = let val insCh = channel() and remCh = channel()

fun loop [] = loop [recv inCh]| loop buf = if (length buf > maxlen)then (send (remCh, hd buf); loop (tl, buf))else (select remCh!(hd buf) => loop (tl buf)or insCh?x => loop (buf @ [x]))inspawn loop;BUF{insCh = insCh,remCh = remCh}endfun insert (BUF{insCh, ...}, v) = send (insCh, v)

fun remove (BUF{remCh, ...}) = recv remCh

7/15/2009 http://www.archub.org/arcsug.txt

Buffered Producer/Consumer in CML

datatype 'a buffer = BUF of {insCh : 'a chan,remCh : 'a chan}fun buffer () = let val insCh = channel() and remCh = channel()

fun loop [] = loop [recv inCh]| loop buf = if (length buf > maxlen)then (send (remCh, hd buf); loop (tl, buf))else (select remCh!(hd buf) => loop (tl buf)or insCh?x => loop (buf @ [x]))

creates buffer datatype containing two channels (insCh-for inserting elements into the buffer and remCh-for removing elements from the buffer

creates two synchronous channels

checks to see if the buffer is full

sends the head of the buffer on the remCh channel, then calls loop with the tail of the buffer and the buffer as arguments

! is an attempt to send, select blocks all channels on a list of send/recv calls and executes the associated code with whichever call returns first (and drops the rest)

? is an attempt to receive,=> connects the associated code to execute

Buffered Producer/Consumer in CML

inspawn loop;BUF{insCh = insCh,remCh = remCh}endfun insert (BUF{insCh, ...}, v) = send (insCh, v)

fun remove (BUF{remCh, ...}) = recv remCh

7/15/2009

creates new thread of control to evaluate body of loop function. A unique ID for thread is returned.

inserts item into buffer by sending item v on insCh

removes item from buffer by receiving on remCh

7/15/2009

File I/O in CML

• Because CML is based in SML, file I/O is similar between the two.

• The functions needed to perform file I/O are included in the IMPERATIVE_IO file.

• This file includes functions such aso openIn : nameo openOut : name

These open the file for reading and writing.o inputLine : strm

This function will take in one line of the file

7/15/2009

File I/O in CML

• TextIO in CML is accessed in a similar manner to TextIO in SML

• The implementation was changed because “two different threads should not access the same queue without synchronization”

http://www.cs.princeton.edu/courses/archive/fall00/cs510/crxw/

7/15/2009

File I/O in CML

• Example: function to copy one text file to another.

Include IMPERATIVE_IOfun copyFile(infile: string, outfile: string)    let        (* Opening files for input and output *)         val ins = TextIO.openIn infile         val outs = TextIO.openOut outfile        (* Recursive statement, copying one character *)        (* from the input file to the output file *)         fun recurs(copt: char option) =                    case copt of                             NONE => (TextIO.closeIn ins; TextIO.closeOut outs                  | SOME(c) => (TextIO.output1(outs, c));  recurs(TextIO.intput1 ins))    in         recurs(TextIO.input1 ins)    end

Conclusions

• Concurrent ML is a well-formed language due to its basis on a pre-established language, SML.

• CML can provide an introduction to the concepts and challenges inherent to concurrent programming for students and hobbyists.

• Unfortunately, there seems to be a lack of example code and sufficient documentation. These facts may prevent many from becoming familiar with the language.

7/15/2009

Programming Language: Concurrent ML

Matt Defenthaler John Maskasky Vinash Seenath

7/15/2009