12/1/98

COP 4020Programming LanguagesParallel Programming in Ada and Java

Gregory A. Riccardi

Department of Computer Science

Florida State University

December 1, 1998

12/1/98

Two Strategies for Parallelism Ada, task synchronization

Tasks execute independently Rendezvous provides synchronized execution

between 2 tasks Java, method and object synchronization

Threads execute independently Synchronized methods are executed as critical

sections only one execution per synch. method

Synchronized statements depend on objects one execution per object of any statement

12/1/98

Tasks in Ada Ada supports a program unit declaration of tasks

Each task object represents a separate unit of execution Tasks can share objects through usual global packages and

nesting Task T is . . . end; -- declaration of a single task object Task type TT is . . . end; -- type for many objects

T1: TT; T2: TT; -- T1 and T2 are task objects Example using global variables g and h

task type TT ; task body TT is x: integer; begin x := g; h := x; end;

-- each task of type TT uses global g T1, T2: TT; g:= 4; g := 5; g:=6;

what is value of h? this is a race condition.

type ptrT is access T;

12/1/98

Synchronization and Communication Synchronization is required to eliminate race conditions. Ada tasks synchronize by 'rendezvous'

Two tasks , one is caller, one is receiver Caller requests a meeting for a specific purpose Receiver offers to accept a meeting for any of a specific

collection of purposes Meeting takes place:

Caller passes information to receiver and waits Receiver gets information, executes by itself, passes information

back and continues its execution Caller gets information from receiver and continues

Place (or purpose) is called entry like procedure specification

Call is an entry call, syntax exactly like procedure call Receive is an accept, very much like a procedure body

12/1/98

Task Execution and Termination declare -- beginning of block

T1: TT; -- T1 gets ready to execute, stack created begin -- T1 begins its execution here <statements of block> -- T1 executes in parallel with

this code end; -- block is not completely finished until T1 finishes.

declare -- beginning of block Tptr: TT * = new TT; -- *Tptr gets ready to execute, and

begins begin <statements of block> -- T1 executes in parallel with

this code end; -- block does not wait for *Tptr to finish.

Terminate T1; -- immediately terminates execution of T1

12/1/98

Storage Management for Tasks Does each task need its own stack?

Each task has access to other stacks appropriate to its nesting

Guarantees of mutual exclusion Two tasks that wish to access shared objects

Access only during rendezvous, receiver accesses object and passes value to caller

Use rendezvous to synchronize Caller references variable, then makes entry call Receiver waits to reference until it has received a call

The accept statement is guaranteed to execute while the caller is blocked.

Create a third task to provide access to shared data New task is a monitor.

Create a message passing task to send/receive messages

12/1/98

Threads in Java

class MyThread extends Thread {public void run() {// code for execution

MyThread threadVar = new MyThread();threadVar.start();

class MyRunner implements Runnable {public void run() { // code for execution

MyRunner runVar = new MyRunner();new Thread(runVar).start();

Other methods stop, sleep, suspend, resume, yield,

destroy

12/1/98

Synchronization in Java Synchronization uses locks and monitors

Objects can be locked Methods can have exclusive execution

synchronized statement synchronized (expression) statement obtain lock for object or array then execute stmt Example of sorting a shared array

synchronized (a) {//sort array here…}

synchronized modifier method that is executed exclusively class MyObject {

public synchronized void update() ...

12/1/98

Distributed Objects in Java

Java supports communication between programs java.net.Socket and Java.net.ServerSocket

To send objects to another program Socket sock = new Socket(host,port);ObjectOutputStream out = new ObjectOutputStream (sock.getOutputStream();out.writeObject(out); // object is transferred!

To receive object, create a server socket open ObjectInputStream readObject