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.
*****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 meeting will give 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. Projects are invited to give a 20 minute presentation. Application talks are encouraged to focus on technical and algorithmic challenges in adopting Kokkos and how Kokkos’s capabilities were used to overcome those.
The Kokkos Team will also be available on the 25th and 26th for project specific meetings. Please request such a meeting if you are interested. Since this is the first Usergroup meeting we are not sure what attendance level to expect. If registrations outpace our current estimate we are considering to extend the meeting by a day to open up more room for application presentations and discussions.
The tentative schedule is located below. We will upload the final agenda when complete.
For questions please send an email to [email protected].
We are looking forward to seeing you in Albuquerque.
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 29–May 2, 2019. This event is sponsored by the Exascale Computing Project (ECP), and driven by the ECP SOLLVE Project. We encourage participation of teams specially interested in porting and optimizing their applications by using the latest OpenMP features.
Hackathon Goal
The goal of this hackathon is to port, optimize and evolve applications towards the latest OpenMP versions (4.5+). This event will be co-organized with ORNL and IBM. In practical terms, this event will enable application teams and developers to accelerate their code with the use of GPUs, as well as exploiting the latest OpenMP functionality to program (IBM Power9) multi-core platforms. Prospective user groups of large hybrid CPU-GPU systems will send teams of at least 3 developers along with either (1) a scalable application that could benefit from GPU accelerators, or (2) an application running on accelerators that has already written OpenMP and needs optimization or (3) applications that have OpenACC in their codes and need assistance to convert them to OpenMP 4.5 offload.
There will be intensive mentoring during this 4-day hands-on event. At the conclusion of the event, participating teams will have a functional GPU-accelerated code, or at least, a clear roadmap of how to get there. To support the hackathon goal, we will have a number of mentors from IBM, ORNL, BNL, NERSC, LLNL, universities, and other vendors on-site during the event. Our mentors have extensive experience in programming GPUs, actively participate in the OpenMP language committee, and conduct research and development in compilers and tools with OpenMP support.
Programming experience with OpenMP 4.5 offload or CUDA is not a requirement. We will hold training events / tutorials covering the set of background topics required. In the weeks preceding the hackathon, you will have a chance to attend training to prepare you for the event. Prior GPU experience is not required!
Target Audience and Format
We are looking for teams, each consisting of 3-5 developers, that wish to work on the optimization and porting of an application to GPU accelerators. Small-to-medium sized applications, mini-apps or specific test cases are especially encouraged. Hence, participating teams should devote significant efforts to isolate the compute/data intensive parts of the code to be optimized. In particular, the development of suitable test-harness and verification machinery to validate that no errors are being introduced during this work-intensive event. Collectively the team should know the application intimately. If an application is a suite of apps, no more than two per team is allowed and a minimum of 2 people per app must attend.
How to Apply
In order to participate in the hackathon, please submit a Team Hacking Application Form. You will have to provide a team name, a brief summary of the application, your intended goals, software/package dependencies and the list of team participants (full name, affiliation and email). In addition, select in the application form whether the application is sensitive in any way (e.g. only for DOE use, not accessible to foreign nationals, is it NDA protected, etc). If in doubt, please contact us.
Participation in the training event is free of charge. The meeting room and lunches, as well as access to the supercomputers throughout the event are offered by BNL, ORNL and our event sponsors. The deadline to submit an application is April 5, 2019. Notification of acceptance will be sent out by April 11, 2019.
For more information visit the OpenMP Brookathon 2019 website at https://www.bnl.gov/ompbrookathon2019.
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 So, You Want to be Agile? Strategies for Introducing Agility into Your Scientific Software Project, and will be presented by Michael Heroux (Sandia National Laboratories). The webinar will take place on Wednesday, May 8, 2019 at 1:00 pm ET.
Abstract:
Scientific software team cultures have natural consistencies with agile practices. Discovery-driven development, a focus on regular delivery of results, in-person discussions within and across research teams, and a focus on long-term sustainable research programs are commonplace dynamics on computational science teams that develop software. These dynamics are also particular expressions of core agile principles.
Many scientific software teams have already assimilated industry best practices in some aspects of their work. The advent of open software development platforms such as GitHub and GitLab have accelerated awareness and adoption, as have numerous on-line resources that enable a motivated person to continue learning new ideas and approaches. Even so, we propose that a healthy team habit is continued exploration and improvement of software practices, processes and skills.
In this webinar, we discuss a few agile practices and strategies that are readily adapted and adopted by scientific software teams. In addition, we describe an attitude and strategy for continual process improvement that enables computational science teams to simultaneously deliver science results and, at the same time, dedicate a slice of time to improving software practices on their way to delivering those results.
