High-performance Code Research Articles

Physiological signal analysis and open science using the Julia language and associated software

In this mini review, we propose the use of the Julia programming language and its software as a strong candidate for reproducible, efficient, and sustainable physiological signal analysis. First, we highlight available software and Julia communities that provide top-of-the-class algorithms for all aspects of physiological signal processing despite the language’s relatively young age. Julia can significantly accelerate both research and software development due to its high-level interactive language and high-performance code generation. It is also particularly suited for open and reproducible science. Openness is supported and welcomed because the overwhelming majority of Julia software programs are open source and developed openly on public platforms, primarily through individual contributions. Such an environment increases the likelihood that an individual not (originally) associated with a software program would still be willing to contribute their code, further promoting code sharing and reuse. On the other hand, Julia’s exceptionally strong package manager and surrounding ecosystem make it easy to create self-contained, reproducible projects that can be instantly installed and run, irrespective of processor architecture or operating system.

Afpdb - an efficient structure manipulation package for AI protein design.

The advent of AlphaFold and other protein Artificial Intelligence (AI) models has transformed protein design, necessitating efficient handling of large-scale data and complex workflows. Using existing programming packages that predate recent AI advancements often leads to inefficiencies in human coding and slow code execution. To address this gap, we developed the Afpdb package. Afpdb, built on AlphaFold's NumPy architecture, offers a high-performance core. It uses RFDiffusion's contig syntax to streamline residue and atom selection, making coding simpler and more readable. Integrating PyMOL's visualization capabilities, Afpdb allows automatic visual quality control. With over 180 methods commonly used in protein AI design, which are otherwise hard to find, Afpdb enhances productivity in structural biology by supporting the development of concise, high-performance code. Code and documentation are available on GitHub (https://github.com/data2code/afpdb) and PyPI (https://pypi.org/project/afpdb). An interactive tutorial is accessible through Google Colab. Supplementary data are available at Bioinformatics online.

Accelerating Fortran codes: A method for integrating Coarray Fortran with CUDA Fortran and OpenMP

Fortran's prominence in scientific computing requires strategies to ensure both that legacy codes are efficient on high-performance computing systems, and that the language remains attractive for the development of new high-performance codes. Coarray Fortran (CAF), part of the Fortran 2008 standard introduced for parallel programming, facilitates distributed memory parallelism with a syntax familiar to Fortran programmers, simplifying the transition from single-processor to multi-processor coding. This research focuses on innovating and refining a parallel programming methodology that fuses the strengths of Intel Coarray Fortran, Nvidia CUDA Fortran, and OpenMP for distributed memory parallelism, high-speed GPU acceleration and shared memory parallelism respectively. We consider the management of pageable and pinned memory, CPU-GPU affinity in NUMA multiprocessors, and robust compiler interfacing with speed optimisation. We demonstrate our method through its application to a parallelised Poisson solver and compare the methodology, implementation, and scaling performance to that of the Message Passing Interface (MPI), finding CAF offers similar speeds with easier implementation. For new codes, this approach offers a faster route to optimised parallel computing. For legacy codes, it eases the transition to parallel computing, allowing their transformation into scalable, high-performance computing applications without the need for extensive re-design or additional syntax.

Deep video compression based on Long-range Temporal Context Learning

Video compression allows for efficient storage and transmission of data, benefiting imaging and vision applications, e.g. computational imaging, photography, and displays by delivering high-quality videos. To exploit more informative contexts of video, we propose DVCL, a novel Deep Video Compression based on Long-range Temporal Context Learning. Aiming at high coding performance, this new compression paradigm makes full use of long-range temporal correlations derived from multiple reference frames to learn richer contexts. Motion vectors (MVs) are estimated to represent the motion relations of videos. By employing MVs, a long-range temporal context learning (LTCL) module is presented to extract context information from multiple reference frames, such that a more accurate and informative temporal contexts can be learned and constructed. The long-range temporal contexts serve as conditions and generate the predicted frames by contextual encoder and decoder. To address the challenge of imbalanced training, we develop a multi-stage training strategy to ensure the whole DVCL framework is trained progressively and stably. Extensive experiments demonstrate the proposed DVCL achieves the highest objective and subjective quality, while maintaining relatively low complexity. Specifically, 25.30% and 45.75% bitrate savings on average can be obtained than x265 codec at the same PSNR and MS-SSIM, respectively.

Unfolding of the neutron spectrum in a nuclear reactor using genetic algorithms method

