HPC Formation 2026

8 Oct 2026, 09:30 → 18 Feb 2027, 16:00 Europe/Brussels

 

Programme:

day 1, 8 Octobre:  Introduction to HPC and SSH
day 2, 15 Octobre: Linux Terminal, finding/using software and text editor (vim)
day 3, 5 November: Bash Scripting and code versioning
day 4, 12 November:Submit jobs with SLURM
day 5, 19 November: Organise your work and storage on HPC
day 6, 26 November: Development good practice and scripting languages
day 7, 3 December: Compiling and debugging
day 8, 10 December: Introduction to scripting language (Python and Julia)
day 9, 14 January: Parallel Computing
day 10, 21 January: Shared Memory and Slurm for complex jobs
day 11, 28 January: Programming on GPU
day 12, 11 February: Scripting for HPC (Python and Julia)
day 13, 18 February: Handling Data on HPC

Thursday 8 October

Day 1: Intro HPC and SSH

1 Introduction to HPC

This first session introduces to the field of high performance computing and presents the whole training offer.

Contents	Information
• Introduction to cluster computing: strengths and weaknesses • Presentation of the CÉCI clusters and collaborators, and Tier-1 • Presentation of the training sessions • Presentation of the account creation process	No prerequisite. Prerequisite for: all the other sessions. Type: Lecture Target audience: Everyone Must: This session is mandatory.

Speaker: Frédéric Wautelet (University of Namur)

2 Help us Help you

This second session explains what you, as a user, can do to "help us help you". Small details in the way you use the clusters can have a large impact on the cluster ecosystem in general and on the availability of the system administrators to help on specific and non-trivial problems in your jobs.

Contents	Information
• Good CÉCI citizenship and user duties • Tips for quick support from the admins • Pre-requisite checklist	No prerequisite. Prerequisite for: all the other sessions. Type: Lecture Target audience: Everyone Must: This session is mandatory.

Speaker: Damien François (UCLouvain/CISM)

3 SSH for mac/unix

4 SSH for windows

SSH is the protocol used to connect to the clusters. This session presents the complete use of the tools to make access to the clusters easy (without being harassed by passphrase requests, coping with firewalls in a transparent manner, transferring files from one cluster to another, etc.).

Contents	Information
• SSH client usage and common errors • SSH keys, passphrases and agents • SSH configuration file • Passphrase managers • Tunnels, proxies and (pseudo-)VPNs • SSH-based file transfer (SCP, rsync, Unison, SSHFS)	Prerequisite: • Being familiar with a text editor Prerequisite for: all the other sessions Type: Hands-on Target audience: Everyone Must: This session is mandatory.

Speaker: Dr Olivier Mattelaer (UCLouvain/CISM)

5 Q/A

Thursday 15 October

Day 2: Linux Terminal, finding/using sofwtare and text editor (vim): HPC Basic I: Linux, Modules, Vim

6 Learn the (Unix) Command Line Interface

We will cover how to use the command line interface. After a short explanation of the unix philosophy, you will learn the basic commands on unix via a serious game (gameshell)

Contents	Information
• Learn to use the Command Line Interface	Prerequisite: • Being able to use SSH with private keys Type: Lecture, Hands-on Target audience: Rookie Must: This session is a must-have for anyone.

Speaker: Bernard Van Renterghem (UCL CISM)

7 How to choose/activate the software version of your choice

Software installed on the clusters is organised and managed with environment modules that allow choosing a specific version of a software package compiled with a given compiler, linked to chosen libraries, etc. This session explains how modules are used on the clusters.

Contents	Information
• The installed software • The modules command • What is EasyBuild • What are the different toolchains • How to install software by yourself	Prerequisite: • Being able to use SSH with private keys • Being familiar with a text editor • Mastering the Linux command line and the GNU utilities (mkdir, cp, scp, etc.) Type: Hands-on Target audience: Everyone Must: This session is a must for anyone.

