Search

Large language models have sparked a lot of attention in the research community in recent days, especially with the introduction of practical tools such as ChatGPT and Github Copilot. Their ability to solve complex programming tasks was also shown in several studies and commercial solutions increasing the interest in using them for software development in different fields. High performance computing is one of such fields, where parallel programming techniques have been extensively used to utilize raw computing power available in contemporary multicore and manycore processors. In this paper, we perform an evaluation of the ChatGPT and Github Copilot tools for OpenMP-based code parallelization using a proposed methodology. We used nine different benchmark applications which represent typical parallel programming workloads and compared their OpenMP-based parallel solutions produced manually and using ChatGPT and Github Copilot in terms of obtained speedup, applied optimizations, and quality of the solution. ChatGPT 3.5 and Github Copilot installed with Visual Studio Code 1.88 were used. We concluded that both tools can produce correct parallel code in most cases. However, performance-wise, ChatGPT can match manually produced and optimized parallel code only in simpler cases, as it lacks a deeper understanding of the code and the context. The results are much better with Github Copilot, where much less effort is needed to obtain correct and performant parallel solution. [ABSTRACT FROM AUTHOR]

Background: Magnetic Resonance Imaging (MRI) is a highly demanded medical imaging system due to high resolution, large volumetric coverage, and ability to capture the dynamic and functional information of body organs e.g. cardiac MRI is employed to assess cardiac structure and evaluate blood flow dynamics through the cardiac valves. Long scan time is the main drawback of MRI, which makes it difficult for the patients to remain still during the scanning process. Objective: By collecting fewer measurements, MRI scan time can be shortened, but this undersampling causes aliasing artifacts in the reconstructed images. Advanced image reconstruction algorithms have been used in literature to overcome these undersampling artifacts. These algorithms are computationally expensive and require a long time for reconstruction which makes them infeasible for real-time clinical applications e.g. cardiac MRI. However, exploiting the inherent parallelism in these algorithms can help to reduce their computation time. Methods: Low-rank plus sparse (L+S) matrix decomposition model is a technique used in literature to reconstruct the highly undersampled dynamic MRI (dMRI) data at the expense of long reconstruction time. In this paper, Compressed Singular Value Decomposition (cSVD) model is used in L+S decomposition model (instead of conventional SVD) to reduce the reconstruction time. The results provide improved quality of the reconstructed images. Furthermore, it has been observed that cSVD and other parts of the L+S model possess highly parallel operations; therefore, a customized GPU based parallel architecture of the modified L+S model has been presented to further reduce the reconstruction time. Results: Four cardiac MRI datasets (three different cardiac perfusion acquired from different patients and one cardiac cine data), each with different acceleration factors of 2, 6 and 8 are used for experiments in this paper. Experimental results demonstrate that using the proposed parallel architecture for the reconstruction of cardiac perfusion data provides a speed-up factor up to 19.15× (with memory latency) and 70.55× (without memory latency) in comparison to the conventional CPU reconstruction with no compromise on image quality. Conclusion: The proposed method is well-suited for real-time clinical applications, offering a substantial reduction in reconstruction time. [ABSTRACT FROM AUTHOR]

Nearly 20 years after the birth of general-purpose GPU computing, the HPC landscape is now dominated by GPUs. After years of undisputed dominance by NVIDIA, new players have entered the arena in a convincing manner, namely AMD and more recently Intel, whose devices currently power the first two clusters in the Top500 ranking. Unfortunately, code porting is still a major problem, even more due to the presence of different vendors, but at the same time the emergence of simplified standard paradigms suggests an encouraging prospect for developers. In this work, we provide a detailed OpenMP porting strategy of STREAmS, a community code for the compressible fluid dynamics. The proposed porting technique is based on the offload functionality of the OpenMP 5.x paradigm and in particular on a hybrid directives/APIs approach that fits seamlessly into the multi-backend software ecosystem of STREAmS. We further carry out a comprehensive performance analysis on the Intel® Data Center GPU Max 1550 (formerly called Ponte Vecchio or PVC). In addition, we analyze the performance of the code on two benchmark clusters powered by PVC, including the exascale Aurora cluster. The performance is evaluated at different levels of parallelism involved, i.e., the intrinsic parallelism of the PVC tile, the inter-tile parallelism within the GPU configuration, between the GPUs within the node and between the nodes within the cluster. The analysis shows that although the implementation complexity of the OpenMP porting is limited, it is necessary to follow some important guidelines to achieve satisfactory performance. The PVC GPU shows about 40% higher performance than the NVIDIA A100 or AMD MI250X GPUs, which, however, were released about 3 years earlier. Both intra-node and internode scalability show good results. Overall, the introduction of PVC into the GPU computing HPC landscape represents a positive step forward for the diversification and competitiveness of the sector. [ABSTRACT FROM AUTHOR]

