Full HTML for

Scripted foilset CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture

Given by Geoffrey C. Fox at Delivered Lectures of CPS615 Basic Simulation Track for Computational Science on 24 September 96. Foils prepared 27 December 1996
Outside Index Summary of Material Secs 139.6

This continues the discussion of Fortran 90 with a set of overview remarks on each of the key new capabilities of this language
We also comment on value of Fortran90/HPF in a world that will switch to Java
We disgress to discuss a general theory of problem architectures as this explains such things as tradeoffs
  • HPCC v Software Engineering
  • HPF versus MPI
And the types of applications each software model is designed to address
(Note Server errors at start which confuses audio)

Table of Contents for full HTML of CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture

 Denote Foils where Image Critical
Denote Foils where Image has important information
Denote Foils where HTML is sufficient
Indicates Available audio which is lightpurpleed out if missing
1 Delivered Lectures for CPS615 -- Base Course for the Simulation Track of Computational Science
Fall Semester 1996 --
Lecture of September 24 - 1996
2 Abstract of Sept 24 1996 CPS615 Lecture
3 Important Features of Fortran90
4 Introduction to Fortran90 Arrays - I
5 Introduction to Fortran90 Arrays - II
6 Fortran90 Arrays and Memory Allocation
7 More on Fortran90 Arrays and Subroutines
8 Typical Use of Array and Intrinsic Operations
9 Derived Type in Fortran90
10 Examples of POINTER's in Fortran90
11 MODULEs in Fortran90
12 MODULEs INTERFACES and Overloaded Operators in Fortran90
13 Outline of HPF Discussion
14 Information on HPF and HPF Forum (HPFF)
15 Possible Programming Models
16 Data Parallel Programming Model
17 Problem Architectures
18 Computing as a Mapping Problem
19 Complex Systems to give a Theory of Computing
20 Parallel Computing is "just" an optimization problem, even if we can't agree on what to optimize
21 Complex System Representation of Levels in Computer Software
22 5 Categories of Problems
23 Example of Basic Problem Architectures Regular Synchronous Problem Class
24 Example of Basic Problem Architectures Irregular Loosely Synchronous
25 Example of Basic Problem Architectures The difficult Asynchronous Class
26 Example of Basic Problem Architectures for MetaProblem Class
27 Software Bus Structure of USMADE
28 The Mapping of Heterogeneous Metaproblems onto Heterogeneous Metacomputer Systems

Outside Index Summary of Material

HTML version of Scripted Foils prepared 27 December 1996

Foil 1 Delivered Lectures for CPS615 -- Base Course for the Simulation Track of Computational Science
Fall Semester 1996 --
Lecture of September 24 - 1996

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index
Geoffrey Fox
NPAC
Room 3-131 CST
111 College Place
Syracuse NY 13244-4100
HTML version of Scripted Foils prepared 27 December 1996

Foil 2 Abstract of Sept 24 1996 CPS615 Lecture

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 139.6
This continues the discussion of Fortran 90 with a set of overview remarks on each of the key new capabilities of this language
We also comment on value of Fortran90/HPF in a world that will switch to Java
We disgress to discuss a general theory of problem architectures as this explains such things as tradeoffs
  • HPCC v Software Engineering
  • HPF versus MPI
And the types of applications each software model is designed to address
(Note Server errors at start which confuses audio)
HTML version of Scripted Foils prepared 27 December 1996

Foil 3 Important Features of Fortran90

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 21.6
Arrays are very well supported with memory allocation and set of intrinsics, better passing to procedures etc.
  • This is key capability for HPF
Derived Types allow general object structure (without inheritance) in F90
  • Pointers
  • This area NOT well supported by HPF Compilers as of Summer 1996
Modules replace COMMON INCLUDE etc.
Procedures (functions,subroutines) allow better interfaces, recursion, optional parameters etc.
Better Syntax with free form, more loop control etc.
HTML version of Scripted Foils prepared 27 December 1996

