Parallel Recursive Algorithms Research Articles

On Optimization and Parallelization of the Little Algorithm for Solving the Travelling Salesman Problem

The paper describes some ways to speed up solution of the NP-complete Traveling Salesman Problem. The classic Little algorithm, belonging to the class of branch-and-bound methods, can solve it both for directed and undirected graphs. For undirected graphs, however, its speed can be increased by eliminating the branches examined earlier from further consideration. We propose changes to be made in the key operations of the algorithm to speed up execution. In addition, we describe the results of an experiment with a significant increase in the speed of solving of the problem by the advanced algorithm. Another way to speed up the solution procedure is to parallelize the algorithm. For problems of this kind, it is difficult to decompose the task into a sufficient number of subtasks that have comparable complexity. Their parallelism arises dynamically during the execution. For such problems, it seems reasonable to use parallel-recursive algorithms. In our case, the RPM_ParLib library developed by the author is a good approach, enabling the development of high-performance applications for parallel computing on a local network using any.NET-compatible programming language. We selected C# as the programming language. Parallel applications were developed to implement the basic and modified algorithms, as well as to compare them in terms of speed. Experiments were performed for the graphs with up to 45 vertexes and up to 16 network computers. We also investigated the speed increase that can be achieved by parallelizing the basic Little algorithm for directed graphs. The results of these experiments are also presented in the paper.

On the Optimization and Parallelizing Little Algorithm for Solving the Traveling Salesman Problem

The paper describes some ways to accelerate solving the NP-complete Traveling Salesman Problem. The classic Little algorithm belonging to the category of ”branch and bound methods” can solve it both for directed and undirected graphs. However, for undirected graphs its operation can be accelerated by eliminating the consideration of branches examined earlier. The paper proposes changes to be made in the key operations of the algorithm to speed up its execution. It also describes the results of an experiment that demonstrated a significant acceleration of solving the problem by using an advanced algorithm. Another way to speed up the work is to parallelize the algorithm. For problems of this kind it is difficult to break the task into a sufficient number of subtasks having comparable complexity. Their parallelism arises dynamically during the execution. For such problems, it seems reasonable to use parallel-recursive algorithms. In our case the use of the library RPM ParLib developed by the author was a good choice. It allows us to develop effective applications for parallel computing on a local network using any .NET-compatible programming language. We used C# to develop the programs. Parallel applications were developed as for basic and modified algorithms, the comparing of their speed was made. Experiments were performed for the graphs with the number of vertexes up to 45 and with the number of network computers up to 16. We also investigated the acceleration that can be achieved by parallelizing the basic Little algorithm for directed graphs. The results of these experiments are also presented in the paper.

Recursion and parallel algorithms in geometric modeling problems

An efficient approach to the accurate computer modeling of phenomena and processes is discussed. The "divide-and-conquer" technique is used to develop a generalized parallel-recursive algorithm for simultaneous solution of a collection of interrelated problems that use a common unified data structure (weighted concatenable queue) at the merge stage. The decomposition stage is common and is executed only once for all tasks. These means are efficient and convenient for constructing and studying complex computational models.

An approximation-based approach to computing image moment invariants

A fast method for computing Hu’s image moment invariants is described. The invariants are found by approximation using generalized moments computed in a sliding window by a parallel recursive algorithm. The proposed method is shown to be computationally more efficient than direct computation.

Evaluation of a compiler with user‐selectable execution strategies for parallel recursion

AbstractThe strategy of evenly distributing processors to each recursive call and the strategy of performing dynamic load‐balancing exist as strategies for executing parallel recursions. There are cases in which an execution strategy efficient for a certain parallel recursive algorithm is not efficient for another parallel recursive algorithm depending on the operation of the parallel recursion algorithm. In addition, there are cases in which the execution efficiency decreases due to overparallelization of recursive calls due to factors such as the communication efficiency of a parallel computing environment. On the one hand, it is not easy for a compiler to analyze these factors mechanically from source programs of a parallel recursive algorithm, select an optimal execution strategy, and suppress overparallelization. In general, in many cases, a programmer understands parallel recursive algorithms and can predict which execution strategy is suitable for the algorithm. Thus, if a programmer can specify a parallel recursive execution strategy or specify a decision to suppress overparallelization, parallel recursive algorithms can be executed efficiently. This paper proposes a strategy for a programmer to clearly designate information useful for efficiently executing parallel recursion. In addition, it shows differences in the performance of various execution strategies of parallel recursive algorithms and shows the usefulness of a programmer having the capability to select an execution strategy. © 2004 Wiley Periodicals, Inc. Syst Comp Jpn, 35(9): 92–103, 2004; Published online in Wiley InterScience (www.interscience.wiley.com). DOI 10.1002/scj.10009

