Scalability Of Parallel Algorithms Research Articles

Bayesian backcalculation of pavement properties using parallel transitional Markov chain Monte Carlo

AbstractThis paper presents a novel Bayesian method for backcalculation of pavement dynamic modulus, stiffness, thickness, and damping using falling weight deflectometer (FWD) data. The backcalculation procedure yields estimates and uncertainties for each pavement property of interest. As a by‐product of the Bayesian procedure, information about measurement error is recovered. The Bayesian method is tested on simulated FWD backcalculations and compared with a state‐of‐the‐art trust‐region optimization algorithm, and it achieves estimation errors that are nearly an order of magnitude lower than the trust‐region solver. Confidence intervals are computed from thousands of simulated backcalculations and are shown to quantify uncertainty in estimated pavement properties. To cope with the computational expense of backcalculation, a fully parallel transitional Markov chain Monte Carlo procedure is developed. The fully parallel algorithm scales well to computation with many processor cores, and it yields up to a 50% reduction in computation time when compared to existing parallel implementations.

Parallel algorithm for synthetic image generation with application to tokamak plasma diagnostics

SummaryThe tomographic reconstruction is a powerful diagnostic tool in nuclear fusion experiments for the determination of the shape and position of the plasma. However, neural networks are emerging as a suitable alternative to conventional plasma tomography algorithms. In order to train such AI/ML based models, we need large‐scale, diversified image data for learning and evaluation which is difficult to obtain from real experiments. Accuracy and real‐time response is also critical, therefore in this article we propose an effective shared memory based parallel algorithm for synthetic imaging diagnostic data generation. The practicality of the proposed parallel algorithm has been evaluated experimentally by comparing it to the sequential algorithm on two different computing architectures. We observe a maximum speedup of 21 at 32 threads and demonstrate that our proposed parallel algorithm scales well over a range of image sizes. The proposed parallel algorithm can be used to obtain the synthetic images within a few seconds which is very important for real time applications. We also provide an analysis on the importance of choosing the right scheduling type and optimum chunk size to obtain the maximum speedup.

High-resolution cerebral blood flow simulation with a domain decomposition method and verified by the TCD measurement

Background: An efficient and accurate blood flow simulation can be useful for understanding many vascular diseases. Accurately resolving the blood flow velocity based on patient-specific geometries and model parameters is still a major challenge because of complex geomerty and turbulence issues. In addition, obtaining results in a short amount of computing time is important so that the simulation can be used in the clinical environment. In this work, we present a parallel scalable method for the patient-specific blood flow simulation with focuses on its parallel performance study and clinical verification.Methods: We adopt a fully implicit unstructured finite element method for a patient-specific simulation of blood flow in a full precerebral artery. The 3D artery is constructed from MRI images, and a parallel Newton–Krylov method preconditioned with a two-level domain decomposition method is adopted to solve the large nonlinear system discretized from the time-dependent 3D Navier-Stokes equations in the artery with an integral outlet boundary condition. The simulated results are verified using the clinical data measured by transcranial Doppler ultrasound, and the parallel performance of the algorithm is studied on a supercomputer.Results: The simulated velocity matches the clinical measured data well. Other simulated blood flow parameters, such as pressure and wall shear stress, are within reasonable ranges. The results show that the parallel algorithm scales up to 2160 processors with a 49% parallel efficiency for solving a problem with over 20 million unstructured elements on a supercomputer. For a standard cerebral blood flow simulation case with approximately 4 million finite elements, the calculation of one cardiac cycle can be finished within one hour with 1000 processors.Conclusion: The proposed method is able to perform high-resolution 3D blood flow simulations in a patient-specific full precerebral artery within an acceptable time, and the simulated results are comparable with the clinical measured data, which demonstrates its high potential for clinical applications.

A Spark Parallel Betweenness Centrality Computation and its Application to Community Detection Problems

The Brandes algorithm has the lowest computational complexity for computing the betweenness centrality measures of all nodes or edges in a given graph. Its numerous applications make it one of the most used algorithms in social network analysis. In this work, we provide a parallel version of the algorithm implemented in Spark. The experimental results show that the parallel algorithm scales as the number of cores increases. Finally, we provide a version of the well-known community detection Girvan-Newman algorithm, based on the Spark version of Brandes algorithm.

Analysis of a parallel MCMC algorithm for graph coloring with nearly uniform balancing

