Small Number Of Processors Research Articles

Параллельная реализация метода сопряженных градиентов с предобусловливателем IC1 на основе использования переупорядочения узлов сетки

The paper proposes a method for using MPI+OpenMP technology for constructing and inverting a first-order incomplete triangular Cholesky expansion preconditioner IC1(τ) for solving system of linear algebraic equations with an arbitrary symmetric positive definite matrix on a small number of processors. Methods of using MPI and MPI+OpenMP technologies are based on the use of grid node orderings consistent with the division of the calculation area. When constructing the preconditioning matrix IC1(τ) using MPI, cutting is performed at positions in some of its rows. The use of OpenMP technology in the construction and inversion of the preconditioner is carried out for most rows of the matrix. The time taken to solve problems using the conjugate gradient method with the IC1(τ) preconditioner using MPI and hybrid MPI+OpenMP technology is compared using the example of a model problem and a number of problems from the SuiteSparse collection of sparse matrices.

Source-to-source translation for code-optimization

Multi-core design intends to serve a large market with user-oriented and highproductivity management as opposed to any other parallel system. Small numbers of processors, a frequent feature of current multi-core systems, are ideal for future generation of CPUs, where automated parallelization succeeds on shared space architectures. The multi-core compiler optimization platform CETUS (high-level to high-level compiler) offers initiates automatic parallelization in compiled programmes. This compiler’s infrastructure is built with C programmes in mind and is user-friendly and simple to use. It offers the significant parallelization passes and also the underlying empowering techniques, allows source-to-source conversions, and delivers these features. This compiler has undergone numerous benchmark investigations (techniques) and approach implementation iterations. It might enhance the programs’ parallel performance. The main drawback of advanced optimising compilers, however, is that they don’t provide runtime details like the program’s input data. The approaches presented in this paper facilitatedynamic optimization using CETUS. The large amount of proposed compiler analyses and modifications for parallelization is the last point. To research the behaviour as well as the throughput gains, we investigated both non-CETUS based and CETUS based parallelized program features in this work.

Метричні системи оцінки ефективності та масштабованості паралельних обчислень

"The current state of development of computer technology allows you to build parallel computer systems that use almost unlimited number of processors. The availability of such systems has aroused interest in studying the performance of parallel computers, which contain a large number of processors, in the implementation of real multidimensional problems. One way to increase the efficiency of parallel architectures is to reduce the time required to perform a time-consuming task, which should be commensurate with the number of processing resources used to solve this problem. The second direction is the development of highly scalable parallel or parallel algorithms. Under the scalability of the parallel algorithm on the parallel architecture we will consider a measure of its ability to efficiently use a growing number of processors. Scalability analysis can be used to select the best combination of algorithm architecture for a problem with different constraints on the size of the problem and the number of processors. It can be used to predict the performance of a parallel algorithm and a parallel architecture for a large number of processors based on known performance on a smaller number of processors. For a fixed size of the problem, it can be used to determine the optimal number of processors, which will be used and the maximum possible acceleration that can be obtained. Scalability analysis can also predict the impact of changes in hardware technology on performance and thus help develop the best parallel architectures to solve different problems The aim of the work is to critically evaluate the state of modern theory of analysis of aircraft performance and scalability and to demonstrate further research on the development of new and more complex analytical tools to analyze the effective use of the benefits of parallel equipment. The main task of the study is to develop new and modify existing theoretical models, methods and formalisms to study the problems of efficiency and scalability of parallel computing. Mathematically, to simplify the analysis, it is assumed that all temporal characteristics are non-negative. This means that acceleration is always limited by the number of processors, p, and efficiency - by one. For example, acceleration can be super-linear, overhead can be negative if memory is hierarchical and access time is increased discretely by increasing the memory used by the program. In this case, the effective computing speed of a large program will be slower on a serial processor than on a parallel computer with similar processors."

Load Balancing Problem on Hyper Hexa Cell Interconnection Network