The objective of this paper is to present the results of the neutron spectrum unfolding using a high-performance code that we have developed, which is based on genetic algorithm. This paper presents the methodology used for neutron spectrum unfolding and describes the general architecture of our developed code. It also includes results of neutron spectrum unfolding in the case of the ARC-700 reactor using our genetic algorithm-based code and using an iterative method. In order to evaluate and validate our code, a comparison between reference values and results obtained using the iterative and genetic algorithm methods was presented. The comparison is performed both at the spectra as well as at the reproduced activation scale. This comparison shows a very good agreement between the results obtained using our code and the reference values and also shows a clear distinction of the genetic algorithm method compared with the iterative method. This validation shows that our code can be successfully used for neutron spectra unfolding in nuclear reactors using the activation detectors approach.

The QISG suite: High-performance codes for studying quantum Ising spin glasses

We release a set of GPU programs for the study of the Quantum (S=1/2) Spin Glass on a square lattice, with binary couplings. The library contains two main codes: MCQSG (that carries out Monte Carlo simulations using both the Metropolis and the Parallel Tempering algorithms, for the problem formulated in the Trotter-Suzuki approximation), and EDQSG (that obtains the extremal eigenvalues of the Transfer Matrix using the Lanczos algorithm). EDQSG has allowed us to diagonalize transfer matrices with size up to 236×236. From its side, MCQSG running on four NVIDIA A100 cards delivers a sub-picosecond time per spin-update, a performance that is competitive with dedicated hardware. We include as well in our library GPU programs for the analysis of the spin configurations generated by MCQSG. Finally, we provide two auxiliary codes: the first generates the lookup tables employed by the random number generator of MCQSG; the second one simplifies the execution of multiple runs using different input data. Program summaryProgram Title: QISG SuiteCPC Library link to program files:https://doi.org/10.17632/g97sn2t8z2.1Licensing provisions: MITProgramming language: CUDA-CNature of problem: The critical properties of quantum disordered systems are known only in a few, simple, cases whereas there is a growing interest in gaining a better understanding of their behaviour due to the potential application of quantum annealing techniques for solving optimization problems. In this context, we provide a suite of codes, that we have recently developed, to the purpose of studying the 2D Quantum Ising Spin Glass.Solution method: We provide a highly tuned multi-GPU code for the Montecarlo simulation of the 2D QISG based on a combination of Metropolis and Parallel Tempering algorithms. Moreover, we provide a code for the evaluation of the eigenvalues of the transfer matrix of the 2D QISG for size up to L=6. The eigenvalues are computed by using the classic Lanczos algorithm that, however, relies on a custom multi-GPU-CPU matrix-vector product that speeds-up dramatically the execution of the algorithm.

Program generation meets program verification: A case study on number-theoretic transform

Program generation allows us to produce high-performance code specialized to each application domain. Although it has had great success in various domains, it remains to be seen whether it is effective for cryptography, where the correctness of programs is indispensable.This work presents a unified approach to program generation, analysis, and verification. Our target is Number-Theoretic Transform (NTT), a key building block of several candidates in Post Quantum Cryptography. We developed a program-generation framework based on the typed tagless-final style, and obtained highly efficient implementations with vector instructions such as AVX2 and AVX-512. The framework allows us to implement a program analyzer for integer-overflow analysis. By combining a brute-force analysis with the standard static interval analysis, we have obtained more precise results than the state-of-the-art static analyzer, which let us find a new optimization.We have verified the generated program using the framework. While verifying the generated program all at once is intractable, we can separately verify the low-level components and the high-level algorithm, thanks to the compositional nature of our program generator. We have used an SMT solver for the former and a custom symbolic interpreter for the latter to prove the functional correctness of the generated program successfully.

The General Atomic and Molecular Electronic Structure System (GAMESS): Novel Methods on Novel Architectures.

The primary focus of GAMESS over the last 5 years has been the development of new high-performance codes that are able to take effective and efficient advantage of the most advanced computer architectures, both CPU and accelerators. These efforts include employing density fitting and fragmentation methods to reduce the high scaling of well-correlated (e.g., coupled-cluster) methods as well as developing novel codes that can take optimal advantage of graphical processing units and other modern accelerators. Because accurate wave functions can be very complex, an important new functionality in GAMESS is the quasi-atomic orbital analysis, an unbiased approach to the understanding of covalent bonds embedded in the wave function. Best practices for the maintenance and distribution of GAMESS are also discussed.