• We propose the convergence analysis of a parallel MCMC algorithm for graph coloring. • We prove that, throughout the iterations of the algorithm, the number of color conflicts converges in probability to 0. • We propose a qualitative analysis of the balancing level of the color class sizes achieved. • The parallel algorithm scales well with the graph size. • The effectiveness of the algorithm is assessed on large real-world graphs taken from social analysis. We propose the analysis of a scalable parallel MCMC algorithm for graph coloring aimed at balancing the color class sizes, provided that a suitable number of colors is made available. Firstly, it is shown that the Markov chain converges to the target distribution by repeatedly sampling from suitable proposed distributions over the neighboring colors of each node, independently and hence in parallel manner. We prove that the number of conflicts in the improper colorings genereted thoughout the iterations of the algorithm rapidly converges in probability to 0. As for the balancing, given to the complexity of the distributions involved, we propose a qualitative analysis about the balancing level achieved. Based on a collection of multinoulli distributions arising from the color occurrences within every node neighborhood, we provide some evidence about the character of the final color balancing, which results to be nearly uniform over the color classes. Some numerical simulations on big social graphs confirm the fast convergence and the balancing trend, which is validated through a statistical hypothesis test eventually.

Parallel finite-difference algorithms for three-dimensional space-fractional diffusion equation with $$\psi $$-Caputo derivatives

The paper deals with the issues of parallel computations’ organization while solving three-dimensional space-fractional diffusion equation with the $$\psi $$ -Caputo derivatives using finite difference schemes. For an implicit scheme and locally one-dimensional splitting scheme, we present parallel algorithms for distributed memory systems that use one-dimensional block and red–black data partitioning. To reduce the order of algorithms’ computational complexity, we use an approach based on the expansion of integral operator’s kernel into series. We present the theoretical estimates of parallel algorithms’ performance and the results of computational experiments conducted on a testing problem that has an analytical solution for the case of the Caputo–Katugampola derivative. The results of the experiments show close-to-linear parallelization efficiency of one-dimensional splitting scheme with block partitioning and inefficiency of red–black partitioning in this case. For the implicit scheme, the scalability of parallel algorithms is weak and the use of red–black partitioning is more efficient than the use of block partitioning when running on a small number of computational resources.

Optimizing energy consumption of robotic cells by a Branch & Bound algorithm

Nowadays, robotic cells are mostly designed with the main goal to meet the desired production rate without any consideration of the energy efficiency, therefore, it is often possible to achieve significant energy savings without downsizing the production. In our previous study, we established the mathematical formulation of the energy optimization problem, proposed a parallel heuristic, and optimized an existing robotic cell in Škoda Auto, the results of which revealed a 20% reduction in the energy consumption of robot drive systems. This study proposes a novel parallel Branch & Bound algorithm to optimize the energy consumption of robotic cells without deterioration in throughput. The energy saving is achieved by changing robot speeds and positions, applying robot power-saving modes (brakes, bus power off), and selecting an order of operations. The core part of the algorithm is our tight lower bound, based on convex envelopes. Besides the bounding, a Deep Jumping approach is introduced to guide the search to the promising parts of the Branch & Bound tree, and the parallelization accelerates the exploration of the tree. The experimental results revealed that the performance of the parallel algorithm scales almost linearly up to 12 processor cores, and the quality of obtained solutions is better or comparable to other existing works.

Grid-based algorithm to search critical points, in the electron density, accelerated by graphics processing units.

Using a grid-based method to search the critical points in electron density, we show how to accelerate such a method with graphics processing units (GPUs). When the GPU implementation is contrasted with that used on central processing units (CPUs), we found a large difference between the time elapsed by both implementations: the smallest time is observed when GPUs are used. We tested two GPUs, one related with video games and other used for high-performance computing (HPC). By the side of the CPUs, two processors were tested, one used in common personal computers and other used for HPC, both of last generation. Although our parallel algorithm scales quite well on CPUs, the same implementation on GPUs runs around 10× faster than 16 CPUs, with any of the tested GPUs and CPUs. We have found what one GPU dedicated for video games can be used without any problem for our application, delivering a remarkable performance, in fact; this GPU competes against one HPC GPU, in particular when single-precision is used.

Scalability of Neville elimination using checkerboard partitioning

The scalability of a parallel system is a measure of its capacity to effectively use an increasing number of processors. Both the isoefficiency function and the scaled efficiency are metrics used to analyse the scalability of parallel algorithms and architectures. The first function relates the size of the problem being solved to the number of processors required to maintain efficiency at a fixed value, while the second function shows how an algorithm scales when both the size of the problem and the number of processors are increased. This paper models and measures the parallel scalability of the Neville method when a checkerboard partitioning is performed. Neville elimination is a method for solving a system of linear equations. This process appears naturally when the Neville strategy of interpolation is used to solve linear systems. The scaled efficiency of some algorithms of this method is studied on an IBM SP2 and also over an HP cluster.

Analyzing Scalability of Neville Elimination

