DynAX Project - Revision history

imported>Admin at 18:54, April 23, 2014

2014-04-23T18:54:40Z

← Older revision		Revision as of 18:54, April 23, 2014
Line 115:		Line 115:

	'''R-Stream'''		'''R-Stream'''
	[[File:R-~~StreamMF~~.~~jpg~~\|right\|350px]]		[[File:R-Stream.png\|right\|350px]]
	* Current capabilities:		* Current capabilities:
	** Automatic parallelization and mapping		** Automatic parallelization and mapping

imported>Admin: /* Software Stack */

2014-04-23T18:22:01Z

Software Stack

← Older revision		Revision as of 18:22, April 23, 2014
Line 115:		Line 115:

	'''R-Stream'''		'''R-Stream'''
			[[File:R-StreamMF.jpg\|right\|350px]]
	* Current capabilities:		* Current capabilities:
	** Automatic parallelization and mapping		** Automatic parallelization and mapping

imported>Admin at 18:08, April 23, 2014

2014-04-23T18:08:04Z

← Older revision		Revision as of 18:08, April 23, 2014
Line 10:		Line 10:
	John Feo (PNNL)		John Feo (PNNL)
	}}		}}


	'''Dynamically Adaptive X-Stack''' or '''DynAX''' is a team led by ET International to conduct a research on runtime software for exascale computing.		'''Dynamically Adaptive X-Stack''' or '''DynAX''' is a team led by ET International to conduct a research on runtime software for exascale computing.
Line 88:		Line 89:
	* Provide NWChem kernels and expertise to all X-Stack projects		* Provide NWChem kernels and expertise to all X-Stack projects
	* Use Co-Design and NWChem applications to evaluate the Brandywine Team Software Stack		* Use Co-Design and NWChem applications to evaluate the Brandywine Team Software Stack


	== Software Stack ==		== Software Stack ==
Line 110:		Line 112:
	* Active Global Address Space (planned)		* Active Global Address Space (planned)
	* Fault tolerance (planned)		* Fault tolerance (planned)


	'''R-Stream'''		'''R-Stream'''
Line 124:		Line 127:
	** Generation of SCALE IR and tuning hints on scheduling and data placement		** Generation of SCALE IR and tuning hints on scheduling and data placement
	** Automatic mapping of irregular mesh codes		** Automatic mapping of irregular mesh codes


	[[File:HTA.png\|right\|350px]]		[[File:HTA.png\|right\|350px]]
Line 133:		Line 137:
	** Represent parallelism using parallel constructs such as parallel loops		** Represent parallelism using parallel constructs such as parallel loops
	* Compiler optimizations on sequences of HTA operations will be evaluated		* Compiler optimizations on sequences of HTA operations will be evaluated


	[[File:RPDTA.png\|right\|350px]]		[[File:RPDTA.png\|right\|350px]]
Line 144:		Line 149:
	** Memory allocation/deallocation/copying		** Memory allocation/deallocation/copying
	** Memory consistency models		** Memory consistency models


	'''NWChem'''		'''NWChem'''

imported>Admin at 18:06, April 23, 2014

2014-04-23T18:06:03Z