Speaker: Bernard Van Renterghem (UCL CISM)

8 Vim

Vim is a very powerful text editor installed on all Unix systems, including macOS, and used by many programs as the default text editor. Knowing the basics is crucial on HPC systems. Mastering it will dramatically speed up tasks such as editing submission scripts, configuration files, code, and more.

Contents	Information
• Why use Vim on user interfaces? • Vim modes • Movement and action commands • Macros • Plugins	Prerequisite: • Being able to use SSH with private keys Type: Hands-on Target audience: Everyone Must: This session is a must for anyone.

Speaker: Mr Jérôme de Favereau (UCLouvain/IRMP/CP3)

Thursday 5 November

Day 3: Bash Scripting and code versioning

9 Bash Scripting

Writing effective Bash scripts is an essential skill for working on HPC clusters. This session introduces the core concepts of shell scripting and shows how to automate repetitive tasks, process files efficiently, and build robust workflows using loops, conditions, and functions.

Contents	Information
• Shell script structure and execution • Variables and command-line arguments • Conditional statements (if, case) • Loops (for, while) • Functions and code reuse • Input/output redirection and pipes	Prerequisite: • Being able to use SSH with private keys • Basic familiarity with the Linux command line Type: Hands-on Target audience: Beginners and intermediate users Must: Strongly recommended for anyone planning to automate tasks on HPC systems.

Speakers: Mr Jérôme de Favereau (UCLouvain/IRMP/CP3), Mr Pierre-Yves Barriat (UCL/ELIC)

10 Code versionning

Git is the de facto standard for version control in research and software development. In this session, participants learn Git through a serious game that simulates real-world collaboration scenarios. Working individually and in teams, they will practice managing changes, resolving conflicts, organizing development with branches, and interacting with GitHub.

Contents	Information
• Introduction to version control and Git concepts • Creating and managing local repositories • Tracking changes and writing meaningful commits • Working with branches and merging developments • Resolving merge conflicts • Interacting with remote repositories on GitHub • Pull requests and collaborative workflows • Serious game challenges based on realistic development scenarios	Prerequisite: • Basic familiarity with the Linux command line • Being comfortable using a text editor Type: Hands-on serious game Target audience: Everyone Must: Strongly recommended for anyone developing code, scripts, analyses, or collaborating on software projects.

Speaker: Dr Olivier Mattelaer (UCLouvain/CISM)

Thursday 12 November

Day 4: Job sunmission with SLURM: Day 4: SLURM

11 SLURM: Submitting jobs on HPC

Slurm is the job manager installed on all CÉCI clusters. This session teaches attendees how to prepare submission scripts, submit jobs, monitor their execution, manage resources efficiently, and debug common issues encountered on the clusters.

Contents

Information

• Role of a job scheduler • Creating and submitting a job • Setting job constraints and parameters • Managing and monitoring jobs • Working interactively • Getting accounting information • How priorities are computed • Creating basic submission scripts • Best practices

Prerequisite: • Being able to use SSH with private keys • Being familiar with a text editor • Mastering the Linux command line and GNU utilities Follow-up: • Checkpointing to make jobs fit maximum allowed execution times • Workflows to organise jobs and experiments • Advanced Slurm to write more complex parallel submission scripts Type: Hands-on Target audience: Everyone Must: This session is mandatory.

Speaker: Damien François (UCLouvain/CISM)

12 SLURM Debugging

Speaker: Damien François (UCLouvain/CISM)

13 CECI lab

Speaker: Nicolas Potvin (ULB département informatique)

Thursday 19 November

Day 5: Organise your work and storage on HPC

14 Stop and Restart program: (how to beat walltime on HPC)

Checkpointing and restarting, or the art of stopping computations and resuming them later, is a powerful technique for overcoming job time limits, surviving hardware or software failures, and improving the robustness of long-running computations on HPC clusters. This session introduces the main checkpointing approaches and teaches how to use them effectively on CÉCI clusters.