Foil 4 Introduction to Fortran90 Arrays - I

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 436.3
Arrays are "true" objects in Fortran90 and are stored as values of elements plus a data descriptor!
There are operations on full arrays which have natural parallel implementations seen in HPF
New set of array intrinsic (built-in) functions for elements, reductions (process array into a single value), tranformational (reshaping)
  • Note these functions are NOT sufficient for real problems and must have FORALL to define new parallel Array functions
  • FORALL is in HPF but not F90 -- Expected in next round of standard (Fortran95)
  • FORALL( I=0:nx)
    • IF((A(I)+I) < 0) THEN A(I)=0
    • ELSE A(i) = SQRT(A(I)=I)
    • END IF
  • END FORALL
HTML version of Scripted Foils prepared 27 December 1996

Foil 5 Introduction to Fortran90 Arrays - II

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 305.2
Extract sections (subarrays) of arrays as u(lb:ub:step)
  • lb is Lower Bound
  • ub is Upper Bound
  • step (defaults to 1) is step
masked (conditional) Array operations using WHERE .... ELSEWHERE
Can still do Fortran77 array element operations (DO Loops) but of course this might not be interpretable for efficient parallelism by HPF compiler
Note Fortran90 designed for science and engineering with originally special concern for vector supercomputers but Cray supports F77 better than F90(!)
HTML version of Scripted Foils prepared 27 December 1996

Foil 6 Fortran90 Arrays and Memory Allocation

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 128.1
ALLOCATABLE Arrays can be defined at runtime with variable sizing
  • REAL, ALLOCATABLE :: u(:,:) , f(:,:)
  • ALLOCATE ( u(0:nx,0:ny) , f(1:27,0:ny) )
One can define POINTER and TARGET attributes which can be used like REAL, DIMENSION etc.
  • => operator allows one to set a POINTER to "point to" a TARGET
Arguments of a subroutine need NOT define array dimensions in subroutine as these as passed by calling program in data descriptor
Local arrays are created on stack and bounds maybe non constant and evaluated at procedure entry
HTML version of Scripted Foils prepared 27 December 1996

Foil 7 More on Fortran90 Arrays and Subroutines

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 73.4
One passes "assumed-shape" arrays from calling to callee routines using INTERFACE syntax
INTERFACE
  • SUBROUTINE residual (r,u,f)
    • REAL r(:,:) , u(:,:) , F(:,:)
  • END SUBROUTINE
END INTERFACE is called by
call residual (r,u,f) or
call residual ( r(0:nx:2, 0:ny:2) , u(0:nx:2, 0:ny:2) , f(0:nx:2, 0:ny:2) )
where latter example just processes every other element of arrays
HTML version of Scripted Foils prepared 27 December 1996

