Scoop: Simple Concurrent Object-oriented Programming

SCOOP: Simple Concurrent Object-Oriented Programming Piotr Nienaltowski, Volkan Arslan, Bertrand Meyer

presented by: Mark Schall

The Problem “What is the simplest, smallest and most convincing extension to the method of systematic object-oriented software construction that can address the needs of concurrent and distributed computing as well as those of sequential computation?” – Bertrand Meyer

SCOOP Model • • • •

High-level concurrency mechanism Based on Design by Contract Full use of inheritance Applicable to many physical setups: multiprocessing, multithreading, distributed execution

Brief History • First published in 1993 by Bertrand Meyer • Designed as extension to Eiffel • First prototype was implemented in 1995

Architecture • Top Layer: – platform independent

• Bottom Layer: – language/platform specific

Bottom Layer • Eiffel: – Added single new keyword separate

• .NET – Add two new classes to be inherited: • SEPARATE_CLIENT • SEPARATE_SUPPLIER

Separate Calls • Keyword separate declares if an object should be handled on the same processor or not SOME_ROUTINE( x: separate CLASS ) is do x.f() end

… x: separate CLASS create x.make b.SOME_ROUTINE(x)

x.f() will be handled on a different processor then the call b.SOME_ROUTINE(x )

Client and Supplier Object b (Client) SOME_ROUTINE(x)

Object x (Supplier) f() is do

x.f()

… end Processor 2

Processor 1

Processors • • • • •

Not just mean physical CPU Threads Processes Computers in a distributed system Application Domain

Access control policy • Separate calls are valid if the target of the call is an argument of the enclosing routine SOME_ROUTINE( x: separate CLASS ) is do x.f() end … a: separate CLASS create a.make SOME_ROUTINE(a) -- instead of a.f()

Basic Access Control Policy Example Processor 1

Processor 2

while( !lock(a) ) wait( a ) SOME_ROUTINE(a ) a.f() release(a)

f() is do … end

Access control policy • Using Design by Contract store(buffer: separate BUFFER; value: INTEGER) is require -- precondition buffer_not_full: not buffer.is_full do buffer.put(value) ensure -- postcondition buffer_not_empty: not buffer.is_empty end … buf: separate BUFFER store(buf, 20)

Wait by necessity • Client Objects – do not need to wait for feature calls of a supplier in order to call another feature call – must wait on query calls for all previous calls to finish on the same supplier

Example some_feature( x, y, z: separate CLASS ) is do x.f y.f x.g z.f y.g v := x.is_empty -- wait for x.f and x.g v := x.value > y.value -- wait for y.f and y.g end

Producer/Consumer Example

ProduceAndConsume( p: separate PRODUCER, c: separate CONSUMER ) is do c.consume_n(5); p.produce_n(5); end … buf: separate BUFFER consumer: separate CONSUMER producer: separate PRODUCER create c.make(buf) create p.make(buf) ProduceAndConsume(producer, consumer)

Producer

store (buffer: separate BUFFER [INTEG produce_n (n: INTEGER) is value: INTEGER) is local require value: INTEGER buffer_not_full: not buffer.is_ful i: INTEGER value_provided: value /= Void do do from i := 1 buffer.put (value) until i > n end loop value := random_gen.next store (buf, value) i := i + 1 end end end -- class PRODUCER

Consumer consume_n (n: INTEGER) is local i: INTEGER do from i := 1 until i > n

loop consume_one (buf) i := i + 1 end end

consume_one (buffer: separate BUFFER [INTEGER]) is require buffer_specified: buffer /= Void buffer_not_empty: not buffer.is_empty do value := buffer.item buffer.remove end

Producer/Consumer Example

ProduceAndConsume( p: separate PRODUCER, c: separate CONSUMER ) is do c.consume_n(5); p.produce_n(5); end … buf: separate BUFFER consumer: separate CONSUMER producer: separate PRODUCER create c.make(buf) create p.make(buf) ProduceAndConsume(producer, consumer)

Reusing old software • Support for inheritance allows for reuse of non-concurrent software • May only require a simple wrapper class separate class BUFFER inherit QUEUE end

Distributed Computing • Processors can be Computers in the network • Concurrency Control File – maps processors to physical addresses • machines • processes • etc.

• Can take advantage of .NET Remoting library

Distributed Computing Home Desktop Processor 1 o 1 Processor 2 o 2

Internet

pacific.cse.msu. edu Processor 3 o 3 o 4

LAN

arctic.cse.msu.ed uProcessor 4 o 5 Processor 5 o 6

Duels • An attempt to grab a shared object from the current holder • Holder – retain (default) – yield

• Challenger – wait_turn (default) – demand – insist

• Exceptions interrupt either the Holder or Challenger to settle the Duel

Future Work • Real-time programming – Priority mechanisms – Timeout controls

• Deadlock Avoidance

Future Work • RECOOP – Reliable and Efficient Concurrent Object-Oriented Programs • Microsoft’s Safe and Scalable Multicore Computing RFP • Continuation of SCOOP • Developing a practical formal semantics and proof mechanism