Air pollution is the second leading cause of mortality globally and is linked to numerous adverse health outcomes. Accurate estimation of air pollutant concentrations is critical for air pollution health studies. These estimates are often derived from a range of methods, including machine learning, statistical models, and chemical transport models (CTMs), but the inherent challenges of complex spatio-temporal air pollutant data pose obstacles in modeling. Although many prediction models have been developed by different research groups, their performance varies widely across space and time. Moreover, most models do not provide estimates of the spatio-temporal uncertainty in predictions, especially regarding variation across models. To address these gaps, we developed the Bayesian Nonparametric Ensemble (BNE), a machine learning algorithm that provides a structured approach for spatio-temporal ensemble prediction while incorporating uncertainty and inter-model disagreement. However, BNE is computationally intensive, particularly for predictions when applied at fine spatio-temporal resolutions for health studies. This, along with the need for regular model updates to produce predictions for recent years, requires high-performance computing (HPC) resources. In this paper, we focus on the use of HPC resources—specifically National Science Foundation-funded ACCESS HPC resources—to implement BNE for large-scale daily air pollution prediction at 1 km2 resolution across the continental U.S. from 2010 to 2016. We discuss computational challenges, including memory, data storage, and runtime limitations, and highlight parallel computing strategies. This work presents a scalable framework for air pollution prediction with spatio-temporal uncertainty, supporting advances in environmental health and policy.
Graphs are a fundamental tool for representing and analyzing relationships in data, with applications spanning social networks, the web, and the biological sciences. As the volume of data continues to grow, so too do the size and complexity of the graphs we must process. Extracting insights from these massive graphs requires scalable, high-performance algorithmsWhile many graph algorithms exhibit substantial parallelism, it is often extremely fine-grained—just a few instructions—making it difficult to exploit efficiently on conventional architectures. In this work, we demonstrate how to restructure graph algorithms to run efficiently on UpDown, a scalable, programmable accelerator designed specifically for fine-grained parallelism. UpDown enables scaling graph processing algorithms to systems with millions of concurrent hardware threadsThrough detailed simulation of UpDown systems with up to one million cores, we show that our approach achieves over 100,000× parallel speedup and absolute performance that outperforms the best reported distributed systems in terms of power efficiency. At the same time, our load-balanced approach retains strong performance at smaller scales, outperforming optimized multicore implementations under similar power budgets—all using a single, unified implementation.
GMRES(m) is a popular iterative method for solving linear systems with large, sparse, (possibly) nonsymmetric, and invertible matrices. If a matrix is not positive definite, GMRES(m) will exhibit slow or stagnating convergence behavior. Baker et al. have proposed αGMRES(mmax,mmin), which modifies the restart parameter m based on angles between consecutive residual vectors across two cycles of GMRES(m). This method results in faster convergence compared to the baseline of full-precision GMRES(m). Lindquist et al. have proposed a strategy for accelerating GMRES(m) via mixed precision arithmetic. The development of this method is motivated by the recent trend in newer GPUs offering better low-precision performance than high-precision. Although their method takes around the same number of iterations for both mixed precision and the baseline of full-precision GMRES(m), their GPU implementation results in a greater amount of low-precision parallelism offered by newer GPUs. Our work combines optimization strategies proposed by Baker et al. and Lindquist et al. We present a mixed-precision implementation of αGMRES(mmax, mmin). Our GPU implementation exhibits 47.16% better performance on average compared to full-precision GMRES(m). We also show 38.89% and 7.8% better performance with mixed-precision αGMRES(mmax,mmin) over both mixed-precision GMRES(m) and full-precision αGMRES(mmax,mmin), respectively. We are not aware of any other work that explores the effects that mixed-precision arithmetic and varied restarts have on each other.
High-performance computing (HPC) systems face challenges in jointly optimizing energy efficiency, reliability, and job throughput across heterogeneous architectures. Traditional schedulers rely on fixed heuristics that struggle under dynamic conditions and conflicting objectives. We present AIMS (Adaptive Intelligent Multi-objective Scheduler), a framework that combines uncertainty-aware deep reinforcement learning with digital twin technology for autonomous HPC scheduling. AIMS features a five-layer architecture with four predictive digital twins: fault prediction via LSTM-attention, energy forecasting using a CNN-LSTM hybrid, ensemble performance modeling, and physics-informed thermal analysis. These models supply state information to a Dueling DQN with epistemic uncertainty quantification, enabling adaptive decision-making. Policy gradient-based weight evolution drives multi-objective optimization toward Pareto-efficient scheduling. Tested on 389,620 production job records from Aurora, Polaris, Mira, and Cooley systems, AIMS outperforms ten baselines, including Slurm and PBS Pro, achieving 12.1% higher energy efficiency, 8.7% improved reliability, and 15.3% greater throughput. Under fault conditions, its uncertainty-aware design yields a performance gain of 12.8% versus 5.2% in stable settings. Scalability tests confirm real-time operation at exascale (up to 262K nodes) with sub-50ms decision latency. AIMS offers a robust and scalable solution for next-generation HPC scheduling where traditional methods fall short.
AMD-Xilinx Versal Adaptive System-on-Chip devices are powerful hardware accelerators with a variety of tools for implementing high-performance, low-power, deep-learning models. Vitis AI, a machine-learning framework created by AMD-Xilinx, accelerates deep-learning algorithms using the Deep-Learning Processor Unit (DPU), which includes a Versal-specific architecture designed to take full advantage of the unique processing elements on select Versal platforms. However, the DPU does not run efficiently for small models due to its general-purpose nature. FINN, another machine-learning framework created by AMD-Xilinx, complements Vitis AI by providing custom low-latency, high-throughput accelerators for highly quantized networks. Due to the Versal’s incompatibility with FINN’s software drivers, FINN has not yet been tested on Versal hardware against Vitis AI. In this research, we create a novel custom wrapper and driver to allow FINN accelerators to run efficiently on Versal devices. We also add preprocessing to the generated FINN accelerator to avoid bottlenecks at high levels of parallelization. We use this adjusted accelerator and wrapper to directly compare Vitis AI’s DPU against FINN-created accelerators on the Versal AI Core across two deep-learning classification models in terms of throughput, power efficiency, and device utilization. We found that for a small convolutional model designed in the original FINN research, FINN achieves a speedup of 10.1× over a DPU architecture that consumes a similar amount of power. Running MobileNetV1, the most performant (highest framerate) DPU tested achieves a speedup of 3.0× compared to the most performant FINN architecture tested, but consumes significantly more power (40.8 W vs 17.8 W). From our results, we conclude that FINN can offer better performance and power efficiency for small models and can be used as a low-power alternative to Vitis AI’s DPU on larger edge-computing models such as MobileNetV1.
Processing of parametric linear systems of the form G(P) := X⊤PX is computationally intensive as they use double precision, and matrix X can be large. Many applications can tolerate numerical errors and GPUs support a range of low-precision formats, so a hybrid coarse-grained transprecision computing approach is proposed to improve the performance under a predefined error threshold. In the offline phase, suitable low-precision formats for X and P matrices are identified. In the online phase, incoming Ps are analyzed dynamically and an appropriate low-precision format is selected for computing G(P). A 21.6M × 500 X matrix is processed 14x faster compared to its double precision version, enabling real-time evaluation of one P matrix every 2 seconds on an NVIDIA A100 GPU with an average relative error of less than 0.3%.
The unpredictability of real-world graph workloads complicates the realization of high-performance graph analytics on the GPU. For example, variance in sparsity and neighbor commonality can dramatically alter computing costs and memory-access patterns, even within different regions of the same graph.In this paper, we investigate Jaccard similarity, a metric that measures the similarity of two sets. We compare and contrast the performance an edge-centric parallelization of Jaccard similarity with respect to the vertex-centric approach from NVIDIA’s cuGraph library. We then characterize the impact of graph metrics (e.g., average degree, maximum degree, Gini index) on the performance of edge-centric and vertex-centric kernels. By combining the above graph metrics with performance metrics (e.g., bandwidth utilization and thread activity), we deliver insight into why certain graphs benefit from edge-centric over vertex-centric parallelization, while other graphs benefit conversely. Finally, based on these results, we make a case for sparsity-aware parallelization, i.e., choosing between an edge-centric or a vertex-centric parallelized kernel, for improved performance by showing that selecting the best-performing parallelized kernel can deliver a geometric mean speedup of 3.2× over the reference cuGraph kernel on an NVIDIA A100 GPU.
This paper presents a probabilistic update model for the computation of the dominant eigenpair of a symmetric matrix via the power iteration algorithm. Each index of the approximate dominant eigenvector is updated according to a fixed probability, and at any given iteration, the update decision is guided by a Bernoulli trial with success probability equal to the update probability. Such probabilistic or stochastic models of the power iteration algorithm can model uncertainties in the update of the approximate eigenvector resulting either from faults during matrix-vector product computations or straggling in public cloud servers. In this paper we present an analysis of power iteration with probabilistic updates from a heterogeneous performance perspective, discuss practical details, and illustrate its performance on a set of matrix problems.
An unprecedented increment in the information content of exoplanetary datasets has highlighted a key bottleneck in their interpretation: a lack of fidelity of our models. One of such deficiencies is rooted in how well we model light-matter interactions (a.k.a. opacity models) and, thus, translate spectral data into physical inferences. High-fidelity models are necessary for robustly constraining the molecular abundances and reliably detecting life elsewhere. Opacity models are primarily built up and extrapolated from laboratory studies, which are both time and resource-intensive. Here, we present an alternative method for calculating collisional molecular properties from ab initio calculations, thereby paving a path for an efficient, scalable solution for the much-needed model upgrade. We have successfully demonstrated the feasibility of our approach by successfully calculating the collisional properties for CO2-H2 in approximately 25,000 CPU hours. With an achieved scaling of $\mathcal{O}\left( {{N^2}} \right)$, and ongoing efforts including sparse matrix optimizations, our method is extendable to more complex systems such as H2O-H2. This enables systematic and timely expansion of spectroscopic databases required for robust exoplanetary atmospheric retrievals in the JWST era.
Large-scale network sensing plays a vital role in network traffic analysis and characterization. As network packet data grows increasingly large, parallel methods have become mainstream for network analytics. While effective, GPU-based implementations still face start-up challenges in host-device memory management and porting complex workloads on devices, among others. To mitigate these challenges, composable frameworks have emerged using modern C++ programming language, for efficiently deploying analytics tasks on GPUs. Specifically, the recent C++26 Senders model of asynchronous data operation chaining provides a simple interface for bulk pushing tasks to varied device execution contexts. Considering the prominence of contemporary dense-GPU platforms and vendor-leveraged software libraries, such a programming model consider GPUs as first-class execution resources (compared to traditional host-centric programming models), allowing convenient development of multi-GPU application workloads via expressive and standardized asynchronous semantics. In this paper, we discuss practical aspects of developing the Anonymized Network Sensing Graph Challenge on dense-GPU systems using the recently proposed C++26 Senders model. Adopting a generic and productive programming model does not necessarily impact the critical-path performance (as compared to low-level proprietary vendor-based programming models): our commodity library-based implementation achieves up to 55x performance improvements on 8x NVIDIA A100 GPUs as compared to the reference serial GraphBLAS baseline.
Etymology is a branch of linguistics concerned with finding the languages of origin of words, where the words may have evolved from an ancient language or are borrowed from an extant language. A recently proposed method of text and style analysis aims to determine the deeper layer of etymological distributions and features for characterizing text, in view of determination of style and authorship. Finding the etymological distribution adds to the complexity of text analysis. We discuss the complexity of this task and indicate ways of optimizing the etymological analysis. One way of balancing time and memory demands is to use an etymological dictionary in memory for the most used words in the language and searching over the Internet for the etymology of words that are probable hapax legomena in typical texts. A special topic treated is that of the etymological distribution of AI-generated texts.
This study explores multi-stage stochastic optimization frameworks for routing heavy-duty electric trucks making long-haul deliveries, while dealing with uncertainty in public charging station congestion. We examine a multi-stage problem in which multiple vehicles share limited charging resources in a dynamic environment. Each decision stage corresponds to a distinct routing event, such as the arrival at a delivery location, with congestion levels at public charging stations progressively revealed. The key state variable is the vehicle’s position, represented as integer indices based on predefined route sequences. These route sequences introduce global constraints that must be reconciled with the stage-wise independence assumption.To solve this integer-state problem, we compare two decomposition algorithms: Stochastic Dual Dynamic integer Programming (SDDiP) using strengthened Benders’ cuts and Stochastic Dual Dynamic Programming (SDDP) using piecewise linear Bellman cuts. Computational experiments are conducted on a realistic mid-mile transportation network in California, featuring up to 15 vehicles, 169 delivery nodes and 25 public charging stations. We evaluate computational time, convergence behavior and policy performance across varying network scales. On a 5-vehicle instance, our results show that SDDP reduces runtime per iteration by up to 17.22% compared with SDDiP solver and delivers policy within a 2.90% convergence gap. We conclude with practical insights regarding the scalability and stability of the linear programming relaxation (LP-relaxation) cuts versus integer-state cuts in large-scale Electric Vehicle Routing Problem (EVRP) applications.
In the past year, generative AI (GenAI) models have received a tremendous amount of attention, which in turn has increased attention to computing systems for training and inference for GenAI. Hence, an update to this survey is due. This paper is an update of the survey of AI accelerators and processors from past seven years, which is called the Lincoln AI Computing Survey – LAICS (pronounced "lace"). This multi-year survey collects and summarizes the current commercial accelerators that have been publicly announced with peak performance and peak power consumption numbers. In the same tradition of past papers of this survey, the performance and power values are plotted on a scatter graph, and a number of dimensions and observations from the trends on this plot are again discussed and analyzed. Market segments are highlighted on the scatter plot, and zoomed plots of each segment are also included. A brief description of each of the new accelerators that have been added in the survey this year is included, and this update features a new categorization of computing architectures that implement each of the accelerators.
The evolution of GPUs has resulted in democratized access to increasingly powerful low-precision compute capabilities, designed for artificial intelligence (AI), particularly large language models (LLMs) and generative AI. These algorithms heavily utilize hardware units specialized for matrix multiplication, such as Tensor Cores, that have advanced since their introduction, offering improved functionality, throughput, and energy efficiency. Two key techniques: mixed-precision algorithms and floating-point emulation, leveraging these resources, have emerged. They enable scientific applications, many dependent upon high-precision linear algebra, to achieve dramatic gains in performance and power efficiency. Additionally, these methods facilitate innovation in areas such as fine-grained mixed-precision strategies and data compression, broadening their impact across diverse computing platforms. This paper explores the opportunities afforded by these developments. We highlight both evolutionary advances and revolutionary features, such as the enhanced scaling capabilities of the latest NVIDIA Blackwell architecture’s Tensor Cores, and present empirical results, demonstrating their effectiveness on these GPUs.
Subgraph matching is a core primitive in graph analytics, yet it remains difficult to scale due to its combinatorial complexity and highly irregular memory access patterns. Despite decades of algorithmic innovation, existing CPU and GPU-based systems struggle to fully utilize available compute resources, as the memory-bound nature of subgraph workloads severely limits sustained throughput. Our empirical characterization reveals that even state-of-the-art GPU solutions, including recent GraphChallenge champions, achieve only a small fraction of their theoretical peak performance on real workloads.This paper presents Prism, the first solution to address the GraphChallenge contest using practical emerging processing-in-memory (PIM) hardware. Prism targets UPMEM, a commercially available platform that integrates thousands of in-memory compute units known as DPUs. To harness UPMEM’s massively parallel, memory-centric architecture and overcome its unique architectural constraints, Prism introduces a cross-layer design that integrates skew-aware task decomposition, asynchronous memory-compute decoupling, and topology-adaptive intersection kernels. We evaluate Prism across diverse subgraph workloads and datasets. It delivers up to 10.73×, 26.53×, 11.13×, and 10.11× speedup over GraphChallenge champions MERCURY and SMOG, and recent SOTA systems including TRUST and PimPam, while scaling near-linearly to 40,960 DPUs. The source codes are available at https://github.com/CGCL-codes/Prism.
It is difficult to accurately predict application run times in high performance computing (HPC), yet these predictions have useful applications in job scheduling and user feedback. User-led predictions can be inaccurate for a variety of factors, including inexperience, user burden, and an incentive to overpredict. Most automated efforts consider standardized job inputs from submission scripts but ignore application input parameters. Application input parameters can greatly enhance run time prediction accuracy but have typically been avoided due to the need for manual, per-application parameter collection.This work is an extension of our previous publication, which evaluated and compared the trade-offs between conventional, job script-based predictors and specialized, application input-based predictors. To extend the prior work, this paper provides prediction results as applied the Empire application suite, a suite of more realistic verification tests and regression runs, rather than the synthetically generated testing previously evaluated. As in that work and prior work, the random forest regressor and decision tree models offer the best trade-off between accuracy and training time among all tested model variants. We show that resource manager parameters alone, such as those used by Slurm, are insufficient to produce adequate predictions, while application input parameters provide excellent results, as high as 0.95 R2.
This work explores the potential of the generalized canonical polyadic (GCP) tensor decomposition to be used as a diagnostic tool to determine the underlying statistical nature of a dataset. The GCP reformulates the standard canonical polyadic (CP) decomposition problem as a maximum likelihood estimate and models the natural parameter of the statistical distribution assumed to be associated with a data tensor as opposed to modeling the data itself through the use of a variety of statistically motivated loss functions. This property is of particular interest when a dataset is strongly non-Gaussian, such as is the case with binary or count data. In the work presented, we compare competing CP models of datasets with differing statistical natures to determine if the GCP can be used as an exploratory tool for the statistical characterization of a data tensor of interest. The quality of competing models is assessed via multiple metrics that include fit score, cosine similarity of the tensors, and the Core Consistency Diagnostic (CORCONDIA) score. Results are presented for a variety of artificially generated data tensors.
In this paper, we show how various forms of Fully Homomorphic Encryption can be used to solve the problem of embedding a virtual network onto multiple substrate networks where the substrate network providers do not wish to reveal information about their inner network structures. We implement a basic Greedy Shortest Paths Virtual Network Embedding algorithm and show that while node mapping is relatively efficient, edge mapping of a fully encrypted substrate network description using Dijkstra’s Shortest Paths algorithm is heavily dependent upon the amount of information we are willing to reveal to the program implementing the algorithm. We provide runtime performance metrics for various parts of the embedding problem and show that through the use of interactive comparison, where the result of each encrypted comparison operation are jointly decrypted by all network providers, we can significantly improve the runtime of edge mapping to the point where it is of practical value.
Community detection is a fundamental task in the analysis of large-scale dynamic networks. As graphs continuously evolve through edge insertions and deletions, maintaining high-quality community structures with low latency remains a significant computational challenge. We introduce SCoDa, a fully dynamic parallel algorithm for community detection that supports real-time streaming updates in both edge addition and deletion scenarios. SCoDa combines a GPU-optimized Louvain algorithm for initial static partitioning with efficient, parallel update routines that apply updated affected regions computations to selectively recompute only the affected regions of the graph. This localized update strategy minimizes redundant processing and maximizes scalability.By leveraging fine-grained parallelism on modern GPUs, SCoDa enables low-latency updates and high-throughput processing of streaming graph modifications. We evaluate our approach on large-scale real-world datasets from SNAP and SuiteSparse, with graphs scaling up to 42.6 billion edges, spanning domains like social media, communication, road networks, and the web. Experimental results show that SCoDa achieves an average 1.7× speedup over existing parallel baselines during update computation, while maintaining modularity and community quality. These findings underscore SCoDa’s scalability and effectiveness for real-time dynamic graph analytics at a massive scale.
Communication and IoT networks require efficient energy optimization to extend the node lifetime, enhance the throughput, and minimize the operating cost. In contrast to the previous research which samples individual practices, this paper suggests an integrated AI-based approach consolidating several smart modules into one pipeline. The structure starts with a Federated Monitoring Framework of secure low overhead data collection across distributed nodes. Hybrid Entropy Genetic Algorithm is used to perform preprocessing of features, which reduces input dimensions and improves efficiency. A hybrid LSTM-GRU + Temporal Convolutional Network (TCN) model allows predicting network energy consumption with low RMSE and a short latency in real-time. Particle Swarm Optimization-Deep Reinforcement Learning (PSO-DRL) can dynamically manage routing and partial replacement of component swapping to further enhance efficiency, and Reinforced Federated Learning (RFL) ensure ongoing model updates at the edge in a privacy-preserving way. The simulation results of the large-scale network cases indicate that proposed framework is infinitely better in comparison with the baseline models in terms of consuming less energy, high ratios of delivering packets, as well as higher throughput. The findings demonstrate the potentials of the proposed pipeline in providing sustainable, intelligent and adaptive network operations.