Dynamic load balancing techniques prevents computer nodes from overloading unevenly while leaving other idle. It is considered as one of the most challenging topics in parallel computing. Moreover, it is essential for increasing the efficiency of highly parallel systems especially in solving multitask problems with unpredictable load estimates. Particularly, over each processor in the parallel systems and interconnection networks. This paper focuses on developing an efficient algorithm for load balancing on Hyper Hexa Cell (HHC) interconnection network, namely, HHCLB algorithm. Basically, the Dimension Exchange Method (DEM) approach is used in this paper to construct a new load balancing approach on the network of HHC interconnections. Thus, an algorithm was introduced and simulated using java threads, where the performance of the algorithm is evaluated both analytically and experimentally. The evaluation was in terms of various performance metrics, including, execution time, load balancing accuracy, communication cost. By implementing the proposed load balancing algorithm to the HHC network, a high degree of accuracy and minimal execution time was achieved. It is important to highlight that the algorithm recorded small gap between the execution time for small number of processors and large number of processors. For instance, the algorithm achieved 0.14 seconds for balancing the load of 6 processors while 0.59 seconds for balancing the load of 3072 processors. This proves how effective the algorithm is in balancing the load for different network sizes from small to large number of processors, with a slight difference in execution time.

Variants of Networks of Evolutionary Processors with Polarizations and a Small Number of Processors

We improve previous results obtained for networks of evolutionary processors — using the operations insertion, deletion, and substitution on strings — with elementary polarizations [Formula: see text] by showing that only seven processors are needed to obtain computational completeness. In the case of not requiring a special output node, only five processors are shown to be sufficient. We also prove that if the communication structure is allowed to be a directed graph without self-loops, then two polarizations are sufficient (with 12 or 17 nodes, depending on the definition). Moreover, we consider the case of not restricting the number of polarizations, thus obtaining the minimal number of three nodes for hybrid systems and even only one node where all three operations can be carried out.

Performance Evaluation of Parallel Bubble Sort Algorithm on Supercomputer IMAN1

Parallel sorting algorithms order a set of elements USING MULTIPLE processors in order to enhance the performance of sequential sorting algorithms. In general, the performance of sorting algorithms are EVALUATED IN term of algorithm growth rate according to the input size. In this paper, the running time, parallel speedup and parallel efficiency OF PARALLEL bubble sort is evaluated and measured. Message Passing Interface (MPI) IS USED for implementing the parallel version of bubble sort and IMAN1 supercomputer is used to conduct the results. The evaluation results show that parallel bubble sort has better running time as the number of processors increases. On other hand, regarding parallel efficiency, parallel bubble sort algorithm is more efficient to be applied OVER SMALL number of processors.

Performance Evaluation of Parallel Bubble Sort Algorithm on Supercomputer IMAN1

Parallel sorting algorithms order a set of elements USING MULTIPLE processors in order to enhance the performance of sequential sorting algorithms. In general, the performance of sorting algorithms are EVALUATED IN term of algorithm growth rate according to the input size. In this paper, the running time, parallel speedup and parallel efficiency OF PARALLEL bubble sort is evaluated and measured. Message Passing Interface (MPI) IS USED for implementing the parallel version of bubble sort and IMAN1 supercomputer is used to conduct the results. The evaluation results show that parallel bubble sort has better running time as the number of processors increases. On other hand, regarding parallel efficiency, parallel bubble sort algorithm is more efficient to be applied OVER SMALL number of processors

Computational completeness of complete, star-like, and linear hybrid networks of evolutionary processors with a small number of processors

A hybrid network of evolutionary processors (HNEP) is a graph where each node is associated with a special rewriting system called an evolutionary processor, an input filter, and an output filter. Each evolutionary processor is given a finite set of one type of point mutations (insertion, deletion or a substitution of a symbol) which can be applied to certain positions in a string. An HNEP rewrites the strings in the nodes and then re-distributes them according to a filter-based communication protocol; the filters are defined by certain variants of random-context conditions. HNEPs can be considered both as languages generating devices (GHNEPs) and language accepting devices (AHNEPs); most previous approaches treated the accepting and generating cases separately. For both cases, in this paper we show that five nodes are sufficient to accept (AHNEPs) or generate (GHNEPs) any recursively enumerable language by showing the more general result that any partial recursive relation can be computed by an HNEP with (at most) five nodes with the underlying graph structure for the communication between the evolutionary processors being the complete or the linear graph with five nodes, whereas with a star-like communication graph we need six nodes. If the final results are defined by only taking the terminal strings out of the designated output node, then for these extended HNEPs we can prove that only four nodes are needed in all cases--for computing any partial recursive relation as well as for generating and accepting any recursively enumerable language--and the underlying communication structure can be a complete or a linear graph, but now even a star-like graph, too.

