COP 4020 Programming Languages Parallel Programming in Ada and Java

1
COP 4020Programming LanguagesParallel
Programming in Ada and Java

• Gregory A. Riccardi
• Department of Computer Science
• Florida State University
• December 1, 1998

2
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

3
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 g6
• what is value of h?
• this is a race condition.
• type ptrT is access T

4
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

5
Task Execution and Termination

• declare -- beginning of block
• T1 TT -- T1 gets ready to execute, stack
  created
• begin -- T1 begins its execution here
• ltstatements of blockgt -- 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
• ltstatements of blockgt -- T1 executes in parallel
  with this code
• end -- block does not wait for Tptr to finish.
• Terminate T1 -- immediately terminates execution
  of T1

6
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

7
Threads in Java

• class MyThread extends Thread public void
  run() // code for execution
• MyThread threadVar new MyThread()threadVar.sta
  rt()
• 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

8
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() ...

9
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)ObjectOutputS
  tream out new ObjectOutputStream
  (sock.getOutputStream()out.writeObject(out) //
  object is transferred!
• To receive object,
• create a server socket
• open ObjectInputStream
• readObject