Skip to content

6th EasyBuild User Meeting

Jump to bottom
Kenneth Hoste edited this page Dec 18, 2020 · 66 revisions

Collecting ideas for next EasyBuild User Meeting, to be held online some time early 2021.

Practical info

  • online meeting (Zoom + YouTube)
  • dates: week of Jan 25-29 2021 (multiple sessions spread over the week)

Agenda

The intention is to have multiple sessions, spread out across the entire week (not full days), with sufficient time for Q&A + buffer in between individual talks.

Monday Jan 25th 2021 (all times are UTC)

There will be ample time for Q&A + informal chat + switching to the next speaker in between talks.

  • [16:00-16:30] Writing powerful HPC regression tests with ReFrame

    • by Vasileios Karakasis (CSCS, Switzerland)
    • In this talk series we will present ReFrame, a framework for writing regression tests for HPC systems. The goal of the ReFrame is to abstract away the complexity of the interactions with the system, separating the logic of a regression test from the low-level details, which pertain to the system configuration and setup. This allows users to write easily portable regression tests, focusing only on the functionality. We will start with an introductory talk about the framework and its capabilities, which we will gradually explore in more depth in the subsequent series of tutorial talks.

  • [17:00-17:30] CernVM-FS: Overview and Roadmap

    • by Jakob Blomer (CERN, Switzerland)

    • Delivering complex software across a worldwide distributed infrastructure of data centers and supercomputers is a major challenge in scientific computing. Copying the entire software stack everywhere it’s needed is often impractical and inefficient -- software stacks can grow very large, new versions are produced frequently, while any given job only needs a small fraction of the total software.

      To address application delivery at scale, CernVM-FS distributes software to hundreds of thousands of machines around the world in the form of a global, purpose-built shared software area. This presentation gives a technology overview and discusses use cases, experience from operations, and future plans.

  • [18:00-19:30] EasyBuild: State of the Union

    • by Kenneth Hoste (HPC-UGent, Belgium)
    • Let's look back at what was changed in EasyBuild in the last year, how we are doing right now, what we are currently working on, which challenges are ahead, and the enhancements and changes in EasyBuild we envision for the future. In addition, the highlights of the last EasyBuild User Survey will be covered in this talk.