← Older revision		Revision as of 18:06, April 23, 2014
Line 1:		Line 1:
			{{Infobox project
			\| title = DynAX
			\| image = [[File:BrandywineTeam-logo.png\|180px]]
			\| imagecaption =
			\| website = [http://www.etinternational.com/xstack/ www.etinternational.com/xstack]
			\| team-members = [http://www.etinternational.com/ ETI], [https://www.reservoir.com/ Reservoir Labs], [http://cs.illinois.edu/ UIUC], [http://www.pnnl.gov/ PNNL]
			\| pi = Guang Gao (ETI)
			\| co-pi = Benoit Meister (Reservoir Labs),
			David Padua (UIUC),
			John Feo (PNNL)
			}}

	'''Dynamically Adaptive X-Stack''' or '''DynAX''' is a team led by ET International to conduct a research on runtime software for exascale computing.		'''Dynamically Adaptive X-Stack''' or '''DynAX''' is a team led by ET International to conduct a research on runtime software for exascale computing.

imported>Admin at 18:05, April 23, 2014

2014-04-23T18:05:30Z

← Older revision		Revision as of 18:05, April 23, 2014
Line 8:		Line 8:

	This work will be done in the context of DOE co-design applications. We will use kernels of these applications as well as other benchmarks and synthetic kernels in the course of our research. The needs of the co-design applications will provide valuable feedback to the research process.		This work will be done in the context of DOE co-design applications. We will use kernels of these applications as well as other benchmarks and synthetic kernels in the course of our research. The needs of the co-design applications will provide valuable feedback to the research process.


			== Team Members ==
			* '''[http://www.etinternational.com/ ET International (ETI):]''' Execution Model, Runtime Systems, Parallel Intermediate Language, Resilience
			* '''[https://www.reservoir.com/ Reservoir Labs:]''' Programming Models, Loop Optimizations
			* '''[http://cs.illinois.edu/ University of Illinois at Urbana-Champaign (UIUC):]''' High level data structures and algorithms for parallelism and locality
			* '''[http://www.pnnl.gov/ Pacific Northwest National Laboratory (PNNL):]''' Co-design and NWChem kernels for evaluation, energy efficiency


			== Objectives ==
			'''Scalability:''' Expose, express, and exploit O(10^10) concurrency

			'''Locality:''' Locality aware data types, algorithms, and optimizations

			'''Programmability:''' Easy expression of asynchrony, concurrency, locality

			'''Portability:''' Stack portability across heterogeneous architectures

			'''Energy Efficiency:''' Maximize static and dynamic energy savings while managing the tradeoff between energy efficiency, resilience, and performance

			'''Resilience:''' Gradual degradation in the face of many faults

			'''Interoperability:''' Leverage legacy code through a gradual transformation towards exascale performance

			'''Applications:''' Support NWChem


			== Roadmap ==
			[[File:DynAX-Roadmap.png\|500px]]


			== Impact ==
			'''Scalability:'''
			* Expose, express and exploit new forms of parallelism
			* Provide mechanisms of task scheduling across the system as if it were one system rather than many disparate pieces
			* Symmetric access semantics across heterogeneous devices

			'''Locality:'''
			* Provide mechanisms to express locality as a first-class citizen
			* Expose the memory hierarchies to the compiler (and programmer)
			* Provide data types and memory models so that the programmer can view the system as one system instead of many disparate memories

			'''Programmability:'''
			* Create easier ways of expressing asynchrony thereby enabling programmers to write more scalable programs
			* R-Stream will automatically extract parallelism and locality from common idioms
			* Provide data types and algorithms that provide high-level representations of arrays mapped to the memory and algorithm hierarchy for automatic parallelization and data placement

			'''Portability:'''
			* Demonstrate a software stack that is portable to multiple architectures provided a C compiler
			* Support a platform abstraction layer in SWARM, which will allow it to operate on multiple heterogeneous architectures
			* Work with Xpress on the XPI interface to show application portability between runtime systems

			'''Energy Efficiency:'''
			* Collocate execution and data
			* Dynamically load balance execution based on resource availability
			* Dynamically scale resources based on load
			* Provide new programming constructs (Rescinded Primitive Data Types) that allow compressed data formats at higher memory levels to minimize data transfer costs

			'''Resilience:'''
			* Integrate containment domains and their extensions into the SWARM runtime system and SCALE compiler
			* Allow graceful degradation in the face of exascale-level faults and a framework for software validation of soft faults

			'''Interoperability:'''
			* Work with Xpress on XPI interoperability with legacy codes such that all X-Stack runtime systems and all X-Stack applications can benefit from Evolutionary/Revolutionary runtime system interoperability

			'''Applications:'''
			* Provide NWChem kernels and expertise to all X-Stack projects
			* Use Co-Design and NWChem applications to evaluate the Brandywine Team Software Stack

			== Software Stack ==

			[[File:Xstack-software-stack.png\|X-Stack Software Stack\|500px]]


			The X-Stack software stack consists of high level data objects and algorithms (HTA: Hierarchical Tiled Arrays), R-Stream loop optimizing compiler, SCALE parallel language compiler, and SWARM distributed heterogeneous runtime system. The project will extend the existing software tools to improve on parallelism, locality, programmability, portability, energy efficiency, resilience, and interoperability (see left). In addition, it will add new infrastructure for energy efficiency (Rescinded Primitive Data Types) and resilience (Containment Domains).

			'''SWARM (SWift Adaptive Runtime Machine)'''
			[[File:SWARM-trace-comparison.png\|right\|350px]]
			* Codelets
			** Basic unit of parallelism
			** Nonblocking tasks
			** Scheduled upon satisfaction of precedent constraints
			* Hierarchical Locale Tree: spatial position, data locality
			* Lightweight Synchronization
			* Asynchronous Split-phase Transactions: latency hiding
			* Message Driven Computation
			* Control-flow and Dataflow Futures
			* Error Handling
			* Active Global Address Space (planned)
			* Fault tolerance (planned)

	'''R-Stream'''		'''R-Stream'''

imported>Admin: Created page with "'''Dynamically Adaptive X-Stack''' or '''DynAX''' is a team led by ET International to conduct a research on runtime software for exascale computing. Moving forward, exascal..."

2014-04-23T18:03:46Z

Created page with "'''Dynamically Adaptive X-Stack''' or '''DynAX''' is a team led by ET International to conduct a research on runtime software for exascale computing. Moving forward, exascal..."

New page

'''Dynamically Adaptive X-Stack''' or '''DynAX''' is a team led by ET International to conduct a research on runtime software for exascale computing.

Moving forward, exascale software will be unable to rely on minimally invasive system interfaces to provide an execution environment. Instead, a software runtime layer is necessary to mediate between an application and the underlying hardware and software. This proposal describes a model of execution based on codelets, which are small pieces of work that are sequenced by expressing their interdependencies to runtime software instead of relying on the implicit sequencing of a software thread. In addition, this document will also describe interactions between the runtime layer, compiler, and programming language.

The runtime software for exascale computing must be able to deal with a very large amount of outstanding work at any given time and manage enormous amounts of data, some of which may be highly volatile. The relationship between work and the data it acts upon or generates is crucial to maintaining high performance and low power usage. A poor understanding of data locality may lead to a much higher amount of communication, which is extremely undesirable in an exascale environment. To assist it in associating work with data and facilitating the migration of work to data and vice versa, such a runtime may impose a hierarchy on regions of the system, dividing it up along address space and privacy boundaries to allow it to guess at the cost inherent in communicating between regions. Furthermore, tying data and work to locations in the hierarchy creates a construct by which transparent work stealing and sharing may be applied, helping to keep stolen work near its data and allowing shared work to be issued to specific regions.

Compilers also need to reflect the requirements of exascale computing systems. A compiler that supports a codelet execution model must be able to determine appropriate boundaries for codelets in software and generate the codelets and code to interface with both the runtime and a transformed version of the input program. We propose that a three-step compilation process be used, wherein program code is compiled down to a high-level-language-independent internal representation, which can then be compiled down to C code that makes API calls into runtime software. This C code can then be compiled down to a platform-specific binary for execution on the target system, using existing C compilers for the generated sequential code. Higher-level analysis of the relationship between codelets and data can be performed in earlier steps, and this can enable the compiler to emit static hints to the runtime to assist in making decisions on scheduling and placement. Compilers can also assist in providing for fault tolerance by supporting containment domains, which can be used by the runtime software to assist in program checkpointing.

This work will be done in the context of DOE co-design applications. We will use kernels of these applications as well as other benchmarks and synthetic kernels in the course of our research. The needs of the co-design applications will provide valuable feedback to the research process.

'''R-Stream'''
* Current capabilities:
** Automatic parallelization and mapping
** Heterogeneous, hierarchical targets
** Automatic DMA/comm. generation/optimization
** Auto-tuning tile sizes, mapping strategies, etc.
** Scheduling with parallelism/locality layout tradeoffs
** Corrective array expansion
* Planned capabilities:
** Extend explicit data placement
** Generation of parallel codelet codes from serial codes
** Generation of SCALE IR and tuning hints on scheduling and data placement
** Automatic mapping of irregular mesh codes

[[File:HTA.png|right|350px]]
'''Hierarchical Tiled Arrays'''
* HTAs are recursive data structure
** Tree structured representation of memory
* Includes library of operations to enable the programming of codelets in the familiar notation of C/C++
** Represent parallelism using operations on arrays and sets
** Represent parallelism using parallel constructs such as parallel loops
* Compiler optimizations on sequences of HTA operations will be evaluated

[[File:RPDTA.png|right|350px]]
'''Rescinded Primitive Data Type Access'''
* Redundancy removal to improve performance/energy
** Communication
** Storage
* Redundancy addition to improve fault tolerance
** High Level fault tolerant error correction codes and their distributed placement
* Placeholder representation for aggregated data elements
** Memory allocation/deallocation/copying
** Memory consistency models

'''NWChem'''
* DOE’s Premier computational chemistry software
* One-of-a-kind solution scalable with respect to scientific challenge and compute platforms
* From molecules and nanoparticles to solid state and biomolecular systems
* Open-source has greatly expanded user and developer base (ECL 2.0)
* Worldwide distribution (70% is academia)
* Ab initio molecular dynamics runs at petascale
* Scalability to 100,000 processors demonstrated
* Smart data distribution and communication algorithms enable hybrid-DFT to scale to large numbers of processors

== Deliverables ==
'''Q1 (12/1/2012)'''
* [[media:BrandywineXStackReportQ1.docx|Q1 Report]]
* [[media:Q1-cholesky.pptx|Presentation on Cholesky Decomposition work]]

'''Q2 (3/1/2013)'''
* [[media:BrandywineXStackReportQ2.pdf|Q2 Report]]
* [[media:pil_api_v0.3.pdf|PIL Design v0.3]]
* [[media:SCF_text_document.docx|NWChem SCF module description]]
* [[media:Scf.tar.gz|NWChem SCF code download]]
'''March 2013 PI Meeting''': [[media:DynAX_March_2013_PI_meeting.pptx|PI Meeting presentation]]

'''EXaCT All-hands meeting''': [[media:DynAX_EXaCT_meeting.pptx|DynAX Presentation]]

'''Q3 (6/1/2013)'''
* [[media:BrandywineXStackReportQ3.pdf|Q3 Report]]
* [[media:Scf2.tar.gz|NWChem SCF code download version 2]]
* [[media:Pil_api_v0.4.pdf|PIL Design v0.4]]
* [[media:TCG.tar.gz|Tensor Contraction Engine (OpenMP, CUDA, C, Fortran)]]

'''Year 1 report''': [[media:BrandywineXStackReportY1.pdf|Y1 Report]]

'''Q4 (9/1/2013)'''
* [[media:BrandywineXStackReportQ4.pdf|Q4 Report]]

'''Q5 (12/1/2013)'''
* [[media:BrandywineXStackReportQ5.pdf|Q5 Report]]
* [[media:Tce.tar.gz|TCE C Generator code]]

'''Q6 (3/1/2014)'''
* [[media:BrandywineXStackReportQ6.pdf|Q6 Report]]
* [[media:TCE slides.pdf|TCE Presentation]]

'''Year 2 report''': [[media:DynAXX-StackYear2report.pdf|Y2 Report]]