Contents	Information
• Uses and challenges of checkpointing • The different checkpointing approaches • Checkpointing support in Slurm • Using DMTCP for application-level checkpointing and restart • Best practices for long-running jobs	Prerequisite: • Being able to use SSH with private keys • Being familiar with a text editor • Mastering the Linux command line and GNU utilities (mkdir, cp, scp, etc.) • Passive knowledge of either C, Fortran, Octave, Python, or R Type: Hands-on Target audience: Everyone Must: This session is a must-have for anyone feeling oppressed by time limits.

Speaker: Dr Olivier Mattelaer (UCLouvain/CISM)

15 Workflows Management System

Whenever one has to deal with multiple jobs on an HPC system, the idea of automating parts or all of the job management process naturally leads to the concept of workflows. Workflow management solutions range from basic scheduler features such as job arrays and dependencies to sophisticated workflow engines capable of coordinating large-scale computational campaigns. This session helps participants identify the most appropriate workflow solution for their needs and teaches best practices to reduce manual job management and improve reproducibility.

Contents	Information
• Introduction to workflows • Types of workflow management systems • Choosing a workflow management system • Using scheduler features such as job arrays and dependencies • An example workflow implementation with Maestro • Best practices for automating computational campaigns	Prerequisite: • Being able to use SSH with private keys • Being familiar with a text editor • Mastering the Linux

Speaker: Damien François (UCLouvain/CISM)

16 Data Storage on CECI cluster

Data storage on CÉCI clusters differs from that of a standalone workstation. Thanks to the shared filesystem infrastructure, users can seamlessly access the same files from multiple clusters, making it easier to move computations, collaborate with colleagues, and manage data across the entire CÉCI ecosystem. This session explains how storage is organized, how to use it efficiently, and how to avoid common pitfalls that can negatively impact performance.

Contents

Information

• Overview of the CÉCI storage infrastructure • Shared filesystems and their role in the CÉCI ecosystem • Home, data, scratch, and project storage areas • Accessing the same data from multiple clusters • Data performance considerations and best practices • Managing quotas and monitoring disk usage • Data transfers between local computers and clusters • Backup policies and data safety • Organizing data for reproducible research

Prerequisite: • Being able to use SSH with private keys Type: Hands-on Target audience: Everyone Must: Strongly recommended for all CÉCI users to avoid storage-related issues and make efficient use of the shared infrastructure.

Speaker: Ariel Lozano (ULB)

Thursday 26 November

Day 6: Development good practice and scripting languages: Day 6: Development good practice and scripting languate

17 Introduction to scientific software development and deployment

Often, the workflow for researchers is to acquire a piece of software and then adapt it to their needs, whether by modifying the source code, wrapping it in scripts, deploying it on HPC clusters, or maintaining it across multiple systems. This session introduces the tools, concepts, and best practices that make software development and deployment more efficient and sustainable in a research environment.

Contents	Information
• Programming paradigms • Types of programming languages and how to choose the appropriate one • Tools for building and deploying software • The programmer's toolkit (editors, debuggers, build systems, version control, etc.) • Writing comments, documentation, and coding style guidelines	Prerequisite: • Being familiar with a text editor • Mastering the Linux command line and GNU utilities (mkdir, cp, scp, etc.) Type: Lecture Target audience: Rookie programmers Must: This session

Speaker: Damien François (UCLouvain/CISM)

18 Containers on HPC

Containers have become a standard way to package and distribute scientific software. Apptainer (formerly Singularity) allows users to run complex software stacks on HPC clusters in a portable, reproducible, and secure manner without requiring administrator privileges. This session introduces container technologies and teaches participants how to use, create, and deploy Apptainer containers on CÉCI clusters.

