Performance Portable Software Design Patterns – What they can do and why we should collect them.

With the transition to heterogeneous supercomputing, the high-performance computing

community was tasked with developing solutions to leverage various heterogeneous hardware.

This led to the development of performance-portability libraries like Kokkos, Raja, Hemi, YAKL,

etc. which provide performance portable abstractions for algorithmic elements (loops,

reductions, etc.) and data storage. Nevertheless, leveraging these abstractions in scientific

software in a sustainable way is left to the developers of that software.

Software design patterns are a common way to help developers create sustainable software by

making software easier to understand and maintain. The design patterns achieve this by

representing reusable solutions to common problems. Therefore, they help to reduce

complexity of large code bases and allow to design, teach, and learn software in steps.

Furthermore, they are designed to be extensible and general, thus ensuring sustainable

software design.

Most widely spread software design patterns are CPU focused. But many of the techniques

that the software patterns leverage are unavailable on contemporary computing hardware that is

heterogeneous and massively parallel. For example, GPUs do not allow to allocate heap

memory within kernels and dynamic polymorphism is restricted.

Here a crucial gap appears:

Performance portable design patterns that solve these abstract software design problems lack a

central place where they are collected, discussed, and curated. I present a public Github Pages

website that showcases performance portable patterns extracted from performance-portable

open-source code. The collection helps developers to decide which design patterns apply to a

problem via abstract descriptions (synopsis), example implementation, and links to open-source

software where they are used. Furthermore, it lists the restrictions of heterogeneous hardware

to motivate and explain the patterns.

This new resource becomes especially relevant in AI-assisted development. As the correctness

check is crucial for scientific code, it needs to be reviewable, and the reviewer needs high

confidence regarding correctness. Design patterns help to break the complexity of scientific

codes into manageable pieces and allow scientists to focus more time on domain science.

A pattern with applicability in various areas like adaptive mesh refinement, is the “Generator-

Processor-Scan” pattern, an alternative to the classical “Stream Compaction” pattern. Both

process an unknown number of elements in order with comparable performance, but the

“Generator-Processor-Scan” can reuse already allocated memory and provide a significant

performance improvement.

The talk will present three exemplary patterns, discuss their potential applications, and

performance. Furthermore the performanceportablepatterns.github.io website will be introduced

including how patterns can be contributed, and how they get evaluated.

This work is done as part of my Better Scientific Software (BSSw) fellowship.