Data-parallel computations, such as linear algebra routines and stencil computations, constitute one of the most relevant classes in parallel computing, e.g., due to their importance for deep learning. Efficiently de-composing such computations for the memory and core hierarchies of modern architectures and re-composing the computed intermediate results back to the final result—we say (de/re)-composition for short—is key to achieve high performance for these computations on, e.g., GPU and CPU. Current high-level approaches to generating data-parallel code are often restricted to a particular subclass of data-parallel computations and architectures (e.g., only linear algebra routines on only GPU or only stencil computations), and/or the approaches rely on a user-guided optimization process for a well-performing (de/re)-composition of computations, which is complex and error prone for the user. We formally introduce a systematic (de/re)-composition approach, based on the algebraic formalism of Multi-Dimensional Homomorphisms (MDHs). Our approach is designed as general enough to be applicable to a wide range of data-parallel computations and for various kinds of target parallel architectures. To efficiently target the deep and complex memory and core hierarchies of contemporary architectures, we exploit our introduced (de/re)-composition approach for a correct-by-construction, parametrized cache blocking, and parallelization strategy. We show that our approach is powerful enough to express, in the same formalism, the (de/re)-composition strategies of different classes of state-of-the-art approaches (scheduling-based, polyhedral, etc.), and we demonstrate that the parameters of our strategies enable systematically generating code that can be fully automatically optimized (auto-tuned) for the particular target architecture and characteristics of the input and output data (e.g., their sizes and memory layouts). Particularly, our experiments confirm that via auto-tuning, we achieve higher performance than state-of-the-art approaches, including hand-optimized solutions provided by vendors (such as NVIDIA cuBLAS/cuDNN and Intel oneMKL/oneDNN), on real-world datasets and for a variety of data-parallel computations, including linear algebra routines, stencil and quantum chemistry computations, data mining algorithms, and computations that recently gained high attention due to their relevance for deep learning. [ABSTRACT FROM AUTHOR]

As one of the hot spots in virtual process engineering research in materials, the molecular dynamics of silicon crystal is simulated using Tersoff multi-body potential. In the multi-body potential, the interaction between particles is computationally intensive, and there are dependencies between data. Efficient and accurate large-scale simulation on parallel architectures faces two challenges: write conflict and low computational efficiency. To address these issues, a series of optimization methods tailored for silicon crystal molecular dynamics applications have been implemented based on the OpenMP sharedmemory programming model to enhance simulation efficiency: (1)In the process of large-scale threadlevel parallel simulation, the spatial decomposition graph coloring idea is used to eliminate the data dependence between particles and effectively solve the problem of write conflict; (2)For the core computing program segment, the overall vectorization is used to improve the computational efficiency, and the series estimation is used to realize the transcendental function to achieve the parallel optimization of multi-body potential Tersoff on multi-core processors. The experimental results show that the Tersoff potential has good optimization potential on the X86 platform, and the spatial decomposition graph coloring and vectorization are feasible and scalable for silicon crystal application, which can effectively solve the write conflict caused by data intersection and computationally intensive optimization problems, and the speedup of final result can reach 23.17. [ABSTRACT FROM AUTHOR]