The scalability of a parallel system is a measure of its capacity to effectively use an increasing number of processors. Several performance evaluation metrics have been developed to study the scalability of parallel algorithms and architectures. The isoefficiency function is one of those metrics. It relates the size of the problem being solved to the number of processors required to maintain efficiency at a fixed value. This work studies the scalability of Neville elimination, which is a method to solve a linear equation system. This process appears naturally when the Neville strategy of interpolation is used to solve linear systems. The scalability behavior of some algorithms of this method is studied on an IBM SP2 and also over a network of personal computers using the isoefficiency function and the scaled efficiency.

AVERAGE-CASE SCALABILITY ANALYSIS OF PARALLEL COMPUTATIONS ON k-ARY d-CUBES

We investigate the average-case scalability of parallel algorithms executing on multicomputer systems whose static networks are k-ary d-cubes. Our performance metrics are isoefficiency function and isospeed scalability. For the purpose of average-case performance analysis, we formally define the concepts of average-case isoefficiency function and average-case isospeed scalability. By modeling parallel algorithms on multicomputers using task interaction graphs, we are mainly interested in the effects of communication overhead and load imbalance on the performance of parallel computations. We focus on the topology of static networks whose limited connectivities are constraints to high performance. In our probabilistic model, task computation and communication times are treated as random variables, so that we can analyze the average-case performance of parallel computations. We derive the expected parallel execution time on symmetric static networks and apply the result to k-ary d-cubes. We characterize the maximum tolerable communication overhead such that constant average-case efficiency and average-case average-speed could be maintained and that the number of tasks has a growth rate Θ(P log P), where P is the number of processors. It is found that the scalability of a parallel computation is essentially determined by the topology of a static network, i.e., the architecture of a parallel computer system. We also argue that under our probabilistic model, the number of tasks should grow at least in the rate of Θ(P log P), so that constant average-case efficiency and average-speed can be maintained.

2-phase GA-based image registration on parallel clusters

Genetic algorithms (GAs) are known to be robust for search and optimization problems. Image registration can take advantage of the robustness of GAs in finding best transformation between two images, of the same location with slightly different orientation, produced by moving spaceborne remote sensing instruments. In this paper, we present 2-phase sequential and coarse-grained parallel image registration algorithms using GAs as optimization mechanism. In its first phase, the algorithm finds a small set of good solutions using low-resolution versions of the images. Based on these candidate low-resolution solutions, the algorithm uses the full resolution image data to refine the final registration results in the second phase. Experimental results are presented and revealed that our algorithms yield very accurate registration results for LandSat Thematic Mapper images, and the parallel algorithm scales quite well on the Beowulf parallel cluster.

AVERAGE-CASE ANALYSIS OF ISOSPEED SCALABILITY OF PARALLEL COMPUTATIONS ON MULTIPROCESSORS

We investigate the average-case speed and scalability of parallel algorithms executing on multiprocessors. Our performance metrics are average-speed and isospeed scalability. For the purpose of average-case performance prediction, we formally define the concepts of average-case average-speed and average-case isospeed scalability. By modeling parallel algorithms on multiprocessors using task precedence graphs, we are mainly interested in the effects of synchronization overhead and load imbalance on the performance of parallel computations. Thus, we focus on the structures of parallel computations, whose inherent sequential parts are limitations to high performance. Task execution times are treated as random variables, so that we can analyze the average-case performance of parallel computations. For several typical classes of task graphs, including iterative computations, search trees, partitioning algorithms, and diamond dags, we derive the growth rate of the number of tasks as well as isospeed scalability in keeping constant average-speed. In addition to analytical results, extensive numerical data are also demonstrated. An important discovery of our study is that while a parallel computation can be made scalable by increasing the problem size together with the system size, it is actually the amount of parallelism that should scale up with the system size. We also argue that under our probabilistic model of parallel algorithms and the list scheduling strategy, the number of tasks should grow at least at the rate of Θ(P log P), where P is the number of processors, so that a constant average-speed can be maintained. Furthermore, Θ(log P/ log P') is the highest isospeed scalability achievable.

Special Issue on Scalability of Parallel Algorithms and Architectures: Guest Editors′ Introduction

The invention of the transistor in 1948 ranks as a seminal event of technology. It influenced the electronics industry profoundly, giving us portable TVs, pocket radios, personal computers, and the virtual demise of vacuum tubes. But the real electronics revolution came in the 1960s with the integration of transistors and other semiconductor devices into monolithic circuits. Now integrated circuits (called chips) can be found in everything from wristwatches to automobile engines and are the driving force behind the boom in personal computers. The latest advance, though, involves the integration of digital communication networks with the computer which has given birth to the global Internet.