Performance analysis of Polar Codes in a Visible Light Communication System

One of the vital entity of any communication systems is Channel coding, which leads to the design of high performance codes for future wireless systems having low complexity encoder and decoder design. These systems will have a requirement of operating in highly reliable conditions, maximum throughput, and low and high code rates and to work with short and long information messages. Polar codes are one of the promising error correcting channel codes that can be used in these situations to obtain maximum throughput and coding gain in a communication systems because of their capacity approaching performance and finds interests in Satellite communication and 4G/5G services. These codes uses the concept of channel polarization to be constructed. The work proposed in this paper focusses on the Bit Error Rate evaluation and analysis of the Polar codes using traditional approach and Deep learning approach. The feedforward deep learning networks using different activation functions were used for the Deep learning approach. The Successive Cancellation algorithm and its variant using List decoding were used as traditional decoding methodology. The results obtained using Deep learning approach were satisfactory and was matching as per the traditional decoding.

Autotuning Convolutions Is Easier Than You Think

A wide range of scientific and machine learning applications depend on highly optimized implementations of tensor computations. Exploiting the full capacity of a given processor architecture remains a challenging task, due to the complexity of the microarchitectural features that come into play when seeking near-peak performance. Among the state-of-the-art techniques for loop transformations for performance optimization, AutoScheduler [Zheng et al. 2020a ] tends to outperform other systems. It often yields higher performance as compared to vendor libraries, but takes a large number of runs to converge, while also involving a complex training environment. In this article, we define a structured configuration space that enables much faster convergence to high-performance code versions, using only random sampling of candidates. We focus on two-dimensional convolutions on CPUs. Compared to state-of-the-art libraries, our structured search space enables higher performance for typical tensor shapes encountered in convolution stages in deep learning pipelines. Compared to auto-tuning code generators like AutoScheduler, it prunes the search space while increasing the density of efficient implementations. We analyze the impact on convergence speed and performance distribution, on two Intel x86 processors and one ARM AArch64 processor. We match or outperform the performance of the state-of-the-art oneDNN library and TVM’s AutoScheduler, while reducing the autotuning effort by at least an order of magnitude.

Efficient and portable Winograd convolutions for multi-core processors

We take a step forward towards developing high-performance codes for the convolution operator, based on the Winograd algorithm, that are easy to customise for general-purpose processor architectures. In our approach, augmenting the portability of the solution is achieved via the introduction of vector instructions from Intel SSE/AVX2/AVX512 and ARM NEON/SVE to exploit the single-instruction multiple-data capabilities of current processors as well as OpenMP pragmas to exploit multi-threaded parallelism. While this comes at the cost of sacrificing a fraction of the computational performance, our experimental results on three distinct processors, with Intel Xeon Skylake, ARM Cortex A57 and Fujitsu A64FX processors, show that the impact is affordable and still renders a Winograd-based solution that is competitive when compared with the lowering gemm-based convolution.

High-Performance Computation of the Number of Nested RNA Structures with 3D Parallel Tiled Code