The Clacc project has developed OpenACC compiler, runtime, and profiling interface support for C/C++ by extending Clang and LLVM. A key Clacc design feature is that it translates OpenACC to OpenMP to leverage the OpenMP offloading support that is actively being developed for Clang and LLVM. A benefit of this design is support for two compilation modes: traditional compilation mode produces a binary, and source-to-source mode produces OpenMP source. Clacc has been deployed on Oak Ridge National Laboratory's (ORNL's) Frontier, on which Clacc is the only OpenACC implementation for C/C++. Clacc supports x86_64, POWER9, AMD GPUs, and NVIDIA GPUs. Clacc's OpenACC profiling interface support has been integrated with TAU, which is also deployed on Frontier. While Clacc has always supported C as a base language, Clacc also has increasing C++ support, including support for Kokkos's OpenACC back end. Clacc itself is hosted publicly on GitHub. In this paper, we describe Clacc's design and mapping from OpenACC directives to OpenMP. We also present a performance evaluation on ORNL's Frontier (AMD MI250x GPU offload) and Argonne National Laboratory's (ANL's) Polaris (NVIDIA A100 GPU offload) for various SPEC ACCEL and Kokkos OpenACC back end benchmarks. [ABSTRACT FROM AUTHOR]

To perform the stability analysis of soil slopes, the traditional limit equilibrium method (LEM) based on geostresses calculated by the standard finite element method (LEM-FEM) appears to be competitive. In LEM-FEM, the stress variables are stored at the Gaussian points within each element, so stress interpolation from the Gaussian points for each line segment of trial slip surfaces shall be inefficient for stability analysis of soil slope. To improve the accuracy and efficiency of stress interpolation, an implicit stabilized node-based smoothed finite element method (NsFEMstab) in conjunction with 3-node triangular (T3) elements, in which stress variables are stored at the element nodes, is implemented to calculate the stresses at each line segment. Furthermore, a novel method of LEM-NsFEMstab is developed by replacing the standard FEM in LEM-FEM with NsFEMstab. Based on four plane-strain slope examples, the stability analysis results disclose that the factor of safety (FOS) and the slip surfaces predicted by LEM-NsFEMstab agree well with those predicted by LEM-FEM in conjunction with 6-node triangular (T6) elements. Additionally, the search of the critical slip surface is accelerated using the OpenMP parallel platform. Compared to the serial implementation of LEM-FEM(T6) and the serial implementation of LEM-NsFEMstab, the computational efficiency of the parallel version of LEM-NsFEMstab may be increased by 5~7 and 4~6 times, respectively, and based on comparisons of threads parallel performance, it is found that one half of the total number of CPU threads can be utilized to achieve optimal computational efficiency. [ABSTRACT FROM AUTHOR]

We investigate the OpenMP parallelization and optimizationof two novel data classification algorithms. The new algorithms arebased on graph and PDE solution techniques and provide significant accuracy and performance advantages over traditional data classificationalgorithms in serial mode. The methods leverage the Nystrom extensionto calculate eigenvalue/eigenvectors of the graph Laplacian and thisis a self-contained module that can be used in conjunction with othergraph-Laplacian based methods such as spectral clustering. We use performancetools to collect the hotspots and memory access of the serialcodes and use OpenMP as the parallelization language to parallelize themost time-consuming parts. Where possible, we also use library routines.We then optimize the OpenMP implementations and detail the performanceon traditional supercomputer nodes (in our case a Cray XC30),and test the optimization steps on emerging testbed systems based on Intel’sKnights Corner and Landing processors. We show both performanceimprovement and strong scaling behavior. A large number of optimizationtechniques and analyses are necessary before the algorithm reachesalmost ideal scaling.

Abstract Large language models have sparked a lot of attention in the research community in recent days, especially with the introduction of practical tools such as ChatGPT and Github Copilot. Their ability to solve complex programming tasks was also shown in several studies and commercial solutions increasing the interest in using them for software development in different fields. High performance computing is one of such fields, where parallel programming techniques have been extensively used to utilize raw computing power available in contemporary multicore and manycore processors. In this paper, we perform an evaluation of the ChatGPT and Github Copilot tools for OpenMP-based code parallelization using a proposed methodology. We used nine different benchmark applications which represent typical parallel programming workloads and compared their OpenMP-based parallel solutions produced manually and using ChatGPT and Github Copilot in terms of obtained speedup, applied optimizations, and quality of the solution. ChatGPT 3.5 and Github Copilot installed with Visual Studio Code 1.88 were used. We concluded that both tools can produce correct parallel code in most cases. However, performance-wise, ChatGPT can match manually produced and optimized parallel code only in simpler cases, as it lacks a deeper understanding of the code and the context. The results are much better with Github Copilot, where much less effort is needed to obtain correct and performant parallel solution.

