A Runtime System for Dynamic Grain Packing

1
Scalable Object Oriented Parallel Programming
(SCOOPP)
João Luís SobralDepartamento de
InformáticaUniversidade do MinhoBraga - Portugal
2
Object Oriented Concurrent Programming

• Concurrent and Parallel Programming
• Concerned with efficiency
• Abstractions
• Processes or/and threads
• Inter-processes communication (IPC) or/and
  synchronisation
• Object Oriented Programming
• Concerned with development and maintenance costs
• Abstractions
• Objects and classes
• Method calls

3
Object Oriented Concurrent Programming

• Parallel Programming Object Oriented
  Programming
• Efficiency low development and maintenance
  costs
• Abstractions?
• Processes or/and threads and Inter-processes
  communication?
• Objects and method calls
• Design approaches
• Centred on processes
• Centred on objects
• Object based
• Method based

4
Object Oriented Concurrent Programming

• Process centred approach
• Abstractions
• Processes IPC objects method calls
• Drawbacks
• Processes and IPC lack of OO features
• Static bind of objects to process

5
Object Oriented Concurrent Programming

• Object centred approach - Method based
• Abstractions
• Objects method calls asynchronous method
  calls
• Based on intra-object concurrency
• Drawbacks
• Low efficiency on distributed memory systems
• Object centred approach - Object based
• Abstractions
• Active objects method Calls asynchronous
  method calls
• Based on inter-object concurrency
• Drawbacks
• High implementation costs of active objects

6
SCOOPP overview(SCalable Object Oriented
Parallel Programming)

• Main Goals
• Support scalable, portable and efficient //
  applications
• Support already developed OO sequential code
• Main Features
• Support both explicit and implicit parallelism
• Parallelism extraction
• Excess parallelism removal at run-time(e.g.,
  dynamic granularity control)
• Hybrid compile and run-time system

7
SCOOPP overview

• Motivation
• Parallelism grain-size has a strong impact on
  performance
• Larger number of parallel tasks may help to scale
  the application and improve load distribution
• If parallel tasks are too fine, performance may
  degrade due to parallelism overheads
• Example (prime numbers sieve)

8
SCOOPP programming model

• Based on parallel and sequential objects
• Parallel objects are specified at class level
• Sequential objects are placed in a parallel
  object context
• Inter-parallel object communication based on
  asynchronous or synchronous method invocation
• First class references to parallel objects

9
SCOOPP parallelism extraction

• Transforms sequential objects into parallel
  objects
• Adds further parallelism to parallel code
• Performs inter-object dependency analysis to
  preserve the sequential code determinism
• Example

10
SCOOPP dynamic grain-size adaptation

• Packing methodologies
• How to adapt the grain-size?
• Which tasks to pack?
• Packing policies
• When to adapt the grain-size?
• How many items to pack?

11
SCOOPP dynamic grain-size adaptation

• How to adapt the grain-size?
• Pack // objects
• Associate a process to several // objects
• Serialise intra-process operations
• Intra-grain method calls performed directly
• Object creation/deletion performed directly
• Pack method calls
• Include several method calls in a single message
• Example

12
SCOOPP dynamic grain-size adaptation

• Which tasks to pack/unpack?
• On // object creations
• Pack a newly created // object into de source
  grain or create a new remote grain
• On method calls
• Generate a new message for method call or pack it
  together with other method calls
• Based on run-time granularity information

13
SCOOPP dynamic grain-size adaptation

• Granularity information
• Application independent
• Latency of a remote null-method call
• Inter-node communication bandwidth
• Application dependent
• Average overhead of method parameters passing
• Average method execution time
• Average method fan-out

14
SCOOPP dynamic grain-size adaptation

• When to adapt the grain-size?
• When the overhead of a remote method call is
  larger than the average method execution time
• When the systems is highly loaded
• How many items to pack?
• // objects
• Remote call overhead should be less than remote
  work
• Method calls
• Message passing overhead should be less than
  remote work

15
Current prototype (ParC)

• Extension to C
• Runs on Parix and PVM environments
• RTS

Inter-grains a) and intra-grain b) method call,
RTS c) and d) direct object creation
16
Current prototype (ParC)

• Example - prime number sieve
• parallel class SieveFilter
• SieveFilter seg, int myVal // next sieve and
  my prime number
• public
• SieveFilter(int prime) myValprime seg0
• void Process(int num)
• if ((nummyVal)0) / nothing / // myVal
  divides num
• else if (seg!0) seg-gtProcess(num) // may be
  prime number
• else seg new SieveFilter(num) //is a
  prime
• void openOn(void)
• SieveFilter firstSieve new SieveFilter(3)
  // create first sieve
• for(int i5 iltmax i2) firstSieve-gtProcess(i)
  // send values

17
Evaluation results (on ParC)

• Low level evaluation
• Object management overhead costs (Myrinet cluster
  of 4x PII, 350Mhz, in msec)

18
Evaluation results (on ParC)

• High level evaluation - prime number sieve

19
Concluding remarks

• SCOOPP main benefits
• Allows the expression of the full potential
  parallelism, following an OO approach, in a
  platform independent way
• Provides dynamic and efficient scalability across
  several target platforms, without any code
  modification
• Current and future work
• Packing policies for other types of applications
• More case studies