Contents	Information
• Introduction to containers and reproducibility • Why Apptainer is used on HPC systems • Pulling and running existing container images • Accessing files and directories from within containers • Building Apptainer images from definition files • Using containers with Slurm jobs • Managing software dependencies with containers • Best practices for portable and reproducible research workflows	Prerequisite: • Mastering the Linux command line and GNU utilities • Basic familiarity with Slurm job submission Type: Hands-on Target audience: Everyone Must: Strongly recommended for users who need custom software environments or reproducible workflows.

Speaker: Dr Olivier Mattelaer (UCLouvain/CISM)

19 Introduction to scripting

Interpreted languages are often perceived as less performance-oriented than compiled languages. However, they offer significant advantages in terms of development speed, flexibility, and ease of use. Modern scientific ecosystems provide powerful tools that allow interpreted languages to reach near-compiled performance while maintaining high productivity. This session introduces the main interpreted languages used in scientific computing and demonstrates how to deploy and optimize them on CÉCI clusters.

Contents

Information

• Use cases, strengths, and weaknesses of interpreted languages • The scientific computing trilogy: Octave, R, and Python • Understanding and selecting interpreter builds • Installing and managing additional libraries and packages • Using compiled code from interpreted languages • Techniques for improving performance • Compiling or accelerating interpreted code • Best practices for scientific computing on HPC systems

Prerequisite: • Basic understanding of procedural programming (conditions, loops, functions, etc.) • Being able to use SSH with private keys • Being familiar with a text editor • Mastering the Linux command line and GNU utilities (mkdir, cp, scp, etc.) Type: Hands-on Target audience: Rookie programmers Must: This session is a nice-to-have.

Speaker: Damien François (UCLouvain/CISM)

Thursday 3 December

Day 7: Compiling and debugging

20 How to speed up your code at low cost?

The choice of compiler can have a significant impact on both the performance and portability of scientific software. Modern HPC systems provide several compiler toolchains, each with different strengths, optimization capabilities, and supported libraries. This session introduces the main compilers available on CÉCI clusters and teaches how to build, optimize, and benchmark software efficiently.

Contents

Information

• The GCC compiler suite and its options • Intel oneAPI compilers and development tools • Understanding compiler optimization levels • Performance versus portability trade-offs • Using external libraries during compilation and linking • Building software with configure, cmake, and make • Downloading, configuring, and compiling source code • Using optimized mathematical libraries (BLAS, LAPACK, MKL, OpenBLAS, FFT libraries, etc.) • Benchmarking and validating compiled applications

Prerequisite: • Being able to use SSH with private keys • Being familiar with a text editor • Mastering the Linux command line and GNU utilities (mkdir, cp, scp, etc.) • Passive knowledge of C or Fortran Type: Hands-on Target audience: Rookie programmers Must: This session is a must for anyone who needs to compile software from source code.

Speaker: Bernard Van Renterghem (UCL CISM)

21 Make/Cmake

Building scientific software often involves much more than invoking a compiler. As projects grow, managing dependencies, libraries, compilation options, and multiple source files can quickly become complex and error-prone. This session introduces modern build systems and teaches how to automate the compilation process using Make and CMake, from small personal projects to larger research software.

Contents	Information
• Writing a minimal Makefile for small projects • Reading and understanding more advanced Makefiles • Managing dependencies and multi-file projects • Automating build configuration with CMake • Using CMake for medium and large software projects • Handling external libraries and package discovery • Managing environment variables and build options • Parametrizing code and features at compile time • Best practices for portable and maintainable build systems	Prerequisite: • Basic knowledge of compilers • Basic knowledge of compiled languages (e.g. C, C++, Fortran) • Being familiar with Linux • Being familiar with a text editor Type: Hands-on Target audience: Anyone needing to compile or develop software projects. Must: Strongly recommended for users developing, modifying, or compiling scientific software.
``

Speaker: Nicolas Potvin (ULB département informatique)

22 Debuggin and profiling

Debugging and profiling are essential skills for developing reliable and efficient scientific software. While debugging helps identify and fix incorrect behavior, profiling helps understand where execution time and resources are spent. This session introduces practical tools and methodologies to diagnose problems, improve performance, and optimize applications running on HPC systems.