Network telemetry plays a pivotal role in understanding and optimizing underlying network infrastructures by facilitating essential operations like troubleshooting and traffic load balancing. However, real-time processing of network packets, especially at speeds of 100 Gbps or more, presents significant challenges due to the uncoordinated processing performance between kernel and user-space applications. This study introduces high-performance telemetry collector (HPTCollector) aims at harmonizing the processing activities of kernel and user-space applications, thereby enhancing the performance of network telemetry systems. HPTCollector demonstrates exceptional adaptability and efficiency, achieving remarkable throughput rates. Specifically, our mechanism can process up to 31 million packets per second using just 12 CPU cores in user-space, an achievement made possible through parallel packet processing techniques. This capability ensures robust support for network telemetry processing at collector for network infrastructures with bandwidth of 350 Gbps and 2.03 Tbps, MTU size of 1500 and 9000 respectively. This breakthrough not only showcases the potential of our proposed mechanism but also sets a new benchmark in network telemetry collector performance. [ABSTRACT FROM AUTHOR]

Este trabalho é dedicado à simulação numérica do escoamento de gás natural em reservatórios não convencionais na presença dos efeitos de adsorção e escorregamento. Uma formulação numérica totalmente implícita, utilizando o método Control Volume Finite Difference (CVFD), foi adotada tendo em vista a resolução numérica da equação diferencial parcial não linear que governa o escoamento da fase gás. O método dos Gradientes Conjugados foi utilizado na solução do sistema de equações algébricas obtidas a partir do processo de discretização. A fim de melhorar a eficiência computacional, a Application Programming Interface (API) Open Multi-Processing (OpenMP) foi empregada na paralelização do método dos Gradientes Conjugados. Uma análise de sensibilidade foi realizada e mostrou-se que foi possível alcançar, para as simulações consideradas, valores de speedup superiores a 5.

The necessity of parallel programming for leveraging the full potential of modern multicore processors cannot be overstated. One of the fundamental algorithms used extensively across a multitude of fields is the array sum reduction algorithm. This algorithm is pivotal in scenarios requiring the aggregation of array elements, a task that can benefit significantly from parallel processing techniques. Implementing the array sum reduction algorithm on a multiprocessor system can be approached using various parallel programming models. This paper delves into a comparative analysis of two prominent parallel programming approaches for the array sum reduction algorithm on a shared memory microprocessor environment. We explore the implementation and performance characteristics of C with OpenMP, a well-established and widely adopted parallel programming model in the C programming ecosystem, and C# with Parallel.For, a robust and flexible parallel programming framework within the .NET environment. Our analysis involves a rigorous empirical evaluation and benchmarking process to assess the execution efficiency, scalability, and ease of implementation associated with each approach. By systematically examining these factors, we aim to elucidate the specific contexts and application scenarios where each parallel programming paradigm excels or may present limitations. Furthermore, we consider the development overhead and learning curve associated with adopting these technologies, providing a holistic view of their practicality in real-world applications. In addition to performance metrics, we examine the debugging and maintenance complexities that developers may encounter when working with these paradigms. We also assess the extent to which each approach supports advanced parallelism features such as task parallelism and load balancing. Another important aspect of our study is the interoperability of these programming models with other tools and libraries commonly used in high-performance computing. Through this comparative study, we seek to provide developers and researchers with a comprehensive understanding of the trade-offs involved in selecting between C with OpenMP and C# with Parallel.For. The insights garnered from our evaluation will aid in making informed decisions, ensuring optimal performance and resource utilization in parallel programming applications tailored to modern multicore processors. Ultimately, our findings contribute to the broader discourse on parallel computing best practices and the future directions of parallel algorithm development. Our results aim to serve as a reference point for future research, highlighting potential areas for enhancement in both programming models. We hope to inspire further innovation in parallel computing techniques, fostering advancements that can lead to more efficient and scalable software solutions. [ABSTRACT FROM AUTHOR]