Many current bioinformatics algorithms have been implemented in parallel programming code. Some of them have already reached the limits imposed by Amdahl’s law, but many can still be improved. In our paper, we present an approach allowing us to generate a high-performance code for calculating the number of RNA pairs. The approach allows us to generate parallel tiled code of the maximal dimension of tiles, which for the discussed algorithm is 3D. Experiments carried out by us on two modern multi-core computers, an Intel(R) Xeon(R) Gold 6326 (2.90 GHz, 2 physical units, 32 cores, 64 threads, 24 MB Cache) and Intel(R) i7(11700KF (3.6 GHz, 8 cores, 16 threads, 16 MB Cache), demonstrate a significant increase in performance and scalability of the generated parallel tiled code. For the Intel(R) Xeon(R) Gold 6326 and Intel(R) i7, target code speedup increases linearly with an increase in the number of threads. An approach presented in the paper to generate target code can be used by programmers to generate target parallel tiled code for other bioinformatics codes whose dependence patterns are similar to those of the code implementing the counting algorithm.

Performance–energy trade-offs of deep learning convolution algorithms on ARM processors

In this work, we assess the performance and energy efficiency of high-performance codes for the convolution operator, based on the direct, explicit/implicit lowering and Winograd algorithms used for deep learning (DL) inference on a series of ARM-based processor architectures. Specifically, we evaluate the NVIDIA Denver2 and Carmel processors, as well as the ARM Cortex-A57 and Cortex-A78AE CPUs as part of a recent set of NVIDIA Jetson platforms. The performance–energy evaluation is carried out using the ResNet-50 v1.5 convolutional neural network (CNN) on varying configurations of convolution algorithms, number of threads/cores, and operating frequencies on the tested processor cores. The results demonstrate that the best throughput is obtained on all platforms with the Winograd convolution operator running on all the cores at their highest frequency. However, if the goal is to reduce the energy footprint, there is no rule of thumb for the optimal configuration.

C++ Unveiled: A Scholarly Expedition into the Integration of Procedural and Object-Oriented Paradigms

C++ is a programming language famous for its diversity, efficiency, and durability. C++, an extension of C, lets developers construct efficient, modular, high-performance Code by combining procedural and object-oriented concepts. This comprehensive C++ language guide covers its fundamentals, advanced capabilities, and real-world applications. Advanced C++ technologies like templates and the Standard Template Library (STL) are explored to learn generic programming and use pre-built components for productivity. Exception handling is simplified with comprehensive error management and best practices. This article guides us through C++'s journey from the C language to its current status as a powerful, versatile programming tool. This guide is for developers who want to learn C++ and use it in various programming applications, not only beginners.

Accelerating turbulent reacting flow simulations on many-core/GPUs using matrix-based kinetics

The present work assesses the impact - in terms of time to solution, throughput analysis, and hardware scalability - of transferring computationally intensive tasks, found in compressible reacting flow solvers, to the GPU. Attention is focused on outlining the workflow and data transfer penalties associated with “plugging in” a recently developed GPU-based chemistry library into (a) a purely CPU-based solver and (b) a GPU-based solver, where, except for the chemistry, all other variables are computed on the GPU. This comparison allows quantification of host-to-device (and vice versa) data transfer penalties on the overall solver speedup as a function of mesh and reaction mechanism size. To this end, a recently developed GPU-based chemistry library known as UMChemGPU is employed to treat the kinetics in the flow solver KARFS. UMChemGPU replaces conventional CPU-based Cantera routines using a matrix-based formulation. The impact of i) data transfer times, ii) chemistry acceleration, and iii) the hardware architecture is studied in detail in the context of GPU saturation limits. Hydrogen and dimethyl ether (DME) reaction mechanisms are used to assess the impact of the number of species/reactions on overall/chemistry-only speedup. It was found that offloading the source term computation to UMChemGPU results in up to 7X reduction in overall time to solution and four orders of magnitude faster source term computation compared to conventional CPU-based methods. Furthermore, the metrics for achieving maximum performance gain using GPU chemistry with an MPI + CUDA solver are explained using the Roofline model. Integrating the UMChemGPU with an MPI + OpenMP solver does not improve the overall performance due to the associated data copy time between the device (GPU) and host (CPU) memory spaces. The performance portability was demonstrated using three different GPU architectures, and the findings are expected to translate to a wide variety of high-performance codes in the combustion community.

Heat mining from super-hot horizons of the Larderello geothermal field, Italy

Super-hot rock geothermal is an emerging source of renewable and carbon-free energy. This paper is the first attempt to explore fluid and heat flow dynamics in the reservoir-wellbore coupled system, to assess the power generation performance of a super-hot (>450 °C) enhanced geothermal system (EGS). We developed a high-performance code and built a 3-D wellbore-reservoir coupled model based on data from a recently completed deep-drilling project at Larderello, Italy. The general pattern of the super-hot EGS is characterized by a significant temperature plummet (>60 °C), after which the production fluid evolves from steam to a two-phase mixture till the end of the operation period. Reservoir pressure emerges as a key parameter to determine the temperature of the two-phase mixture. By realistically capturing phase transitions driven by coupled thermo-hydraulic processes during operations, our numerical model predicts a lower power generation efficiency compared to previous attempts based on ultra-simplified models. Although finalized at assessing the thermodynamic viability of a specific system, this modeling approach provides general information on fundamental thermo-hydraulic processes in the Earth crust that might be applied for the design of similar EGS projects elsewhere.

Metrics and Algorithms for Designing Convolutional Codes With Unequal Error Protection

