The webinar will discuss a development process and practices that incorporate secure software knowledge into scientific software development. The process seeks to mitigate and to defend against malicious attacks that can cause extreme damage to any software, compromising integrity, authentication, availability, and long-term sustainability.
The ECP SOLLVE project, which is working to evolve OpenMP for Exascale computing, invites you to participate in a new series of monthly telecons that will occur on the last Friday of every month. The next call in the series will take place on Friday, December 1st, between 11:00 am and 12:00 pm ET.
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.
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.
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.
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.
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.
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.
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.
This webinar will provide an overview of the current activities of ECP’s Broadening Participation Initiative, which seeks to foster a supportive and inclusive culture within DOE national laboratories for recruiting and retaining a diverse workforce in HPC.
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.
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.
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.
Mentorship is a dynamic, career-long phenomenon spanning many different relationships that support our personal and professional development. In this webinar, the speaker will discuss insights into the science of mentorship, ongoing research into mentorship among computing professionals, and experiences with inclusive mentorship.
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.
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.
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.
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.
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.
This webinar will discuss unexpected benefits of involving a more diverse population in science, arguing that diverse groups both do scientific research differently and do different scientific research. The webinar will conclude with a call for accountability through disaggregating data in diversity, equity, and inclusion initiatives.
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 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.
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.
This webinar will discuss skills for people with power and influence to be more effective in a modern diverse workforce, including skills such as listening, amplifying marginalized voices, and speaking up when it is uncomfortable.
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.
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.
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.
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.
Mentoring is vital to developing and retaining a diverse, talented, and enabled workforce. In this penal, the speakers will share what they have learned from their mentees about developing, networking, and sponsoring the next generation of HPC and STEM professionals.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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
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.
This webinar shows a simple but practically relevant example of drastic performance differences when using HDF5.
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.
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.
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.
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, an acceptance testing framework for HPC systems.
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.
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.
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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++ is a C++ library of classes and functions that support Partitioned Global Address Space (PGAS) programming. The webinar will introduce basic concepts and advanced optimization with UPC++, execution models and basic algorithm implementations.
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
Software testing is an invaluable practice, albeit the level of testing in scientific applications can vary widely, from no testing at all to full continuous. This webinar discusses experiences while developing a mini-app as an approach to learn about new programming models.
Introduction to Kokkos
The Kokkos C++ Performance Portability Ecosystem is a production-level solution for writing modern C++ applications in a hardware-agnostic way. This webinar we will give a short overview of what the Kokkos Ecosystem provides, including its programming model, math kernels library, and tools.
Refactoring EXAALT MD for Emerging Architectures
As part of the DOE Exascale Computing Project, the EXAALT project has worked to increase the accuracy, time, and length scales of molecular dynamics simulations of materials for fusion energy. The webinar will discuss the approach used to rewrite kernels, emphasizing key strategies and lessons learned in code transitions for emerging architectures.
Kokkos Bootcamp / Training
This training was intended to teach new Kokkos users how to get started and to help existing Kokkos users to further improve their codes. The training covered the minimum required topics to get application started on using Kokkos.
ECP/NERSC UPC++ Tutorial
This tutorial we introduced basic concepts and advanced optimization techniques of UPC++, including. UPC++ memory and execution models, and the implementation of basic algorithms in UPC++.
Building Community through xSDK Software Policies
The Extreme-scale Scientific Software Development Kit (xSDK) provides a coordinated infrastructure for independent mathematical libraries to support the productive and efficient development of high-quality applications. The webinar discussed the development and impact of xSDK community policies.
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
This tutorial we introduced basic concepts and advanced optimization techniques of UPC++, including. UPC++ memory and execution models, and the implementation of basic algorithms in UPC++.
Tools and Techniques for Floating-Point Analysis
Scientific software is central in research computing, although the development of accurate and reliable software is notoriously difficult. This webinar discusses tools available tools for analyzing floating-point scientific software, focusing on effects and fixes of potential bugs.
Discovering and Addressing Social Challenges in the Evolution of Scientific Software Projects
This webinar discusses topics pertinent to scientific software projects, such as building and maintaining a welcoming community atmosphere, overcoming skepticism of sharing science and software, mediating between users working on conflicting topics, and providing credit and growth opportunities for community members.
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
Software is a necessary by-product of research. This webinar discusses a Software Management Plan (SMP) that deals with software as a first-class citizen, in particular for grant formulations. The webinar goes through questions that developers should consider when developing a SMP, and how to manage the implementation of the plan.
CMake Training
The training class targeted at a deeper understanding of CMake. It sought to assist ECP developers in learning how to resolve issues outside of their control, in addition to writing a build system generator capable of seamlessly configuring for multiple unique architectures with a variety of compilers.
When 100 Flops/Watt was a Giant Leap: The Apollo Guidance Computer Hardware, Software and Application in Moon Missions
Commemorating the 50th Anniversary of the Apollo Moon landings, this webinar described the revolutionary computer, the Apollo Guidance Computer (AGC). The AGC made autonomous travel to the Moon and back not only possible but safe. The webinar concluded with several user stories about the actual operation of the AGC in various Apollo missions.
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
Since its creation in the early 1980s, C++ has steadily evolved to become a multi-paradigm programming language that fully supports the needs of modern programmers. This webinar gave a tour of features from modern C++ relevant to HPC, along with guidelines for their use.
Webinar: Introduction to AMD GPU Programming with HIP
HIP is a C++ runtime API that allows developers to write portable code to run on AMD and NVIDIA GPUs. The API is similar to CUDA so porting existing codes from CUDA to HIP should be fairly straightforward in most cases. The webinar included guidance on the manual coding and performance tuning work needed to complete the port.
So, You Want to be Agile? Strategies for Introducing Agility into Your Scientific Software Project
Scientific software team cultures have natural consistencies with agile practices. The webinar, discussed a few agile practices and strategies that are readily adapted and adopted by scientific software teams, and an attitude and strategy for a continual process that targets the delivery of science results.
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
This meeting gave the growing Kokkos community a chance to present progress in adopting Kokkos, exchange experiences, discuss challenges and help set priorities for the future roadmap of Kokkos.
Testing Fortran Software with pFUnit
Over the past two decades, the emergence of highly effective software testing frameworks has greatly simplified the development and use of unit. This webinar began with a basic introduction to the use of pFUnit to develop tests for MPI+Fortran, and some specialized methodologies for testing numerical algorithms.
Performance Portability with Kokkos Bootcamp March 2019
This workshop was intendeded to teach new Kokkos users how to get started and to help existing Kokkos users to further improve their codes. The training covered the minimum required topics to get application started on using Kokkos; Kokkos experts helped more advanced users.
Parallel I/O with HDF5: Overview, Tuning, and New Features
This webinar gave an introduction of the HDF5 library, with a focus on parallel I/O and performance tuning options. The webinar also presented an overview of the latest performance and productivity enhancement features being developed as part of the DOE’s Exascale Computing Project.
Containers in HPC
Containers have gained adoption in the HPC and scientific computing space through specialized runtimes like Shifter, Singularity and Charliecloud. The webinar provided a brief introduction on how to build images and run containers on HPC systems, and discussed some best practices to ensure containers can take full advantage of HPC systems.
Quantitatively Assessing Performance Portability with Roofline
This webinar focused on ‘performance portability’, why it is important and desirable, and how to quantitatively measure it. The webinar discussed the concept of performance portability, and introduced a simple yet powerful metric and an empirical methodology to quantitatively assess a code’s performance portability across multiple platforms.
Introduction to Software Licensing
Software licensing and related matters of intellectual property can often seem confusing or complicated. This webinar proposes a different approach: think about software licensing from the standpoint of what you want others to be able to do (or not do) with your software.
Open Source Best Practices: From Continuous Integration to Static Linters
This webinar discusses open-source software (OSS) opportunities within the scientific ecosystem, including continuous integration, code coverage, and static analysis. The presenters demonstrate the usefulness of these tools, which are agnostic to software language or applications, and their long-term benefits.
Modern CMake
This webinar gives an introduction to development with modern CMake constructs. CMake has evolved over time into the most widely used C++ build tool in the world, and many new features have been added to CMake to make the creation of cross-platform build files easier.
Software Sustainability – Lessons Learned
This webinar goes through what the UK’s Software Sustainability Institute has learned from 8 years of work towards making software sustainable. The webinar discusses efforts around understanding the scale of software use in research, and raising the profile of software as a key part of the research ecosystem.
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.
Popper
This webinar introduces a tool – Popper – for creating and publishing workflows, data, and models that are easy to reproduce, thus streamlining scientific analysis. The tool repurposes DevOps practices in the context of scientific explorations, and researchers can leverage existing tools and technologies to enable reproducibility.
On-demand Learning for Better Scientific Software: How to Use Resources & Technology to Optimize your Productivity
Advances in technologies for computational science often require members of the HPC community to learn new tools, techniques, or processes. Taking cases and examples from Python and Git, this webinar demonstrates how to develop a personalized learning framework leveraging massively open online courses, podcasts, social media, videos, etc.
Software Citation Today and Tomorrow
Software is increasingly important in research, and some of the scholarly communications community has been pushing the concept of software citations to allow software developers and maintainers to get academic credit for their work. This webinar discusses the state of software citation, obstacles to progress and how they may be overcome.
Scientific Software Development with Eclipse
The Eclipse IDE is one of the most popular IDEs available, and its support for multiple languages - C, C++ and Fortran - has made it attractive for scientific software development. This webinar demonstrates features available in Eclipse that useful for that purpose, and shows how they can be used in a variety of different scenarios.
Jupyter and HPC: Current State and Future Roadmap
The Jupyter notebook has become one of the tools of choice for the data science and high-performance computing (HPC) communities. This webinar provides an overview of why Jupyter is gaining traction in education, data science, and HPC, with emphasis on how notebooks can be used as interactive documents for exploration and reporting.
Bringing Best Practices to a Long-Lived Production Code
This webinar discusses the adoption of best software practices in long-lived scientific production code, with a significant user base, that may be reluctant to a change in culture - “just write the code fast.” The speaker discusses some of the peculiar problems faced by long-lived codes, and present a case study to deal with some of the issues.
Better Scientific Software Webinar
Better Scientific Software (BSSw) is an organization dedicated to improving developer productivity and software sustainability for computational science and engineering. This webinar introduced https://bssw.io: a community exchange for scientific software improvement.
This BoF gathered a forum of HPC experts to identify what they consider to be key challenges in achieving exascale computing and how they would best propose to meet them, with special attention to collaboration opportunities.
TAU Performance System Webinar
This workshop focused on TAU, a powerful profiling and tracing toolkit that covers multiple aspects of performance instrumentation, measurement, and analysis. The workshop demonstrated how performance data is collected using TAU’s automated instrumentation and then analyzed.
Managing Defects in HPC Software Development
This webinar discusses methods for performing software verification, to remove defects at code construction time, helping in algorithm and method development, increased productivity, and increased confidence in the results of even basic scientific computations.
Scalable Node Programming with OpenACC
This webinar focused on OpenACC, in particular the problems it can address, its important elements, how it is being adopted and used in production science and engineering applications, and how to build and used applications with OpenACC for different targets.
Barely Sufficient Project Management: A few techniques for improving your scientific software development efforts
Software development is an essential activity for many scientific teams, and this webinar discusses several light-weight techniques for managing scientific software efforts. These techniques include managing the initiation and exit of team members, and ways to improve communication within a team and with its stakeholders.
Using the Roofline Model and Intel Advisor
This webinar introduced the Roofline Model and its “Cache-Aware” variant, general guidelines and historical approaches to Roofline-based program analysis, and provided a discussion of how changes in data locality and arithmetic intensity of two canonical benchmarks manifest in those two Roofline formulations.
Intermediate Git
This webinar covered useful information about the git version control system. The webinar took the view that the best way to learn to use git effectively is to learn it as a data-structure and a set of algorithms to manipulate that data-structure.
Python in HPC
Python's powerful elegance has driven its adoption at HPC centers. However, maximizing performance from Python applications can be challenging especially on supercomputing architectures. This webinar discussed some of those challenges (and potential solutions) using Python at NERSC, ALCF, and OLCF.
Sign up with your email to receive the latest ECP updates.