Summary: The breadth‐first search procedure is an algorithm that traverses the vertices of a graph, determining the distance from each vertex to the initial vertex. The distance is infinite for a non‐reachable vertex from the starting vertex. Despite having an efficient serial version, this important algorithm is irregular, making its effective parallel implementation a daunting task. This paper shows the results of an OpenMP‐based implementation of the breadth‐first search procedure using the bag data structure. Furthermore, the code relied on the C++ programming language. This paper reimplements an existing proposal coded using the Cilk++ programming language. The experiments relied on 32 strongly connected graphs and 31 disconnected graphs in executions performed on two machines. The first machine contained 28 cores and two threads per core. The second machine comprised 48 processing cores, with hyperthreading disabled. Regarding the serial version, the parallel implementation yielded a speedup of up to 20× when using 28 processing cores and up to 25× when using 56 threads in tests performed on a machine with the first generation of Intel® Xeon® Scalable processors. Furthermore, the new parallel implementation yielded speedups of up to 45× when using 48 cores in experiments performed on a machine with the second generation of Intel® Xeon® Scalable processors. [ABSTRACT FROM AUTHOR]

Summary: The Oak Ridge Leadership Computing Facility (OLCF) has a long history of supporting and promoting GPU‐accelerated computing starting with the deployment of the Titan supercomputer in 2021 and continuing with the Summit supercomputer which has a theoretical peak performance of approximately 200 petaflops. Because the majority of Summit's computational power comes from its 27,972 GPUs, users must port their applications to one of the supported programming models in order to make efficient use of the system. To prepare the transition to Frontier, the OLCF's exascale supercomputer, users will need to adapt to an entirely new ecosystem which will include new hardware and software technologies. First, users will need to familiarize themselves with the AMD Radeon GPU architecture. Furthermore, users who have been previously relying on CUDA will need to transition to the Heterogeneous‐Computing Interface for Portability (HIP) or one of the other supported programming models (e.g., OpenMP, OpenACC). In this work, we describe our initial experiences and lessons learned in porting three applications or proxy apps currently running on Summit to the HPE/Cray ecosystem to leverage the compute power from AMD GPUs: minisweep, GenASiS, and Sparkler. Each one is representative of current production workloads utilized at the OLCF, different programming languages, and different programming models. [ABSTRACT FROM AUTHOR]

The discovery of Allele-Specific Methylation (ASM) is an important research field in biology as it regulates genomic imprinting, which has been identified as the cause of some genetic diseases. Nevertheless, the high computational cost of the bioinformatic tools developed for this purpose prevents their application to large-scale datasets. Hence, much faster tools are required to further progress in this research field. In this work we present PARamrfinder, a parallel tool that applies a statistical model to identify ASM in data from high-throughput short-read bisulfite sequencing. It is based on the state-of-the-art sequential tool amrfinder, which is able to detect ASM at regional level from Bisulfite Sequencing (BS-Seq) experiments in the absence of Single Nucleotide Polymorphism information. PARamrfinder provides the same Allelically Methylated Regions as amrfinder but at significantly reduced runtime thanks to exploiting the compute capabilities of common multicore CPU clusters and MPI RMA operations to attain an efficient dynamic workload balance. As an example, our tool is up to 567 times faster for real data experiments on a cluster with 8 nodes, each one containing two 16-core processors. The source code of PARamrfinder, as well as a reference manual, is available at https://github.com/UDC-GAC/PARamrfinder. [ABSTRACT FROM AUTHOR]

In this research, we present the pure open multi-processing (OpenMP), pure message passing interface (MPI), and hybrid MPI/OpenMP parallel solvers within the dynamic explicit central difference algorithm for the coining process to address the challenge of capturing fine relief features of approximately 50 microns. Achieving such precision demands the utilization of at least 7 million tetrahedron elements, surpassing the capabilities of traditional serial programs previously developed. To mitigate data races when calculating internal forces, intermediate arrays are introduced within the OpenMP directive. This helps ensure proper synchronization and avoid conflicts during parallel execution. Additionally, in the MPI implementation, the coins are partitioned into the desired number of regions. This division allows for efficient distribution of computational tasks across multiple processes. Numerical simulation examples are conducted to compare the three solvers with serial programs, evaluating correctness, acceleration ratio, and parallel efficiency. The results reveal a relative error of approximately 0.3% in forming force among the parallel and serial solvers, while the predicted insufficient material zones align with experimental observations. Additionally, speedup ratio and parallel efficiency are assessed for the coining process simulation. The pureMPI parallel solver achieves a maximum acceleration of 9.5 on a single computer (utilizing 12 cores) and the hybrid solver exhibits a speedup ratio of 136 in a cluster (using 6 compute nodes and 12 cores per compute node), showing the strong scalability of the hybrid MPI/OpenMP programming model. This approach effectively meets the simulation requirements for commemorative coins with intricate relief patterns. [ABSTRACT FROM AUTHOR]