Contents

Information

• Introduction to debugging and performance analysis • Common programming errors and how to identify them • Interactive debugging with GDB • Memory debugging with Valgrind • Understanding stack traces and core dumps • Profiling CPU usage and execution hotspots • Measuring memory usage and I/O performance • Using compiler flags to aid debugging and optimization • Interpreting profiling reports • Best practices for debugging and performance tuning on HPC systems

Prerequisite: • Basic knowledge of a compiled programming language (C, C++, or Fortran) • Being familiar with Linux • Being familiar with a text editor • Basic knowledge of compilation and build systems Type: Hands-on Target audience: Programmers and researchers developing or modifying software. Must: Strongly recommended for anyone writing, compiling, or optimizing scientific applications.

Speaker: Bernard Van Renterghem (UCL CISM)

Thursday 10 December

Day 8: Introduction to scripting language (Python and Julia)

23 Introduction to Python

Python is a versatile programming language widely used in scientific computing, data analysis, machine learning, automation, and software development. It combines the ease of scripting languages with a rich ecosystem of scientific libraries, making it an essential tool for researchers and HPC users. This session introduces Python programming and teaches participants how to develop, organize, and distribute Python code efficiently on CÉCI clusters.

Contents	Information
• Python language syntax and core concepts • The Python standard library and core modules • Managing Python environments • Installing external modules and packages with pip • Introduction to scientific libraries (NumPy, SciPy, Matplotlib, etc.) • Writing reusable Python modules and packages • Distributing and sharing Python code • Best practices for scientific programming	Prerequisite: • Being able to use SSH with private keys • Being familiar with a text editor • Mastering the Linux command line and GNU utilities (mkdir, cp, scp, etc.) • Basic notions of programming Type: Hands-on Target audience: Rookie programmers Must: This session is a nice-to-have for those who do not already know Python.

Speaker: Mr Jérôme de Favereau (UCLouvain/IRMP/CP3)

24 Introduction to Julia

Julia is a modern programming language created at MIT to combine the performance of compiled languages such as C and Fortran with the ease of use and productivity of languages such as Python and MATLAB. Thanks to its innovative design, Julia is particularly well suited for scientific computing, numerical simulations, data analysis, and high-performance computing. This session introduces the key concepts of Julia and provides participants with the tools needed to start developing scientific applications efficiently.

Contents	Information
• Installing Julia and setting up the environment • Julia language fundamentals and syntax • Variables, functions, and data structures • Multiple dispatch and its role in performance and code design • Installing and managing packages • Working with scientific computing libraries • Writing efficient and idiomatic Julia code • Introduction to the Julia ecosystem and community resources	Prerequisite: • Being able to use SSH with private keys • Being familiar with a text editor • Mastering the Linux command line and GNU utilities (mkdir, cp, scp, etc.) Type: Hands-on Target audience: Rookie programmers Must: This session is a nice-to-have for those who need to develop fast scientific software.

Speaker: Cédric Simal (Université de Namur)

Thursday 14 January

Day 9: Parallel Computing: Day 9: Parralel Computing

25 Intro to parallel computing

Parallel computing is at the heart of modern HPC systems. Before learning programming models such as MPI or OpenMP, it is important to understand the fundamental concepts behind parallel execution and the tools that can be used to exploit parallelism even when applications themselves are not designed for it. This session introduces the theoretical foundations of parallel computing and presents practical Linux tools for running workloads concurrently.

Contents

Information

• Theoretical concepts: parallelism, concurrency, speedup, scaling, efficiency, and overhead • Amdahl's and Gustafson's laws • Common parallel computing paradigms (SPMD, MPMD, Map/Reduce, master-worker, etc.) • GNU tools for parallel computing (xargs and GNU Parallel) • Parallel execution of independent tasks • Parallel computing with pipelines, UNIX pipes, and FIFO files • Choosing the appropriate parallelization strategy for a workload • Preparing for MPI and OpenMP programming

