Embed Size (px)
Citation preview
Transparent Grid EnablementTransparent Grid EnablementUsing Transparent Shaping and GRID superscalar
I. Description and MotivationI. Description and Motivation II. Background Information: Transparent ShapingII. Background Information: Transparent Shaping
S. Masoud Sadjadi, Juan Carlos Martinez, Luis Atencio, and Tatiana SoldoAutonomic and Grid Computing Research Lab
School of Computing and Information Sciences, FIUContact: [email protected]
IV. IV. Activity DiagramActivity Diagram: Integration Approach with Matrix Multiplication Case Study: Integration Approach with Matrix Multiplication Case Study
Rosa M. Badia and Jorge EjarqueGrid Computing and Clusters
Barcelona Supercomputing Center and UPC, SpainContact: [email protected]
What is the project trying to do?
– Explore techniques and tools to simplify the process of grid enablement
Why is it important?
– Building, debugging, deploying, and maintaining Grid enabled application is difficult (even when a sequential version of the application exists)
What is the expected output?
– Methodologies and tools that enable easy implementation of Grid applications.
Case Study
– Matrix Multiplication
– Hurricane Mitigation Applications
Transparent Shaping is a programming model that allows software systems to change their behavior transparently at runtime, i.e. without any manual modifications to the original code.
TRAP/J (Transparent Reflective Aspect Programming in Java) is the realization of this model in Java, which provides dynamic adaptation to existing Java application.
A B C
X =
Flow of Control in the Original Application
Development Time
Original Application
A scientist will develop the business logic of the application using a sequential code
(e.g., a matrix multiplication algorithm).
Compile Time
Adapt-ReadyApplication
Merge
GRIDsuperscalar
Grid-Enabled Adapt-ReadyApplication
Runtime
Time
Invoke Original Task
Execute the Original Task
Flow of Control in the Adapt-Ready Application
Invoke Original Task
Execute the Original Task
Execute the New Task
Adapt?YesNoTRAP/J
Configuration
TRAP/J
Grid-EnabledApplication
startup Time
Scientist
ComputerExpert
1
2
A B C
X =A00 A01
A10 A11
B00 B01
B10 B11
C00 C01
C10 C11
Finer-Grain Parallelism: Adaptive code for maximum parallelism of 9.
A computer expert will identify sections of the code that can be parallelized.
A B C
X =A00 A01
A10 A11
A20 A21
A02
A12
A22
B00 B01
B10 B11
B20 B21
B02
B12
B22
C00 C01
C10 C11
C20 C21
C02
C12
C22
A computer expert will develop adaptive code with different parallelism granularity.
Coarser-Grain Parallelism: Adaptive code for maximum parallelism of 4.
A system administrator will configure the application to use the appropriate parallel
algorithm based on the availability of resources (e.g., number of available
nodes).
System Administrator
C10=C10+A10*B00
C10=C10+A11*B10
C10=C10+A12*B20
C11=C11+A10*B01
C11=C11+A11*B11
C11=C11+A12*B21
C12=C12+A10*B02
C12=C12+A11*B12
C12=C12+A12*B22
C20=C20+A20*B00
C20=C20+A21*B10
C20=C20+A22*B20
C21=C21+A20*B01
C21=C21+A21*B11
C21=C21+A22*B21
C22=C22+A20*B02
C22=C22+A21*B12
C22=C22+A22*B22
Maximum parallelism is 9
C00=C00+A00*B00
C00=C00+A01*B10
C00=C00+A02*B20
C01=C01+A00*B00
C01=C01+A01*B10
C01=C01+A02*B20
C02=C02+A00*B00
C02=C02+A01*B10
C02=C02+A02*B20
C00=C00+A00*B00C00=C00+A01*B10C01=C01+A00*B01C01=C01+A01*B11C10=C10+A10*B00C10=C10+A11*B10C11=C11+A10*B01C11=C11+A11*B11
Maximum parallelism is 4
OR
III. Background Information: GRID SuperscalarIII. Background Information: GRID Superscalar
GRID superscalar is a new programming paradigm for GRID enabling applications. With GRID superscalar a sequential application, composed of tasks of certain granularity, is automatically converted into a parallel application where the tasks are executed in different servers of a computational GRID.
At runtime, when a task is called from the main program, GRID superscalar adds a node in a directed graph. Also, adds edges to denote data dependencies with other tasks. Those tasks that do not have dependencies between them can be executed concurrently.
GRID superscalar performs all actions related to the Grid: sends data to the Grid resources, decides which resource to use for each task, submits tasks for execution, exploits data locality to reduce transfers, ...
GRID superscalar environment provides the user with a set of different tools: a code generation tool, that decomposes the code in two, the master and the worker; a deployment center, that checks the Grid and deploys the application; the runtime library, that makes all the decisions; and a graphical monitor, that enables to follow the execution of the application.