An approach to enhance pnetCDF performance in environmental modeling applications

Abstract. Data intensive simulations are often limited by their I/O (input/output) performance, and "novel" techniques need to be developed in order to overcome this limitation. The software package pnetCDF (parallel network Common Data Form), which works with parallel file systems, was developed to address this issue by providing parallel I/O capability. This study examines the performance of an application-level data aggregation approach which performs data aggregation along either row or column dimension of MPI (Message Passing Interface) processes on a spatially decomposed domain, and then applies the pnetCDF parallel I/O paradigm. The test was done with three different domain sizes which represent small, moderately large, and large data domains, using a small-scale Community Multiscale Air Quality model (CMAQ) mock-up code. The examination includes comparing I/O performance with traditional serial I/O technique, straight application of pnetCDF, and the data aggregation along row and column dimension before applying pnetCDF. After the comparison, "optimal" I/O configurations of this application-level data aggregation approach were quantified. Data aggregation along the row dimension (pnetCDFcr) works better than along the column dimension (pnetCDFcc) although it may perform slightly worse than the straight pnetCDF method with a small number of processors. When the number of processors becomes larger, pnetCDFcr outperforms pnetCDF significantly. If the number of processors keeps increasing, pnetCDF reaches a point where the performance is even worse than the serial I/O technique. This new technique has also been tested for a real application where it performs two times better than the straight pnetCDF paradigm.

Reconfigurable Architecture for Minimizing the Network Delays in the Multi-core Systems

Noc architecture performs better comparing to bus based when the number of processors is small. On the other hand bus based performs better than noc when number of the processors is large. This leads to new architecture which is hybrid bus based architecture where each node is packet switched in a mesh network of noc architecture that contains bus based system with small number of processors. Few results showed that this hybrid architecture performs optimally better than either purely noc based or purely bus based architecture. Hybrid architecture contains a processor connected to the bus, the bus in turn connected to the router. Each processor contains a private Level 1 (L1) cache. When hybrid architecture is preferable, the optimal number of processors on each bus subsystem varies based on the application. Hence the proposed architecture allows scalable bus-based multiprocessor subsystems on each node in the NoC. This system provides a multi-bus execution environment where each processor is connected to a bus and the bus-based subsystems communicate via routers connected in a mesh-style configuration. The system can be reconfigured to vary the number of bus subsystems and the number of processors on each subsystem. This architecture provides reliability and adaptability and reduces the network delays. Implementing and presenting the details of architecture and experimental results using ns2 indicating the advantages of this architecture.

Decoupled load balancing

Modern scientific simulations divide work between parallel processors by decomposing a spatial domain of mesh cells, particles, or other elements. A balanced assignment of the computational load is critical for parallel performance. If the computation per element changes over the simulation time, simulations can use dynamic load balance algorithms to evenly redistribute work to processes. Graph partitioners are widely used and balance very effectively, but they do not strong scale well. Typical SPMD simulations wait while a load balance algorithm runs on all processors, so a poorly scaling algorithm can itself become a bottleneck. We observe that the load balance algorithm is separate from the main application computation and has its own scaling properties. We propose to decouple the load balance algorithm from the application, and to offload the load balance computation so that it runs concurrently with the application on a smaller number of processors. We demonstrate the costs of decoupling and offloading the load balancing algorithm from a Barnes-Hut application.

A family of explicit parallel Runge–Kutta–Nyström methods

A procedure for the construction of high-order explicit parallel Runge–Kutta–Nyström (RKN) methods for solving second-order nonstiff initial value problems (IVPs) is analyzed. The analysis reveals that starting the procedure with a reference symmetric RKN method it is possible to construct high-order RKN schemes which can be implemented in parallel on a small number of processors. These schemes are defined by means of a convex combination of k disjoint s i -stage explicit RKN methods which are constructed by connecting s i steps of a reference explicit symmetric method. Based on the reference second-order Störmer–Verlet methods we derive a family of high-order explicit parallel schemes which can be implemented in variable-step codes without additional cost. The numerical experiments carried out show that the new parallel schemes are more efficient than some sequential and parallel codes proposed in the scientific literature for solving second-order nonstiff IVPs.

