Proposed Parallel Algorithm Research Articles

Parallel algorithms for semi-lagrangian advection

SUMMARY Numerical time step limitations associated with the explicit treatment of advection-dominated problems in computational fluid dynamics are often relaxed by employing Eulerian‐Lagrangian methods. These are also known as semi-Lagrangian methods in the atmospheric sciences. Such methods involve backward time integration of a characteristic equation to find the departure point of a fluid particle arriving at a Eulerian grid point. The value of the advected field at the departure point is obtained by interpolation. Both the trajectory integration and repeated interpolation influence accuracy. We compare the accuracy and performance of interpolation schemes based on piecewise cubic polynomials and cubic B-splines in the context of a distributed memory, parallel computing environment. The computational cost and interprocessor communication requirements for both methods are reported. Spline interpolation has better conservation properties but requires the solution of a global linear system, initially appearing to hinder a distributed memory implementation. The proposed parallel algorithm for multidimensional spline interpolation has almost the same communication overhead as local piecewise polynomial interpolation. We also compare various techniques for tracking trajectories given different values for the Courant number. Large Courant numbers require a high-order ODE solver involving multiple interpolations of the velocity field. # 1997 by John Wiley & Sons, Ltd.

Parallel Solution of Dense Linear Systems on the k-ary n-cube Networks

In this paper a parallel algorithm for solving systems of linear equation on the k-ary n-cube is presented and evaluated for the first time. The proposed algorithm is of O(N3/kn) computation complexity and uses O(Nn) communication time to factorize a matrix of order N on the k-ary n-cube. This is better than the best known results for the hypercube, O(N log kn), and the mesh, , each with approximately kn nodes. The proposed parallel algorithm takes advantage of the extra connectivity in the k-ary n-cube in order to reduce the communication time involved in tasks such as pivoting, row/column interchanges, and pivot row and multipliers column broadcasts.

A parallel two-list algorithm for the knapsack problem

An n-element knapsack problem has 2 n possible solutions to search over, so a task which can be accomplished in 2″ trials if an exhaustive search is used. Due to the exponential time in solving the knapsack problem, the problem is considered to be very hard. In the past decade, much effort has been done in order to find techniques which could lead to practical algorithms with reasonable running time. In 1994, Chang et al. proposed a brilliant parallel algorithm, which needs O(2 n/8 ) processors to solve the knapsack problem in O(2 n/2 ) time; that is, the cost of Chang et al.'s parallel algorithm is O(2 5 n/8 ). In this paper, we propose a parallel algorithm to improve Chang et al.'s parallel algorithm by reducing the time complexity to be O(2 3 n/8 ) under the same O(2 n/8 ) processors available. Thus, the proposed parallel algorithm has a cost of O(2 n/2 ). It is an improvement over previous literature. We believe that the proposed parallel algorithm is pragmatically feasible at the moment when multiprocessor systems become more and more popular.

A Cost Optimal Search Technique for the Knapsack Problem

The knapsack problem is known to be a typical NP-complete problem, which has 2n possible solutions to search over. Thus a task for solving the knapsack problem can be accomplished in 2n trials if an exhaustive search is applied. In the past decade, much effort has been devoted in order to reduce the computation time of this problem instead of exhaustive search. In 1984, Karnin proposed a brilliant parallel algorithm, which needs O(2n/6) processors to solve the knapsack problem in O(2n/2) time; that is, the cost of Karnin's parallel algorithm is O(22n/3). In this paper, we propose a fast search technique to improve Karnin's parallel algorithm by reducing the search time complexity of Karnin's parallel algorithm to be O(2n/3) under the same O(2n/6) processors available. Thus, the cost of the proposed parallel algorithm is O(2n/2). Furthermore, we extend this search technique to the case that the number of available processors is P = O(2x), where x ≥ 1. From the analytical results, we see that our search technique is indeed superior to the previously proposed methods. We do believe our proposed parallel algorithm is pragmatically feasible at the moment when multiprocessor systems become more and more popular.

Matrix decomposition on the star graph