Image enhancement is frequently used to improve the input image's visual quality. Experts also utilize image enhancement as a preprocessing method rather than a complete solution in computer vision applications. In addition, consumers want to acquire digital images with good real-life contrast, which balances the number of pixels with darker and brighter intensity values. Unfortunately, acquired images become too dark or bright to inspect visually due to bad lighting or unwanted reflections. These undesired images may cause problems in applications such as medical imaging, satellite imagery, or UAV imaging. Therefore, this study introduces an image enhancement method using local and global enhancements to overcome the above-mentioned issues. Besides image quality, there is another problem with image processing applications, such as image size. As the image size gets larger, computers usually take much more time to complete the given task. Parallel computing is a method that takes advantage of several processing units on the same system using some libraries or APIs. Since it is easy to use and requires fewer sequential code changes, we preferred to use OpenMP in this study to parallelize sequential implementation. Although the proposed work is developed in C++ and is based on a small sample of dark images, the findings suggest that proposed parallel implementations can be very efficient and feasible in other programming languages for different types of image processing operations. Then, we compared the performance of both sequential and parallel implementations. Based on the experimental results, we observed that the proposed parallel implementation of the reference algorithm runs up to 38 times faster than the sequential version on a cloud computing platform with 48 physical cores. [ABSTRACT FROM AUTHOR]

GrPPI library aims to simplify the burdening task of parallel programming. It provides a unified, abstract, and generic layer while promising minimal overhead on performance. Although it supports stream parallelism, GrPPI lacks an evaluation regarding representative performance metrics for this domain, such as throughput and latency. This work evaluates GrPPI focused on parallel stream processing. We compare the throughput and latency performance, memory usage, and programmability of GrPPI against handwritten parallel code. For this, we use the benchmarking framework SPBench to build custom GrPPI benchmarks and benchmarks with handwritten parallel code using the same backends supported by GrPPI. The basis of the benchmarks is real applications, such as Lane Detection, Bzip2, Face Recognizer, and Ferret. Experiments show that while performance is often competitive with handwritten parallel code, the infeasibility of fine-tuning GrPPI is a crucial drawback for emerging applications. Despite this, programmability experiments estimate that GrPPI can potentially reduce the development time of parallel applications by about three times. [ABSTRACT FROM AUTHOR]

Studying the propagation law of seismic wavefields is the basis of seismic exploration. The finite difference method is commonly used to solve the wave equation for seismic forward modeling, which has advantages of low memory usage, fast computation speed, and easy implementation. However, in the case of three dimensions (3D), the computational and data requirements increase dramatically and traditional, serial, seismic, numerical simulations can no longer meet efficiency demands. This study proposes a 3D wave equation, seismic, numerical simulation method based on half-precision floating-point numbers and OpenMP. This method optimizes commonly-used floating-point data in seismic calculations using half-precision floating-point numbers. It also utilizes the OpenMP application interface to achieve parallel computation on multi-core central processing units by dividing the wavefield calculation region. This strategy ensures the accuracy of the computation results while effectively improving the computation efficiency of 3D seismic numerical simulations and reducing memory requirements by almost half. The effectiveness and practicality of this method are demonstrated through numerical experiments.

В статье представлено исследование вычислительной эффективности параллельной версии численного алгоритма для решения уравнения Риккати с производной дробного перменного порядка типа Герасимова-Капуто. Численный алгоритм представляет собой нелокальную неявную конечно-разностную схему, которая сводится к системе нелинейных алгебраических уравнений и решается с помощью модифицированного метода Ньютона. Нелокальность численной схемы создает высокую вычислительную нагрузку на вычислительные ресурсы, из-за чего возникает необходимость в реализации эффективных параллельных алгоритмов их решения. Исследуемый на эффективность численный алгоритм реализован на языке C из-за его универсальности при работе с памятью. Распаралеливание проводилось с помощью технологии OpenMP. Проводится серия вычислительных экспериментов на вычислительном сервере NVIDIA DGX STATION (Институт математики имени В.И. Романовского, г. Ташкент, Узбекистан) и ноутбуке HP Pavilion Gaming Laptop Z270X, где решалась задача Коши для дробного уравнения Риккати с непостоянными коэффициентами. На основе среднего времени вычисления вычисляются: ускорение, эффективность и стоимость алгоритма. Из анализа данных видно, что OpenMP параллельная программная реализация нелокальной неявной конечно-разностной схемы показывает ускорение работы от 9-12 раз в зависимости от количества задействованных ядер CPU.

