Christodoulos Stylianou, PhD

My research focus is on developing and optimizing sparse linear algebra for efficient high-performance computing. In particular, I am interested in the optimization of Sparse Matrix Vector Multiplication (SpMV) on heterogeneous and distributed architectures through automatic format selection using AI. The selection aims to better match the underlying data structure to the computation by better exploiting the hardware characteristics and available resources, offering new optimization opportunities. I also work on performance portability for Multi- and Manycore (GPU) computing with frameworks like Kokkos and SYCL.

Morpheus

Morpheus, is a library of sparse matrix storage formats that is designed for efficient and transparent format switching across architectures without introducing prohibitive overheads at runtime and that, at the same time, enables the straightforward addition of new storage formats without major application code changes.

The library has a functional design which separates the containers that implement the storage formats from the algorithm that implement operations such as multiplication. Each container is aware of the memory space it resides in, and the algorithms require knowledge of the execution space that they will be running in. This design allows Morpheus to target multiple heterogeneous architectures.

Morpheus is a C++ header-only library written in C++17 and makes heavy use of template and meta-programming techniques. Currently supports 6 sparse matrix storage formats (COO, CSR, DIA, ELL, HYB and HDC) and 5 backends (Serial, OpenMP, CUDA, HIP and Kokkos).

Lyncs.IO

Lyncs, is a Python API for Lattice QCD, currently under development. Lyncs aims to bring several popular libraries for Lattice QCD under a common framework. Lyncs interfaces with libraries for GPUs and CPUs in a way that can accommodate additional computing architectures as these arise, achieving the best performance for the calculations while maintaining the same high-level workflow.

lyncs_io aims to provide an all-inclusive framework for IO in Python. It responds to the necessity of missing tools for parallel IO and user-friendliness in various file formats. Therefore it implements a very simple interface with two main functionalities, load and save; it supports various file formats and, where possible, parallel IO for domain decomposed arrays. Additionally, it also implements file formats that are common in Lattice QCD as, for instance, the Lattice QCD Interchange Message Encapsulation (LIME).

The objectives of the package are:

• Seamlessly IO: we have tried to simplify the IO as much as possible, without having to open files, directly specify the format or using more than one line of code. Three main functions are provided save(obj, filename) for saving, obj=load(filename) for loading and obj=head(filename) for retrieving metadata without loading data.
• Many formats supported (e.g., numpy, hdf5, tar, lime). The file format can be either deduced from the filename’s extension or with the option format passed as an argument to the above functions. The structure of the package is flexible enough to easily accommodate new/customized file formats as these arise. For instance we support file formats typical in lattice QCD like LIME.
• Omission of extension: When saving, if the extension is omitted, the optimal file format is deduced from the data type and the extension is added to the filename. When loading, any extension is considered, i.e. filename.*, and if only one match is available, the file is loaded.
• Support for archives: In case of archives, e.g. HDF5, zip etc., the content can be accessed directly by specifying it in the path.
• Support for Parallel IO: Where possible and implemented, parallel IO is supported. This is enabled either via MPI providing a Cartesian communicator with the option comm, or via Dask with the option chunks.

Cyclone Benchmarking & Performance Automation with Reframe

Cyclone Benchmarking & Performance Automation with Reframe, is a Pyhton project where I contributed to the development of an automated benchmarking and performance evaluation framework for the Cyclone supercomputer, leveraging ReFrame, a regression testing framework tailored for high-performance computing (HPC) systems. The primary objective was to create pipelines that routinely assess system performance and operational status, particularly after maintenance or configuration changes, ensuring sustained reliability and optimal performance across heterogeneous hardware partitions.

The project involved designing and implementing three key automated pipelines. The first focused on benchmarking the various partitions on computation, communication and storage performance, utilizing tools such as HPL, HPCG, DistributedStream, BenchIO and MPI OSU to measure metrics like FLOPS, memory bandwidth, and latency. The second pipeline ensured system health by verifying node availability, compiler and library compatibility, and the operational status of GPUs and filesystems. The third pipeline benchmarked representative applications, including GROMACS, TensorFlow, and PyTorch, to evaluate real-world performance scenarios relevant to the system's user base.

Zephyr - A Supercomputer in a Suitcase

Zephyr is a miniaturized supercomputer designed to make High-Performance Computing (HPC) accessible for educational purposes. This compact system integrates 18 Raspberry Pi modules, emulating the functions of supercomputer nodes on a smaller scale. Each module measures 85x56x17mm and features quad-core CPUs, allowing simultaneous execution of multiple tasks.

Zephyr boasts an innovative design, housed in a custom-made transparent plexiglass case created with SolidEdge 3D CAD software. This makes it both visually appealing and functionally robust, while the transparent casing provides an educational view into its inner workings. Efficient networking is achieved through Ethernet cables and switches, forming a scalable network with all nodes operating on a single power source, simplifying energy management. Additionally, Zephyr features programmable LEDs that visually demonstrate CPU utilization, memory, temperature, and communication patterns, enhancing its educational value. Furthermore, interactive simulations such as "Aircraft Wing Design" and "Coastal Defense" highlight real-world problem-solving capabilities of HPC, inspiring learners of all ages.

Zephyr serves as a tool to demystify advanced computing technologies, promoting STEM education and fostering curiosity among youth. It was prominently showcased at the sCYence Fair 2024, captivating audiences by making supercomputing concepts engaging and relatable.

Zephyr's journey so far:

1. European Researchers’ Night
2. Youth Makers Fair 2024
3. Reflect Festival 2024
4. sCYence Fair 2024

Unlocking Cyclone: A Comprehensive Guide to HPC Workflows

Unlocking Cyclone: A Comprehensive Guide to HPC Workflows is a tutorial series that I led and coordinated, designed to equip users with the knowledge and skills necessary to effectively utilize the Cyclone High-Performance Computing (HPC) system. The goal of this project was to demystify HPC workflows and address common challenges faced by researchers, developers, and newcomers working with HPC resources. The tutorials cater to a diverse audience, including researchers running simulations, Python developers optimizing workflows, and scientists utilizing HPC applications like GROMACS and OpenFOAM.

The series covers essential topics such as HPC system architecture, secure access and navigation, development tool setup, scaling Python workloads, and efficient use of Jupyter Notebooks on Cyclone. As the project lead, I coordinated the development process, ensuring the content was both comprehensive and accessible. Additionally, I contributed to the creation of several tutorials, focusing on enhancing user proficiency in job scheduling, resource management, and workflow optimization.

This project aims to improve user confidence and competence in HPC usage, fostering best practices for resource management, and enhancing the productivity of Cyclone's user base. The tutorials were written using MkDocs in a blend of Markdown and HTML.