Prerequisite: • Being able to use SSH with private keys • Being familiar with a text editor • Mastering the Linux command line and GNU utilities (mkdir, cp, scp, etc.) Type: Hands-on **Target audience

Speaker: Damien François (UCLouvain/CISM)

26 MPI

MPI (Message Passing Interface) is the standard programming model for distributed-memory parallel computing. It enables programs running on multiple processes, potentially across many compute nodes, to exchange data efficiently and coordinate their execution. This session introduces the fundamentals of MPI programming and provides hands-on experience with the communication patterns commonly used in scientific and engineering applications.

Contents	Information
• Parallel programming paradigms • Shared-memory versus message-passing approaches • The MPI programming model • Compiling and running MPI programs • Point-to-point communications • Collective communication operations • Reduction and aggregation operations • Communication modes and synchronization • Debugging and performance considerations for MPI applications	Prerequisite: • Being able to use SSH with private keys • Being familiar with a text editor • Mastering the Linux command line

Speaker: Mr Orian Louant (Université de Liège)

Thursday 21 January

Day 10: Shared Memory and Slurm for complex jobs

27 Parallel programming with OpenMP

OpenMP is a widely used API for shared-memory parallel programming. It provides a simple and portable way to exploit multicore processors by adding compiler directives to existing C, C++, and Fortran programs. Compared to low-level threading libraries such as pthreads, OpenMP allows developers to parallelize applications with minimal code modifications while maintaining readability and portability. This session introduces the OpenMP programming model and teaches how to develop efficient multithreaded applications for modern HPC systems.

Contents	Information
• Parallel programming paradigms • Shared-memory parallelism concepts • The OpenMP execution model • Compiling and running OpenMP programs • Creating and managing threads • Data sharing attributes and variable scoping • Data races and thread safety • Parallel loops and work-sharing constructs • Barriers, synchronization, and critical sections • Performance considerations and best practices	Prerequisite: • Being able to use SSH with private keys • Being familiar with a text editor • Mastering the Linux command line and GNU utilities (mkdir, cp, scp, etc.) • Passive knowledge of C or Fortran Type: Hands-on Target audience: Rookie programmers Must:

Speaker: Mr Orian Louant (Université de Liège)

28 Slurm for complex jobs

Speaker: Damien François (UCLouvain/CISM)

Thursday 28 January

Day 11: Programming with GPU: Day 11: Programming on GPU

29 Introduction to GPU and CUDA

CUDA is NVIDIA's parallel computing platform and programming model for GPUs. It allows developers to exploit the massive parallelism available on modern NVIDIA accelerators and achieve performance levels that are often impossible to reach on CPUs alone. This session introduces the fundamentals of GPU architecture, teaches the basics of CUDA programming, and shows how to analyze and optimize applications using NVIDIA's profiling tools.

Contents

Information

• Fundamentals of GPU hardware and architecture • Differences between CPU and GPU computing • CUDA programming model and execution hierarchy • Writing and launching CUDA kernels • Managing memory transfers between CPU and GPU • Optimizing memory access patterns • Basic performance optimization techniques • Profiling applications with NVIDIA Nsight tools • Identifying bottlenecks and tuning GPU performance

Prerequisite: • Being able to use SSH with private keys • Being familiar with a text editor • Mastering the Linux command line and GNU utilities (mkdir, cp, scp, etc.) • Basic knowledge of C Type: Hands-on Target audience: Rookie programmers Must: This session is a nice-to-have for those who need to develop highly parallel scientific software

Speaker: Dr Olivier Mattelaer (UCLouvain/CISM)

30 HIP

HIP (Heterogeneous-computing Interface for Portability) is AMD's programming model for GPU acceleration. It provides a CUDA-like development experience while promoting portability across different hardware platforms. HIP enables developers to write high-performance GPU applications, port existing CUDA codes, and target modern AMD accelerators increasingly used in HPC systems. This session introduces GPU programming with HIP and teaches how to develop, port, profile, and optimize scientific applications for heterogeneous computing environments.