We consider multi-input convolutional codes with unequal error protection (UEP) among the inputs. Using conventional metrics including the free input distance and free input sum weight as a measure for UEP degree, we design efficient and optimal algorithms to evaluate these metrics for any number of inputs. Next, we discuss several ambiguities arisen from using these metrics to estimate convolutional code UEP property and propose two new metrics, the average weight per path and the ant colony system UEP (ACS-UEP) index. The ACS-UEP index can accurately and consistently capture UEP properties over all ranges of SNR. Using these metrics, we propose an algorithmic process for designing convolutional codes with bounded external degree complexity to minimize a weighted sum of input error probabilities. We analyze the effectiveness of the design approach and show significant improvements over existing UEP convolutional code designing approach in terms of both the absolute and UEP input error protections. Our proposed algorithms for designing multi-input convolutional codes with UEP are flexible, adaptable, and provide high performance codes within the specified complexity.

A high-performance code for EPRL spin foam amplitudes

We present sl2cfoam-next, a high-performance software library for computing Lorentzian EPRL spin foam amplitudes. The library improves on previous codes by many orders of magnitude in single-core performance, can be parallelized on a large number of CPUs and on the GPU, and can be used interactively. We describe the techniques used in the code and provide many usage examples. As first applications, we use sl2cfoam-next to complete the numerical test of the Lorentzian single-vertex asymptotics and to confirm the presence of the ‘flatness problem’ of spin foam models in the BF and EPRL cases.

PySPH: A Python-based Framework for Smoothed Particle Hydrodynamics

PySPH is an open-source, Python-based, framework for particle methods in general and Smoothed Particle Hydrodynamics (SPH) in particular. PySPH allows a user to define a complete SPH simulation using pure Python. High-performance code is generated from this high-level Python code and executed on either multiple cores, or on GPUs, seamlessly. It also supports distributed execution using MPI. PySPH supports a wide variety of SPH schemes and formulations. These include, incompressible and compressible fluid flow, elastic dynamics, rigid body dynamics, shallow water equations, and other problems. PySPH supports a variety of boundary conditions including mirror, periodic, solid wall, and inlet/outlet boundary conditions. The package is written to facilitate reuse and reproducibility. This article discusses the overall design of PySPH and demonstrates many of its features. Several example results are shown to demonstrate the range of features that PySPH provides.

Idealised 3D simulations of diabatically forced Ledoux convection

Aims.We investigate the impact of dimensionality, resolution, and long timescales on convective numerical simulations forced by thermo-compositional diabatic processes. We focus our study on simulations that are stable to the Schwarzschild criterion but unstable to the Ledoux one (i.e. simulations with a stabilising temperature gradient and a destabilising mean-molecular-weight gradient). We aim to establish the possibility of a reduced temperature gradient in such setups.Methods.A suite of 3D simulations incorporating both time series and convergence studies were conducted using a high-performance numerical hydrodynamic code. We used, as a simplified and idealised test case, a sample region of the secondary atmosphere of a hot rocky exoplanet, of the order of the scale height of the system, within which the chemical transition CO + O ↔ CO2could occur. Newtonian cooling was employed to force an equilibrium temperature, and a chemical source term was used to maintain a negative mean-molecular-weight gradient in the vertical direction.Results.Our results demonstrate that a mean-molecular-weight gradient and a chemical source term can reduce the atmosphere temperature gradient, a result that does not converge away with resolution and is stable when exploring long timescales. Simulations in two dimensions are prone to the development of shear modes, as already seen in the literature for double-diffusive convection. The 3D convective steady state is not impacted by these shear modes, suggesting that this phenomenon is linked to the dimensionality of the problem. We also show that the presence of the reduced temperature gradient is a function of the forcing timescales, disappearing if the chemical forcing is too slow. We find that the above transition leads to a bifurcation of the atmosphere’s temperature profile when the chemical forcing is fast. Such a bifurcation is reminiscent of the bifurcation seen in the boiling crisis for steam or liquid convection.Conclusions.With the reduced temperature gradient in these idealised setups, there exists the possibility of an analogy of the reddening (currently observed in the spectra of brown dwarfs) in the spectra of rocky exoplanet atmospheres. This possibility needs, however, to be checked with detailed 1D models in order to precisely characterise the equilibrium thermal and compositional gradients, the thermal and compositional forcing timescales, and the impact of a realistic equation of state to, in turn, assess if the regime identified here will develop in realistic situations. However, the possibility of this reddening cannot be excluded a priori. This prediction is new for terrestrial atmospheres and represents strong motivation for the use of diabatic models when analysing the atmospheric spectra of rocky exoplanets that will be observed with, for example, theJames WebbSpace Telescope.