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.
As part of this series, we offer one-hour webinars on topics in scientific software development and high-performance computing, approximately once a month. The next webinar in the series was titled “How Open Source Software Supports the Largest Computers on the Planet”, and was presented by Ian Lee of Lawrence Livermore National Laboratory. The webinar took place on Wednesday, July 18, 2018 at 1:00 pm ET.
Abstract:
This talk provided an overview of the work at Lawrence Livermore National Laboratory to re-vamp their open source project offerings, release processes, and engagements across the Department of Energy and the US Government through efforts such as DOECode and Code.gov. The presenter discussed ongoing work to make it easier for Livermore staff to engage with open source communities, via both the creation of new projects and contributions to existing open source projects. These experiences and insights may be useful to a wide range of developers of high-performance scientific 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) has resumed the webinar series on Best Practices for HPC Software Developers, which we began in 2016.
As part of this series, we offer one-hour webinars on topics in scientific software development and high-performance computing, approximately once a month. The next webinar in the series is titled “Software Sustainability – lessons learned from different disciplines”, and will be presented by Neil Chue Hong of the Software Sustainability Institute (University of Edinburgh). The webinar will take place on Wednesday, August 21, 2018 at 12:00 pm ET.
Abstract:
How do you make software sustainable? How much is it about process and how much about practice? Does it vary between countries or disciplines? In this webinar, I’ll present what the UK’s Software Sustainability Institute has learned from 8 years of work in this area including efforts around understanding the scale of software use in research, raising the profile of software as a key part of the research ecosystem, and how we can enable researchers and developers to build better 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) has resumed the webinar series on Best Practices for HPC Software Developers, which we began in 2016.
As part of this series, we offer one-hour webinars on topics in scientific software development and high-performance computing, approximately once a month. The next webinar in the series was titled Modern CMake, and was presented by Bill Hoffman. The webinar took place on Wednesday, September 19, 2018 at 1:00 pm ET.
Abstract:
Bill Hoffman, the creator of the CMake project, will give an introduction to development with modern CMake constructs. CMake is 17 years old and has evolved over time into the most widely used C++ build tool in the world. In the past 5 years, many new features have been added to CMake to make the creation of cross-platform build files easier. This webinar will provide best practices for development and maintenance of a CMake build system. The webinar will cover the “target centric” approach to writing CMake files. In addition, testing and quality dashboards with CDash will be covered. Kitware’s experience with HPC systems and CMake will also be discussed.
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 Developers, which we began in 2016.
As part of this series, we offer one-hour webinars on topics in scientific software development and high-performance computing, approximately once a month. The next webinar is titled Open Source Best Practices: From Continuous Integration to Static Linters, and will be presented by Daniel Smith and Ben Pritchard (members of the NSF-funded Molecular Sciences Software Institute, or MolSSI). The webinar will take place on Wednesday, October 17, 2018 at 1:00 pm ET.
Abstract:
This webinar will continue the discussion of open source software (OSS) opportunities within the scientific ecosystem to include the many cloud and local services available to OSS free of charge. The services to be discussed include continuous integration, code coverage, and static analysis. The presenters will demonstrate the usefulness of these tools and how a small time investment at the beginning is traded for long-term benefits. These services and ideas are agnostic to software language or HPC software application and should apply to any party interested in tools that help ease the burden of software maintenance.
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 Developers, which we began in 2016.
As part of this series, we offer one-hour webinars on topics in scientific software development and high-performance computing, approximately once a month. The next webinar is titled Introduction to Software Licensing, and will be presented by David Bernholdt (Oak Ridge National Laboratory). The webinar took place on Wednesday, December 5, 2018 at 1:00 pm ET.
Abstract:
Software licensing and related matters of intellectual property can often seem confusing or hopelessly complicated, especially when many present their opinions as dogma. This presentation takes a different approach: getting you to think about software licensing from the standpoint of what you want others to be able to do (or not do) with your software. We started by developing a common understanding of the terminology used around software licenses. Then considered various scenarios of what you might want to accomplish with a software license, and what to look for in the license. We also discussed some pragmatic issues around actually applying a license to your 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) has resumed the webinar series on Best Practices for HPC Software Developers, which we began in 2016.
As part of this series, we offer one-hour webinars on topics in scientific software development and high-performance computing, approximately once a month. The next webinar is titled Quantitatively Assessing Performance Portability with Roofline, and will be presented by John Pennycook (Intel), Charlene Yang (Lawrence Berkeley National Laboratory) and Jack Deslippe (Lawrence Berkeley National Laboratory). The webinar will take place on Wednesday, January 23, 2019 at 1:00 pm ET.
Abstract:
Wouldn’t it be great if we could port a code to a new high-performance architecture without substantially changing the code yet achieving a similar level of performance as hand-optimized code? This webinar will frame the discussion around ‘performance portability’, why it is important and desirable, and how to quantitatively measure it. The webinar started with a background check on how the concept of performance portability came about and past attempts to define it and quantify it. Then the speaker introduced a simple yet powerful metric and an empirical methodology to quantitatively assess a code’s performance portability across multiple platforms. The methodology uses the Roofline performance model to measure an ‘architectural efficiency’ term in the metric proposed by Pennycook et al. The speaker then dove into a few nuances of this methodology, for example, how and why empirical ceilings should be used for performance bounds, how to accurately account for complex instructions such as divides, how to model strided memory accesses, and how to select the appropriate Roofline ceilings and application performance points to make sure that the performance portability analysis is not erroneously skewed. We also showed some results of measuring performance portability using the aforementioned metric and methodology on two modern architectures, Intel Xeon Phi and NVIDIA V100 GPUs.
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 Developers, which we began in 2016.
As part of this series, we offer one-hour webinars on topics in scientific software development and high-performance computing, approximately once a month. The next webinar is titled Containers in HPC, and will be presented by Shane Canon (LBNL). The webinar will take place on Wednesday, February 13, 2019 at 1:00 pm ET
Abstract:
Containers have gained adoption in the HPC and scientific computing space through specialized runtimes like Shifter, Singularity and Charliecloud. Containers enable reproducible, shareable, portable execution of applications. In this webinar, we will give a brief introduction on how to build images and run containers on HPC systems. We will also discuss some best practices to ensure containers can take full advantage of HPC systems.
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 Developers, which we began in 2016.
As part of this series, we offer one-hour webinars on topics in scientific software development and high-performance computing, approximately once a month. The next webinar was titled Parallel I/O with HDF5: Overview, Tuning, and New Features, and was presented by Quincey Koziol (NERSC). The webinar took place on Wednesday, March 13, 2019 at 1:00 pm ET
Abstract:
HDF5 is a data model, file format, and I/O library that has become a de facto standard for HPC applications to achieve scalable I/O and for storing and managing big data from computer modeling, large physics experiments and observations. This webinar gave an introduction to using 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 (ECP) ExaHDF5 effort, and optimizations used in improving I/O performance of ECP applications.
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 Bootcamp March 26-29, 2019 at the Oakland City Center Conference Center in Oakland, CA. 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, and Kokkos experts will be on hand to help the more advanced users.
What is Kokkos?
Kokkos is a programming model and library for writing performance portable code in C++. It includes abstractions for on-node parallel execution and data layout. These abstractions are mapped at compile time to fit a device’s architecture for best performance. It uses standard C++ in the same spirit as libraries such at Thrust and Thread Building Blocks.
Who should attend?
Anyone who has a C++ application, or would like to create C++ Kokkos kernels that hook onto an application, and would like to have a single source code run well on multiple platforms. We also encourage developers to bring applications that already use Kokkos since Kokkos experts will be available to help with more advanced use cases. Although we strongly suggest teams of two (or more) per application, please do not hesitate to apply if you are a single developer who wants attend this event.
What happens at the event?
We will have Kokkos experts to help you with your application. This event is a tutorial and a playground to experiment with integrating Kokkos with your application and to help optimize existing Kokkos applications.
What happens after the event?
Attendance to this event will help us create a relationship with your team that we hope to continue as you return home to continue your work. We plan to host regular office hours to tend to your teams questions in the initial stages and to help your team continue to make significant progress.
How should I prepare?
After signing up, we will contact you to discuss your application. If you are new to Kokkos, we can help you prepare a kernel for the event. If you have an existing Kokkos application, we would like to understand your needs before the event. We hope that doing this prep work will maximize your time learning from Kokkos experts.
How do I apply?
Registration for this event is now closed.
If you have any questions, please contact one of the following organizers:
- Graham Lopez, [email protected]
- Galen Shipman, [email protected]
- Christian Trott, [email protected]
- Geoff Womeldorff, [email protected]
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 Developers, which we began in 2016.
As part of this series, we offer one-hour webinars on topics in scientific software development and high-performance computing, approximately once a month. The next webinar is titled Testing Fortran Software with pFUnit, and will be presented by Thomas Clune (NASA). The webinar will take place on Wednesday, April 10, 2019 at 1:00 pm ET
Abstract:
Over the past two decades, the emergence of highly effective software testing frameworks has greatly simplified the development and use of unit tests and has led to new software development paradigms such as test driven development (TDD). However, technical computing introduces a number of unique testing challenges, including distributed parallelism and numerical accuracy. This webinar will begin with a basic introduction to the use of pFUnit to develop tests for MPI+Fortran software and then present some of the new capabilities in the latest release. We will also discuss some specialized methodologies for testing numerical algorithms and speculate about future framework capabilities that may improve our ability to test at exascale.