Contents

Information

• Fundamentals of GPU hardware and accelerator architectures • Introduction to the HIP programming model • Comparing HIP and CUDA • Porting CUDA applications to HIP • Writing and launching HIP kernels • Memory management on GPUs • Optimizing data movement and memory access patterns • Using AMD profiling and performance analysis tools • Performance optimization techniques • Portability considerations for heterogeneous HPC systems

Prerequisite: • Being able to use SSH with private keys • Being familiar with a text editor • Mastering the Linux command line and GNU utilities (mkdir, cp, scp, etc.) • Basic knowledge of C or C++ Type: Hands-on Target audience: Rookie programmers Must: This session is a nice-to-have for those who need to develop portable GPU-accelerated scientific software or target AMD accelerators.

Speaker: Mr Orian Louant (Université de Liège)

31 Excercice on how to port/optimize cuda kernel

This session takes the form of a serious game in which participants compete to transform a poorly performing GPU application into a highly efficient one. Through a series of challenges, they will learn how to analyze CUDA kernels, identify performance bottlenecks, port code to alternative GPU programming models, and apply optimization techniques commonly used in production HPC applications.

Contents

Information

• Profiling and understanding an existing CUDA application • Identifying performance bottlenecks • Optimizing memory transfers and memory access patterns • Improving kernel occupancy and parallel efficiency • Reducing synchronization and communication overheads • Porting CUDA kernels to HIP • Benchmarking and validating performance improvements • Serious game challenges based on realistic scientific applications • Team competition and optimization leaderboard

Prerequisite: • Basic knowledge of CUDA programming • Familiarity with GPU concepts and architecture • Being familiar with Linux and the command line • Basic knowledge of C or C++ Type: Hands-on serious game Target audience: Intermediate GPU programmers Must: Strongly recommended for anyone planning to optimize, maintain, or port GPU-accelerated scientific applications.

Speakers: Dr Olivier Mattelaer (UCLouvain/CISM), Mr Orian Louant (Université de Liège)

Thursday 11 February

Day 12: Scripting for HPC (Python and Julia)

32 Julia for HPC

Julia is designed for high-performance scientific computing and combines the productivity of dynamic languages with the speed of compiled ones. Thanks to its rich ecosystem, native support for parallelism, and excellent interoperability with existing scientific software, Julia is becoming an increasingly popular choice for HPC applications. This session introduces participants to the tools and techniques required to efficiently run Julia applications on CÉCI clusters and exploit modern HPC resources.

Contents

Information

• Running Julia on CÉCI clusters • Managing Julia environments and packages • Interfacing Julia with external libraries and compiled code • Performance tips and common pitfalls • Multithreading in Julia • Distributed computing with Julia processes • Using MPI from Julia • GPU computing with Julia • Profiling and optimizing Julia applications • Best practices for deploying Julia workloads on HPC systems

Prerequisite: • Basic knowledge of Julia programming • Being able to use SSH with private keys • Being familiar with a text editor • Mastering the Linux command line and GNU utilities (mkdir, cp, scp, etc.) Type: Hands-on **Target audience

Speaker: Cédric Simal (Université de Namur)

33 Python for HPC

Python has become one of the most widely used languages in scientific computing thanks to libraries such as NumPy, SciPy, and Matplotlib. However, writing efficient Python applications on HPC systems often requires going beyond basic usage of these libraries. This session focuses on performance-oriented Python programming, showing how to deploy scientific Python environments on CÉCI clusters, exploit parallelism, and accelerate applications through compilation and optimization techniques.

Contents

Information

• Managing Python environments and installing libraries • Efficient numerical computing with NumPy • Scientific computing with SciPy • Performance analysis and optimization techniques • Multithreading and multiprocessing in Python • Understanding the Global Interpreter Lock (GIL) • Accelerating Python with compiled extensions • JIT compilation with Numba and related tools • Best practices for running Python applications on HPC systems