Reliable performance prediction for multigrid software on distributed memory systems

We propose a model for describing and predicting the parallel performance of a broad class of parallel numerical software on distributed memory architectures. The purpose of this model is to allow reliable predictions to be made for the performance of the software on large numbers of processors of a given parallel system, by only benchmarking the code on small numbers of processors. Having described the methods used, and emphasized the simplicity of their implementation, the approach is tested on a range of engineering software applications that are built upon the use of multigrid algorithms. Despite their simplicity, the models are demonstrated to provide both accurate and robust predictions across a range of different parallel architectures, partitioning strategies and multigrid codes. In particular, the effectiveness of the predictive methodology is shown for a practical engineering software implementation of an elastohydrodynamic lubrication solver.

A Performance Comparison of the Parallel Preconditioners for Iterative Methods for Large Sparse Linear Systems Arising from Partial Differential Equations on Structured Grids

In this paper we compare various parallel preconditioners such as Point-SSOR (Symmetric Successive OverRelaxation), ILU(0) (Incomplete LU) in the Wavefront ordering, ILU(0) in the Multi-color ordering, Multi-Color Block SOR (Successive OverRelaxation), SPAI (SParse Approximate Inverse) and pARMS (Parallel Algebraic Recursive Multilevel Solver) for solving large sparse linear systems arising from two-dimensional PDE (Partial Differential Equation)s on structured grids. Point-SSOR is well-known, and ILU(0) is one of the most popular preconditioner, but it is inherently serial. ILU(0) in the Wavefront ordering maximizes the parallelism in the natural order, but the lengths of the wavefronts are often nonuniform. ILU(0) in the Multi-color ordering is a simple way of achieving a parallelism of the order N, where N is the order of the matrix, but its convergence rate often deteriorates as compared to that of natural ordering. We have chosen the Multi-Color Block SOR preconditioner combined with direct sparse matrix solver, since for the Laplacian matrix the SOR method is known to have a nondeteriorating rate of convergence when used with the Multi-Color ordering. By using block version we expect to minimize the interprocessor communications. SPAI computes the sparse approximate inverse directly by least squares method. Finally, ARMS is a preconditioner recursively exploiting the concept of independent sets and pARMS is the parallel version of ARMS. Experiments were conducted for the Finite Difference and Finite Element discretizations of five two-dimensional PDEs with large meshsizes up to a million on an IBM p595 machine with distributed memory. Our matrices are real positive, i.e., their real parts of the eigenvalues are positive. We have used GMRES(m) as our outer iterative method, so that the convergence of GMRES(m) for our test matrices are mathematically guaranteed. Interprocessor communications were done using MPI (Message Passing Interface) primitives. The results show that in general ILU(0) in the Multi-Color ordering and ILU(0) in the Wavefront ordering outperform the other methods but for symmetric and nearly symmetric 5-point matrices Multi-Color Block SOR gives the best performance, except for a few cases with a small number of processors.

Parallel radial basis function methods for the global optimization of expensive functions

We introduce a master–worker framework for parallel global optimization of computationally expensive functions using response surface models. In particular, we parallelize two radial basis function (RBF) methods for global optimization, namely, the RBF method by Gutmann [Gutmann, H.M., 2001a. A radial basis function method for global optimization. Journal of Global Optimization 19(3), 201–227] (Gutmann-RBF) and the RBF method by Regis and Shoemaker [Regis, R.G., Shoemaker, C.A., 2005. Constrained global optimization of expensive black box functions using radial basis functions, Journal of Global Optimization 31, 153–171] (CORS-RBF). We modify these algorithms so that they can generate multiple points for simultaneous evaluation in parallel. We compare the performance of the two parallel RBF methods with a parallel multistart derivative-based algorithm, a parallel multistart derivative-free trust-region algorithm, and a parallel evolutionary algorithm on eleven test problems and on a 6-dimensional groundwater bioremediation application. The results indicate that the two parallel RBF algorithms are generally better than the other three alternatives on most of the test problems. Moreover, the two parallel RBF algorithms have comparable performances on the test problems considered. Finally, we report good speedups for both parallel RBF algorithms when using a small number of processors.

