ABSTRACT. The growing adoption of RISC-V in high-performance computing has increased the demand for performance-portable software targeting the RISC-V Vector (RVV) extension. However, current compiler infrastructures still lack complete support for generating optimized RVV code from high-level intermediate representations to executable implementations.

This work presents a hybrid MLIR-xDSL compilation framework that enables automatic generation of high-performance RVV micro-kernels. The proposed infrastructure introduces custom dialects, lowering passes, and transformation pipelines that translate high-level MLIR representations into portable C code enriched with native RVV intrinsics through the emitc dialect.

Using this infrastructure, we develop a fully automated workflow for generating and benchmarking General Matrix Multiplication (GEMM) micro-kernels with different dimensions, data types, and vector configurations. The generated kernels are evaluated on two RVV 1.0 platforms, the K230 and BananaPi F3, using synthetic GEMM benchmarks and transformer-based workloads derived from BERT-Large.

The generated kernels consistently outperform OpenBLAS, reaching up to 12.2 GFLOPS versus 5.1 GFLOPS for the baseline, while achieving performance comparable to hand-written implementations. These results demonstrate that the proposed MLIR-xDSL framework provides an effective pathway for automatic generation of optimized RVV code for the RISC-V ecosystem.

ABSTRACT. In the context of High-Performance Computing (HPC) applications, a significant fraction of them exhibit dynamic behaviour with different execution phases and varying computational intensity. For this class of applications, a rigid resource allocation policy does not always guarantee the most efficient execution and use of resources. A static approach can be inefficient for two primary reasons: either more resources are provisioned than necessary, which the application cannot effectively use (for instance, consuming more energy than necessary), or a lack of resources increases execution time and most likely the energy consumption of the most demanding computational phases.

In this paper, we address this challenge by first investigating the energy behaviour of an agent-based epidemiological simulator under different configurations. We then analyse the impact of different process-to-core affinity policies on application performance. Building on these, we propose to dynamically manage the number of processes used by the application at runtime, focusing on simultaneously reducing execution time and energy consumption. Our experiments demonstrate that by dynamically reconfiguring resources to match the different computational phases of the application, it is possible to reduce up to 84 % and 8 % total execution time and overall energy consumption, respectively.

ABSTRACT. Neighborhood collectives are a key communication paradigm in MPI, enabling efficient localized communication that is essential for many HPC applications with sparse communication patterns. This paper proposes new algorithms for neighborhood allgather and alltoall, aimed at reducing inter-node communication overhead. The algorithms utilize virtual topology information to construct balanced and optimized communication patterns and employ message combining to reduce the number of messages. This approach leverages virtual topology information to allow ranks on a node to collaboratively restructure their communication patterns. By distributing incoming messages across multiple local receivers, our design reduces communication time and balances the network load, utilizing shared memory as the underlying transport in intra-node communication. The proposed algorithms were implemented in Open MPI and evaluated through a comprehensive performance study using random sparse graphs and Moore microbenchmarks, across a wide range of message sizes and neighborhood densities, as well as a sparse matrix-matrix multiplication kernel. Our experimental results demonstrate speedups of up to 18.75x over the default Open MPI implementation for neighborhood allgather and up to 5.61x for neighborhood alltoall. In addition, the proposed algorithm shows up to 4.86x performance improvement over the Distance-halving neighborhood allgather algorithm.

ABSTRACT. Heavy HPC users have traditionally viewed renting cloud resources as being more expensive than owning on-premises resources. However, changing economics and relaxed data sovereignty laws are prompting them to explore cloud bursting. While there are many solutions for moving data to the cloud, repatriating results cost-effectively and promptly has received less attention. HPC applications generate large output data, leading to inefficient use of expensive cloud instances. This issue is exacerbated when using Spot instances in two ways: checkpoints are required to safeguard against excessive recomputation should the instance be terminated prematurely, and; all pending outputs need to securely transferred within the eviction notice window. This paper investigates solutions to this costly problem and introduces Sync Engine, a user-space, file-specific, storage-agnostic data mirroring solution loaded at job submission time that does not require modifying the application. The \textsc{Sync Engine} synchronizes outputs to on-premises storage using two mechanisms: primarily (i) LibSync, a novel middleware that transparently mirrors POSIX writes to a secondary target asynchronously, overlapping I/O with computation, and (ii) Rsync, a widely used Unix file synchronization tool that employs a delta-transfer algorithm to minimize network traffic, being used if LibSync is unable to complete its operations within the eviction window. LibSync also supports policy-driven synchronization, bounded close behavior for Spot resilience, and optional streaming compression. An evaluation with production-scale reservoir simulations demonstrated that LibSync with compression persists 21 GB of data back to on-premises storage (5,000 miles away, from AWS US to Brazil) with only 3% time overhead over an optimal baseline. In relation to the currently adopted solution, it was both 10% faster and 10% cheaper and reliably writes the final checkpoint within AWS's 2-minute spot eviction window.

ABSTRACT. Uncertainty estimation is required for the trustworthy deployment of deep learning solutions in medical environments. However, current approaches rely on model ensembling, which substantially increases inference latency and computational costs. Research primarily focuses on improving predictive quality, while for actual runtime performance it often relies on scale-out strategies requiring additional hardware to meet latency constraints.