Foil 8 Typical Use of Array and Intrinsic Operations

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 201.6
REAL u(0:nx,0:ny), A(100,100) , fact , avg
u= fact * (u -avg) Scales and translates all elements of u
avg = .25*( CSHIFT(u,1,1) + CSHIFT(u,-1,1) + CSHIFT(u,1,2) + CSHIFT(u,-1,2)
calculates of average of 4 array elements surrounding each point. Note third argument in CSHIFT is label for axis (1=x 2=y)
SQRT( A(1:100) ) calculates a new array containing 100 square roots
SUM(A) is a reduction operator sumimg all elements of array A as a scalar
SIZE(A,1) is an Array Query Intrinsic giving size of A in the first dimension and is particularly useful for "assumed-shape" arrays passed into subroutines
HTML version of Scripted Foils prepared 27 December 1996

Foil 9 Derived Type in Fortran90

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 164.1
TYPE PERSON
  • CHARACTER(LEN=10) NAME
  • REAL AGE
  • INTEGER ID
END TYPE PERSON
TYPE(PERSON) YOU,ME
The Identification number of YOU would be accessed as YOU%ID as an ordinary integer
One can define global operators so that YOU+ME could be defined
One can use name of derived type as a constructor
YOU = PERSON ('Pamela Fox', 12, 3)
HTML version of Scripted Foils prepared 27 December 1996

Foil 10 Examples of POINTER's in Fortran90

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 128.1
One can define a linked list as:
TYPE ENTRY
  • REAL VALUE
  • INTEGER INDEX
  • TYPE(ENTRY), POINTER :: NEXT
END TYPE ENTRY
ALLOCATE Creates dynamically elements in a linked list
CURRENT = ENTRY( NEW_VALUE, NEW_INDEX, FIRST)
FIRST => CURRENT
adds a new entry at start of linked list and renames it with POINTER FIRST
HTML version of Scripted Foils prepared 27 December 1996

Foil 11 MODULEs in Fortran90

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 64.8
General Syntax is:
MODULE name
  • Specify it!
CONTAINS This is optional
  • module subprograms
END MODULE name
MODULE IllustratingCommonBlock
  • INTEGER DIMENSION(52) :: CARDS
END MODULE IllustratingCommonBlock
replaces COMMON construct and can be used as
USE IllustratingCommonBlock
HTML version of Scripted Foils prepared 27 December 1996

Foil 12 MODULEs INTERFACES and Overloaded Operators in Fortran90

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 80.6
MODULE INTERVAL_ARITHMETIC
  • TYPE INTERVAL
    • REAL LOWER, UPPER
  • END TYPE INTERVAL
  • INTERFACE OPERATOR(+) define overloaded + operator
    • MODULE PROCEDURE ADD_INTERVALS
  • END INTERFACE
CONTAINS
  • FUNCTION ADD_INTERVALS(A,B)
    • TYPE(INTERVAL) ADD_INTERVALS, A, B
    • ADD_INTERVALS%LOWER = A%LOWER + B%LOWER
    • ADD_INTERVALS%UPPER = A%UPPER + B%UPPER
  • END FUNCTION ADD_INTERVALS(A,B)
END MODULE INTERVAL_ARITHMETIC
HTML version of Scripted Foils prepared 27 December 1996

Foil 13 Outline of HPF Discussion

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 48.9
What is HPF, what we need it for, where it came from
Why it is called "High Performance"?
What are HPF compiler directives
Data mapping in HPF
Parallel statements and constructs in HPF
Latest Discussions -- HPF-2
HTML version of Scripted Foils prepared 27 December 1996

Foil 14 Information on HPF and HPF Forum (HPFF)

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 90.7
Rice has taken lead in HPF Forum which is a much faster mechanism of getting agreement than formal 10 year process which Fortran90 suffered
World Wide Web at rice and Vienna
  • http://www.crpc.rice.edu/HPFF/home.html
  • http://www.vcpc.univie.ac.at/HPFF/home.html
Mailing List is majordomo@cs.rice.edu and choose list (hpff, hpff-interpret, hpff-core) you wish to subscribe to
Anonymous FTP to titan.cs.rice.edu and look at
  • public/HPFF/README for latest list of files
HTML version of Scripted Foils prepared 27 December 1996

Foil 15 Possible Programming Models

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 218.8
Explicit Message Passing as in PVM or MPI
User breaks program into parts and the parts send messages between them to implement communication necessary for synchronization and integration of parts into solution of a single program
This matches hardware but is not particularly natural for problem and can be machine dependent
Object Oriented programming is like message passing but now objects and not programs communicate
  • Very good when objects are natural from the problem and represent functional parallelism
  • However in data parallel problems tackled with object oriented approach, one must break problem up into a number of objects that depends on number of processors and so reflects machine and not problem
HTML version of Scripted Foils prepared 27 December 1996

Foil 16 Data Parallel Programming Model

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 159.8
Data Parallelism is higher level than either message passing or object models (if objects used to break up data to respect computer)
It provides a Shared Memory Programming Model which can be executed on SIMD or MIMD computers, distributed or shared memory computers
Note it specifies problem not machine structure
It in principle provides the most attractive machine independent model for programmers as it reflects problem and not computer
Its disadvantage is that hard to build compilers especially for the most interesting new algorithms which are dynamic and irregular!
HTML version of Scripted Foils prepared 27 December 1996

Foil 17 Problem Architectures

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 303.8
See Parallel Computing Works for general discussion of problem architecture
Software Maps
Problem ---> Machine
Often software designed around machine architecture
Rather software should be designed around problem architecture
Only able to persuade application scientist to parallelize
HTML version of Scripted Foils prepared 27 December 1996

Foil 18 Computing as a Mapping Problem

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 133.9
A hierarchy of mapping problems
We would like to optimize the overall mapping
HTML version of Scripted Foils prepared 27 December 1996

Foil 19 Complex Systems to give a Theory of Computing

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 184.3
Both problems and computer are
Collections of homogeneous or heterogeneous basic entities with some sort of static or dynamic connection between them
Modeling involves mapping one "complex problem" into another
Simulation or parallel computing involves map
    • Complex problem ---> Complex Computer
What parameters of these two underlying complex systems control effectiveness of map?
HTML version of Scripted Foils prepared 27 December 1996

Foil 20 Parallel Computing is "just" an optimization problem, even if we can't agree on what to optimize

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 122.4
Execution time
  • main focus of HPCC community?
User happiness
  • main focus of software engineering community
HTML version of Scripted Foils prepared 27 December 1996

Foil 21 Complex System Representation of Levels in Computer Software

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 159.8
See Parallel Computing Works for problem architecture
HTML version of Scripted Foils prepared 27 December 1996

Foil 22 5 Categories of Problems

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 48.9
Synchronous: Data Parallel Tightly coupled and software needs to exploit features of problem structure to get good performance. Comparatively easy as different data elements are essentially identical.
Loosely Synchronous:
  • As above but data elements are not identical. Still parallelizes due to macroscopic time synchronization.
Asynchronous:
  • Functional (or data) parallelism that is irregular in space and time. Often loosely coupled and so need not worry about optimal decompositions to minimize communication. Hard to parallelize (massively) unless ....
Embarrassingly parallel:
  • Essentially independent execution of disconnected components. (can involve reductions)
Metaproblems
  • Asynchronous collection of (loosely) synchronous components where these programs themselves can be parallelized
HTML version of Scripted Foils prepared 27 December 1996

Foil 23 Example of Basic Problem Architectures Regular Synchronous Problem Class

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 190
See Parallel Computing Works for QCD and Synchronous problems
eg. Quantum chromodynamics calculations (calculate proton mass)
Regular grid in 4D space-time - domain decomposition
Update algorithm identical at each point
Time evolution very simple
The world looked at microscopically in terms of a set of similar fundamental quantities
Monte Carlo - subtlety that cannot update concurrently points linked in Hamiltonian
HTML version of Scripted Foils prepared 27 December 1996

Foil 24 Example of Basic Problem Architectures Irregular Loosely Synchronous

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 381.6
See Parallel Computing Works for Loosely Synchronous problems
The world looked at macroscopically in terms of interactions between irregular inhomogeneous objects evolved as a time synchronized simulation
eg. circuit simulation for computer or biological applications
Linked sets of neurons (components) of different types
Time taken to model one time step of type i depends on nature of node and interconnect between them
HTML version of Scripted Foils prepared 27 December 1996

Foil 25 Example of Basic Problem Architectures The difficult Asynchronous Class

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 228.9
See Parallel Computing Works Asynchronous problems (including Computer Chess)
The world looked at macroscopically in terms of interactions between irregular inhomogeneous objects evolved as an event driven simulation
eg. Battle of Hastings
HTML version of Scripted Foils prepared 27 December 1996

Foil 26 Example of Basic Problem Architectures for MetaProblem Class

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 247.6
See Parallel Computing Works for Metaproblems including Command and Control
Metaproblems are of growing importance in general HPCC community
One important Example is:
Manufacturing and Design including Multidisciplinary Optimization which combines many fields to look at total product design, manufacturability etc.
  • Geometry
  • Grid Generation
  • Fluid Flow ----> Performance
  • Acoustics
  • Structural Analysis
  • Optimization Module
  • Visualization
Also link in concurrent engineering
  • Design - Manufacturing - Marketing - Service
HTML version of Scripted Foils prepared 27 December 1996

Foil 27 Software Bus Structure of USMADE

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 53.2
USMADE is US Multidisciplinary Analysis and Design Environment Project of MADIC Industrial Consortium
HTML version of Scripted Foils prepared 27 December 1996

Foil 28 The Mapping of Heterogeneous Metaproblems onto Heterogeneous Metacomputer Systems

From CPS615-Introduction to F90 Features, Rationale for HPF and Problem Architecture Delivered Lectures of CPS615 Basic Simulation Track for Computational Science -- 24 September 96. *
Full HTML Index Secs 141.1
© Northeast Parallel Architectures Center, Syracuse University, npac@npac.syr.edu

If you have any comments about this server, send e-mail to webmaster@npac.syr.edu.

Page produced by wwwfoil on Fri Aug 15 1997