Loading…
Back To Schedule
Tuesday, March 5 • 12:00pm - 12:20pm
Software Technology & Applications: Swift and Parsl: Parallel Scripting for HPC Workflow in Science and Engineering

Sign up or log in to save this to your schedule, view media, leave feedback and see who's attending!

WATCH VIDEO

Scientists, engineers, and data analysts frequently find themselves
needing to execute a set of application tasks hundreds — or even
millions — of times, for example to optimize a design being simulated,
or to process large collections of data objects such as in oil and gas
exploration. Such activities can be intellectually and
administratively arduous, due to the need to orchestrate many large
data transfer and application execution tasks, and to track the
resulting outputs, which themselves often serve as inputs to
subsequent application stages. Further complicating these activities
is the frequent need to leverage diverse and distributed and parallel
computing resources in order to complete computations in a timely
manner.

The Swift parallel scripting language (which has no relation to the
Apple Swift language) is used by scientists and engineers to express
and run such large or complex parallel invocation patterns
(“workflows”) of programs or functions on parallel systems.  The need
for its scripted workflow automation is pervasive across a wide
spectrum of science and engineering disciplines, and is a hallmark of
HPC for oil and gas applications.

Significant user demand for Swift has been demonstrated in a growing
set of academic and industrial domains, with several hundred users
running on workstations, cluster, clouds, and the largest
supercomputers. Swift has proven its ability to address the needs of
applications from astronomy and bioinformatics to earth systems
science, geology and zoology.

We will survey in this talk the history and evolution of the Swift
parallel scripting/programming model, and its three implementation in
portable, extreme-scale, and Python-based forms.

We will report on the status of the more recent Swift/E (“ecosystem”)
project, which enhances Swift’s power via integration with widely used
scientific software elements: Globus for data management,
collaboration and usability; Jupyter for interactive parallel/
distributed workflow; Python and R for productivity; and git for
maintainability.

We will conclude with a description of the structure and applications
of Parallel Works, a commercial software-as-a-service implementation
of Swift that supports both elastic cloud-based execution of Swift
workflows and on-premise and hybrid/burstable operations.

While a relative newcomer to the field of oil and gas HPC, Swift has
been applied in a wide range of disciplines relevant to the main areas
of O&G computational science, which collectively cover the breadth of
computational workflow patterns that comprise O&G HPC applications.

We will conclude by surveying a set of O&G-relevant Swift applications
in materials science, large-scale image dataset analysis,
oceanography, geospatial earth systems science, and combustion engine
and fuel chemistry, and machine learning and uncertainty
quantification.

Further details are provided on Swift, below, to which demonstrate
its relevance to the O&G HPC domain.

The Swift parallel scripting language and its Python-based successor,
"Parsl", the parallel scripting library, represent a unique approach
to the problem of rapidly and productively integrating existing
application codes (both libraries and application programs) into
scalable and complete higher-level workflow applications.

Like other scripting languages, Swift allows programmers to express
computations via the linking together of existing application code by,
for example, specifying that the output of program A be provided as
input to tasks B and C, the outputs of which are then consumed by task
D. This approach has the advantages of allowing for rapid application
development and avoiding the need to modify existing programs. Swift
supports concurrency implicitly, so that in our example, if tasks B
and C have no other dependencies, they can both execute in parallel as
soon as A completes. This model is quite general: Swift is not limited
to directed acyclic graph (DAG) dependency expressions.

Additionally, Swift introduces a powerful data model that allows for
typical scalars (integers, floats, strings), arrays, structs, and so
on. Swift also supports an unformatted byte array (called a blob for
“binary large object”), which can hold arbitrary native data for
messaging from one task to the next. Furthermore, Swift represents
external files as variables, which can also be the subject of data
dependent operation (similar to Makefiles). These features together
can reduce greatly the costs of developing and running complex and/or
very large-scale workflows.

The original implementation of Swift (called Swift/K because it is
based on a portable Java-based runtime system called Karajan) was
designed for coordination of large-scale distributed computations that
make use of multiple autonomous computing resources distributed over
varied administrative domains, such as clusters, clouds, and
grids. Swift/K focused on reliability and interoperability with many
systems at the expense of performance: execution of the program logic
is confined to a single shared-memory master node, with calls to
external executable applications dispatched to execution resources as
parallel tasks over a highly-distributed agent-based execution
provider framework.

With its fast execution provider executing tasks on a local cluster,
approximately 500–1000 tasks can be dispatched per second by
Swift/K. This rate is more than ample for many command-line
application workflows, but insufficient for applications with more
demanding performance needs such as a high degree of parallelism or
very short task duration.

Optimizations to the language interpreter, network protocols, and
other components could increase throughput, but Swift/K's
single-master architecture ultimately limits scaling and is unsuitable
for applications with tasks with durations of hundreds of milliseconds
or less or with a high degree of parallelism (more than several
thousand parallel tasks).

In order to address the needs of many demanding parallel applications,
a second-generation Swift implementation was developed under the DOE
X-Stack (exascale stack) program.  This version was called Swift/T,
because it is based on a runtime system called Turbine in turn based
on ADLB, the asynchronous, dynamic MPI-based load-balancer. Swift/T
achieves extreme-scale workflow performance on petascale and
exascale-precursor systems (100K to 1M+ cores) by parallelizing and
distributing script execution and task management across many nodes.

Swift focuses on enabling a hierarchical programming model for
high-performance fine-grained task parallelism, orchestrating
large-scale computations composed of external functions with in-memory
data, computational kernels on GPUs and other accelerators, and
parallel functions implemented in lower-level parallel programming
models—typically threads or message-passing. These functions and
kernels are integrated into the Swift language as typed leaf functions
that encapsulate computationally intensive code, leaving parallel
coordination, task distribution, and data dependency management to the
Swift implementation.

Swift can be rigorously analyzed and enhanced by a range of compiler
optimization techniques to achieve high efficiency and scalability for
a broad range of applications on massively parallel distributed-memory
computers. Its design is motivated by the limitations of current
programming models for programming extreme-scale systems and
addressing emerging problems such as programmability for nonexpert
parallel programmers, abstraction of heterogeneous compute resources,
and the composition of

Speakers
YB

Yadu Babuji

University of chicago
KC

Kyle Chard

University of Chicago
BC

Benjamin Clifford

University of Chicago
avatar for Ian Foster

Ian Foster

Argonne National Laboratory
Use Case: Materials Data Facility (Co-Lead PI)Research Interests: Distributed, parallel, and data-intensive computing technologies.
SG

Stefan Gary

Scottish Association of Marine Science
avatar for Daniel S. Katz

Daniel S. Katz

Chief Scientist, NCSA, University of Illinois at Urbana-Champaign
Dan is Chief Scientist at the National Center for Supercomputing Applications (NCSA) and Research Associate Professor in Computer Science, Electrical and Computer Engineering, and the School of Information Sciences (iSchool), at the University of Illinois Urbana-Champaign. In past... Read More →
ZL

Zhuozhao Li

University of Chicago
MM

Marmar Mehrabadi

Parallel Works Inc.
MS

Matthew Shaxted

Parallel Works Inc.
AV

Alvaro Vidal Torreira

Parallel Works Inc.
MW

Michael Wilde

CEO, Parallel Works Inc, University of Chicago, and Argonne National Laboratory (on leave)
HPC Workflow - scaling, automation, productivity, democratization
AW

Anna Woodward

University of Chicago
JW

Justin Wozniak

Argonne National Laboratory and University of Chicago



Tuesday March 5, 2019 12:00pm - 12:20pm CST
Room 280