Training Archive
All Past Events
A cast of thousands: How the IDEAS Productivity project has advanced software productivity and sustainability
The webinar will describe strategies that the IDEAS Productivity Project has used to help software teams across the Exascale Computing Project “up their game” with respect to their software practices. The webinar will wrap up with lessons learned by the IDEAS team and briefly consider possible futures for the DOE scientific software community.
Taking HACC into the Exascale Era: New Code Capabilities, and Challenges
The webinar will discuss lessons learned by the HACC (Hardware/Hybrid Accelerated Cosmology Code) development team in contending with novel programming modes while preparing HACC for multiple exascale systems, simultaneously adding new capabilities and focusing on performance.
Simplifying Scientific Python Package Installation and Usage
This webinar will discuss how to simplify scientific Python package installation in HPC environments, by using a tool developed by the speaker and his collaborators. The tool reduces errors and enables sharing of package installations among users. HPC centers can customize the tool to incorporate additional software dependencies and help messages.
2023 HDF5 User Group Meeting (HUG23)
The 2023 HDF5 User Group Meeting will be held August 16-18, 2023 in Columbus, Ohio. Celebrating 25 years of HDF5, the event will feature presentations from community members, keynotes and lunch talks, a full day of tutorials and more.
Infrastructure for High-Fidelity Testing in HPC Facilities
The webinar will discuss infrastructure and tools for high-fidelity testing, which is essential for hardening the software developed by DOE’s Exascale Computing Project. The webinar will provide an overview of the testing infrastructure, discuss what this could look like post-ECP, and how it could benefit other HPC environments.
Introduction to High-Performance Parallel Distributed Computing using Chapel, UPC++ and Coarray Fortran
This tutorial introduces HPC distributed computing using three alternative parallel programming models, Chapel, UPC++, and Coarray Fortran. The goal is to demonstrate basic concepts of distributed programming, highlight the benefits of each model and provide experience in running examples with each.
Writing Clean Scientific Software
The webinar will focus on tips and strategies on how to write readable, reusable, and maintainable code, including writing short functions that do exactly one thing with no effects, restructuring complicated functions into smaller and manageable chunks, and good use of comments and error messages. Motto: think of code as communication.
ECP Broadening Participation Initiative: Challenges, Gaps, and Opportunities in Computing Workforce Development and Retention
Abstract The ECP Broadening Participation Initiative seeks to foster a supportive and inclusive culture within the computing sciences at DOE national laboratories. Its mission is to establish a sustainable plan
The OpenSSF Best Practices Badge Program
The webinar will give an overview of the OpenSSF Best Practices Badge Program, which provides resources for the creation, maintenance, and sustainability of robust, high quality, and secure open source software. The webinar will also describe how these resources can be used to support advances in software quality and sustainability efforts in CS&E.
Lessons Learned Developing Performance-Portable QMCPACK
The webinar will outline the redesign and reimplementation of QMCPACK, a code that predicts the properties of materials, to achieve portability and performance on GPUs and CPUs. The webinar will discuss development practices, the importance of extensive tests, and a set of strategies that can benefit HPC application developers and facilities.
Facilitating Electronic Structure Calculations on GPU-based Exascale Platforms
The webinar will focus on the porting of electronic structure codes to exascale platforms, and how it can be done with the PROGRESS and BML libraries developed by ECP’s CoPA project. The webinar will discuss implementations and algorithmic choices made in those libraries, and lessons learned for achieving performance portability and strong scaling.
Strategies for Inclusive Mentorship in Computing
Abstract Mentorship is a dynamic, career-long phenomenon spanning many different relationships that support our personal and professional development. A wealth of scholarship on mentorship practices has emerged across
Our Road to Exascale: Particle Accelerator & Laser-Plasma Modeling
The webinar will focus on the experience of the WarpX developers towards exascale, culminating in the 2022 ACM Gordon Bell Prize. WarpX uses GPUs and CPUs at massive scale, and research efforts advanced particle-in-cell algorithms and solvers. A team-of-teams approach improved software architecture, quality, developer & user productivity.
2023 ECP Community BOF Days
The Exascale Computing Project (ECP) Community Birds-of-a-Feather (BOF) Days provide an opportunity for the HPC community to engage with ECP teams to discuss our latest development efforts. BOF sessions will be 60 to 90 minutes long, opening with a brief overview and concluding with a Q&A.
ECP Tutorial Days
The ECP Project Tutorial Days will cover best practices for exascale-era systems, including topics on power management on exascale platforms, performance evaluation, auto-tuning tools, robust and scalable next-generation workflows, applications, systems, and much more.
Openscapes: supporting better science for future us
The webinar will focus on the activities fostered by Openscapes, and lessons the speaker learned from her work mentoring government, non-profit, and academic environmental and Earth teams, with specific stories from projects with NASA and NOAA Fisheries. The speaker will also highlight how more reusing and less reinventing is critical for science.
Lab Notebooks for Computational Mathematics, Sciences & Engineering
The webinar will focus on the role of lab notebooks in experimental sciences and will present concrete examples that address the challenges associated with adapting lab notebooks to computational research. The webinar builds upon the presenter’s experience in transitioning from experimental and observational sciences to computational sciences.
Work/Life Balance? Lessons from SC22 Early Career Program Panelists
This session features lessons from the SC22 Early Career Program on work/life balance, strategies for working remotely, and on how those early in their careers can apply lessons learned from pandemic-driven change and resiliency.
Managing Academic Software Development
This webinar will discuss specifics of academic software development. It will describe approaches to manage the development and release of software, including coding best practices, project boards, development environments, and automated documentation that can help developers write sustainable code that is easy to use, streamlining collaborations.
Black Lives Count: Toward Accountability in Efforts to Diversify Computing
Abstract In April, the United States presidential administration announced a whole-of-government effort focused largely on gathering and increasing access to disaggregated data on the experiences of historically underserved
Investing in Code Reviews for Better Research Software
Code review is a development practice that can improve readability and maintainability of software projects, making collaboration easier and more effective. The webinar will discuss the benefits of code review for scientific software development (e.g., improved quality, teamwork, and knowledge transfer), and approaches to facilitate code reviews.
Subfiling and Multiple dataset APIs: An introduction to two new features in HDF5 version 1.14
Subfiling uses I/O concentrator processes for per-node subfiles creation. HDF5 multiple dataset APIs let multiple datasets be accessed with a single I/O call. The webinar will cover both new features' implementation, usage, and performance benefits.
Template Task Graph: a Task Programming Paradigm for Irregular Applications
The tutorial will introduce the Template Task Graph (TTG) programming paradigm, which enables a straightforward expression of task parallelism for algorithms dealing with irregular and unbalanced data sets. The tutorial will describe the installation of TTG on ECP platforms and other environments, and show how to integrate TTG with applications.
Software Packaging
This webinar discusses software packaging practices to accelerate development and facilitate re-use. After a survey of packaging technologies and ideas that are popular in scientific software, it covers some real-world examples and some simple steps to make connections between software deployment and package use.
Focus on Ally Skills
This talk explains why focusing on teaching ally skills to people with power and influence is more effective than changing the behavior of marginalized people. It then describes a dozen specific ally skills such as listening, amplifying marginalized voices, and speaking up when it is uncomfortable. It ends with a 20 minute question and answer perio
What Can Be Learned from Applying Team of Teams Principles to the ECP projects PETSc, Trillinos, xSDK, and E4S?
We consider how, why, and when these distributed teams may and may not function as Teams of Teams, and when applying Team of Teams principles might benefit. We present strategies centered around developing engaged and productive virtual software teams and offer a deeper dive into these communities.
E4S at NERSC 2022
The Extreme-scale Scientific Software Stack (E4S) is a collection of open source packages for running scientific applications on high performance computing platforms. In this event, the presenters will describe the components of E4S, discuss related activities in the Exascale Computing Project, and give an overview of E4S stacks installed at NERSC.
Effective Strategies for Writing Proposal Work Plans for Research Software
The webinar will discuss strategies for writing proposals involving research software development, to help persuade reviewers that the project can be achieved. The speaker will survey software project scoping, estimation methods, requirements specification, etc., and suggest strategies for maximizing the impact of these artifacts within a proposal.
Coordinating Dynamic Ensembles of Computations with libEnsemble
This tutorial will introduce libEnsemble, a Python toolkit for coordinating asynchronous and dynamic ensembles of calculations across massively parallel resources. The tutorial will include examples to demonstrate how libEnsemble’s mix-and-match approach can help interface libraries and applications with exascale-level resources.
Growing preCICE from an as-is Coupling Library to a Sustainable, Batteries-included Ecosystem
The webinar will discuss the evolution of preCICE, from a coupling library for fluid-structure interaction problems used by a few academic groups, to a complete coupling ecosystem used worldwide for a wide range of applications. The presenter will discuss lessons learned that can help any research software project grow in a sustainable way.
Normalizing Inclusion by Embracing Difference
The webinar will discuss ways to achieve an ecosystem for diversity, equity, and inclusion in Computational Science and Engineering, and how this ecosystem can contribute to an increase in innovation and developer productivity. The webinar will include opportunities for attendees to interact and explore the concepts discussed.
Aurora COE Workshop
The Intel Center of Excellence in collaboration with Argonne Leadership Computing Facility will host a workshop focused on the upcoming exascale system, Aurora. The workshop will provide updates and guidance to help researchers prepare for Aurora; participants will have access to the most recent Intel GPU hardware and software, and hands-on work.
How to be a Great Mentor
Mentoring is vital to developing and retaining a diverse, talented, and enabled workforce. The first session in our Workforce Development Webinar series will feature a panel of experienced mentors drawn
Acquisition and Analysis of Times Series of Satellite Data in the Cloud – Lessons from the Field
The webinar will discuss a set of Python codes and tools to extract and do temporal analysis of satellite data on the cloud. The speaker will share the lessons learned in developing a methodology for new users to navigate the beginning of cloud data and computing, and discuss how to potentially extend their use to new and diverse research areas.
2022 ECP Community BOF Days
The Exascale Computing Project (ECP) Community Birds-of-a-Feather (BOF) Days provide an opportunity for the HPC community to engage with ECP teams to discuss our latest development efforts. Each BOF will be a 60- to 90-minute session on a given topic, with a brief overview followed by Q&A.
Evaluating Performance Portability of HPC Applications and Benchmarks Across Diverse HPC Architectures
The webinar will discuss the progress being made on achieving performance portability by a subset of applications in DOE’s Exascale Computing Project, or their related mini-apps, and approaches to achieving performance portability across diverse HPC architectures, including AMD, Intel, and NVIDIA GPUs.
Rebroadcast of Strategies for Working Remotely Panel Series @SC21 – Sustainable Hybrid Approaches for HPC
This panel discussion was held during SC21 and is being rebroadcast with live chat Q&A. The panel explored strategies for working remotely, with emphasis on how teams in high-performance computing (HPC) can be effective and efficient in long-term hybrid settings, where some staff work remotely and others on site, or are geographically dispersed.
Software Design Patterns in Research Software with Examples from OpenFOAM
The webinar will discuss the benefits of general repeatable descriptions, or software design patterns, to address runtime and algorithm combinations and requirements. The webinar will discuss how the adoption of software design patterns can facilitate the development of robust scientific software, taking OpenFOAM as a case study.
HDF5 Tutorial: Constructing a Simple Terminal VOL Connector
The HDF group will give a tutorial covering the basics needed to construct a simple terminal Virtual Object Layer (VOL) connector. The tutorial will focus on the mapping of HDF5 API calls to alternative storage and setting up VOL fields and callbacks.
Wrong Way: Lessons Learned and Possibilities for Using the “Wrong” Programming Approach on Leadership Computing Facility Systems
This webinar will consider the impact of using a "wrong" programming approach for a given system. The presenter will go through a few of these "wrong" programming approaches for current and near-term future systems, and will discuss specific software packages that enable such approaches, as well as lessons learned.
Scientific software ecosystems and communities: Why we need them and how each of us can help them thrive
The webinar will discuss how a set of scientific applications builds on programming models, math libraries, and development tools available in the Extreme-scale Scientific Software Stack (E4S). The webinar will introduce strategies that are increasing developer productivity and software sustainability, leading to reproducible, sustainable science.
Strategies for Working Remotely Panel Series @SC21 – Sustainable Hybrid Approaches for HPC
This panel discussion held during SC21 explores strategies for working remotely, with emphasis on how teams in high-performance computing (HPC) can be effective and efficient in long-term hybrid settings, where some staff work remotely and others on site, or collaborate while geographically dispersed.
55+ years in High-Performance Computing: One Woman’s Experiences and Perspectives
This webinar will differ from webinars in the HPC-BP webinar series, as it will have a Q&A session with Jean Shuler, a woman who has worked at the leading edge of HPC for almost 50 years. By 1972, Jean joined LLNL where she has worked ever since. Jean will share her stories providing support on a range of computer architectures.
Strategies for Working Remotely at the DOE Laboratories of the Future Workshop on Effective Teaming and Virtual Collaboration
the DOE Laboratories of the Future (LOTF) workshop series will be focused on effective teaming across the DOE laboratories and how we can best integrate new tools and mechanisms for virtual collaboration.
Migrating to Heterogeneous Computing: Lessons Learned in the Sierra and El Capitan Centers of Excellence
This webinar will describe the operations of the Sierra and El Capitan Centers of Excellence, in the migration of applications, system software, and tools to heterogeneous computing environments. The webinar will describe best practices for managing collaborations with vendors in that process, and in the optimization of application performance.
2021 HDF5 User Group Meeting
The HDF group has announced the 2021 HDF users Group Meeting. The event is scheduled for 10/12/2021-10/14/2021 and registration is required.
E4S at DOE Facilities with Deep Dive at NERSC
The Extreme-scale Scientific Software Stack (E4S) is a collection of open source packages for running scientific applications on high performance computing platforms. In this event, the presenters will describe the components of E4S, discuss related activities in the Exascale Computing Project, and give an overview of E4S stacks installed at NERSC.
Webinar: New Features in the HDF5 1.13.0 Release
This webinar will cover the the major new features of the HDF5 1.13.0 release, including pluggable virtual file drivers (VFDs) and changes to the virtual object layer (VOL),
Strategies for Working Remotely Panel Series – Training Virtualization
Many organizations abruptly transitioned to a primarily remote work experience last spring. However, organizations still have training needs that were once largely accomplished through in-person events. This panel will share their insights about lessons learned over the past year and how those experiences will inform plans moving forward.
What I Learned from 20 Years of Leading Open Source Projects
In this webinar, the speaker will comment on the evolution of community software development, and will discuss lessons learned from the technical management of two large open source projects scientific software projects (deal.II and ASPECT), and the social side of these projects.
Facility Testing of E4S via E4S Testsuite, Spack Test, and buildtest
This presentation will provide an overview of buildtest,which is a HPC testing framework designed to help facilities develop and run tests to validate their system and software stack. The presentation will include a summary of Extreme-Scale Scientific Software Stack (E4S) tests that are run at NERSC.
CMake Training
ECP is partnering with Kitware, ALCF, NERSC and OLCF to offer a 4 day CMake Training class on August 23-26. The training class will be virtual and will use computational resources available at NERSC for the exercises.
Variorum Lecture Series
Variorum is a production-grade, open-source, vendor-neutral software infrastructure for exposing low-level control and monitoring of a system’s underlying hardware features. In this lecture series, the Variorum team will provide attendees the opportunity to learn everything necessary to start using Variorum to write portable power management code.
Software Engineering Challenges and Best Practices for Multi-Institutional Scientific Software Development
The multi-institutional nature of many science projects presents unique challenges to how scientific software can be effectively developed and maintained over the long term. The webinar will discuss such challenges and a set of best-practices that can be effective in producing impactful and trustworthy scientific software.
Argonne Training Program on Extreme-Scale Computing 2021
The deadline to apply for the Argonne Training Program on Extreme-Scale Computing (ATPESC) has been extended to Friday, March 5, 2021 (midnight, Anywhere on Earth). Don't miss out on an opportunity to learn the latest supercomputing tools and techniques from some of the world's leading HPC experts. This year's program will be held August 1-13, 202
Mining Development Data to Understand and Improve Software Engineering Processes in HPC Projects
The webinar will discuss a set of existing and emerging tools for analyzing code, git, emails, issues, test results, and dependencies, with the long-term goal of improving development processes and enhancing developer productivity. The webinar will include analysis examples of ECP projects.
Strategies for Working Remotely Panel Series – I Finally Have the Internship I Always Wanted, Now What?
What does a “virtual internship” lack, and what changes to mentoring or onboarding must be made? In the ninth installment of the panel discussion series, seasoned scientists offer career advice for students and early career scientists on weathering a pandemic, time management, and how to adjust to long-term change.
Getting Started with E4S for Industry and Agencies Workshop
This webinar shows a simple but practically relevant example of drastic performance differences when using HDF5.
Using the PSIP Toolkit to Achieve Your Goals – A Case Study at The HDF Group
The webinar will discuss the Productivity and Sustainability Improvement Planning (PSIP) methodology, and describe how it was successfully employed to improve three key areas of the HDF5 project.
Automated Fortran–C++ Bindings for Large-Scale Scientific Applications
The webinar will introduce SWIG-Fortran, which provides a solution for binding Fortran and C++ codes with a wide range of flexibility, including support for performant data transfers, MPI support, and direct translation of C++ features to Fortran interfaces.
Webinar: HDF5 Application Tuning (part 2)
This webinar shows a simple but practically relevant example of drastic performance differences when using HDF5.
Timemory ECP Tutorial
This tutorial will introduce Timemory, a C++ toolkit for implementing profiling, debugging, and logging solutions as well as providing a holistic profiling solution. The tutorial will be interactive, and will cover the front-end tools for C/C++/Fortran/CUDA/Python, as well as how to use the C++ toolkit.
ALCF GPU Hackathon 2021
The hackathon is a multi-day event designed to help teams of three to six developers accelerate their own codes on GPUs using a programming model, or machine learning framework of their choice. Each team will be assigned mentors for the duration of the event.
Using Spack to Accelerate Developer Workflows Tutorial
The webinar will discuss a minimalistic workflow that increases the quality of research software in Computational Science and Engineering (CSE) . The workflow applies established software engineering practices extended with CSE-specific testing and visualization and periodical cross-linking of software with reports/publications and datasets.
HPC System and Software Testing via Buildtest
This talk was held on April 15, 2021 as part of the 2021 ECP Annual Meeting. This talk introduced buildtest (https://buildtest.readthedocs.io/en/devel/index.html), an acceptance testing framework for HPC systems.
Product Lifecycle Management – An Industry Perspective
This talk was held on April 14, 2021 as part of the 2021 ECP Annual Meeting and was a dialog between ECP leadership and experts from industry around product lifecycle management.
Introduction to Containers for HPC
This tutorial was held on April 14, 2021 as part of the 2021 ECP Annual Meeting and introduced attendees to the basics of creating container images, explained best practices, and covered more advanced topics such as creating images to be run on HPC platforms using various container runtimes.
ADIOS Storage and in situ I:O Tutorial
This tutorial was held on April 13, 2021 as part of the 2021 ECP Annual Meeting. This is a short, 2-hour long tutorial that aimed to teach the basic concepts, demonstrated the capabilities, and provided pointers to interested parties to incorporate ADIOS into their science applications.
Developing a Testing and Continuous Integration Strategy for your Team
This tutorial was held on April 12, 2021 as part of the 2021 ECP Annual Meeting. In this tutorial, which was aimed at those with beginner to intermediate levels of comfort with testing and continuous integration, we briefly reviewed the multiple motivations for testing, and the different types of tests that address them.
Automating Application Performance Analysis with Caliper, SPOT, and Hatchet
This tutorial was held on April 12, 2021 as part of the 2021 ECP Annual Meeting and demonstrated how to profile your applications with Caliper, how to visualize your performance data in SPOT, and how to programmatically analyze your data with Hatchet.
Cabana Tutorial
This tutorial was held on April 12, 2021 as part of the 2021 ECP Annual Meeting. This tutorial explained the design and use of the CoPA developed Cabana Particle Simulation Toolkit and provided hands-on exercises in the form of simple examples and proxy applications
A Workflow for Increasing the Quality of Scientific Software
The webinar will discuss a minimalistic workflow that increases the quality of research software in Computational Science and Engineering (CSE) . The workflow applies established software engineering practices extended with CSE-specific testing and visualization and periodical cross-linking of software with reports/publications and datasets.
2021 ECP Community BOF Days
The Exascale Computing Project (ECP) Community Birds-of-a-Feather (BOF) Days provide an opportunity for the HPC community to engage with ECP teams to discuss our latest development efforts. Each BOF will be a 90-minute session on a given topic, with a brief overview followed by Q&A. Topics and details coming soon!
Strategies for Working Remotely Panel Series – How does remote work impact creativity and innovation?
How does working remotely and a phased return to “the office” impact our creativity and innovation? What is it about serendipitous face-to-face interactions that we find difficult to replicate online? In this discussion we explore thinking differently about co-located collaboration and question unintended effects of working remotely.
An Overview of the RAJA Portability Suite
The webinar will provide an overview of the RAJA Portability Suite, a collection of open-source software libraries that enable developers to write applications that are portable across a wide range of HPC architectures. The webinar will present code examples and performance results for several applications that rely on the Suite for portability.
Good Practices for Research Software Documentation
This webinar will discuss the importance of software documentation and the different approaches that may be taken in the software development life cycle. The presenters will share examples and stimulative questions to showcase the relationship between documentation and process.
ALCF Developer Series: Running on ThetaGPU with NVIDIA HPC SDK
This webinar will cover the NVIDIA HPC SDK, an integrated suite of compilers, libraries, and tools for NVIDIA HPC platforms. The webinar will introduce new features available in SDK that continue to open GPU computing to a wider audience of developers and users.
Extreme-scale Scientific Software Stack (E4S)
The webinar will present the main features of the Extreme-scale Scientific Software Stack (E4S), a Spack-based, comprehensive and coherent software stack that enables application developers to productively write highly parallel applications that can portably target diverse exascale architectures.
E4S Hackathon
This hackathon will give participants an opportunity to learn how to use e4s.io tools to port numerical tools, libraries, and applications to three different GPU architectures -- NVIDIA, Intel, AMD -- and making them available through Spack.
Strategies for Working Remotely Panel Series – Year in Review: What have we learned so far?
As we bring 2020 to a close, what have we learned so far, and what do we have yet to learn about working remotely, or working effectively in hybrid configurations? In this fireside chat, we look at key highlights from the Strategies for Working Remotely panel series and dig deeper. "Ask me anything" questions may be submitted to remote@acm.org.
Tutorial: In Situ Scientific Visualization and Analysis using ALPINE Ascent
This tutorial will describe Ascent, an in situ lightweight visualization framework being developed by the ECP ALPINE Project. The tutorial will cover how to present data to Ascent, render pictures, and export results. Attendees will be able to execute tutorial examples using cloud hosted Jupyter Notebooks or a public Ascent install.
Software Design for Longevity with Performance Portability
The webinar will discuss basic principles of scientific software design that have been instrumental in mitigating some of the challenges that applications developers face, specifically, performance portability and software longevity.
UPC++: An Asynchronous RMA/RPC Library for Distributed C++ Applications
This tutorial will introduce basic concepts and advanced optimization techniques of UPC++. The presenters will discuss the UPC++ memory and execution models and examine basic algorithm implementations. Participants will gain hands-on experience incorporating UPC++ features into several application examples.
Reducing Technical Debt with Reproducible Containers
The webinar discusses the concept of technical debt, which can make experiments difficult to reproduce. Focusing on scientific software, the webinar introduces isolation in containers as a powerful mechanism for reducing software portability debt, and shows results of use of reproducible containers on domain science and HPC applications.
Strategies for Working Remotely Panel Series – Sustainable Hybrid Approaches
In Spring 2020 many workers abruptly transitioned from a primarily on-site to a primarily remote work experience. Many people will be (or already are) transitioning to a hybrid experience. In this panel discussion we explore teams who are blended remote and on site, and how to be effective and efficient in long-term hybrid settings.
Scalable Precision Tuning of Numerical Software
This webinar will discuss tools for tuning the precision of floating-point programs. The tools conduct a data-driven approach to search over the types of floating-point variables to lower their precision given accuracy constraints and performance goals. The webinar will discuss opportunities for scalable precision tuning of HPC applications.
HDF5 User Group Meeting (HUG 2020)
Join the HDF Group and NERSC for a virtual HDF5 User Group Meeting on October 13-16, 2020. A hands-on tutorial on HDF5 performance tuning techniques will be held on October 13, and technical and invited talks will be held on October 14-16.
Webinar: HDF5 Application Tuning (part 1)
This webinar shows a simple but practically relevant example of drastic performance differences when using HDF5.
The Second Extreme-scale Scientific Software Stack Forum (E4S Forum)
This forum is the first in a series of events that will highlight key components of Extreme-scale Scientific Software Stack (E4S), a comprehensive and coherent software stack that will enable application developers to productively write highly parallel applications that can portably target diverse exascale architectures.
Testing and Code Review Practices in Research Software Development
The webinar will cover the relevance of software testing and peer code review in the development of research software. The webinar will discuss the motivation, challenges, barriers, and necessary improvements to make those two practices effective for research software development.
Kokkos Online Class Series
The Kokkos team will provide its first Kokkos Lecture Series, where attendees learn everything necessary to start using Kokkos to write performance portable code. This online series will consist of a 2-hour online lecture every Friday and exercises as homework. Support will be provided via GitHub and Slack throughout the time of the training.
Strategies for Working Remotely Panel Series – How to Make Teams Tick
In response to the need for many to transition to unplanned remote work, the IDEAS-ECP Productivity project launched the panel series Strategies for Working Remotely. This panel discussion “How to Make Virtual Teams Tick” addresses ways to bring teams who have been disrupted by change back into balance.
Colormapping Strategies for Large Multivariate Data in Scientific Applications
The webinar will discuss the effective use of colors in scientific visualization, and introduce concepts that can help developers make design decisions when writing simulation codes, to make better use of visualization tools.
Webinar: A Study of HACC-IO Benchmarks
This webinar presents a study that analyzes and tunes HACC-IO benchmarks for improved HDF5 performance.
Argonne Training Program on Extreme-Scale Computing 2020
ATPESC is an intensive two-week training on the key skills, approaches, and tools to design, implement, and execute applications on current and next-generation supercomputers. Lectures will be given by renowned computer scientists, and participants will be granted access to some of the world’s most powerful supercomputers.
What’s new in Spack?
The webinar will provide an overview of new features available in Spack. Spack is a package manager for scientific computing: it makes installing scientific software easy and it is agnostic to computer languages.
ALCF/ECP CMake Workshop
ECP and the Argonne Leadership Computing Facility are partnering with Kitware to host an in-depth CMake Workshop held online from July 15-17, 2020.
Strategies for Working Remotely Panel Discussion – Virtual Onboarding and Mentoring
Several laboratories have onboarded interns and new team members to work remotely with geographically dispersed teams. What are some lessons learned and best practices that we can take away from this experience? Staff members of DOE laboratories will speak about their experiences in onboarding and mentoring new hires virtually.
Parallel I/O with HDF5 and Performance Tuning Techniques
This presentation is designed for users who have had exposure to HDF5 and MPI I/O and would like to learn about doing parallel I/O with the HDF5 library. Our main goal is to make our users aware of how to avoid poor I/O performance when using parallel HDF5 library and equip them with the tools to investigate performance.
OpenMP Offload Capabilities in the oneAPI HPC Toolkit
This presentation described the key capabilities of the C/C++/Fortran compilers in oneAPI HPC Toolkit, especially those to exploit the Intel Xe GPUs to be in Aurora, the ALCF's forthcoming exascale system. Use cases of HPC applications from the Aurora Early Science Program were also discussed.
SYCL – Introduction and Best Practices
The webinar provided an overview of SYCL, a single source heterogeneous programming model based on standard C++ that is hardware agnostic and offers portability across a variety of computer platforms. The webinar covered the core concepts of SYCL and included examples to highlight its key features.
An Introduction to HDF5 in HPC Environments Supporting Materials Webinar
This presentation was designed for users who have had exposure to HDF5 and MPI I/O and would like to learn about doing parallel I/O with the HDF5 library. The main goal is to make users aware of how to avoid poor I/O performance when using parallel HDF5 library and equip them with the tools to investigate performance.
Preparing applications for Aurora using the Intel DPC++ Compatibility Tool
This presentation introduced the Intel DPC++ Compatibility Tool, and described the workflow associated with migrating CUDA codes to the DPC++ language.
ALCF/ECP UPC++ Webinar
UPC++: An Asynchronous RMA/RPC Library for Distributed C++ Applications UPC++ is a C++ library providing classes and functions that support Partitioned Global Address Space (PGAS) programming. The UPC++ API offers
Strategies for Working Remotely: Making the Transition to Virtual Software Teams
As working remotely has suddenly become a near-universal experience, many software teams are now functioning as completely virtual teams. This panel brings together staff members of DOE laboratories, who will speak about experiences in recent transitions from co-located and partially distributed software teams to fully virtual software teams.
Accelerating Numerical Software Libraries with Multi-Precision Algorithms
Multi-precision arithmetic can lead to performance gains while preserving solution quality for various algorithms in computational sciences. The webinar discussed multi-precision algorithms that have proven successful and elaborated on their realization and usage. The webinar focused on lessons learned and generally applicable strategies.
Strategies for Working Remotely: Challenges Faced by Parents Who are Working Remotely, and Overcoming Them
While working remotely is challenging enough, many are currently experiencing unique complexities involved with parenting, transitioning to online school at home, and work. This panel brought together ECP staff members, a new staff member on-boarding with a National Lab, and a Montessori educator to share ideas and provide resources to assist.
Best Practices for Using Proxy Applications as Benchmarks
Proxy applications have many uses in software development and hardware/software co-design. Most proxies are easy to build, run, and understand, and are especially appealing for use in benchmark suites and studies. This webinar examined the role of proxy apps as effective benchmarks, also for procurement purposes.
Strategies for Working Remotely: Advice from Colleagues with Experience
Working remotely has suddenly become a near-universal experience for staff members of research organizations, but for some it has been a way of life for years. This panel brought together five staff members of U.S. Department of Energy laboratories, all members of the Exascale Computing Project, with years of varied experience.
DAOS: Next-Generation Data Management for Exascale
This presentation introduced the key concepts behind DAOS (Distributed Asynchronous Object Storage) an open-source, scale-out object store designed from the ground up for massively distributed Non-Volatile Memory (NVM). The presentation provided details on the DAOS deployment on Aurora and how applications can benefit from it.
Testing: Strategies When Learning Programming Models and Using High-Performance Libraries
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
Introduction to Kokkos
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
Refactoring EXAALT MD for Emerging Architectures
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
Kokkos Bootcamp / Training
We are pleased to announce that we are hosting the next Performance Portability with Kokkos Bootcamp January 14-17, 2020 at the Buffalo Thunder Resort in Santa Fe NM. This training
ECP/NERSC UPC++ Tutorial
This event was a repeat of the tutorial delivered on November 1, but with the restoration of the hands-on component which was omitted due to uncertainty surrounding the power outage
Building Community through xSDK Software Policies
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
A Roadmap for SYCL/DPC++ on Aurora
This talk introduced SYCL as a programming model for Aurora, the upcoming Argonne exascale machine. SYCL is a single source heterogeneous programming model based on standard C++. It is hardware agnostic and offers the potential to be portable across many of DOE’s largest machines.
ECP/NERSC UPC++ Tutorial
Registration is now open for the one day ECP/NERSC UPC++ tutorial. UPC++ is a C++11 library providing classes and functions that support Partitioned Global Address Space (PGAS) programming. UPC++ provides
Tools and Techniques for Floating-Point Analysis
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
Discovering and Addressing Social Challenges in the Evolution of Scientific Software Projects
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
Machine Learning with Tensorflow, Horovod and PyTorch on HPC
This webinar covered the basics of when you should use TensorFlow, Horovod, and PyTorch on leadership computing systems, how to build and deploy models on HPC systems, and how to get good performance. The presentation also discussed techniques for profiling deep learning workloads on HPC systems and how to solve bottlenecks.
Software Management Plans in Research Projects
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) offers a monthly webinar series on Best Practices for HPC Software
CMake Training
ECP is partnering with Kitware and NERSC to offer an introductory 1.5 day CMake training class at NERSC on July 29-30. Registration is now closed for this event. The training
When 100 Flops/Watt was a Giant Leap: The Apollo Guidance Computer Hardware, Software and Application in Moon Missions
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
Overview of OpenMP 4.5 and 5.0 Features
This webinar reviewed the fork-join OpenMP programming model, its execution model and data environment for accelerators such as GPUs, the basic constructs of concepts in OpenMP 4.5, and new constructs available in OpenMP 5.0 that improve usability and offload flexibility.
Advanced MPI Tutorial at ISC High Performance 2019
Advanced MPI Tutorial When: Sunday, June 16, 9am - 6pm Where: Applaus, Messe Frankfurt Tor Ost (East Gate) Hall 3, Frankfurt am Main, Germany Presenters: Pavan Balaji (Argonne National Laboratory),
Modern C++ for High-Performance Computing
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
Webinar: Introduction to AMD GPU Programming with HIP
AMD Research presented a webinar titled, "Introduction to AMD GPU programming with HIP" on June 7th. HIP is a C++ runtime API that allows developers to write portable code to
So, You Want to be Agile? Strategies for Introducing Agility into Your Scientific Software Project
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
OpenMP Brookathon 2019
OpenMP Brookathon 2019 The Computational Science Initiative at Brookhaven National Laboratory (BNL) is organizing in conjunction with Oak Ridge National Laboratory (ORNL) and IBM, the "OpenMP Brookathon 2019", on April
First Kokkos Usergroup Meeting
*****Registration is now closed for this event.****** The Kokkos team is announcing the first Kokkos Usergroup Meeting to be held in Albuquerque New Mexico, USA April 23rd and 24th. The
Testing Fortran Software with pFUnit
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
Performance Portability with Kokkos Bootcamp March 2019
Performance Portability with Kokkos Bootcamp - Registration for this event is now closed. March 26-29, 2019 We are pleased to announce that we are hosting the next Performance Portability with Kokkos
Parallel I/O with HDF5: Overview, Tuning, and New Features
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
Containers in HPC
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
Quantitatively Assessing Performance Portability with Roofline
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
Introduction to Software Licensing
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
Open Source Best Practices: From Continuous Integration to Static Linters
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
Watch ECP Training Videos Available on YouTube
Advances in next-generation computational science require the development of applications that can fully exploit emerging exascale architectures for optimal performance and provide high-fidelity multiphysics and multiscale capabilities. ECP’s Training and Productivity programs
Modern CMake
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
Software Sustainability – Lessons Learned
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
New York Scientific Data Summit (NYSDS 2018)
New York Scientific Data Summit (NYSDS 2018): Aug. 6–8 Led by the Computational Science Initiative’s at Brookhaven National Laboratory (BNL), the New York Scientific Data Summit (NYSDS) aims to accelerate data-driven discovery and innovation by bringing
Argonne Training Program on Extreme-Scale Computing 2018
Argonne Training Program on Extreme-Scale Computing (ATPESC) 2018 Computational scientists now have the opportunity to apply for the upcoming Argonne Training Program on Extreme-Scale Computing (ATPESC), to take place from
Performance Portability with Kokkos Bootcamp July 2018
This workshop is intended to teach new Kokkos users how to get started and to help existing Kokkos users to further improve their codes. The training will cover the minimum required topics to get your application started on using Kokkos
Open Source Software
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) facilitates a webinar series on Best Practices for HPC Software Developers.
Advanced MPI Tutorial at ISC 2018
The ECP Project will host an advanced Message-Passing Interface (MPI) tutorial on June 24. This tutorial will cover a vast of new features that are being introduced in MPI-3. The
Popper
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
On-demand Learning for Better Scientific Software: How to Use Resources & Technology to Optimize your Productivity
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
Software Citation Today and Tomorrow
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
Scientific Software Development with Eclipse
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
Jupyter and HPC: Current State and Future Roadmap
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
Bringing Best Practices to a Long-Lived Production Code
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) has resumed the webinar series on Best Practices for HPC Software
BSSw Fellowship Program Webinar
The IDEAS Productivity project and the Exascale Computing Project (ECP) are pleased to announce a new fellowship program. BSSw Fellowship Program Q&A Session 4:30-5:30pm ET Tuesday December 12, 2017 Presenters: Mike Heroux, SNL,
Better Scientific Software Webinar
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) is resuming the webinar series on Best Practices for HPC Software
MPI Forum: Standardization Meeting for MPI
The MPI Forum is an open group, with representatives from many organizations, which defines and maintains the MPI standard. The MPI Forum hosts regular standardization meetings that are open to all
Exascale Challenges and Opportunities (SC17 BOF Session)
This BoF explores the challenges and opportunities of Exascale Computing. The motivations for exascale are centered on drivers such as economic competitiveness, national security, health care, energy, manufacturing, materials, and
TAU Performance System Webinar
The DOE Exascale Computing Project (ECP) is pleased to have sponsored a webinar presented by Sameer Shende of the University of Oregon on the TAU Performance System. The webinar took place on Wednesday, November 8,
Managing Defects in HPC Software Development
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) is resuming the webinar series on Best Practices for HPC Software
HipChat Webinar
The DOE Exascale Computing Project (ECP) will be offering a short tutorial on using HipChat, another tool available to members of ECP which helps to enable and archive communications with your ECP colleagues. The
HipChat Webinar
The DOE Exascale Computing Project (ECP) will be offering a short tutorial on using HipChat, another tool available to members of ECP which helps to enable and archive communications with your ECP colleagues. The
Scalable Node Programming with OpenACC
The DOE Exascale Computing Project (ECP) is pleased to sponsor a webinar presented by Michael Wolfe of NVIDIA titled "Scalable Node Programming with OpenACC" that took place on Wednesday, September 20, at 1:00 pm
Barely Sufficient Project Management: A few techniques for improving your scientific software development efforts
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP) is resuming the webinar series on Best Practices for HPC Software
Using the Roofline Model and Intel Advisor
The IDEAS Productivity project, in partnership with the DOE Computing Facilities of the ALCF, OLCF, and NERSC and the DOE Exascale Computing Project (ECP), is resuming the webinar series on Best Practices for HPC Software
Argonne Training Program on Extreme-Scale Computing 2017
Argonne Training Program on Extreme-Scale Computing (ATPESC) 2017 Computational scientists had the opportunity to apply for the Argonne Training Program on Extreme-Scale Computing (ATPESC) 2017, which took place July 30
Intermediate Git
The IDEAS Productivity project, in partnership with several DOE Computing Facilities and the DOE Exascale Computing Project (ECP) is resuming the webinar series on Best Practices for HPC Software Developers, which we began last year.
OpenMP Tutorial
The Exascale Computing Project held an OpenMP tutorial on June 28 at 1:00 pm EDT. The tutorial was open to everyone. This webinar briefly discussed what's new in OpenMP 4.5 and what
Python in HPC
The Exascale Computing Project is partnering with several DOE Computing Facilities to offer a webinar covering Python in HPC. Python's powerful elegance has driven its adoption at HPC centers for job
