Simple Concurrent Object-Oriented Programming

Simple Concurrent Object-Oriented
Programming
Nati Fuks
Department of Computer Science, York University

SCOOP Outline
 SCOOP Introduction
 Generator
 SCOOP vs Java
 PRODUCER-CONSUMER example
 SCOOP Semantics
 Mapping from SCOOP to Eiffel+THREADs

Concurrency
 Concurrent programming is difficult

 e.g. Java Memory Flaw circa 1999
 A variety of mechanisms must be mastered
 Thread class, synchronize, wait, notify,
mutexes, monitor, critical regions
 Problems such as deadlock, safety and liveness
properties, inheritance anomaly

SCOOP
A single new keyword (separate) provides for a full-
fledged concurrency mechanism !!!
SCOOP platform-independent
.NET
Eiffel + Framework POSIX …
Threads

SCOOP
SCOOP: Simple Concurrent Object-Oriented

Programming. Defined by Bertrand Meyer in OOSC
in 1997
Implementations:
1. Compton. Changes in the open source SmallEiffel

compiler
2. This work
3. SCOOP in the .NET framework

SCOOP Generator
Why SCOOP Generator?

Object-Oriented Design
Design By Contract
Simple and intuitive concurrency model of SCOOP
What do we achieve?
Concurrent programs using SCOOP

SCOOP Generator
 Eiffel SCOOP -> Eiffel + THREAD
 Standard Eiffel code (mutexes and THREADs)

 Eiffel Studio 5.4
Advantages
 Pure Eiffel
 Independence
 Target code is cross-platform
Disadvantage – Debugging on a target code

Producer-Consumer Java Solution

Producer-Consumer SCOOP Solution
- same behaviour as the Java solution
- only one extra keyword separate is used (||)
- uses contracts with all the benefits of DbC

ROOT_CLASS
class ROOT_CLASS creation

make
feature
b: separate BUFFER
p: PRODUCER -- declared separate
c: CONSUMER -- declared separate
make is
-- Creation procedure.
do
create b.make
create p.make(b)
create c.make(b)
end
end

Bounded BUFFER
class BUFFER creation

make
feature
put (x:INTEGER) is
require count <= 3
do q.put(x)
ensure count = old count + 1 and q.has (x)
end
remove is
require count > 0
do q.remove
ensure count = old count - 1
end
…

PRODUCER
separate class PRODUCER creation

make
feature
buffer: separate BUFFER
make (b: separate BUFFER) is do …keep_producing … end
keep_producing is do … produce(buffer,i) … end
produce (b : separate BUFFER; i:INTEGER) is

require b.count <= 2
do b.put(i)
ensure b.has(i)
end
end

CONSUMER
separate class CONSUMER creation

make
feature
buffer: separate BUFFER
make (b: separate BUFFER) is do …keep_consuming… end
keep_consuming is do …consume(buffer)… end
consume (b: separate BUFFER) is

require b.count > 0
do b.remove
ensure b.count = old b.count - 1
end
end

Synchronization in SCOOP
A call to the routine produce with a separate will block until:
(a) the producer gets sole access to the buffer
(b) the buffer must not be full as indicated in the

precondition

Preconditions in SCOOP
if not buffer.full then

buffer.put(value)
produce (b: separate BUFFER; i: INTEGER) is

require
b.count <= 2
i >= 0
do
b.put (i)
end

Mapping to Eiffel + THREAD
separate class class ROOT_CLASS inherit
ROOT_CLASS THREAD_CONTROL
feature feature
request_pended: INTEGER_REF
requests_pended_mutex:MUTEX
b:separate BUFFER b:BUFFER

b_mutex: MUTEX
p:PRODUCER p:PRODUCER

Mapping to Eiffel 2
make is
make is
do
do
requests_pended := 1
b_mutex.lock
create b.make create b.make
b_mutex.unlock

Mapping to Eiffel 3
create p.make (b) create p.make (b, b_mutex,

requests_pended,
requests_pended_mutex)
p.launch
set_feature_to_do ([Current,
"KEEP_PRODUCING_ROUTINE"])

Mapping to Eiffel 4
create c.make (b) same as p.make…
requests_pended_mutex.lock
requests_pended.copy
(requests_pended-1)
requests_pended_mutex.unlock
join_all
end end
Contributions
 Analysis of Meyer’s SCOOP with a view to

implementation – semantics of SCOOP via
Compton’s subsystems
 Based on the semantics of SCOOP – provided a
mapping from SCOOP to Eiffel + Threads.
 Generator parses SCOOP programs, flags syntax
errors and automatically translates to portable
executable code based on the mapping.
 First full implementation of SCOOP
 contracts
 routine calls with multiple separate objects

Thank You

Simple Concurrent Object-Oriented Programming

Uploaded by

Simple Concurrent Object-Oriented Programming

Uploaded by

Simple Concurrent Object-Oriented

Department of Computer Science, York University

 Mapping from SCOOP to Eiffel+THREADs

Department of Computer Science, York University

 Concurrent programming is difficult

Department of Computer Science, York University

Department of Computer Science, York University

SCOOP: Simple Concurrent Object-Oriented

1. Compton. Changes in the open source SmallEiffel

3. SCOOP in the .NET framework

Department of Computer Science, York University

Why SCOOP Generator?

Simple and intuitive concurrency model of SCOOP

Department of Computer Science, York University

 Eiffel SCOOP -> Eiffel + THREAD

 Standard Eiffel code (mutexes and THREADs)

Disadvantage – Debugging on a target code

Department of Computer Science, York University

Department of Computer Science, York University

- same behaviour as the Java solution

- only one extra keyword separate is used (||)

- uses contracts with all the benefits of DbC

Department of Computer Science, York University

class ROOT_CLASS creation

Department of Computer Science, York University

class BUFFER creation

Department of Computer Science, York University

separate class PRODUCER creation

make (b: separate BUFFER) is do …keep_producing … end

keep_producing is do … produce(buffer,i) … end

produce (b : separate BUFFER; i:INTEGER) is

Department of Computer Science, York University

separate class CONSUMER creation

make (b: separate BUFFER) is do …keep_consuming… end

keep_consuming is do …consume(buffer)… end

consume (b: separate BUFFER) is

Department of Computer Science, York University

(a) the producer gets sole access to the buffer

(b) the buffer must not be full as indicated in the

Department of Computer Science, York University

if not buffer.full then

produce (b: separate BUFFER; i: INTEGER) is

Department of Computer Science, York University

b:separate BUFFER b:BUFFER

Department of Computer Science, York University

Department of Computer Science, York University

create p.make (b) create p.make (b, b_mutex,

Department of Computer Science, York University

 Analysis of Meyer’s SCOOP with a view to

Department of Computer Science, York University

Department of Computer Science, York University

You might also like