In this work, we propose a scale-in inference strategy that maximizes existing hardware utilization. We develop a memory-efficient, model-parallel inference framework that performs online uncertainty aggregation over intermediate predictions. The proposed approach increases single-GPU utilization to over 95% during inference while avoiding out-of-memory failures across all evaluated input volumes.

Experiments on the state-of-the-art nnUNet medical image segmentation model demonstrate end-to-end latency reductions of 1.6--2x. Furthermore, for the common five-fold ensemble deployment scenario, our model-parallel approach achieves an approximately 1.9-2.5x speedups while maintaining equivalent predictive outputs. These results demonstrate that substantial inference acceleration can be achieved through algorithmic and systems-level optimization, reducing the reliance on scale-out deployments and improving the practicality of uncertainty-aware medical image segmentation in resource-constrained clinical settings.

ABSTRACT. Vision pre-training increasingly relies on massive datasets and complex data preparation pipelines, which introduce substantial storage, I/O, and preprocessing overheads.Procedurally generated synthetic datasets provide an alternative to disk-based training corpora by enabling on-the-fly sample generation during training, eliminating storage requirements while providing virtually unbounded training samples. However, integrating continuous synthetic generation into modern pipelines introduces new systems challenges involving data generation locality, augmentation execution, batching strategies, and overlap between data preparation and model execution.

In this work, we present a continuous synthetic data pipeline architecture based on VisualAtom, supporting both CPU- and GPU-based generation through different dataset abstractions and augmentation pipelines. We investigate how execution locality (CPU vs GPU generation), generation granularity (per-sample vs batched execution), and augmentation frameworks (timm, torchvision, and NVIDIA DALI) jointly affect performance.

Our study shows that pipeline organization and the compatibility between generation and augmentation granularity have a larger impact on end-to-end training efficiency than execution locality alone. We also find that existing augmentation frameworks expose different execution constraints when integrated with continuous synthetic streams, motivating hybrid configurations. Within the evaluated VisualAtom and DeiT-Tiny/Base setting, these results illustrate the system-level trade-offs involved in designing continuous training pipelines. The source code is publicly available at https://github.com/hpca-uji/sbac-pad2026.

ABSTRACT. The evaluation of a deep learning model— propagating inputs through its computational graph—is the fundamental kernel of both inference and training. As models scale from millions to tens of billions of parameters, the question of how to distribute this computation across processing elements becomes critical, non-trivial, and tightly coupled to the underlying memory hierarchy. We present a unified, empirical study spanning two hardware platforms separated by three orders of magnitude in compute density: (i) an Intel Xeon Sapphire Rapids CPU (AWS EC2 c7i.4xlarge), where six SIMD vectorization strategies and three partitioning policies (Horizontal, Vertical, Mixed) are evaluated over more than 300 configurations on MLP models from 0.8 M to 188.6 M parameters, and (ii) an 8× NVIDIA Tesla V100-SXM2-32GB GPU cluster, where Data Parallelism (DDP), Tensor Parallelism (TP), and Mixed strategies are benchmarked for transformer language models from 5 M to 30 B parameters covering training, fine-tuning, and multi-GPU inference. We contribute: (1) a roofline-grounded analysis of CPU SIMD scaling with explicit FMA dependency-chain reasoning and a 4-accumulator unrolling technique that recovers 15–25% of lost throughput; (2) closed-form Amdahl’s-law models for Horizontal and Vertical partitioning, fitted to measured 2–16-thread data and used to predict asymptotic scaling; (3) a quantitative communication model for NVLink ring-reduce that predicts the observed MFU collapse to 1.2% at TP=4; (4) a memory- decomposition study of multi-GPU inference, including two-phase prefill/decode analysis explaining super-linear scaling at batch=16 (8.19× on 8 GPUs) and OPT-30B which physically cannot load on any single V100; (5) an architecture-agnostic bottleneck taxonomy unifying CPU and GPU findings; and (6) ten concrete design recommendations grounded entirely in the data. Headline results: CPU Vertical partitioning achieves 114.99× speedup over scalar 1- thread on Large_200M (3.64× better than Horizontal), GPU DDP delivers 91–99% scaling efficiency for memory-feasible models, and TP becomes mandatory above∼700 M parameters under fp32 Adam training on 32 GB GPUs.

ABSTRACT. Efficient use of large-scale supercomputing systems depends on accurate runtime estimation and walltime selection. To avoid premature termination, users often overestimate walltime, leading to poor resource utilization and reduced scheduling efficiency. \new{This paper presents an empirical study of safe walltime recommendation policies that combine runtime prediction with conservative adjustment rules suitable for production HPC environments.}

We evaluate the approach using large-scale production job histories from the Fugaku and NREL Eagle supercomputers, comprising approximately 24M and 11M jobs, respectively.

Runtime prediction models include linear regression, neural networks, and a neural ensemble that improves robustness across workloads. Predicted runtimes are translated into walltime recommendations through bounded adjustment policies.

Experimental results indicate that similarity-aware representations improve prediction accuracy across the evaluated models and time scales, with particularly strong gains for jobs similar to past executions. When combined with the proposed conservative adjustment policies, these improvements translate into significant reductions in wasted walltime ($\approx32\%$) while maintaining a very low risk of job termination across both systems ($<1\%$).