We present and evaluate, for the first time, a parallel algorithm for solving the LU decomposition problem on the star graph. The proposed parallel algorithm is of O(N/sup 3//n!) computation complexity and uses O(Nn) communication time to decompose a matrix of order N on a star graph of dimension n, where N/spl ges/(n-1)!. The incurred communication time is better than the best known results for the hypercube, O(Nlogn!), and the mesh, O(N/spl radic/n!), each with approximately n! nodes. The proposed parallel algorithm takes advantage of the attractive topological qualities of the star graph in order to reduce the communication time involved in tasks such as pivoting, row/column interchanges, and pivot row and multipliers column broadcasts.

AN OPTIMAL PARALLEL ALGORITHM TO COLOR AN INTERVAL GRAPH

An optimal parallel algorithm is presented for coloring an interval graph using minimum number of colors. The proposed parallel algorithm takes [Formula: see text] time with P processors on an EREW PRAM.

A parallel progressive radiosity algorithm based on patch data circulation

Current research on radiosity has concentrated on increasing the accuracy and the speed of the solution. Although algorithmic and meshing techniques decrease the execution time, still excessive computational power is required for complex scenes. Hence, parallelism can be exploited for speeding up the method further. This paper aims at providing a thorough examination of parallelism in the basic progressive refinement radiosity, and investigates its parallelization on distributed-memory parallel architectures. A synchronous scheme, based on static task assignment, is proposed to achieve better coherence for shooting patch selections. An efficient global circulation scheme is proposed for the parallel light distribution computations, which reduces the total volume of concurrent communication by an asymptotical factor. The proposed parallel algorithm is implemented on an Intel's iPSC/2 hypercube multicomputer. Load balance qualities of the proposed static assignment schemes are evaluated experimentally. The effect of coherence in the parallel light distribution computations on the shooting patch selection sequence is also investigated. Theoretical and experimental evaluation is also presented to verify that the proposed parallelization scheme yields equally good performance on multicomputers implementing the simplest ( e.g. ring) as well as the richest ( e.g. hypercube) interconnection topologies. This paper also proposes and presents a parallel load re-balancing scheme which enhances our basic parallel radiosity algorithm to be usable in the parallelization of radiosity methods adopting adaptive subdivision and meshing techniques.

３次元画像情報技術 物体の多面体表現からｏｃｔｒｅｅを生成する並列アルゴリズム

We propose a parallel algorithm that efficiently generates an octree from a polyhedral shape representation. The algorithm is simple and applicable to general (non-convex) objects. The parallelized algorithm is based on two ideas for the assignment of multiple processors. The algorithm was implemented and tested on MIMD multi-processors having a shared memory. Experimental results demonstrate the effectiveness and efficiency of the proposed method : for example, only 2.5 seconds are required to generate an octree shape representation from a polyhedral object having 148 polygons. We discuss the performance of the proposed parallel algorithm and the features of the parallelism.

FINDING CENTERS AND MEDIANS OF GRAPHS IN PARALLEL

This paper presents a parallel algorithm for finding the centers and medians of graphs. The computational model used is a shared memory single instruction stream, multiple data stream computer which is more commonly known as the parallel random access machine. The design of the parallel algorithm is based on the growing-by-doubling paradigm. Assuming that the graph consists of n nodes, the proposed parallel algorithm can be implemented in O(log 2 n) time with O(n 2 n/logn) processors when no write-conflict is allowed by the computational model. On the other hand, the algorithm can be implemented in O(log n(loglogn)) time with O(n 2 n/loglogn) processors when the computational model allows write-conflict. In case of write-conflict, it is assumed that all the processors involved in the concurrent-write operation must attempt to write the same value.

Parallel Algorithms for the Edge-Coloring and Edge-Coloring Update Problems

LetG(V,E) be a simple undirected graph with a maximum vertex degree Δ(G) (or Δ for short), |V| =nand |E| =m. An edge-coloring ofGis an assignment to each edge inGa color such that all edges sharing a common vertex have different colors. The minimum number of colors needed is denoted by χ′(G) (called thechromatic index). For a simple graphG, it is known that Δ ≤ χ′(G) ≤ Δ + 1. This paper studies two edge-coloring problems. The first problem is to perform edge-coloring for an existing edge-colored graphGwith Δ + 1 colors stemming from the addition of a new vertex intoG. The proposed parallel algorithm for this problem runs inO(Δ3/2log3Δ + Δ logn) time usingO(max{nΔ, Δ3}) processors. The second problem is to color the edges of a given uncolored graphGwith Δ + 1 colors. For this problem, our first parallel algorithm requiresO(Δ5.5log3Δ logn+ Δ5log4n) time andO(max{n2Δ,nΔ3}) processors, which is a slight improvement on the algorithm by H. J. Karloff and D. B. Shmoys [J. Algorithms8 (1987), 39–52]. Their algorithm costsO(Δ6log4n) time andO(n2Δ) processors if we use the fastest known algorithm for finding maximal independent sets by M. Goldberg and T. Spencer [SIAM J. Discrete Math.2 (1989), 322–328]. Our second algorithm requiresO(Δ4.5log3Δ logn+ Δ4log4n) time andO(max{n2,nΔ3}) processors. Finally, we present our third algorithm by incorporating the second algorithm as a subroutine. This algorithm requiresO(Δ3.5log3Δ logn+ Δ3log4n) time andO(max{n2log Δ,nΔ3}) processors, which improves, by anO(Δ2.5) factor in time, on Karloff and Shmoys' algorithm. All of these algorithms run in the COMMON CRCW PRAM model.

A Technique to Speed Up Parallel Fully Dynamic Algorithms for MST

We provide a new EREW PRAM algorithm to maintain the minimum spanning tree (MST) of an undirected weighted graph. Our approach combines the sparsification data structure with a novel parallel technique which efficiently treats single edge deletions. The proposed parallel algorithm requires O(log n) time and O(n2/3 log(m/n)) work, where n and m are respectively the number of nodes and edges of the given graph.

Nonlinear Transient Dynamic Analysis on Parallel Processors

Abstract: Two approaches for parallel implementation of nonlinear transient dynamic analysis algorithms have been presented in this paper. One is based on geometric decomposition, and the other one is processor‐farm approach. Both shared memory (Magnum IV) and transputer‐based message‐passing systems have been chosen for implementation of the proposed parallel algorithms for dynamic analysis. Multithread concepts have been employed on transputer networks to optimize the code by overlapping communications with computations. Numerical studies indicate that explicit transient dynamic analysis can be implemented effectively employing geometric decomposition technique both on shared and message‐passing systems.

Parallel Implementation of Linear Quadtree Codes Using the nCube 2 Supercomputer System

A new parallel algorithm for the linear quadtree coding scheme, named Two-Dimensional Template-based En coding (2DTE), is designed in this study. The proposed parallel algorithm is implemented on a 32-node nCUBE 2 supercomputer system. There are three pro cessing stages in the proposed parallel algorithm, in cluding data allocation, 2DTE coding scheme, and data merging. The proposed parallel algorithm is expected to render a speedup effect that is approximately pro portional to the number of processors, as compared with the result derived by a single-processor system.

Efficient fast Hartley transform algorithms for hypercube-connected multicomputers

Although fast Hartley transform (FHT) provides efficient spectral analysis of real discrete signals, the literature that addresses the parallelization of FHT is extremely rare. FHT is a real transformation and does not necessitate any complex arithmetics. On the other hand, FHT algorithm has an irregular computational structure which makes efficient parallelization harder. In this paper, we propose an efficient restructuring for the sequential FHT algorithm which brings regularity and symmetry to the computational structure of the FHT. Then, we propose an efficient parallel FHT algorithm for medium-to-coarse grain hypercube multicomputers by introducing a dynamic mapping scheme for the restructured FHT. The proposed parallel algorithm achieves perfect load-balance, minimizes both the number and volume of concurrent communications, allows only nearest-neighbor communications and achieves in-place computation and communication. The proposed algorithm is implemented on a 32 node iPSC/2 hypercube multicomputer, high-efficiency values are obtained even for small size FHT problems.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

THE PARALLEL ALGORITHMS FOR DETERMINING EDGE-PACKING AND EFFICIENT EDGE DOMINATING SETS IN INTERVAL GRAPHS

Recently, it has been shown that resource allocation problems in parallel processing systems can be viewed as edge domination problems in graphs. Other applications of edge domination include encoding theory and network routing problems. In a graph G = (V,E) and edge (u,v) ∈ E is said to dominate itself and any edge (u,x) or (v,x) where x ∈ V. An Edge-Packing (EP) in a graph G is a set of edges (B), B CE such that no edge in E is dominated by more than one edge of B. A subset of edges E’ C E is called an Efficient Edge Domination (EED) set for the graph G if all edges in E are dominated by exactly one edge of E’. The EED problem for general graph is NP-complete. For the series parallel graph a linear time sequential algorithm is available. In this paper, a linear time sequential algorithm is presented to find EP for a weighted interval graph. Parallel algorithms are also presented to find EP for weighted and unweighted interval graphs. For the weighted case, the proposed parallel algorithm takes O(log2n) ...

Parallel Construction of (a, b)-Trees

We present an optimal parallel algorithm for the construction of (a, b)-trees-a generalization of 2-3 trees, 2-3-4 trees, and B-trees. We show the existence of a canonical form for (a, b)-trees, with a very regular structure, which allows us to obtain a scalable parallel algorithm for the construction of a minimum-height (a, b)-tree with N keys in O(N/p + log log N) time using p ≤ N/log log N processors on the EREW-PRAM model, and in O(N/p) time using p ≤ N processors on the CREW model. We show that the average memory utilization for the canonical form is at least 50% better than that for the worst-case and is also better than that for a random (a, b)-tree. A significant feature of the proposed parallel algorithm is that its time-complexity depends neither on a nor on b, and hence our general algorithm is superior to earlier algorithms for parallel construction of B-trees.

Parallel String Matching with Variable Length Don′t Cares

String matching is the problem of finding all the occurrences of a pattern P in a text T, where P and T are strings over a finite alphabet Σ. A variable length don′t care is a special character, not belonging to Σ, which can match any string in Σ*. The string-matching problem with variable length don′t cares is an extension of the classical string-matching problem in which the pattern P may contain an arbitrary number of don′t cares. An efficient parallel algorithm is given for solving the string-matching problem with variable length don′t cares. The EREW PRAM model of parallel computer with scan operations is used to obtain an O(log n) running time using O( mn/log n) processors, where m and n are, respectively, the lengths of P and T. The proposed parallel algorithm has an Ω(1/log n) processor utilization, since the fastest serial algorithm known so far has an O( mn/log n) running time.

Parallel computation of the flow of integral viscoelastic fluids on a heterogeneous network of workstations

AbstractWe consider the parallel computation of flows of integral viscoelastic fluids on a heterogeneous network of workstations. The proposed methodology is relevant to computational mechanics problems which involve a compute‐intensive treatment of internal variables (e.g. fibre suspension flow and deformation of viscoplastic solids). The main parallel computing issue in such applications is that of load balancing. Both static and dynamic allocation of work to processors are considered in the present paper. The proposed parallel algorithms have been implemented in an experimental, parallel version of the commercial POLYFLOW package developed in Louvain‐la‐Neuve. The implementation uses the public domain PVM software library (Parallel Virtual Machine), which we have extended in order to ease porting to heterogeneous networks. We describe parallel efficiency results obtained with three PVM configurations, involving up to seven workstations with maximum relative processing speeds of five. The physical problems are the stick/slip and abrupt contraction flows of a K.B.K.Z. integral fluid. Using static allocation, parallel efficiencies in the range 67%–85% were obtained on a PVM network with four workstations having relative speeds of 2:1:1:1. Parallel efficiencies higher than 90% were obtained on the three PVM configurations using the dynamic load‐balancing schemes.

A PARALLEL SIMULATED ANNEALING-BASED CHANNEL ROUTER

The routing problem of VLSI layout design is very compute intensive. Consequently, the routing task often turns out to be a bottleneck in the layout design of large circuits. Parallel processing of the routing problem holds promise for mitigating this situation. In this context, we present a parallel channel routing algorithm that is targetted to run on loosely coupled computers like hypercubes. The proposed parallel algorithm employs the simulated annealing technique for obtaining near- optimum solutions. Initially, the number of tracks in the channel is made equal to the number of nets, and partitions of the channel are appropriately assigned to the nodes of the hypercube. Each node carries out concurrent perturbations to obtain new channel states that satisfy the constraints for a given net list. The algorithm minimizes the number of tracks iteratively by using the simulated annealing technique. For efficient execution, we attempt to reduce the communication overheads by restricting the broadcast updates to cases of interprocessor net transfers only. Performance evaluation studies of the algorithm show promising results.

A parallel algorithm for the knapsack problem using a generation and searching technique

The purpose of this paper is to propose a new parallel algorithm for the knapsack problem. We develop a generation and searching technique to derive the desired two ordered lists in the preliminary process of the general knapsack problem. The proposed parallel algorithm is developed on the basis of an SIMD machine with shared memory. The algorithm needs O(2 n 4 ) memory and O(2 n 8 ) processors to find a solution for the knapsack problem of n components in time O(2 n 2 ) . The proposed parallel algorithm has a cost of O(2 5n 8 ) which is an improved result over the past researches.