A unified algebraic transformation approach for parallel recursive and adaptive filtering and SVD algorithms

In this paper, a unified algebraic transformation approach is presented for designing parallel recursive and adaptive digital filters and singular value decomposition (SVD) algorithms. The approach is based on the explorations of some algebraic properties of the target algorithms' representations. Several typical modern digital signal processing examples are presented to illustrate the applications of the technique. They include the cascaded orthogonal recursive digital filter, the Givens rotation-based adaptive inverse QR algorithm for channel equalization, and the QR decomposition-based SVD algorithms. All three examples exhibit similar throughput constraints. There exist long feedback loops in the algorithms' signal flow graph representation, and the critical path is proportional to the size of the problem. Applying the proposed algebraic transformation techniques, parallel architectures are obtained for all three examples. For cascade orthogonal recursive filter, retiming transformation and orthogonal matrix decompositions (or pseudo-commutativity) are applied to obtain parallel filter architectures with critical path of five Givens rotations. For adaptive inverse QR algorithm, the commutativity and associativity of the matrix multiplications are applied to obtain parallel architectures with critical path of either four Givens rotations or three Givens rotations plus two multiply-add operations, whichever turns out to be larger. For SVD algorithms, retiming and associativity of the matrix multiplications are applied to derive parallel architectures with critical path of eight Givens rotations. The critical paths of all parallel architectures are independent of the problem size as compared with being proportional to the problem size in the original sequential algorithms. Parallelism is achieved at the expense of slight increase (or the same for the SVD case) in the algorithms' computational complexity.

Solutions of two minmax recurrences in parallel processing with variable recombination overhead

A variety of parallel algorithms are based on the paradigm of recursion. However, because of the partition and recombination overheads involved, such algorithms may perform poorly on real architectures. This paper deals with solutions of two minmax recurrence relations that result from optimal execution of parallel recursive algorithms in the presence of variable recombination overheads and constant partition overheads. We solve two models with the recombination overheads shown as a linear function of the partition size and the problem size, respectively. For model 1, we show that the optimal partition sizes for problem size n at any stage of the recursion can easily be found in O(log log n) time using an O(log n) size table. Model 2 is solved for cases k ≤ λ and k > λ, where k and λ are constants related to the parallel computing overheads. For the first case, the optimal partition size is derived to be [ n 2 ] and a closed-form solution of the complexity is exactly characterized. For the second case, the optimal partition size is found to be in the range [ (n − t) 2 ] ± 1 , where t is a nonnegative constant that depends on k and λ, and the overall complexity is shown to be O(2 λn + ( k − λt)log 2( n + t)). This paper develops the theory of solutions of minmax recurrences and provides some insight into this area of computational mathematics which has received little attention so far.

A Self-Tuning Type Neural Net Controller For Robotic Manipulators

ABSTRACTThis article presents a self-tuning type neural net controller for robotic manipulators. A parallel recursive adaptation algorithm is described for on-line implementation of the neural net controller. The proposed control scheme does not require any information about the system dynamics. The control system was implemented for a cylindrical robot by computer simulation. The simulation result shows the effectiveness of the neural net controller and its adaptation and learning capability for nonlinear time-varying robot systems.

Adaptive mesh generation for surface reconstruction—parallel hierarchical triangulation without cracks