Heterogeneous platforms composed of multiple different types of computing devices (such as CPUs, GPUs, and Intel MICs) have been widely used recently. However, most of parallel applications developed in such a heterogeneous platform usually only utilize a certain kind of computing device due to the lack of easy‐to‐use heterogeneous cooperative parallel programming models. To reduce the difficulty of heterogeneous cooperative parallel programming, a directive‐based heterogeneous cooperative parallel programming framework called HeteroPP is proposed. HeteroPP provides an easier way for programmers to fully exploit multiple different types of computing devices to concurrently and cooperatively perform data‐parallel applications on heterogeneous platforms. An extension to OpenMP directives and clauses is proposed to make it possible for programmers to easily offload a data‐parallel compute kernel to multiple different types of computing devices. A source‐to‐source compiler is designed to help programmers to automatically generate multiple device‐specific compute kernels that can be concurrently and cooperatively performed on heterogeneous platforms. Many experiments are conducted with 12 typical data‐parallel applications implemented with HeteroPP on a heterogeneous CPU‐GPU‐MIC platform. The results show that HeteroPP not only greatly simplifies the heterogeneous cooperative parallel programming, but also can fully utilize the CPUs, GPU, and MIC to efficiently perform these applications. [ABSTRACT FROM AUTHOR]

In the past, the number of CPU cores/threads was usually less than 8/16; now, the maximum number is 128/256. As a CPU-based parallel method, OpenMP has an increasing advantage with the increase in CPU cores and threads. A parallel combined finite-discrete element method (FDEM) for modeling underground excavation and rock reinforcement using OpenMP is implemented. Its computational performance is validated in the two advanced CPUs: AMD Ryzen Threadripper PRO 5995WX (64/128 cores/threads); and 2 × AMD EPYC 7T83 (128/256 cores/threads). Then, its ability in simulating tunnel excavation under rockbolt-shotcrete-grouting support is implemented using the novel solid bolt model, which can explicitly capture the interaction between bolt, grout, and rock. The parallel performance validation of the uniaxial compression test shows: (i) for the speedup ratio, the OpenMP-based parallel FDEM obtains maximum speedup ratios of 30 (33 k elements) and 41 (3304 k elements) on the Threadripper, and 31 and 43 on the 2 × EPYC, respectively; (ii) for the scalability of speedup ratio, when the number of threads used is less than 128, the speedup ratio is always increasing with the increase of the number of threads; (iii) for the stability of speedup ratio, it has a stable speedup ratio, regardless of whether the rock is pre- or post-fractured. Highlights: A parallel FDEM for modeling underground excavation and rock reinforcement using OpenMP is implemented. Its computational efficiency is validated in the two advanced CPUs: AMD Ryzen Threadripper PRO 5995WX; and 2 × AMD EPYC 7T83 (128/256 cores/threads). Its ability in simulating rockbolt-shotcrete-grouting support is implemented using the novel solid bolt model. It obtains maximum speedup ratios of 30 (33 k elements) and 41 (3304 k elements) on the Threadripper, and 31 and 43 on the 2 × EPYC. It has good scalability and stability of speedup ratio, regardless of whether the rock is pre- or post-fractured. [ABSTRACT FROM AUTHOR]

Every numerical general relativistic investigation starts from the solution of the initial value equations at a given time. Astrophysically relevant initial values for different systems lead to distinct sets of equations that obey specific assumptions tied to the particular problem. Therefore, a robust and efficient solver for a variety of strongly gravitating sources is needed. In this work, we present the OpenMP version of the Compact Object CALculator (COCAL) on shared memory processors. We performed extensive profiling of the core COCAL modules in order to identify bottlenecks in efficiency, which we addressed. Using modest resources, the new parallel code achieves speedups of approximately one order of magnitude relative to the original serial COCAL code, which is crucial for parameter studies of computationally expensive systems such as magnetized neutron stars, as well as its further development towards more realistic scenarios. As a novel example of our new code, we compute a binary quark system where each companion has a dimensionless spin of 0.43 aligned with the orbital angular momentum. [ABSTRACT FROM AUTHOR]

