12/1/98 cop 4020 programming languages parallel programming in ada and java gregory a. riccardi...
TRANSCRIPT
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