Tuesday Jan 26th 2021 (all times are UTC)

  • [09:00-09:45] CernVM-FS tutorial (part 1/4)

    • by Kenneth Hoste (HPC-UGent, Belgium) and Bob Dröge (Univ. of Groningen, The Netherlands)

  • [10:15-10:45] Easy-Build Singularity Containers: lecture

    • by Jörg Saßmannshausen (Guy's and St Thomas' NHS Foundation Trust and King's College London, UK)

  • [11:00-11:30] Gentoo Prefix

    • by Fabian Groffen (Gentoo)

  • [12:00-12:30] ReFrame tutorial (part 1/3)

    • by Vasileios Karakasis (CSCS, Switzerland)

  • [13:00-13:45] European Environment for Scientific Software Installations (EESSI)

    • by Bob Dröge (Univ. of Groningen, The Netherlands)

Wednesday Jan 27th 2021 (all times are UTC)

  • [09:00-10:00] CernVM-FS tutorial (part 2/4)

    • by Kenneth Hoste (HPC-UGent) and Bob Dröge (Univ. of Groningen)

  • [15:00-15:30] PRACE Best Practice Guide

    • by by Ole Saastad (Univ. of Oslo, Norway)

  • [16:00-16:40] Lmod and XALT: Updates

    • by Robert McLay (TACC, US)
    • Lmod is the modern Environment Module Tool. Sysadmins define packages and let users choice which package and which version of that package. This part of the talk will include a brief overview of Lmod. This will be followed up with the new features such as extensions for connecting modules to packages. (e.g. the python module and packages such as numpy and scipy). This is also include a discussion of the changes to Lmod 8+.
    • XALT is a tool to take the census of what programs and libraries are run on your cluster. This talk will briefly cover what XALT does and how it does it. It will include some "war" stories of XALT usage. Finally I'll cover XALT move to version 3 namely tracking usage in containers and package tracking from R, Python and MATLAB.

  • [17:00-17:30] Magic Castle

    • by Félix-Antoine Fortin (Université Laval, Compute Canada)

  • [18:00-18:45] BLIS: A Framework for Rapidly Instantiating BLAS Functionality

    • by Field G. Van Zee (University of Texas at Austin, US)
    • BLIS is a portable software framework for instantiating high-performance BLAS-like dense linear algebra libraries. The framework was designed to isolate essential kernels of computation that, when optimized, immediately enable optimized implementations of most of its commonly used and computationally-intensive operations. In this talk, I'll take the audience on wide-ranging tour of BLIS, including its history, its design considerations, the APIs it exports, its implementations and how they promote productivity and maintainability, performance on modern hardware, its community organization, its impact on the HPC ecosystem, and our plans for the future.

  • [19:15-19:45] Site presentation by AstraZeneca

    • by Jon Jackson and Ben Carr (AstraZenaca)

Thursday Jan 28th 2021 (all times are UTC)

  • [09:00-09:45] CernVM-FS tutorial (part 3/4)

    • by Kenneth Hoste (HPC-UGent) and Bob Dröge (Univ. of Groningen)

  • [10:15-10:45] ReFrame tutorial (part 2/3)

    • by Vasileios Karakasis (CSCS, Switzerland)

  • [11:00-11:15] LearnHPC

    • by Alan O'Cais (JSC, Germany)

  • [11:25-11:40] Site presentation from Jülich Supercomputing Centre

    • by Anke Kreuzer (JSC, Germany)

  • [12:00-12:45] Cluster-in-the-Cloud

    • by Matt Williams (Univ. of Bristol, UK)

  • [13:15-13:30] Site presentation from LuxProvide

    • by Valentin Plugaru and Robert Mijakovic (LuxProvide, Luxembourg)

  • [13:45-14:00] Site presentation from University of Birmingham

    • by Simon Branford (Univ. of Birmingham, UK)

Friday Jan 29th 2021 (all times are UTC)

  • [09:00-10:00] CernVM-FS tutorial (part 4/4)

    • by Kenneth Hoste (HPC-UGent, Belgium) and Bob Dröge (Univ. of Groningen, The Netherlands)

  • [13:00-13:30] Easy-Build Singularity Containers: tutorial

    • by Jörg Saßmannshausen (Guy's and St Thomas' NHS Foundation Trust and King's College London, UK)

  • [14:00-14:30] ReFrame tutorial (part 3/3)

    • by Vasileios Karakasis (CSCS, Switzerland)

  • [15:00-15:30] buildtest: Testing Framework for HPC systems

    • by Shahzeb Siddiqui (NERSC, US)
    • Buildtest is an HPC testing framework to aid HPC facilities to perform acceptance testing for their system. HPC systems are growing in complexity, with a tightly coupled software and system stack that requires a degree of automation and continuous testing. In the past decade, two build frameworks (Spack, EasyBuild) have emerged and widely used in HPC community for automating build & installation process for scientific software. On the contrary, testing frameworks for HPC systems are limited to a few handful (ReFrame, Pavilion2, buildtest) that are in active development. In buildtest, users will write test recipes in YAML called buildspecs that is the primary interface for writing tests. buildtest utilizes a JSON Schema for validating buildspecs. In this talk we will present an overview of buildtest and how one can write buildspecs. Furthermore, we will discuss Cori Testsuite in buildtest with several real examples on testing various components for Cori system at NERSC. Finally, we will present an overview of the E4S Test Suite, which is an ECP project to help test the Spack E4S software stack, and how buildtest integrates with E4S Testsuite.

  • [15:40-15:55] Automate Module Testing with Lmodule

    • by Shahzeb Siddiqui (NERSC, US)
    • HPC software stacks have become increasingly complex and significantly grown in size with some sites having up to 5,000+ modulefiles. It's imperative that all modules are tested because it is the primary interface for users to interact with the software stack. Lmodule is a Python API for Lmod, with a focus on automating module testing. Lmodule is able to query a software stack via the 'spider' Lmod tool, and individually test each module using "module load". The API consist of three Python classes: Module, Spider, and ModuleLoadTest. Lmodule works with Environment Modules. In this talk we will present an overview of the Lmodule API at Cori (environment-modules) and OLCF (Lmod), to demonstrate how we can automate module testing of software stacks.

  • [16:15-17:00] Spack update

    • by Todd Gamblin (LLNL, US)

Discussion topics

  • EasyBuild on AMD
    • speaker(s): Sebastian Achilles (JSC)?
    • toolchain & libraries, experiences, ...
  • EasyBuild on aarch64/Arm64
    • speaker(s): ???
      • maybe Terje?
    • current status of support in EasyBuild, what (doesn't) work, etc.
  • restructuring common toolchains in diamond DAG (Mikael)
  • better error reporting in EasyBuild
Clone this wiki locally