Scientific Components and Frameworks
|
|
- Bertina Burns
- 6 years ago
- Views:
Transcription
1 High Performance Computing: Concepts, Methods & Means Scientific Components and Frameworks Prof. Daniel S. Katz Department of Electrical and Computer Engineering Louisiana State University April 24 th, 2007 AT LOUISIANA STATE UNIVERSITY
2 Opening Remarks Context: high performance computing May have multiple types of physics May have multiple spatial scales May have multiple time scales May use multiple solvers May need multiple I/O libraries May need multiple visualization interfaces Need to build real, working, complex applications How?
3 Topics Meat Grinder Introduction (slides from Gary Kumfert, part of CCA tutorial) Common Component Architecture (CCA) Cactus Earth System Modeling Framework (ESMF) Summary 3
4 A Pictorial Introduction to Components in Scientific Computing
5 Once upon a time... Input Output Program 5
6 6 As Scientific Computing grew...
7 7 Tried to ease the bottle neck
8 SPMD was born
9 SPMD worked. 1 2 But it isn t easy!!!
10 Meanwhile, corporate computing was growing in a different way Input Input client browser spreadsheet graphics Output editor multimedia Unicode Program database 10
11 This created a whole new set of problems complexity 11 client browser editor multimedia spreadsheet graphics Unicode database Interoperability across multiple languages Interoperability across multiple platforms Incremental evolution of large legacy systems (esp. w/ multiple 3rd party software)
12 Component Technology addresses these problems 12
13 So what s a component??? Implementation : No Direct Access Interface Access : Generated by Tools 13 Matching Connector : Assigned by Framework Hidden from User
14 1. Interoperability across multiple languages C Language & Platform independent interfaces C++ F77 Java 14 Python Automatically generated bindings to working code
15 2. Interoperability Across Multiple Platforms Imagine a company migrates to a new system, OS, etc. 15 What if the source to this one part is lost???
16 Transparent Distributed Computing These wires are very, very smart! internet internet 16
17 3. Incremental Evolution With Multiple 3rd party software v 1.0 v 2.0 v
18 Now suppose you find this bug... v 1.0 v 2.0 v
19 Good news: an upgrade available Bad news: there s a dependency v v 2.0 v
20 Great News: Solvable with Components v
21 Great News: Solvable with Components 2.0 v v
22 Why Components for Scientific Computing Complexity 22 DataFoundry SAMRAI JEEP Sapphire Scientific Viz Ardra Overture nonlinear solvers linear solvers ALPS hypre Interoperability across multiple languages Interoperability across multiple platforms Incremental evolution of large legacy systems (esp. w/ multiple 3rd party software)
23 The Model for Scientific Component Programming Science Industry?CCA 23
24 Topics Meat Grinder Introduction Common Component Architecture (CCA) Cactus Earth System Modeling Framework (ESMF) Summary 24
25 CCA Motivation: Modern Scientific Software Engineering Challenges Productivity Time to first solution (prototyping) Time to solution ( production ) Software infrastructure requirements ( other stuff needed ) Complexity Increasingly sophisticated models Model coupling multi-scale, multi-physics, etc. Interdisciplinarity Performance Increasingly complex algorithms Increasingly complex computers Increasingly demanding applications
26 Motivation: For Library Developers People want to use your software, but need wrappers in languages you don t support Many component models provide language interoperability Discussions about standardizing interfaces are often sidetracked into implementation issues Components separate interfaces from implementation You want users to stick to your published interface and prevent them from stumbling (prying) into the implementation details Most component models actively enforce the separation
27 Motivation: For Application Developers and Users You have difficulty managing multiple third-party libraries in your code You (want to) use more than two languages in your application Your code is long-lived and different pieces evolve at different rates You want to be able to swap competing implementations of the same idea and test without modifying any of your code You want to compose your application with some other(s) that weren t originally designed to be combined
28 Some Observations About Software The complexity of software is an essential property, not an accidental one. [Brooks] We can t get rid of complexity Our failure to master the complexity of software results in projects that are late, over budget, and deficient in their stated requirements. [Booch] We must find ways to manage it A complex system that works is invariably found to have evolved from a simple system that worked A complex system designed from scratch never works and cannot be patched up to make it work. [Gall] Build up from simpler pieces The best software is code you don t have to write [Jobs] Reuse code wherever possible
29 Component-Based Software Engineering CBSE methodology is emerging, especially from business and internet areas Software productivity Provides a plug and play application development environment Many components available off the shelf Abstract interfaces facilitate reuse and interoperability of software Software complexity Components encapsulate much complexity into black boxes Plug and play approach simplifies applications Model coupling is natural in component-based approach Software performance (indirect) Plug and play approach and rich off the shelf component library simplify changes to accommodate different platforms
30 A Simple Example: Numerical Integration Components Interoperable components (provide same interfaces) FunctionPort IntegratorPort FunctionPort NonlinearFunction MidpointIntegrator FunctionPort GoPort Driver IntegratorPort LinearFunction FunctionPort IntegratorPort FunctionPort RandomGeneratorPort MonteCarloIntegrator PiFunction RandomGeneratorPort RandomGenerator
31 Many Applications are Possible Dashed lines indicate alternate connections IntegratorPort FunctionPort FunctionPort NonlinearFunction MidpointIntegrator FunctionPort GoPort Driver IntegratorPort LinearFunction FunctionPort Create different applications in "plug-and-play" fashion IntegratorPort FunctionPort RandomGeneratorPort MonteCarloIntegrator PiFunction RandomGeneratorPort RandomGenerator
32 The Sociology of Components Components need to be shared to be truly useful Sharing can be at several levels Source, binaries, remote service Various models possible for intellectual property/licensing Components with different IP constraints can be mixed in a single application Peer component models facilitate collaboration of groups on software development Group decides overall architecture and interfaces Individuals/sub-groups create individual components
33 Who Writes Components? Everyone involved in creating an application can/should create components Domain scientists as well as computer scientists and applied mathematicians Most will also use components written by other groups Allows developers to focus on their interest/specialty Get other capabilities via reuse of other s components Sharing components within scientific domain allows everyone to be more productive Reuse instead of reinvention As a unit of publication, a well-written and tested component is like a high-quality library Often a more appropriate unit of publication/recognition than an entire application code
34 CCA Concepts: Components IntegratorPort FunctionPort FunctionPort MidpointIntegrator NonlinearFunction Components are a unit of software composition Composition is based on interfaces (ports) Components provide/use one or more ports A component with no ports isn t very interesting Components interact via ports; implementation is opaque to the outside world Components include some code which interacts with the CCA framework The granularity of components is dictated by the application architecture and by performance considerations Components are peers Application architecture determines relationships
35 What is a Component Architecture? A set of standards that allows: Multiple groups to write units of software (components) And have confidence that their components will work with other components written in the same architecture These standards define The rights and responsibilities of a component How components express their interfaces The environment in which are composed to form an application and executed (framework) The rights and responsibilities of the framework
36 CCA Concepts: Frameworks The framework provides the means to hold components and compose them into applications The framework is often application s main or program Frameworks allow exchange of ports among components without exposing implementation details Frameworks provide a small set of standard services to components BuilderService allow programs to compose CCA apps Frameworks may make themselves appear as components in order to connect to components in other frameworks Currently: specific frameworks support specific computing models (parallel, distributed, etc.). Future: full flexibility through integration or interoperation
37 CCA Concepts: Ports IntegratorPort FunctionPort FunctionPort MidpointIntegrator NonlinearFunction Components interact through well-defined interfaces, or ports In OO languages, a port is a class or interface In Fortran, a port is a bunch of subroutines or a module Components may provide ports implement the class or subroutines of the port ( Provides Port ) Components may use ports call methods or subroutines in the port ( Uses Port ) Links denote a procedural (caller/callee) relationship, not dataflow! e.g., FunctionPort could contain: evaluate(in Arg, out Result)
38 Interfaces, Interoperability, and Reuse Interfaces define how components interact Therefore interfaces are key to interoperability and reuse of components In many cases, any old interface will do, but General plug and play interoperability requires multiple implementations providing the same interface Reuse of components occurs when they provide interfaces (functionality) needed in multiple applications
39 Designing for Reuse, Implications Designing for interoperability and reuse requires standard interfaces Typically domain-specific Standard need not imply a formal process, may mean widely used Generally means collaborating with others Higher initial development cost (amortized over multiple uses) Reuse implies longer-lived code thoroughly tested highly optimized improved support for multiple platforms
40 Relationships: Components, Objects, and Libraries Components are typically discussed as objects or collections of objects Interfaces generally designed in OO terms, but Component internals need not be OO OO languages are not required Component environments can enforce the use of published interfaces (prevent access to internals) Libraries can not It is possible to load several instances (versions) of a component in a single application Impossible with libraries Components must include some code to interface with the framework/component environment Libraries and objects do not
41 Domain-Specific Frameworks vs Generic Component Architectures Domain-Specific Often known as frameworks Provide a significant software infrastructure to support applications in a given domain Often attempts to generalize an existing large application Often hard to adapt to use outside the original domain Tend to assume a particular structure/workflow for application Relatively common Generic Provide the infrastructure to hook components together Domain-specific infrastructure can be built as components Usable in many domains Few assumptions about application More opportunities for reuse Better supports model coupling across traditional domain boundaries Relatively rare at present Commodity component models often not so useful in HPC scientific context
42 Special Needs of Scientific HPC Support for legacy software How much change required for component environment? Performance is important What overheads are imposed by the component environment? Both parallel and distributed computing are important What approaches does the component model support? What constraints are imposed? What are the performance costs? Support for languages, data types, and platforms Fortran? Complex numbers? Arrays? (as first-class objects) Is it available on my parallel computer?
43 What is the CCA? (User View) A component model specifically designed for high-performance scientific computing Supports both parallel and distributed applications Designed to be implementable without sacrificing performance Minimalist approach makes it easier to componentize existing software
44 What is the CCA? (2) Components are peers Not just a dataflow model A tool to enhance the productivity of scientific programmers Make the hard things easier, make some intractable things tractable Support & promote reuse & interoperability Not a magic bullet
45 Importance of Provides/Uses Pattern for Ports Fences between components Components must declare both what they provide and what they use Components cannot interact until ports are connected No mechanism to call anything not part of a port Ports preserve high performance direct connection semantics While also allowing distributed computing Component 1 Component 2 Component 1 Provides/Uses Port Direct Connection Provides Port Network Connection Component 2 Uses Port
46 CCA Concepts: Framework Stays Out of the Way of Component Parallelism Single component multiple data (SCMD) model is component analog of widely used SPMD model Each process loaded with the same set of components wired the same way Different components in same process talk to each other via ports and the framework Same component in different processes talk to each other through their favorite communications layer (i.e. MPI, PVM, GA) P0 P1 P2 P3 Components: Blue, Green, Red Framework: Gray MCMD/MPMD also supported Other component models ignore parallelism entirely
47 CCA Concepts: MxN Parallel Data Redistribution Share Data Among Coupled Parallel Models Disparate Parallel Topologies (M processes vs. N) e.g. Ocean & Atmosphere, Solver & Optimizer e.g. Visualization (Mx1, increasingly, MxN) Research area -- tools under development
48 CCA Concepts: Language Interoperability Existing language interoperability approaches are pointto-point solutions f77 Babel provides a unified approach in which all languages are considered peers Babel used primarily at interfaces f77 C f90 C f90 C++ Python C++ Babel Python Java Few other component models support all languages and data types important for scientific computing Java
49 What the CCA isn t CCA doesn t specify who owns main CCA components are peers Up to application to define component relationships Driver component is a common design pattern CCA doesn t specify a parallel programming environment Choose your favorite Mix multiple tools in a single application CCA doesn t specify I/O But it gives you the infrastructure to create I/O components CCA doesn t specify interfaces But it gives you the infrastructure to define and enforce them CCA Forum supports & promotes standard interface efforts CCA doesn t require (but does support) separation of algorithms/physics from data
50 What the CCA is CCA is a specification for a component environment Fundamentally, a design pattern Multiple reference implementations exist Being used by applications CCA increases productivity Supports and promotes software interoperability and reuse Provides plug-and-play paradigm for scientific software CCA offers the flexibility to architect your application as you think best Doesn t dictate component relationships, programming models, etc. Minimal performance overhead Minimal cost for incorporation of existing software CCA provides an environment in which domain-specific application frameworks can be built While retaining opportunities for software reuse at multiple levels
51 Review of CCA Terms & Concepts Ports Interfaces between components Uses/provides model Framework Allows assembly of components into applications Direct Connection Maintain performance of local inter-component calls Parallelism Framework stays out of the way of parallel components MxN Parallel Data Redistribution Model coupling, visualization, etc. Language Interoperability Babel, Scientific Interface Definition Language (SIDL)
52 CCA Summary Components are a software engineering tool to help address software productivity and complexity Important concepts: components, interfaces, frameworks, composability, reuse Scientific component environments come in domain specific and generic flavors Scientific HPC imposes special demands on component environments which commodity tools may have trouble with The Common Component Architecture is specially designed for the needs of HPC CCA is a research project - intended to be quite general - not heavily used yet in production
53 Topics Meat Grinder Introduction Common Component Architecture (CCA) Cactus (slides from Tom Goodale) Earth System Modeling Framework (ESMF) Summary 53
54 What Is Cactus? Cactus is a framework for developing portable, modular applications, in particular, although not exclusively, highperformance simulation codes. Cactus is designed to allow experts in different fields to develop modules based upon their expertise and to leverage off modules developed by experts in other fields to perform their work, with minimal knowledge of the internals or operation of the other modules. This enables it to be used in large, geographically dispersed, collaborations. Cactus and the Cactus Computational Toolkit are Open Source and freely available.
55 Cactus Goals Portable Modular People can write modules that interact through standard interfaces with other modules without knowing internals of the other modules Modules with same functionality are interchangeable Support legacy codes Make use of existing technologies and tools where appropriate Future proof Not tied to any particular paradigm Parallelism is independent but compatible with MPI or PVM I/O system is independent but compatible with HDF or others Easy to use Maintainable
56 Cactus History First developed in 1997 by Paul Walker, Joan Masso, and others, as a continuation of a long line of numerical relativity codes, such as the NCSA G-code and Paul's Framework In first years, Cactus became progressively more modular, allowing modules for different formulations of Einstein's equations and different physical systems Although in principle Cactus was modular, its history and evolution had left many dependencies between modules and between the core and the modules Cactus 4.0 (current) is complete redesign of core -- moved everything possible out into modules, and put structures in place to enable modules to be far more independent
57 Current Cactus Users Numerical Relativity Used by many groups including: AEI (Germany), UNAM (Mexico), Tuebingen (Germany), Southampton (UK), Sissa (Italy), Valencia (Spain), U. of Thessaloniki (Greece), MPA (Germany), RIKEN (Japan), TAT (Denmark), Penn State, U. of Texas at Austin, U. of Texas at Brownsville, LSU (USA), Wash, U. of Pittsburgh, U. of Arizona, Washburn, UIB (Spain), U. of Maryland, Monash (Australia) Quantum Gravity Coastal and Climate Modeling CFD KISTI DLR looking at flow in turbines Lattice Boltzmann Over 150 Science Papers Over 30 Student Theses
58 Cactus Structure Cactus source code consists of core part, the Flesh, and set of modules, the Thorns Flesh Independent of all thorns After initialization, acts as a utility and service library that the thorns call to get information or ask for some action to happen Thorns Separate libraries that encapsulate some functionality In order to keep a distinction between functionality and implementation of the functionality, each thorn declares that it provides a certain implementation Different thorns can provide the same implementation, and thorn dependencies are expressed in terms of implementations rather than explicit references to thorns, thus allowing the different thorns providing the same implementation to be interchangeable
59 Structure Plug-In Thorns (modules) driver input/output interpolation parameters Core Flesh error handling extensible APIs ANSI C scheduling make system remote steering Fortran/C/C++ equations of state black holes SOR solver grid variables boundary conditions wave evolvers multigrid coordinates
60 Cactus Flesh Make System API Organizes builds as configurations which hold everything needed to build with a particular set of options on a particular architecture Functions which must be there for thorns to operate Scheduling Sophisticated scheduler which calls thorn-provided functions as and when needed CCL Configuration language which tells the flesh all it needs to know about the thorns
61 Thorn Specification The Flesh finds out about thorns by configuration files in each thorn These files are converted at compile time into a set of routines the Flesh can call to find out about thorns There are three such files Scheduling directives The flesh incorporates a scheduler which is used to call defined routines from different thorns in a particular order Interface definitions All variables which are passed between scheduled routines need to be declared Any thorn-provided functions which other thorns call should be declared Parameter definitions The flesh and thorns are controlled by a parameter file; parameters must be declared along with their allowed values
62 Scheduling Thorns specify which functions are to be called at which time, and in which order Rule-based scheduling system Routines are either before or after other routines (or don't care) Routines can be grouped, and whole group scheduled Functions or groups can be scheduled while some condition is true Flesh sorts all rules and flags an error for inconsistent schedule requests
63 The Driver Layer In principle, drivers are the only thorns which know anything about parallelism Other thorns access parallelism via an API provided by the flesh Underlying parallel layer could be anything from a TCP-socket to Java RMI -- should be transparent to application thorns Could even be a combination of things Can even run with no parallel layer at all Can pick actual driver to use at runtime - no need to recompile code to test differences between parallel layers Can take one executable and use whatever the best layer for any particular environment happens to be
64 Current Drivers There are several drivers available at the moment, both developed by the cactus team and by the community. PUGH a parallel uni-grid driver, which comes as part of the the computational toolkit PAGH a parallel AMR driver which uses the GrACE library for grid hierarchy management Carpet a parallel fixed mesh refinement driver SimpleDriver a simple demonstration driver which illustrates driver development
65 Cactus Computational Toolkit Core thorns which provide many basic utilities, such as: Boundary conditions I/O methods Reduction and Interpolation operations Coordinate Symmetries Parallel drivers Elliptic solvers Web-based interaction and monitoring interface...
66 Current Capabilities: Methods Almost all codes in Cactus are explicit finite difference codes on structured meshes In principle, finite volume or finite element on structured meshes is possible There is now a generic method-of-lines thorn which makes developing thorns using such methods very quick and easy Interface for elliptic solvers and support for generic elliptic solver packages such as PETSc as well as a numericalrelativity-specific multigrid solver written by Bernd Bruegmann However, interface is not as generic as it could be, and it may not be too useful as it stands for solving general implicit problems
67 Current Capabilities: Interaction HTTPD thorn provides interface that allows web browser to connect to running simulation Allows a user to examine state of running simulation and change parameters, such as frequency of I/O or variables to be output, or any other parameter that thorn author declared may be changed during the simulation These capabilities may be extended by any other thorn E.g. the HTTPDExtra thorn allows the user to download any file output by the I/O thorns in the Computational toolkit, and even to view twodimensional slices as jpegs Also, there is helper script for web browsers that allows appropriate visualization tool to be launched when a user requests a file
68 Cactus Summary Used to build apps in NumRel, and starting to be used in other fields Flesh/Thorns distinction Flesh is like CCA Framework + some general components Thorns are like CCA components Production code for certain domains, well-used and well-tested
69 Topics Meat Grinder Introduction Common Component Architecture (CCA) Cactus Earth System Modeling Framework (ESMF) - slides from ESMF tutorial Summary 69
70 ESMF Motivation and Context In climate research and NWP... increased emphasis on detailed representation of individual physical processes; requires many teams of specialists to contribute components to an overall modeling system In computing technology... increase in hardware and software complexity in highperformance computing, as we shift toward the use of scalable computing architectures In software development of first-generation frameworks, such as FMS, GEMS, CCA and WRF, that encourage software reuse and interoperability
71 What is ESMF? ESMF provides tools for turning model codes into components with standard interfaces and standard drivers. ESMF provides data structures and common utilities that components use for routine services such as data communications, regridding, time management and message logging. ESMF Superstructure AppDriver Component Classes: GridComp, CplComp, State User Code ESMF Infrastructure Data Classes: Bundle, Field, Grid, Array Utility Classes: Clock, LogErr, DELayout, Machine ESMF GOALS 1. Increase scientific productivity by making model components much easier to build, combine, and exchange, and by enabling modelers to take full advantage of high-end computers. 2. Promote new scientific opportunities and services through community building and increased interoperability of codes (impacts in collaboration, code validation and tuning, teaching, migration from research to operations)
72 Application Example: GEOS-5 AGCM GEOS-5 coupler Each box is an agcm ESMF component coupler history Every component dynamics physics has a standard coupler coupler interface so that it is swappable gravity_wave_drag fvcore surface Data in and out of coupler components are packaged lake land_ice data_ocean land infrared as state types with user-defined fields coupler New components can be added to the system vegetation catchment Each ESMF application is also a Gridded Component Entire ESMF applications can be nested within larger applications This strategy can be used to systematically compose very large, multicomponent codes. Coupling tools include regridding and redistribution methods chemistry moist_processes radiation turbulence coupler solar
73 Design Strategies Modularity Gridded Components don t have access to the internals of other Gridded Components, and don t store any coupling information Gridded Components pass their States to other components through their argument list. Components can be used standalone or coupled with others into a larger application. Flexibility Users write their own drivers as well as their own Gridded Components and Coupler Components -- Users decide on their own control flow Communication All communication handled within components. If an atmosphere is coupled to an ocean, Coupler Component is defined on both atmosphere and ocean processors. The same programming interface is used for shared memory, distributed memory, and combinations thereof. This buffers the user from variations and changes in the underlying platforms.
74 Elements of Parallelism: Serial vs. Parallel Computing platforms can have multiple processors, some or all of which may share the same memory pools Can be multiple Persistent Execution Threads (PETs) Can be multiple PETs per processor Software like MPI and OpenMP commonly used for parallelization Programs can run in a serial fashion, with one PET, or in parallel, using multiple PETs Often, a PET can be thought of as a processor Sets of PETs are represented by Virtual Machines (VMs)
75 Elements of Parallelism: Sequential vs. Concurrent In sequential mode components run one after the other on the same set of PETs. PETs In concurrent mode components run at the same time on different sets of PETs PETs T i m e AppDriv er ( Main ) Call Run T i m e AppDriver ( Main ) Call Run Run GridComp Hurricane Model Run LOOP Call Run GridComp Hurricane Model Run LOOP Call Run GridComp Atmosphere Run Run Run GridComp Atmosphere GridComp Ocean GridComp Ocean Run Run CplComp Atm-Ocean Coupler CplComp Atm-Ocean Coupler
76 Elements of Parallelism: DEs Data decomposition represented as set of Decomposition Elements (DEs) Sets of DEs are represented by the DELayout class DELayouts define how data is mapped to PETs In many applications there is one DE per PET Temperature Field T T1 T10 T19 T28 T2 T11 T20 T29 T3 T12 T21 T30 T4 T13 T22 T31 T5 T14 T23 T32 T6 T15 T24 T33 T7 T16 T25 T34 T8 T17 T26 T35 T9 T18 T27 T36 4 x 9 f ield x 9 DELay out DEs VM with 9 PETs PETs
77 Modes of Parallelism: Single vs. Multiple Executable In Single Program Multiple Datastream (SPMD) mode the same program runs across all PETs in the application - components may run sequentially or concurrently. In Multiple Program Multiple Datastream (MPMD) mode the application consists of separate programs launched as separate executables - components may run concurrently or sequentially, but in this mode almost always run concurrently
78 Classes and Objects in ESMF The ESMF Application Programming Interface (API) based on object-oriented programming notion of class A software construct that s used for grouping a set of related variables together with the subroutines and functions that operate on them They help to organize the code, and often make it easier to maintain and understand. A particular instance of a class is an object For example, Field is an ESMF class An actual Field called temperature is an object
79 ESMF Class Structure GridComp Land, ocean, atm, model State Data imported or exported Bundle Collection of fields Field Physical field, e.g. pressure Grid LogRect, Unstruct, etc. CplComp Xfers between GridComps Regrid Computes interp weights Superstructure Infrastructure Array Hybrid F90/C++ arrays PhysGrid Math description DistGrid Grid decomposition DELayout Communications Route Stores comm paths F90 C++ Data Utilities Virtual Machine, TimeMgr, LogErr, IO, ConfigAttr, Base etc. Communications
80 ESMF Superstructure Classes Gridded Component Models, data assimilation systems - real code Coupler Component Data transformations and transfers between Gridded Components State Packages of data sent between Components Can be Bundles, Fields, Arrays, States, or nameplaceholders Application Driver Generic driver
81 ESMF Components Component has two parts One supplied by ESMF - an ESMF derived type that is either a Gridded Component or a Coupler Component One supplied by the user Gridded Component typically represents a physical domain in which data is associated with one or more grids - for example, a sea ice model Coupler Component arranges and executes data transformations and transfers between one or more Gridded Components. Gridded Components and Coupler Components have standard methods, which include initialize, run, and finalize
82 ESMF Infrastructure Data Classes Model data is contained in a hierarchy of multi-use classes The user can reference a Fortran array to an Array or Field, or retrieve a Fortran array out of an Array or Field. Array holds a Fortran array (with other info, such as halo size) Field holds an Array, an associated Grid, and metadata Bundle collection of Fields on the same Grid bundled together for convenience, data locality, latency reduction during communications Supporting these data classes is the Grid class, which represents a numerical grid
83 Application Driver Small, generic program that contains the main for an ESMF application.
84 ESMF Communications Halo Updates edge data for consistency between partitions Redistribution No interpolation, only changes how the data is decomposed Regrid Based on SCRIP package from Los Alamos Methods include bilinear, conservative Bundle, Field, Array-level interfaces
85 ESMF Utilities Time Manager Configuration Attributes (replaces namelists) Message logging Communication libraries Regridding library (parallelized, on-line SCRIP) I/O (barely implemented) Performance profiling (not implemented yet, may simply use Tau)
86 ESMF Summary Developed for and by climate community Sandwich model EMSF provides superstructure and infrastructure, user provides filling Used for some applications, and increasingly, apps are written using it Mostly Fortran-based (user community requirement), and CCA compatible
87 Summary Material for the Test CCA Motivations: slides Component based Software Engineering: slide 29 CCA Concepts: slides What is Cactus: slides 54,55,57 Cactus Architecture: slides Cactus, current capabilities: slides 66,67 What is ESMF: slides 70,71 Design concepts in ESMF: slides ESMF Architectural Components: slides 78-85
88 URLs Common Component Architecture (CCA) Cactus Earth System Modeling Framework (ESMF) 88
89
ESMF. Earth System Modeling Framework. Carsten Lemmen. Schnakenbek, 17 Sep /23
1/23 ESMF Earth System Modeling Framework Carsten Lemmen Schnakenbek, 17 Sep 2013 2/23 Why couple? GEOS5 vorticity We live in a coupled world combine, extend existing models (domains + processes) reuse
More informationCactus: Current Status and Future Plans
Cactus: Current Status and Future Plans Tom Goodale goodale@aei-potsdam.mpg.de Penn State Numrel Lunch February 27 h 2003 What Is Cactus Cactus is a framework for developing portable, modular applications,
More informationIntegration of Trilinos Into The Cactus Code Framework
Integration of Trilinos Into The Cactus Code Framework Josh Abadie Research programmer Center for Computation & Technology Louisiana State University Summary Motivation Objectives The Cactus Code Trilinos
More informationWhat is Cactus? Cactus is a framework for developing portable, modular applications
What is Cactus? Cactus is a framework for developing portable, modular applications What is Cactus? Cactus is a framework for developing portable, modular applications focusing, although not exclusively,
More informationCactus Tutorial. Introduction to Cactus. Yaakoub El Khamra. Cactus Developer, Frameworks Group CCT 27 March, 2007
Cactus Tutorial Introduction to Cactus Yaakoub El Khamra Cactus Developer, Frameworks Group CCT 27 March, 2007 Agenda Introduction to Cactus What is Cactus Flesh and thorns Cactus Computational Toolkit
More informationThe Cactus Framework. Erik Schnetter September 2006
The Cactus Framework Erik Schnetter September 2006 Outline History The Cactus User Community Cactus Usage Patterns Bird s eye view Cactus is a freely available, portable, and manageable environment for
More informationThe Common Component Architecture: Building Frameworks for Computational Science
The : Building Frameworks for Computational Science David E. Bernholdt Oak Ridge National Laboratory bernholdtde@ornl.gov http://www.cca-forum.org Work supported in part by the Scientific Discovery through
More informationFourteen years of Cactus Community
Fourteen years of Cactus Community Frank Löffler Center for Computation and Technology Louisiana State University, Baton Rouge, LA September 6th 2012 Outline Motivation scenario from Astrophysics Cactus
More informationA Software Developing Environment for Earth System Modeling. Depei Qian Beihang University CScADS Workshop, Snowbird, Utah June 27, 2012
A Software Developing Environment for Earth System Modeling Depei Qian Beihang University CScADS Workshop, Snowbird, Utah June 27, 2012 1 Outline Motivation Purpose and Significance Research Contents Technology
More informationHigh Performance and Grid Computing Applications with the Cactus Framework. HPCC Program Grand Challenges (1995)
High Performance and Grid Computing Applications with the Cactus Framework Gabrielle Allen Department of Computer Science Center for Computation & Technology Louisiana State University HPCC Program Grand
More informationChapter 1: Distributed Information Systems
Chapter 1: Distributed Information Systems Contents - Chapter 1 Design of an information system Layers and tiers Bottom up design Top down design Architecture of an information system One tier Two tier
More informationThe Cactus Framework: Design, Applications and Future Directions. Cactus Code
The Cactus Framework: Design, Applications and Future Directions Gabrielle Allen gallen@cct.lsu.edu Center for Computation & Technology Departments of Computer Science & Physics Louisiana State University
More informationMinsoo Ryu. College of Information and Communications Hanyang University.
Software Reuse and Component-Based Software Engineering Minsoo Ryu College of Information and Communications Hanyang University msryu@hanyang.ac.kr Software Reuse Contents Components CBSE (Component-Based
More informationSoftware Infrastructure for Data Assimilation: Object Oriented Prediction System
Software Infrastructure for Data Assimilation: Object Oriented Prediction System Yannick Trémolet ECMWF Blueprints for Next-Generation Data Assimilation Systems, Boulder, March 2016 Why OOPS? Y. Trémolet
More informationContemporary Design. Traditional Hardware Design. Traditional Hardware Design. HDL Based Hardware Design User Inputs. Requirements.
Contemporary Design We have been talking about design process Let s now take next steps into examining in some detail Increasing complexities of contemporary systems Demand the use of increasingly powerful
More informationGustavo Alonso, ETH Zürich. Web services: Concepts, Architectures and Applications - Chapter 1 2
Chapter 1: Distributed Information Systems Gustavo Alonso Computer Science Department Swiss Federal Institute of Technology (ETHZ) alonso@inf.ethz.ch http://www.iks.inf.ethz.ch/ Contents - Chapter 1 Design
More informationOn Software Component for HPC Programmability and Efficiency
On Software Component for HPC Programmability and Efficiency Christian Perez Julien Bigot, Zhenxiong Hou, Vincent Lanore, Jérôme Richard Avalon, LIP, Lyon, France christian.perez@inria.fr Calcul Day @
More information1: Introduction to Object (1)
1: Introduction to Object (1) 김동원 2003.01.20 Overview (1) The progress of abstraction Smalltalk Class & Object Interface The hidden implementation Reusing the implementation Inheritance: Reusing the interface
More informationAn Introduction to Software Architecture. David Garlan & Mary Shaw 94
An Introduction to Software Architecture David Garlan & Mary Shaw 94 Motivation Motivation An increase in (system) size and complexity structural issues communication (type, protocol) synchronization data
More informationWHAT IS SOFTWARE ARCHITECTURE?
WHAT IS SOFTWARE ARCHITECTURE? Chapter Outline What Software Architecture Is and What It Isn t Architectural Structures and Views Architectural Patterns What Makes a Good Architecture? Summary 1 What is
More informationCh 1: The Architecture Business Cycle
Ch 1: The Architecture Business Cycle For decades, software designers have been taught to build systems based exclusively on the technical requirements. Software architecture encompasses the structures
More informationA comparative study of coupling frameworks: the MOM case study
A comparative study of coupling frameworks: the MOM case study V. Balaji Princeton University and NOAA/GFDL Giang Nong and Shep Smithline RSIS Inc. and NOAA/GFDL Rene Redler NEC Europe Ltd ECMWF High Performance
More informationCESM Projects Using ESMF and NUOPC Conventions
CESM Projects Using ESMF and NUOPC Conventions Cecelia DeLuca NOAA ESRL/University of Colorado CESM Annual Workshop June 18, 2014 Outline ESMF development update Joint CESM-ESMF projects ESMF applications:
More informationSoftware Reuse and Component-Based Software Engineering
Software Reuse and Component-Based Software Engineering Minsoo Ryu Hanyang University msryu@hanyang.ac.kr Contents Software Reuse Components CBSE (Component-Based Software Engineering) Domain Engineering
More informationFrom the latency to the throughput age. Prof. Jesús Labarta Director Computer Science Dept (BSC) UPC
From the latency to the throughput age Prof. Jesús Labarta Director Computer Science Dept (BSC) UPC ETP4HPC Post-H2020 HPC Vision Frankfurt, June 24 th 2018 To exascale... and beyond 2 Vision The multicore
More informationCactus Framework: Scaling and Lessons Learnt
Cactus Framework: Scaling and Lessons Learnt Gabrielle Allen, Erik Schnetter, Jian Tao Center for Computation & Technology Departments of Computer Science & Physics Louisiana State University Also: Christian
More informationHPC Performance Advances for Existing US Navy NWP Systems
HPC Performance Advances for Existing US Navy NWP Systems Timothy Whitcomb, Kevin Viner Naval Research Laboratory Marine Meteorology Division Monterey, CA Matthew Turner DeVine Consulting, Monterey, CA
More informationCS:2820 (22C:22) Object-Oriented Software Development
The University of Iowa CS:2820 (22C:22) Object-Oriented Software Development! Spring 2015 Software Complexity by Cesare Tinelli Complexity Software systems are complex artifacts Failure to master this
More informationProgramming Models for Supercomputing in the Era of Multicore
Programming Models for Supercomputing in the Era of Multicore Marc Snir MULTI-CORE CHALLENGES 1 Moore s Law Reinterpreted Number of cores per chip doubles every two years, while clock speed decreases Need
More informationMiddleware. Adapted from Alonso, Casati, Kuno, Machiraju Web Services Springer 2004
Middleware Adapted from Alonso, Casati, Kuno, Machiraju Web Services Springer 2004 Outline Web Services Goals Where do they come from? Understanding middleware Middleware as infrastructure Communication
More informationDay 2 August 06, 2004 (Friday)
An Overview of Grid Computing Day 2 August 06, 2004 (Friday) By CDAC Experts Contact :vcvrao@cdacindia.com; betatest@cdacindia.com URL : http://www.cs.umn.edu/~vcvrao 1 Betatesting Group,NPSF, C-DAC,Pune
More informationFISOC: Framework for Ice Sheet Ocean Coupling
Rupert Gladstone, Ben Galton-Fenzi, David Gwyther, Lenneke Jong Contents Third party coupling software: Earth System Modelling Framework (ESMF). FISOC overview: aims and design ethos. FISOC overview: code
More informationDesign Patterns Design patterns advantages:
Design Patterns Designing object-oriented software is hard, and designing reusable object oriented software is even harder. You must find pertinent objects factor them into classes at the right granularity
More informationCCSM Performance with the New Coupler, cpl6
CCSM Performance with the New Coupler, cpl6 Tony Craig Brian Kauffman Tom Bettge National Center for Atmospheric Research Jay Larson Rob Jacob Everest Ong Argonne National Laboratory Chris Ding Helen He
More informationParallel Programming Models. Parallel Programming Models. Threads Model. Implementations 3/24/2014. Shared Memory Model (without threads)
Parallel Programming Models Parallel Programming Models Shared Memory (without threads) Threads Distributed Memory / Message Passing Data Parallel Hybrid Single Program Multiple Data (SPMD) Multiple Program
More informationComputational Steering
Computational Steering Nate Woody 10/23/2008 www.cac.cornell.edu 1 What is computational steering? Generally, computational steering can be thought of as a method (or set of methods) for providing interactivity
More informationObject Model. Object Orientated Analysis and Design. Benjamin Kenwright
Object Model Object Orientated Analysis and Design Benjamin Kenwright Outline Submissions/Quizzes Review Object Orientated Programming Concepts (e.g., encapsulation, data abstraction,..) What do we mean
More informationThe Analysis and Design of the Object-oriented System Li Xin 1, a
International Conference on Materials Engineering and Information Technology Applications (MEITA 2015) The Analysis and Design of the Object-oriented System Li Xin 1, a 1 Shijiazhuang Vocational Technology
More informationRegCM-ROMS Tutorial: Coupling RegCM-ROMS
RegCM-ROMS Tutorial: Coupling RegCM-ROMS Ufuk Utku Turuncoglu ICTP (International Center for Theoretical Physics) Earth System Physics Section - Outline Outline Information about coupling and ESMF Installation
More informationProgramming with MPI
Programming with MPI p. 1/?? Programming with MPI Miscellaneous Guidelines Nick Maclaren Computing Service nmm1@cam.ac.uk, ext. 34761 March 2010 Programming with MPI p. 2/?? Summary This is a miscellaneous
More informationSetting the stage... Key Design Issues. Main purpose - Manage software system complexity by improving software quality factors
Setting the stage... Dr. Radu Marinescu 1 1946 Key Design Issues Main purpose - Manage software system complexity by...... improving software quality factors... facilitating systematic reuse Dr. Radu Marinescu
More informationIntroduction to Parallel Computing. CPS 5401 Fall 2014 Shirley Moore, Instructor October 13, 2014
Introduction to Parallel Computing CPS 5401 Fall 2014 Shirley Moore, Instructor October 13, 2014 1 Definition of Parallel Computing Simultaneous use of multiple compute resources to solve a computational
More informationWhat is Software Architecture
What is Software Architecture Is this diagram an architecture? (ATM Software) Control Card Interface Cash Dispenser Keyboard Interface What are ambiguities in the previous diagram? Nature of the elements
More informationData Model Considerations for Radar Systems
WHITEPAPER Data Model Considerations for Radar Systems Executive Summary The market demands that today s radar systems be designed to keep up with a rapidly changing threat environment, adapt to new technologies,
More informationParallel programming models. Main weapons
Parallel programming models Von Neumann machine model: A processor and it s memory program = list of stored instructions Processor loads program (reads from memory), decodes, executes instructions (basic
More information6/20/2018 CS5386 SOFTWARE DESIGN & ARCHITECTURE LECTURE 5: ARCHITECTURAL VIEWS C&C STYLES. Outline for Today. Architecture views C&C Views
1 CS5386 SOFTWARE DESIGN & ARCHITECTURE LECTURE 5: ARCHITECTURAL VIEWS C&C STYLES Outline for Today 2 Architecture views C&C Views 1 Components and Connectors (C&C) Styles 3 Elements Relations Properties
More informationA simple OASIS interface for CESM E. Maisonnave TR/CMGC/11/63
A simple OASIS interface for CESM E. Maisonnave TR/CMGC/11/63 Index Strategy... 4 Implementation... 6 Advantages... 6 Current limitations... 7 Annex 1: OASIS3 interface implementation on CESM... 9 Annex
More informationIntroduction to GT3. Introduction to GT3. What is a Grid? A Story of Evolution. The Globus Project
Introduction to GT3 The Globus Project Argonne National Laboratory USC Information Sciences Institute Copyright (C) 2003 University of Chicago and The University of Southern California. All Rights Reserved.
More informationA unified multicore programming model
A unified multicore programming model Simplifying multicore migration By Sven Brehmer Abstract There are a number of different multicore architectures and programming models available, making it challenging
More informationFigure 1 - EDGE Developer Suite Block Diagram
For businesses and consumers, the digital world is a place where user applications and interfaces keep getting easier. Embedded microprocessors aid in nearly every mundane task from monitoring the manufacturing
More informationArchitectural Design. CSCE Lecture 12-09/27/2016
Architectural Design CSCE 740 - Lecture 12-09/27/2016 Architectural Styles 2 Today s Goals Define what architecture means when discussing software development. Discuss methods of documenting and planning
More informationSOFTWARE ARCHITECTURE & DESIGN INTRODUCTION
SOFTWARE ARCHITECTURE & DESIGN INTRODUCTION http://www.tutorialspoint.com/software_architecture_design/introduction.htm Copyright tutorialspoint.com The architecture of a system describes its major components,
More informationVisual Basic Primer A. A. Cousins
Hard Wiring The first research computers of the late 1940s were programmed by hard wiring. Cables were plugged and unplugged into huge patch boards to physically alter the electrical circuitry. To program
More informationOpenACC Course. Office Hour #2 Q&A
OpenACC Course Office Hour #2 Q&A Q1: How many threads does each GPU core have? A: GPU cores execute arithmetic instructions. Each core can execute one single precision floating point instruction per cycle
More informationObject- Oriented Design with UML and Java Part I: Fundamentals
Object- Oriented Design with UML and Java Part I: Fundamentals University of Colorado 1999-2002 CSCI-4448 - Object-Oriented Programming and Design These notes as free PDF files: http://www.softwarefederation.com/cs4448.html
More informationGLAF: A Visual Programming and Auto- Tuning Framework for Parallel Computing
GLAF: A Visual Programming and Auto- Tuning Framework for Parallel Computing Student: Konstantinos Krommydas Collaborator: Dr. Ruchira Sasanka (Intel) Advisor: Dr. Wu-chun Feng Motivation High-performance
More informationLecture 2: Software Engineering (a review)
Lecture 2: Software Engineering (a review) Kenneth M. Anderson Object-Oriented Analysis and Design CSCI 6448 - Spring Semester, 2003 Credit where Credit is Due Some material presented in this lecture is
More informationMaking Frameworks More Useable: Using Model Introspection and Metadata to Develop Model Processing Tools
Making Frameworks More Useable: Using Model Introspection and Metadata to Develop Model Processing Tools J.M.Rahman,S.Seaton,S.M.Cuddy Cooperative Research Centre for Catchment Hydrology, CSIRO Land and
More informationFMS: the Flexible Modeling System
FMS: the Flexible Modeling System Coupling Technologies for Earth System Modeling Toulouse FRANCE V. Balaji balaji@princeton.edu Princeton University 15 December 2010 Balaji (Princeton University) Flexible
More informationSoftware Architecture
Software Architecture Does software architecture global design?, architect designer? Overview What is it, why bother? Architecture Design Viewpoints and view models Architectural styles Architecture asssessment
More informationComponent-Level Design. Slides copyright 1996, 2001, 2005, 2009 by Roger S. Pressman. For non-profit educational use only
Chapter 10 Component-Level Design Slide Set to accompany Software Engineering: A Practitioner s Approach, 7/e by Roger S. Pressman Slides copyright 1996, 2001, 2005, 2009 by Roger S. Pressman For non-profit
More informationComputational Steering
Computational Steering Nate Woody 10/13/2009 www.cac.cornell.edu 1 Lab Materials I ve placed some sample code in ~train100 that performs the operations that I ll demonstrate during this talk. We ll walk
More informationImplementing the Twelve-Factor App Methodology for Developing Cloud- Native Applications
Implementing the Twelve-Factor App Methodology for Developing Cloud- Native Applications By, Janakiram MSV Executive Summary Application development has gone through a fundamental shift in the recent past.
More informationBetter Stories, Better Languages
Better Stories, Better Languages What Would Alyssa P. Hacker Do? François-René Rideau, TUNES Project Bay Area Lispers, 2009-12-29 http://fare.tunes.org/computing/bal2009.pdf 1 The Take Home Points Software
More information1. Write two major differences between Object-oriented programming and procedural programming?
1. Write two major differences between Object-oriented programming and procedural programming? A procedural program is written as a list of instructions, telling the computer, step-by-step, what to do:
More informationIntroduction to MPI. EAS 520 High Performance Scientific Computing. University of Massachusetts Dartmouth. Spring 2014
Introduction to MPI EAS 520 High Performance Scientific Computing University of Massachusetts Dartmouth Spring 2014 References This presentation is almost an exact copy of Dartmouth College's Introduction
More informationIntroduction to Regional Earth System Model (RegESM)
Introduction to Regional Earth System Model (RegESM) Ufuk Turuncoglu Istanbul Technical University Informatics Institute 14/05/2014, 7th ICTP Workshop on the Theory and Use of Regional Climate Models Outline
More informationCS 268: Internet Architecture & E2E Arguments. Today s Agenda. Scott Shenker and Ion Stoica (Fall, 2010) Design goals.
CS 268: Internet Architecture & E2E Arguments Scott Shenker and Ion Stoica (Fall, 2010) 1 Today s Agenda Design goals Layering (review) End-to-end arguments (review) 2 1 Internet Design Goals Goals 0 Connect
More informationPrinciples of Parallel Algorithm Design: Concurrency and Mapping
Principles of Parallel Algorithm Design: Concurrency and Mapping John Mellor-Crummey Department of Computer Science Rice University johnmc@rice.edu COMP 422/534 Lecture 3 28 August 2018 Last Thursday Introduction
More informationIntroducing Computer Programming
ok4 01 f2 5/24/17 9:59 AM Page 3 Chapter 1 Introducing Computer Programming Intended Learning Outcomes After completing this chapter, you should be able to: Explain the difference between computers and
More informationProject Name. The Eclipse Integrated Computational Environment. Jay Jay Billings, ORNL Parent Project. None selected yet.
Project Name The Eclipse Integrated Computational Environment Jay Jay Billings, ORNL 20140219 Parent Project None selected yet. Background The science and engineering community relies heavily on modeling
More informationIntroduction to Parallel Performance Engineering
Introduction to Parallel Performance Engineering Markus Geimer, Brian Wylie Jülich Supercomputing Centre (with content used with permission from tutorials by Bernd Mohr/JSC and Luiz DeRose/Cray) Performance:
More informationMulticore Computing and Scientific Discovery
scientific infrastructure Multicore Computing and Scientific Discovery James Larus Dennis Gannon Microsoft Research In the past half century, parallel computers, parallel computation, and scientific research
More informationAn Introduction to the LFRic Project
An Introduction to the LFRic Project Mike Hobson Acknowledgements: LFRic Project Met Office: Sam Adams, Tommaso Benacchio, Matthew Hambley, Mike Hobson, Chris Maynard, Tom Melvin, Steve Mullerworth, Stephen
More informationOBJECT ORIENTED SYSTEM DEVELOPMENT Software Development Dynamic System Development Information system solution Steps in System Development Analysis
UNIT I INTRODUCTION OBJECT ORIENTED SYSTEM DEVELOPMENT Software Development Dynamic System Development Information system solution Steps in System Development Analysis Design Implementation Testing Maintenance
More informationLearning to Provide Modern Solutions
1 Learning to Provide Modern Solutions Over the course of this book, you will learn to enhance your existing applications to modernize the output of the system. To do this, we ll take advantage of the
More informationThe Cactus Framework and Toolkit: Design and Applications
The Cactus Framework and Toolkit: Design and Applications Tom Goodale 1, Gabrielle Allen 1, Gerd Lanfermann 1, Joan Massó 2, Thomas Radke 1, Edward Seidel 1, and John Shalf 3 1 Max-Planck-Institut für
More informationLecture 1 - Introduction (Class Notes)
Lecture 1 - Introduction (Class Notes) Outline: How does a computer work? Very brief! What is programming? The evolution of programming languages Generations of programming languages Compiled vs. Interpreted
More informationAn Introduction to Software Architecture By David Garlan & Mary Shaw 94
IMPORTANT NOTICE TO STUDENTS These slides are NOT to be used as a replacement for student notes. These slides are sometimes vague and incomplete on purpose to spark a class discussion An Introduction to
More informationRecent Updates to the CFD General Notation System (CGNS)
Recent Updates to the CFD General Notation System (CGNS) C. L. Rumsey NASA Langley Research Center B. Wedan Computational Engineering Solutions T. Hauser University of Colorado M. Poinot ONERA AIAA-2012-1264,
More informationLecture 1: January 23
CMPSCI 677 Distributed and Operating Systems Spring 2019 Lecture 1: January 23 Lecturer: Prashant Shenoy Scribe: Jonathan Westin (2019), Bin Wang (2018) 1.1 Introduction to the course The lecture started
More informationLecture 1: January 22
CMPSCI 677 Distributed and Operating Systems Spring 2018 Lecture 1: January 22 Lecturer: Prashant Shenoy Scribe: Bin Wang 1.1 Introduction to the course The lecture started by outlining the administrative
More information02 - Distributed Systems
02 - Distributed Systems Definition Coulouris 1 (Dis)advantages Coulouris 2 Challenges Saltzer_84.pdf Models Physical Architectural Fundamental 2/60 Definition Distributed Systems Distributed System is
More informationAppendix A - Glossary(of OO software term s)
Appendix A - Glossary(of OO software term s) Abstract Class A class that does not supply an implementation for its entire interface, and so consequently, cannot be instantiated. ActiveX Microsoft s component
More informationManaging Change and Complexity
Managing Change and Complexity The reality of software development Overview Some more Philosophy Reality, representations and descriptions Some more history Managing complexity Managing change Some more
More informationParallel Architectures
Parallel Architectures CPS343 Parallel and High Performance Computing Spring 2018 CPS343 (Parallel and HPC) Parallel Architectures Spring 2018 1 / 36 Outline 1 Parallel Computer Classification Flynn s
More informationUsing JBI for Service-Oriented Integration (SOI)
Using JBI for -Oriented Integration (SOI) Ron Ten-Hove, Sun Microsystems January 27, 2006 2006, Sun Microsystems Inc. Introduction How do you use a service-oriented architecture (SOA)? This is an important
More information6.001 Notes: Section 8.1
6.001 Notes: Section 8.1 Slide 8.1.1 In this lecture we are going to introduce a new data type, specifically to deal with symbols. This may sound a bit odd, but if you step back, you may realize that everything
More informationKepler Scientific Workflow and Climate Modeling
Kepler Scientific Workflow and Climate Modeling Ufuk Turuncoglu Istanbul Technical University Informatics Institute Cecelia DeLuca Sylvia Murphy NOAA/ESRL Computational Science and Engineering Dept. NESII
More informationIntroduction to Computers and Programming Languages. CS 180 Sunil Prabhakar Department of Computer Science Purdue University
Introduction to Computers and Programming Languages CS 180 Sunil Prabhakar Department of Computer Science Purdue University 1 Objectives This week we will study: The notion of hardware and software Programming
More informationPrinciples of Parallel Algorithm Design: Concurrency and Mapping
Principles of Parallel Algorithm Design: Concurrency and Mapping John Mellor-Crummey Department of Computer Science Rice University johnmc@rice.edu COMP 422/534 Lecture 3 17 January 2017 Last Thursday
More informationWeb Interface to Materials Simulations
Web Interface to Materials Simulations Web Interface Generator and Legacy Application Façade Portal Development Team Funding Akos J. Czikmantory (JPL - Wiglaf) DARPA-PROM Hook Hua (JPL - Wiglaf ) JPL SRRF
More informationSystem Name Software Architecture Description
System Name Software Architecture Description Author Name Contact Details Version Date template 2011 Eoin Woods & Nick Rozanski 1 / 25 1. Version History Version Date Author Comments 1 July 08 Eoin Woods
More informationCMSC 714 Lecture 6 MPI vs. OpenMP and OpenACC. Guest Lecturer: Sukhyun Song (original slides by Alan Sussman)
CMSC 714 Lecture 6 MPI vs. OpenMP and OpenACC Guest Lecturer: Sukhyun Song (original slides by Alan Sussman) Parallel Programming with Message Passing and Directives 2 MPI + OpenMP Some applications can
More informationAdvances in Time-Parallel Four Dimensional Data Assimilation in a Modular Software Framework
Advances in Time-Parallel Four Dimensional Data Assimilation in a Modular Software Framework Brian Etherton, with Christopher W. Harrop, Lidia Trailovic, and Mark W. Govett NOAA/ESRL/GSD 28 October 2016
More informationMiddleware. Peter Marwedel TU Dortmund, Informatik 12 Germany. Graphics: Alexandra Nolte, Gesine
Universität Dortmund Middleware Peter Marwedel TU Dortmund, Informatik 12 Germany Marwedel, 2003 Graphics: Alexandra Nolte, Gesine 2011 年 06 月 17 日 These slides use Microsoft clip arts. Microsoft copyright
More informationLet s begin with the very beginning...
Let s begin with the very beginning... As we learned in the fourth grade science course, back in 1801, a French man, Joseph Marie Jacquard, invented a power loom that could weave textiles, which had been
More informationCh 1: The Architecture Business Cycle
Ch 1: The Architecture Business Cycle For decades, software designers have been taught to build systems based exclusively on the technical requirements. Software architecture encompasses the structures
More informationChapter Outline. Chapter 2 Distributed Information Systems Architecture. Layers of an information system. Design strategies.
Prof. Dr.-Ing. Stefan Deßloch AG Heterogene Informationssysteme Geb. 36, Raum 329 Tel. 0631/205 3275 dessloch@informatik.uni-kl.de Chapter 2 Distributed Information Systems Architecture Chapter Outline
More informationA Report on RMI and RPC Submitted by Sudharshan Reddy B
A Report on RMI and RPC Submitted by Sudharshan Reddy B Abstract: This report mainly explains the RMI and RPC technologies. In the first part of the paper the RMI technology is briefly explained and in
More information