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 ) isdo

x.f()end

…x: separate CLASScreate x.makeb.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)

Processor 1

Object x (Supplier)

Processor 2

SOME_ROUTINE(x)

x.f()

f() is do

… end

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 ) isdo

x.f()end

…a: separate CLASScreate a.makeSOME_ROUTINE(a) -- instead of a.f()

Basic Access Control Policy Example

Processor 1

while( !lock(a) )wait( a )

SOME_ROUTINE(a)a.f()release(a)

Processor 2

f() isdo

…end

Access control policy• Using Design by Contractstore(buffer: separate BUFFER; value: INTEGER) is

require -- preconditionbuffer_not_full: not buffer.is_full

dobuffer.put(value)

ensure -- postconditionbuffer_not_empty: not buffer.is_empty

end…buf: separate BUFFERstore(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

Examplesome_feature( x, y, z: separate CLASS ) is

dox.fy.fx.gz.fy.gv := x.is_empty -- wait for x.f and x.gv := x.value > y.value -- wait for y.f and y.g

end

Producer/Consumer ExampleProduceAndConsume( p: separate PRODUCER, c: separate CONSUMER ) is

doc.consume_n(5);p.produce_n(5);

end…buf: separate BUFFERconsumer: separate CONSUMERproducer: separate PRODUCERcreate c.make(buf)create p.make(buf)ProduceAndConsume(producer, consumer)

Producerproduce_n (n: INTEGER) is

localvalue: INTEGERi: INTEGER

dofrom i := 1until i > nloop

value := random_gen.next

store (buf, value)i := i + 1

endend

end -- class PRODUCER

store (buffer: separate BUFFER [INTEGER];value: INTEGER) isrequire

buffer_not_full: not buffer.is_fullvalue_provided: value /= Void

dobuffer.put (value)

end

Consumerconsume_n (n: INTEGER) is

locali: INTEGER

dofrom i := 1

until i > nloop

consume_one (buf)

i := i + 1end

end

consume_one (buffer: separateBUFFER [INTEGER]) isrequirebuffer_specified: buffer /= Voidbuffer_not_empty: not buffer.is_emptydovalue := buffer.itembuffer.removeend

Producer/Consumer ExampleProduceAndConsume( p: separate PRODUCER, c: separate CONSUMER ) is

doc.consume_n(5);p.produce_n(5);

end…buf: separate BUFFERconsumer: separate CONSUMERproducer: separate PRODUCERcreate 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 classseparate class BUFFER

inherit QUEUEend

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 Desktoppacific.cse.msu.edu

arctic.cse.msu.edu

Processor 1Processor 3

Processor 2

Processor 4

Processor 5

o1

o2

o3

o4

o5

o6

LANInternet

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