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 Modern C++ for High-Performance Computing, and will be presented by Andrew Lumsdaine (Pacific Northwest National Laboratory & University of Washington). The webinar will take place on Wednesday, June 12, 2019 at 1:00 pm ET.
Abstract:
Since its creation by Bjarne Stroustrup in the early 1980s, C++ has steadily evolved to become a multi-paradigm programming language that fully supports the needs of modern programmers. Because C++ had its roots in the C programming language, conventional wisdom (and longstanding practice) had been to use C++ in a dichotomous fashion: abstractions for productivity with escape to C for performance. However, C++ today is best viewed holistically — as it is today — rather than as extension of C or even of earlier versions of C++. In this webinar I will give a tour of features from modern C++ relevant to HPC, along with guidelines for their use — and demonstrate that C++ can offer productivity and elegance while sacrificing nothing in performance.
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), Torsten Hoefler (D-INFK ETH Zurich), Antonio Pena (Barcelona Supercomputing Center) and Yanfei Guo (Argonne National Laboratory)
The ECP Project will host an advanced Message-Passing Interface (MPI) Tutorial on June 16. This tutorial will cover a vast of new features that are being introduced in MPI-3. The tutorial is offered as part of the ISC High Performance 2019. The registration is open to everyone through the ISC registration page.
The Message Passing Interface (MPI) has been the de facto standard for parallel programming for nearly two decades now. However, a vast majority of applications only rely on basic MPI-1 features without taking advantage of the rich set of functionalities the rest of the standard provides. Further, with the advent of MPI-3 (released in September 2012), a vast number of new features are being introduced in MPI, including efficient one-sided communication, support for external tools, non-blocking collective operations, and improved support for topology-aware data movement. The upcoming MPI-4 standard aims at introducing further improvements to the standard in a number of aspects. This is an advanced-level tutorial that will provide an overview of various powerful features in MPI, especially with MPI-2 and MPI-3, and will present a brief preview into what is being planned for MPI-4.
Abstract
The webinar consisted of three segments:
- A review of the fork-join OpenMP programming model, followed by an introductory overview of the tasking model. This segment provided application developers with the necessary tools to go beyond the commonly used parallel loop.
- A brief introduction to the OpenMP execution model and data environment for accelerators such as GPUs. This segment also discussed the important basic OpenMP 4.5 constructs and concepts.
- A review of the OpenMP standard, 5.0, and its new constructs. This segment covered several important features in OpenMP 5.0 that can improve usability, offload flexibility, and extend the existing functionality in OpenMP 4.5.
Organizers
- Haritha Siddabathuni Som (ALCF)
- Ray Loy (ALCF)
- Yasaman Ghadar (ALCF)
Webinar material
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, When 100 Flops/Watt was a Giant Leap: The Apollo Guidance Computer Hardware, Software and Application in Moon Missions, and was presented by Mark Miller (Lawrence Livermore National Laboratory). The webinar will took place on Wednesday, July 17, 2019 at 1:00 pm ET.
Abstract:
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 added profoundly to crew safety, flight profile accuracy and even optimized propellant use to such an extent that final missions plans traded fuel for added weight in equipment and lunar samples. The webinar gave an overview of the AGC hardware architecture, the guidance software it executed as well as the pioneering efforts in developing both. HPC/CSE code teams will discover many familiar themes such as flops/watt power constraints and performance portability challenges. The webinar concluded with several user stories about the actual operation of the AGC in various Apollo missions.
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.
For questions please send an email to [email protected].
We are looking forward to seeing you in Berkeley.
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 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 Software Management Plans in Research Projects, and was presented by Shoaib Sufi (Software Sustainability Institute). The webinar took place on Wednesday, August 14, 2019 at 12:00 pm ET. (One hour earlier than the usual time.)
Abstract:
Software is a necessary by-product of research. Software in this context can range from small shell scripts to complex and layered software ecosystems. Dealing with software as a first class citizen at the time of grant formulation is aided by the development of a Software Management Plan (SMP). An SMP can help to formalize a set of structures and goals that ensure your software is accessible and reusable in the short, medium and long term. SMP’s aim at becoming for software what Data Management Plans (DMP’s) have become for research data (DMP’s are mandatory for National Science Foundation grants). This webinar takes you through the questions you should consider when developing a Software Management Plan, how to manage the implementation of the plan, and some of the current motivation driving discussion in this area of research management.
Abstract
Running efficient and scalable deep learning applications on leadership computing systems, including future exascale supercomputers, requires good use of popular deep learning frameworks, such as TensorFlow, Horovod, and PyTorch. In this ESP Webinar, we covered the basics of when you should use these frameworks, how to build and deploy models on HPC systems, and how to get good performance. Additionally, deep learning workloads on HPC also require care when scaling to multi-node jobs, and HPC systems offer opportunities to perform hyperparameter searches as well. The presenters discussed some techniques for profiling deep learning workloads on HPC systems and how to solve bottlenecks.
Organizers
- Haritha Siddabathuni Som (ALCF)
- Ray Loy (ALCF)
- Yasaman Ghadar (ALCF)
Webinar materials
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 Discovering and Addressing Social Challenges in the Evolution of Scientific Software Projects, and was presented by Rene Gassmoeller (UC Davis). The webinar took place on Wednesday, September 11, 2019 at 1:00 pm ET.
Abstract:
In recent years scientific software projects have increasingly incorporated state-of-the-art technical best practices like continuous integration into their development cycle. However, many projects still struggle to create and maintain an active and welcoming user/developer community, and there exists little documentation on what makes a scientific software community successful. In this webinar I will introduce my work — as a Better Scientific Software Fellow — typical social challenges and potential solutions that arise during the evolution of a scientific software project. Aimed at current and prospective software maintainers and community leaders, I will discuss topics such as building and maintaining a welcoming community atmosphere, overcoming skepticism of sharing science and software, mediating between users working on conflicting topics or publications, and providing credit and growth opportunities for community members. Finally, I hope to initiate a conversation among project and community leaders about what makes communities successful so that we can learn from each other and improve scientific software development together.
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 Tools and Techniques for Floating-Point Analysis, and will be presented by Ignacio Laguna (Lawrence Livermore National Laboratory). The webinar will take place on Wednesday, October 16, 2019 at 1:00 pm ET.
Abstract:
Scientific software is central to the practice of research computing. While software is widely used in many science and engineering disciplines to simulate real-world phenomena, developing accurate and reliable scientific software is notoriously difficult. One of the most serious difficulties comes from dealing with floating-point arithmetic to perform numerical computations. Round-off errors occur and accumulate at all levels of computation, while compiler optimizations and low-precision arithmetic can significantly affect the final computational results. With accelerators such as GPUs dominating high-performance computing systems, computational scientists are faced with even bigger challenges, given that ensuring numerical reproducibility in these systems poses a very difficult problem. This webinar provides highlights from a half-day tutorial discussing tools that are available today to analyze floating-point scientific software. We focus on tools that allow programmers to get insight about how different aspects of floating-point arithmetic affect their code and how to fix potential bugs.
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 mechanisms for low-overhead one-sided communication, moving computation to data through remote-procedure calls, and expressing dependencies between asynchronous computations and data movement. It is particularly well-suited for implementing elaborate distributed data structures where communication is irregular or fine-grained. The UPC++ interfaces are designed to be composable and similar to those used in conventional C++. The UPC++ programmer can expect communication to run at close to hardware speeds.
In this tutorial we will introduce basic concepts and advanced optimization techniques of UPC++. We will discuss the UPC++ memory and execution models and walk through implementing basic algorithms in UPC++. We will also look at irregular applications and how to take advantage of UPC++ features to optimize their performance.
This event can be attended on-site at NERSC or remotely via Zoom. The remote connection information will be provided to the registrants closer to the event. Registration is required for this event and space is limited so please register as soon as possible. Registration closes for this event when the limit is reached or on October 18, 2019.