Parallelizing the Discrete Ordinates Method (DOM) for Three-Dimensional Radiative Heat Transfer Calculations using a Priority Queuing Technique

A parallelizing algorithm based on a priority queuing system is developed for solving the three-dimensional radiative transfer equation (RTE) using the discrete ordinates method (DOM) in an absorbing-emitting medium. The classical iterative method of initializing intensity values at processor boundaries and conducting iterations until convergence is very inefficient, and hence a better technique is desired. The method developed here is called the staged technique and relies on the careful organization and prioritization of the multiple inherently serial calculations present in the classical algorithm. A parallel performance analysis is presented for this technique, and measured values of performance metrics are compared to theoretical values. Although theoretical values exhibit possibilities of efficiencies up to 50%, the measured values are lower due to parallel logic overhead. Overall, better performance is obtained for larger problem sizes solved on a relatively small number of processors, but performance can be low outside this configuration.

Some variants of the Bank–Holst parallel adaptive meshing paradigm

The Bank–Holst adaptive meshing paradigm is an efficient approach for parallel adaptive meshing of elliptic partial differential equations. It is designed to keep communication costs low and to take advantage of existing sequential adaptive software. While in principle the procedure could be used in any parallel environment, it was mainly conceived for use on small Beowulf clusters with a relatively small number of processors and a slow communication network. A typical calculation on such a machine might involve, say p = 32 processors, an adaptive fine mesh with a few million vertices, and use 2–3 min of computational time. In this work we, discuss a variant of the original scheme that could be used in situations where a much larger number of processors, say p > 100 is available. In this case the problem size could be much larger, say 10–100 million, with still a low to moderate computation time.

The application of knowledge-based techniques to the monitoring of computers in a large heterogeneous distributed environment

Historically, computer monitoring tools sent alarms to a central point, typically a computer operator. This has been successful in environments with a small number of processors. However, future CERN systems will contain thousands of heterogeneous distributed processors and it may prove impossible for an operator to cope. Consequently, monitoring of the proposed environment has become a research focus. One solution to this problem is to provide monitoring knowledge that correlates alarms and provides fewer, but more meaningful advisory information. Moreover, such a solution could reduce operator load further by taking automatic corrective action.

Toward a grid-based DBMS

The relational database management system (DBMS) community has been progressing toward using specialized grids. EMC/Acxiom's data grid architecture and MySQL Cluster's grid architecture couple the main memories of PCs with redundancy to implement persistence. In a data grid architecture at its base level is a grid abstract machine, which consists of a collection of typed nodes. The grid abstract machine provides redundant storage in case a node fails. It might also provide interfaces that group nodes into enclaves. This grouping could be based on attributes such as assignment, node type, size, capabilities, physical location, and who owns it. This departs from traditional database implementations, which were tuned to small numbers of processors and in which most algorithms for relational operators and most indices were tuned to disk-block transfers

Parallel-in-Time Simulation of Two-Dimensional, Unsteady, Incompressible Laminar Flows

The present work reports an application of a parallel-in-time algorithm to the solution of the unsteady incompressible Navier-Stokes equations. The parallel-in-time algorithm allows one to decompose the time domain of the problem into several subdomains. The solution is based on the iterative use of a coarse- and a finer-time-grid calculation. Calculation starts with a sequential solution along the time domain on the coarse time grid, and this is followed by the iterative procedure. The temporal evolution on the finer time grid is calculated in parallel. This iterative procedure provides successive corrections for the problem solution. When solving the parabolic-elliptic Navier-Stokes and continuity equations, some problems may emerge from the use of two temporal grids in this predictor-corrector fashion. Among them, we have analyzed the influence of the number of processors, or time subdomains, and the number of iterations required for convergence. In addition, an extension of the algorithm to parallelize simultaneously the space and time domains is presented. Although the proposed methodologies are designed for a massive number of processors, significant computer time saving, compared with a single-processor calculation, could be achieved with a very small number of processors.