Sparse linear algebra kernels are memory-bound routines, and their performance varies significantly according to the non-null pattern of the sparse matrix operands. The impressive computing power and memory bandwidth of modern massively parallel computing devices encourage researchers to develop sparse linear algebra kernels that can exploit these platforms efficiently. In this sense, a main line of work improves the storage of matrices, aiming to optimize the communication between the memory and the cores. In previous work, the use of a strategy consisting of a delta-encoding with matrix reorderings compressed the indexing data of the matrix, saving storage and communications. This work presents an algorithm to improve the reordering strategy and the resulting compression of the indexing data. The results show that this strategy leads to important storage savings, which can also reduce data movements between the main memory and processors.
Simulating the propagation of acoustic waves is the basis of seismic imaging software, widely used by the industry for locating and detecting new oil basins. Due to their complexity, these simulations require a high computational processing power obtained using GPUs. To fully exploit these devices' computing potential, it is necessary to rightly define the configuration of the number of blocks and threads per block that will be assigned to a given kernel. However, as we show in this paper, this task is challenging since the ideal configuration will vary according to the grid size and the target metric (e.g., performance or energy). In this scenario, this paper evaluates different execution configurations for the Fletcher method, a widely used seismic application. When evaluating sixteen different grid sizes over a distinct set of configurations, we show that rightly choosing the number of blocks and threads per block can deliver up to 2 times more performance and save 18% of energy consumption compared to the standard way the Fletcher method is implemented.
SVD factorization is a fundamental operation to solve problems in chemistry, biology, physics, and engineering. These problems are image processing, data mining, and big data, among others. There are several methods to get SVD factorization. One of these methods involve the use of Householder transformation, so it is possible to parallelize this task. Furthermore, novel computer architectures are oriented to use heterogeneous computing, such as CPUs and GPUs, in order to increase the performance and reduce the energy consumption. In this work, an heterogeneous parallel implementation of SVD based on Householder transformation is presented. Some strategies for matrix partition are presented in order to scale the program in the use of GPU cards. The speedup is increased when several GPU cards are used.
Wildfires are a latent problem worldwide that every year burns thousands of hectares, negatively impacting the environment. To mitigate the damage, there is software to support wildfire analysis. Many of these computational tools are based on different mathematical models, each with its own advantages and disadvantages. Unfortunately, only a few of the software are open source. This work aims to develop an open-source GPU implementation of a mathematical model for the spread of wildfires using CUDA. The algorithm is based on the Method of Lines, allowing it to work with a system of partial differential equations as a dynamical system. We present the advantages of a GPU versus C and an OpenMP multi-threaded CPU implementation for computing the outcome of several scenarios.
Graphics Processing Units (GPUs) harbor immense parallelization capabilities that can significantly accelerate the processing of large datasets. In the context of geophysical modeling, these capabilities can be harnessed to achieve faster execution times without compromising the accuracy of results. This study investigates optimization techniques implemented in a three-dimensional elastic model developed using the DEVITO tool. DEVITO is a Domain-Specific Language for stencil computation, with a focus on seismic inversion problems. DEVITO enables the creation of geophysical models in Python through functions and classes provided by the tool. Using an internal compiler, DEVITO can translate the model written from symbolic equations in Python into a finite difference code in C/C++. The performance of an initial naive implementation is compared against two optimized versions. One of the approaches was named Tiling, and uses the OpenACC tile directive to block the most relevant loop nests of the application. The other optimized approach, Sig Fission, uses the loop fission technique to divide the workload of one of the nests and then applies the tile directive. These optimizations have led to notable improvements, including an increased cache hit rate, enhanced GPU scheduler occupancy, a decrease in the number of registers needed to issue instructions, and a remarkable 40% reduction in execution time. By capitalizing on the parallel computing power of GPUs, this study demonstrates the efficacy of employing optimization strategies, such as loop tiling and loop fission, in geophysical modeling targeting graphics processing units. These techniques pave the way for accelerated data processing, ultimately contributing to improved efficiency and accuracy in computational geophysics, without any loss of integrity in the results.
Simulations in astrophysics play a crucial role in testing models and comparing them with observational data, for which High-Performance Computing has become indispensable for handling complex scenarios. In this paper, we present two important applications in astrophysical simulations. First, we explore the adaptation of the Pencil Code to study the evolution of magnetic field configurations in stratified stars. Second, we highlight the ARTI framework developed to estimate signals at the Latin American Giant Observatory. In addition, we discuss the importance of reproducibility in scientific analysis.
This article presents a multi-objective optimization approach aimed at minimizing the power consumption while mitigating the quality of service degradation in datacenter operations. The study holds significant relevance for datacenter and supercomputing facilities to effectively participate in the electricity market, especially in demand response events. The research explores an on/off energy-aware strategy combined with five list scheduling heuristics, comparing their efficacy to solve the proposed operation problem. The obtained results demonstrate that the proposed approach provides decision-makers a diverse set of options tailored to their specific business needs in different situations. The comparative analysis reveals that strategies that prioritize recently arrived tasks with a high probability of being completed on time, computed better solutions in scenarios where larger power consumption reductions are requested. The proposed heuristics are useful methods to assist datacenter operators for participating in demand response programs.
In this paper, the Numba, JAX, CuPy, PyTorch, and TensorFlow Python GPU accelerated libraries were benchmarked using scientific numerical kernels on a NVIDIA V100 GPU. The benchmarks consisted of a simple Monte Carlo estimation, a particle interaction kernel, a stencil evolution of an array, and tensor operations. The benchmarking procedure included general memory consumption measurements, a statistical analysis of scalability with problem size to determine the best libraries for the benchmarks, and a productivity measurement using source lines of code (SLOC) as a metric. It was statistically determined that the Numba library outperforms the rest on the Monte Carlo, particle interaction, and stencil benchmarks. The deep learning libraries show better performance on tensor operations. The SLOC count was similar for all the libraries except Numba which presented a higher SLOC count which implies more time is needed for code development.
Concerns over climate change and sustainable agriculture have made nation-wide high resolution environment monitoring and modelling desirable. Recent developments in technology have made it affordable. An environment modelling network is a supercomputer, but not of a familiar kind. Conventional supercomputing approaches are appropriate for the modelling aspect, but not the monitoring aspect. While sensor networks are familiar in the Internet of Things (IoT), geographically remote sensors without access to mains power have harsher resource constraints than, say, internet-ready light bulbs. A “two-realm” approach to system software is needed.
Failure or disruption in High-Performance Computer Systems can have a significant impact on human life, the environment, or the economy. Critical applications refer to software systems or functionalities that are essential for the safety, security, or continuity of critical infrastructure, services, or operations. Considering that semiconductor devices are susceptible to errors and failure, providing error detection and correction mechanisms in such systems is imperative. However, the main challenge for achieving fault tolerance and resiliency is compartmentalizing the causes and the consequences of error, in both hardware and software. Moreover, today’s extreme-scale parallel HPC systems necessitate fundamentally non-deterministic executions, making compartmentalization an even bigger challenge. To address these challenges, this paper proposes leveraging the Sequential Codelet Model (SCM), which facilitates parallel execution of programs expressed sequentially and hierarchically. We propose to exploit SCM’s encapsulation of semantics and data to compartmentalize faults transparently and efficiently. We present multiple techniques that can be implemented in the Sequential Codelet Model to include fault-tolerant and resiliency mechanisms. We implement already-known solutions by extending a functional emulator for the Sequential Codelet Model.
This article presents a parallel-distributed implementation of the Lipizzaner framework for multiobjective coevolutionary Generative Adversarial Networks training. A specific design is proposed following the messagge passing paradigm to execute in high performance computing infrastructures. The implementation is validated for the generation of handwritten digits problems. Accurate efficiency and scalability results, and a proper load balancing are reported.
High-performance computers are now essential in scientific and technological research and development because of their high processing capacity and extensive memory; they allow us to simulate phenomena where processing and handling such information is necessary. The simulation of physicochemical problems involves the inherent analysis and processing of large volumes of data. For this, a large computing capacity is required. Therefore, it is necessary to apply a parallel processing scheme using GPUs that allows an efficient way of obtaining the simulation results. This work presents a simulated diffusion model, considering the factors that affect the corrosion initiation rate of the reinforcement structure, such as the water-cement ratio, temperature, density, and chloride binding capacity of concrete since all these variables are handled. A significant amount of information becomes necessary to use computational architectures based on multiple GPUs to obtain better results in shorter times and thus minimize this phenomenon by changing specific design and manufacturing parameters [1, 2].
This study explores the implementation and analysis of a Multi-GPU system for the application of the Fletcher Method in geophysical exploration, essential in the discovery and extraction of energy sources such as oil and gas. The scalability of the software for the use of multiple GPUs (Graphics Processing Units) allows for improved performance of these applications due to their parallel processing capacity. The proposed strategy emphasizes a judicious approach to workload division, considering the data location and the GPU's processing capacity. This implementation stands out as the first in the seismic application field to utilize multiple V100 GPUs and assess the impact on performance. The experiments results demonstrated that the proposed Multi-GPU implementation provides significant performance improvements over the Single-GPU version (e.g., 2.77 times using 4 GPUs). Furthermore, the Multi-GPU implementation exhibits linear growth in performance and efficiency as the input grid size increases.
Federated Learning (FL) is a distributed technique that allows multiple users to train models collaboratively without accessing private and sensitive data. Iteratively, each user trains a “local” model in a specific machine consuming private data and then sends the model updates to a server for their fusion into a centralized one. Although FL represents a step forward, the training duration in each iteration directly depends on the several configurations set, e.g., hyperparameters. Analyzing hyperparameters during the FL workflow allows for dynamic fine-tuning that can improve the performance of FL regarding training time and quality of results. However, due to its exploratory nature, the user may lose track of which configurations have been used to train the model with the best accuracy if the choices are not correctly registered. Provenance is the natural choice to represent data derivation traces to help hyperparameters fine-tuning by providing a global data-oriented picture of the FL workflow. Yet, the existing FL frameworks do not provide dynamic fine-tuning nor support provenance capturing. Therefore, this paper introduces an FL framework named Flower-PROV that uses provenance data for tracking configurations and evaluation metrics during the FL execution to allow for dynamic fine-tuning of hyperparameters, thus saving training time. We show a use case with Cross-Silo FL where Flower-PROV dynamic fine-tuning reduced the FL training time up to 94.24% when compared with the fine-tuning using grid-search.
The use of classical computers to simulate quantum computing has been successful in aiding the study of quantum algorithms and circuits that are too complex to examine analytically. Current implementations of quantum computing simulators are limited to two-level quantum systems. Recent advances in high-dimensional quantum computing systems have demonstrated the viability of working with multi-level superposition and entanglement. These advances allow an agile increase in the number of dimensions of the system while maintaining quantum entanglement, achieving higher encoding of information and making quantum algorithms less vulnerable to decoherence and computational errors. In this paper, we introduce QuantumSkynet, a novel high-dimensional cloud-based quantum computing simulator. This platform allows simulations of qudit-based quantum algorithms. We also propose a unified generalization of high-dimensional quantum gates, which are available for simulations in QuantumSkynet. Finally, we report simulations and their results for qudit-based versions of the Deutsch--Jozsa and quantum phase estimation algorithms using QuantumSkynet.
The Controlled Source Electromagnetic (CSEM) combined with seismic surveys has been used to explore new oil and gas reservoirs. The MARE2DEM application generates as mesh that represents a resistivity model of the seafloor underground. From a set of electromagnetic readings, the application runs a data inversion (using Maxwell's equations) along many steps to converge to a resistivity model that more closely matches the measured data. This data inversion procedure is very compute-bound because of the large amount of arithmetic operations involved. As consequence, the MARE2DEM application divides the workload into smaller work grains, called refinement groups due to the usage of Adaptive Mesh Refinement (AMR). These groups are processed independently in a parallel fashion by a set of workers. It is known that parallel processing suffers from delays and resource underutilization if the load remains imbalanced. In this article, we propose an analysis of the performance and imbalance of the MARE2DEM through source code inspection and trace analysis. The novelty of our investigation consists in the usage of runtime parameters to more profoundly understand and characterize the refinement groups' execution time and variability. Our results show that the execution time of the refinement groups is strongly impacted by both the number of processed nodes present on the input mesh and the measured data associated to each refinement group.
This paper presents the results obtained in performance tests of task automation in the supercomputing cluster of the University of Guadalajara (CADS Data Analysis and Supercomputing Center). The main objective was to design an automated workflow process to take advantage of high computational performance in scientific applications, routines in R, Python or shell that by nature consume only one core, and that by the volume of data to be processed could allow the execution of multiple tasks at once in a supercomputing cluster environment, or even in the cloud, for an efficient use of the infrastructure. In addition to using Singularity containers to encapsulate applications or scripts to be used in workflows. The following tools were tested: Snakemake as a tool for workflow automation and scaling, as well as Singularity container technologies for application encapsulation and SLURM for managing resource usage in the cluster. The results are presented as well as the experience gained in using these technologies.
The emergence of the COVID-19 pandemic has led to an unprecedented change in the lifestyle routines of millions of people. Beyond the multiple repercussions of the pandemic, we are also facing significant challenges in the population's mental health and health programs. Typical techniques to measure the population's mental health are semiautomatic. Social media allow us to know habits and daily life, making this data a rich silo for understanding emotional and mental wellbeing. This study aims to build a resilient and flexible system that allows us to track and measure the sentiment changes of a given population, in our case, the Mexican people, in response to the COVID-19 pandemic. We built an extensive data system utilizing modern cloud-based server-less architectures to analyze 760,064,879 public domain tweets collected from a public access repository to examine the collective shifts in the general mood about the pandemic evolution, news cycles, and governmental policies using open sentiment analysis tools. We provide metrics, advantages, and challenges of developing serverless cloud-based architectures for a natural language processing project of a large magnitude.
Numerical Linear Algebra (NLA) is a research field that in the last decades has been characterized by the use of kernel libraries that are de facto standards. One of the most remarkable examples, in particular in the HPC field, is the Basic Linear Algebra Subroutines (BLAS). Most BLAS operations are fundamental in multiple scientific algorithms because they generally constitute the most computationally expensive stage. For this reason, numerous efforts have been made to optimize such operations on various hardware platforms. There is a growing concern in the high-performance computing world about power consumption, making energy efficiency an extremely important quality when evaluating hardware platforms. Due to their greater energy efficiency, Field-Programmable Gate Arrays (FPGAs) are available today as an interesting alternative to other hardware platforms for the acceleration of this type of operation. Our study focuses on the evaluation of FPGAs to address dense NLA operations. Specifically, in this work we explore and evaluate the available options for two of the most representative kernels of BLAS, i.e. GEMV and GEMM. The experimental evaluation is carried out in an Alveo U50 accelerator card from Xilinx and an Intel Xeon Silver multicore CPU. Our findings show that even in kernels where the CPU reaches better runtimes, the FPGA counterpart is more energy efficient.
Physics-Informed Neural Networks (PINNs) are machine learning tools that approximate the solution of general partial differential equations (PDEs) by adding them in some form as terms of the loss/cost function of a Neural Network. Most pieces of work in the area of PINNs tackle non-linear PDEs. Nevertheless, many interesting problems involving linear PDEs may benefit from PINNs; these include parametric studies, multi-query problems, and parabolic (transient) PDEs. The purpose of this paper is to explore PINNs for linear PDEs whose solutions may present one or more boundary layers. More specifically, we analyze the steady-state reaction-advection-diffusion equation in regimes in which the diffusive coefficient is small in comparison with the reactive or advective coefficients. We show that adding information about these coefficients as predictor variables in a PINN results in better prediction models than a PINN that only uses spatial information as predictor variables. Even though using these coefficients when training a PINN model is a common strategy for inverse problems, to the best of our knowledge we are the first to consider these coefficients for parametric direct problems. This finding may be instrumental in multiscale problems where the coefficients of the PDEs present high variability in small spatiotemporal regions of the domain, and therefore PINNs may be employed together with domain decomposition techniques to efficiently approximate the PDEs locally at each partition of the spatiotemporal domain, without resorting to different learned PINN models at each of these partitions.