This paper describes a method of precisely and effectively visualizing a complex 3-dimensionally curved surface from a set of range data by using meshes (parallel hierarchical triangulation) which are adaptive to the degree of its complexity. The method can reconstruct the curved surface without cracks by approximating its intrinsic shape and discontinuity with a polygon. The algorithm used can be processed by fact parallel local calculations with an upper limit in time and space. This paper proposes a parallel recursive algorithm for generating an adaptive mesh using a 3D-curvature based on the intrinsic shape of an object, and another parallel recursive algorithm to avoid the formation of a crack which occurs between two subdivisions. Experimental results applied to range images of human faces are shown. The proposed method can be applied to general images (e.g., gray-level image and color images) other than range images so that the compression or reconstruction of an image can be carried out by adaptively using its geometrical features (e.g., the pixel value, its first-order differential, and second order differential).

Parallel Recursive Algorithms in Asymptotically Efficient Adaptive Control of Linear Stochastic Systems

First, a review of some recent developments in stochastic adaptive control of linear stochastic systems is given. By integrating and refining several basic ideas in these developments, a relatively complete asymptotic solution to the adaptive control problem is then provided for such systems. The solution involves parallel implementation of a few basic recursive identification algorithms that serve to complement each other. It also involves occasional use of a dither signal to probe the system for information.

Improved deterministic parallel integer sorting

We consider the problem of deterministic sorting of integers on a parallel RAM (PRAM). The best previous result ( T. Hagerup, 1987 , Inform. and Comput. 75 , 39–51) states that n integers of size polynomial in n can be sorted in time O (log n ) on a Priority CRCW PRAM with O( n log log n log n ) processors. We prove that n integers drawn from a set {0, …, m −1} can be sorted on an Arbitrary CRCW PRAM in time O( log n log log n + log log m) with a time-processor product of O ( n log log m ). In particular, if m = n (log n ) O (1) , the time and number of processors used are O( log n log log n ) and O( n( log log n) 2 log n ) , respectively. This improves the previous result in several respects: The new algorithm is faster, it works on a weaker PRAM model, and it is closer to optimality for input numbers of superpolynomial size. If log log m = O( log n log log n ) , the new algorithm is optimally fast, for any polynomial number of processors, and if log log m = (1 + Ω(1)) log log n and log log m = 0 ( log n ), it has optimal speedup relative to the fastest known sequential algorithm. The space needed is O ( nm ε ), for arbitrary but fixed ε > 0. The sorting algorithm derives its speed from a fast solution to a special list ranking problem of possible independent interest, the monotonic list ranking problem . In monotonic list ranking, each list element has an associated key, and the keys are known to increase monotonically along the list. We show that monotonic list ranking problems of size n can be solved optimally in time O( log n log log n ) . We also discuss and attempt to solve some of the problems arising in the precise description and implementation of parallel recursive algorithms. As part of this effort, we introduce a new PRAM variant, the allocated PRAM .

Getting graphics in gear

Man-in-the-loop simulation uses a person in the control loop to provide feedback to the system operations. Proper operator cueing must be provided to ensure a realistic response. Real-time computer graphics and dynamics both play dominant roles in providing these necessary cues. Dynamics simulation of modern vehicles requires a multi-body non-linear approach for acceptable fidelity of motion. A vehicle can be modeled as a set of linked rigid bodies, whose connections are described by a graph. Real-time constraints on the computation of non-linear dynamics equations require the development of naturally parallel recursive algorithms, whose organization closely follows the system graph. Significant speed-up can be accomplished using these parallel algorithms.

On supercomputing with systolic/wavefront array processors

In many scientific and signal processing applications, there are increasing demands for large-volume and/or high-speed computations which call for not only high-speed computing hardware, but also for novel approaches in computer architecture and software techniques in future supercomputers. Tremendous progress has been made on several promising parallel architectures for scientific computations, including a variety of digital filters, fast Fourier transform (FFT) processors, data-flow processors, systolic arrays, and wavefront arrays. This paper describes these computing networks in terms of signal-flow graphs (SFG) or data-flow graphs (DFG), and proposes a methodology of converting SFG computing networks into synchronous systolic arrays or data-driven wavefront arrays. Both one- and two-dimensional arrays are discussed theoretically, as well as with illustrative examples. A wavefront-oriented programming language, which describes the (parallel) data flow in systolic/wavefront-type arrays, is presented. The structural property of parallel recursive algorithms points to the feasibility of a Hierarchical Iterative Flow-Graph Design (HIFD) of VLSI Array Processors. The proposed array processor architectures, we believe, will have significant impact on the development of future supercomputers.