Prerequisite: • Being able to use SSH with private keys • Being familiar with a text editor • Mastering the Linux command line and GNU utilities (mkdir, cp, scp, etc.) • Working knowledge of Python **Type

Speakers: Ariel Lozano (ULB), Nicolas Potvin (ULB département informatique)

Thursday 18 February

Day 13: Handling Data on HPC

34 NetCDF and HDF5: file formats for HPC

NetCDF and HDF5 are among the most widely used data formats in scientific computing. They provide efficient, portable, and self-describing ways to store large and complex datasets while supporting high-performance I/O on modern HPC systems. This session introduces both formats, explains their strengths and differences, and provides hands-on experience using Python, Fortran, and C to create, manipulate, and visualize scientific data.

Contents

Information

• Overview of data formats in scientific computing • Comparing NetCDF and HDF5: strengths, weaknesses, and use cases • Data models, metadata, dimensions, and attributes • Tools and libraries for working with NetCDF and HDF5 • Reading and writing data with Python, Fortran, and C • Efficient I/O practices for large datasets • Use cases in scientific research and HPC • Hands-on exercises in creating, reading, and visualizing data • Best practices for managing structured scientific datasets

Prerequisite: • Being able to connect to the clusters • Basic programming skills (Python, Fortran, or C) • Familiarity with Linux (navigation, file creation, and editing) Type: Hands-on Target audience: Researchers and data scientists using HPC systems Must: Essential for geoscientists, climate scientists, and anyone needing efficient and structured scientific data formats.

Speaker: Mr Pierre-Yves Barriat (UCL/ELIC)

35 Data Privacy

Data confidentiality is a critical aspect of scientific computing. Researchers working on HPC systems may handle unpublished results, personal data, industrial collaborations, or legally protected datasets. This session introduces the principles of secure data management on CÉCI clusters and presents the tools and best practices required to protect sensitive information while remaining compliant with institutional and legal requirements.

Contents

Information

• Why data confidentiality matters in HPC • Understanding data classification and sensitivity levels • Risks associated with shared computing environments • Authentication, SSH keys, and access control mechanisms • Linux file permissions and access management • Managing project and shared data securely • Encrypting data at rest and in transit • Handling personal and sensitive research data • Secure data transfers and backups • Regulatory considerations (GDPR and research data policies) • Best practices and common security mistakes

Prerequisite: • Being able to use SSH with private keys • Basic familiarity with Linux and file management Type: Lecture, Hands-on Target audience: Everyone Must: Strongly recommended for anyone handling unpublished, personal, confidential, or regulated data on HPC systems.

Speaker: Damien François (UCLouvain/CISM)

36 Datalad: Control version system for large files

DataLad is a data management and distribution tool built on top of Git and git-annex. It enables researchers to track datasets, code, and computational workflows in a reproducible manner while efficiently handling large files that would be impractical to store directly in Git. This session introduces DataLad as a solution for reproducible research, collaborative projects, and large-scale scientific data management on HPC systems.

Contents

Information

• Motivation for reproducible data management • Introduction to Git, git-annex, and DataLad • Creating and managing DataLad datasets • Tracking large datasets efficiently • Cloning, sharing, and publishing datasets • Organizing code, data, and results in a reproducible workflow • Working with remote storage and HPC filesystems • Data provenance and dataset versioning • Collaborative workflows with DataLad • Practical examples for scientific projects

Prerequisite: • Being able to use SSH with private keys • Familiarity with the Linux command line • Basic knowledge of Git concepts (commits, branches, repositories) Type: Hands-on Target audience: Researchers, data scientists, and software developers managing datasets on HPC systems Must: Strongly recommended for anyone interested in reproducible research, collaborative data management, or versioning large scientific datasets.

Speaker: Damien François (UCLouvain/CISM)