Copyright of CT Theory & Applications is the property of Editorial Department of CT Theory & Applications and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

This paper introduces a modified sequential version method for optimizing a linear function over an integer efficient set, as well as a new exact parallel algorithm. The performance of parallel programming in this context is clear and shown through different instances with different sizes. Each procedure builds a finite monotonous sequence of values for the main criterion to be optimized, in a reasonable amount of CPU execution time. This latter remains much better. For the first time, the Algerian IBNBADIS cluster—CERIST—was used with this type of problem. Significant results are obtained by both proposed techniques, particularly with the parallel one. [ABSTRACT FROM AUTHOR]

Summary: This work explores the performance of single‐ and multi‐GPU computing on state‐of‐the‐art NVIDIA‐ and AMD‐based server‐class hardware using various programming interfaces to accelerate a real‐world scientific application for solidification modeling based on the phase‐field method. The main computations of this memory‐bound application correspond to 20 stencils computed across grid nodes. We investigate the application's scalability for two basic schemes of organizing computation: without and with hiding data transfers behind computation, combined with using either peer‐to‐peer inter‐GPU data transfers through NVIDIA NVLink and AMD Infinity interconnects or communication over the PCIe and main memory. Among the studied programming interfaces is CUDA, HIP, and OpenMP Accelerator Model. While the first two are designed to write the codes for a specific hardware platform, OpenMP enables code portability between NVIDIA and AMD GPUs. The resulting performance is experimentally assessed on computing platforms containing NVIDIA V100 (up to 8 GPUs) and A100 (one GPU), as well as AMD MI210 (one device) and MI250 (up to 8 logical GPUs). [ABSTRACT FROM AUTHOR]

Today, various applications in different domains increasingly rely on high-performance computing (HPC) to accomplish computations swiftly. Integrating one or more programming models alongside the used programming language enhances system parallelism, thereby improving its performance. However, this integration can introduce runtime errors such as race conditions, deadlocks, or livelocks. Some of these errors may go undetected using conventional testing techniques, necessitating the exploration of additional methods for enhanced reliability. Formal methods, such as temporal logic, can be useful for detecting runtime errors since they have been widely used in real-time systems. Additionally, many software systems must adhere to temporal properties to ensure correct functionality. Temporal logics indeed serve as a formal frame that takes into account the temporal aspect when describing changes in elements or states over time. This paper proposes a temporal-logic-based testing tool utilizing instrumentation techniques designed for a dual-level programming model, namely, Message Passing Interface (MPI) and Open Multi-Processing (OpenMP), integrated with the C++ programming language. After a comprehensive study of temporal logic types, we found and proved that linear temporal logic is well suited as the foundation for our tool. Notably, while the tool is currently in development, our approach is poised to effectively address the highlighted examples of runtime errors by the proposed solution. This paper thoroughly explores various types and operators of temporal logic to inform the design of the testing tool based on temporal properties, aiming for a robust and reliable system. [ABSTRACT FROM AUTHOR]

Four‐Wave Mixing (FWM) is one of the non‐linear phenomena affecting long‐reach communication systems and high bandwidth. Research communities use simulation tools for parameter optimization. Unfortunately, such a simulation is time‐consuming and requires more time as the number of channels increases. This paper proposes two fast implementations of Dense Wavelength Division Multiplexing (DWDM) system, limited by FWM and the intrinsic Amplified Spontaneous Emission (ASE) noise of optical amplifiers employed in each segment. Additionally, this work compares the efficiency and speed improvement of the proposed parallelization model versus an earlier sequential model. We present the computational complexity analysis of sequential and parallel models. The paper considers two different parallel implementations: a multicore processor using Open MultiProcessing (OpenMP) and Compute Unified Device Architecture (CUDA), which is based on the use of a Graphics Processing Unit (GPU). Results show that parallelism using CUDA improves by up to 70 times the simulation performance compared to the sequential model. Parallelism with CUDA is up to 15 times compared to OpenMP using 12 logical processors. It is possible to simulate an increased number of channels within our parallel execution, which was impractical in the sequential simulation. [ABSTRACT FROM AUTHOR]