Downloads & Free Reading Options - Results

High-end graphics workstations provide us with the ability to interactively display polygonal models of high geometric complexity. It is our hope that future graphics workstations will also provide us with shading models that go beyond Gouraud shading of polygons. This paper describes performance improvements that result from storing a polygon's shading parameters at each pixel and deferring the shading calculations until all the polygons have been processed. One benefit of this approach is that the shading calculations are only performed on the parts of a surface that are visible, which means that this method becomes more attractive as shading models become more complex and as the depth complexity of the scene increases. We also show how this method can be used to produce real-time images that incorporate Phong shading and procedural texture mapping on Pixel-Planes 5. Pixel-Planes 5 is a massively parallel SIMD machine that is under construction at UNC. Since the processing elements of Pixel-Planes are fully programmable, new shading models can be incorporated in the system without any hardware modifications.

Many theorems in graph theory give simple characterizations for testing the existence of objects with certain properties, which can be translated into fast parallel algorithms. However, transforming these tests into algorithms for constructing such objects is often a real challenge. In this thesis we develop fast parallel (NC) algorithms for several such construction problems. The first part is about tournaments. (A tournament is a digraph in which there is precisely one arc between every two vertices.) Two classical results state that every tournament has a Hamiltonian path and every strongly connected tournament has a Hamiltonian cycle. We derive efficient parallel algorithms for finding these objects. Our algorithms yield new proofs of these theorems. In solving the cycle problem we also solve the problem of finding a Hamiltonian path with one fixed endpoint. Next we address the problem of constructing a tournament with a specified degree-sequence, and give an NC algorithm for it which achieves optimal speedup. The second part is concerned with making graphs strongly connected via orientation and augmentation. A graph is strongly orientable if its edges can be assigned orientations to yield a strongly connected digraph. Robbins' theorem states the conditions for a graph to be strongly orientable. His theorem was generalized for mixed graphs, i.e. ones that have both directed and undirected edges. We give a fast parallel algorithm for strongly orienting mixed graphs. We then solve the problem of adding a minimum number of arcs to a mixed graph to make it strongly orientable. This problem was not previously known to have even a polynomial time sequential solution \201a sequential algorithm was discovered independently by Gusfield\202. In the process of solving the general problem we derive solutions for the special cases of undirected graphs. The final part of the thesis describes a methodology which yields deterministic parallel algorithms.

Sequential multi-constraint graph partitioners have been developed to address the load balancing requirements of multi-phase simulations. the efficient execution of large multi-phase simulations on high performance parallel computer requires that the multi-constraint partitionings are computed in parallel. This paper presents a parallel formulation of a recently developed multi-constraint graph partitioning algorithm. We describe this algorithm and give experimental results conducted on a 128-processor Cray T3E. We show that our parallel algorithm is able to efficiently compute partitionings of similar edge-cuts as serial multi-constraint algorithms, and can scale to very large graphs. Our parallel multi-constraint graph partitioner is able to compute a three-constrain 128-way partitioning of a 7.5 million node graph in about 7 seconds on 128 processors of a Cray T3E.

The existence of parallel computers has motivated the development of parallel problems solving techniques for many problems. Techniques are studied for solving graph problems on an unbounded parallel model of computation. It is shown that solutions to graph problems can be organized to reveal a large amount of parallelism, which can be exploited to substantially reduce the computation time. Precisely, for an appropriate measure of time complexity, algorithms of time complexity 0 log-squared n are developed to solve each of the following problems for graphs with n vertices: finding minimum spanning trees, biconnected components, dominators, bridges, cycles, cycle bases, and shortest cycles. The number of processors needed to execute each algorithm is bounded above by a polynomial function of n. It is shown that 2 log n + c is a lower bound on the time required to solve each of these graph problems. Thus, the algorithms obtained have time complexities which are optimal to within a factor of log n.

Two algorithms for channel routing using simulated annealing are presented. Simulated annealing is an optimization methodology which allows the solution process to back up out of local minima that may be encountered by inappropriate selections. By properly controlling the annealing process, it is very likely that the optimal solution to an NP-complete problem such as channel routing may be found. The algorithm presented proposes very relaxed restrictions on the types of allowable transformations, including overlapping nets. By freeing that restriction and controlling overlap situations with an appropriate cost function, the algorithm becomes very flexible and can be applied to many extensions of channel routing. The selection of the transformation utilizes a number of heuristics, still retaining the pseudorandom nature of simulated annealing. The algorithm was implemented as a serial program for a workstation, and a parallel program designed for a hypercube computer. The details of the serial implementation are presented, including many of the heuristics used and some of the resulting solutions.

The fastest known algorithms for the solution of a large elliptic boundary value problem on a massively parallel hypercube all require O(log(n)) floating point operations and O(log(n)) distance-1 communications, if massively parallel is defined to mean a number of processors proportional to the size n of the problem. The Totally Parallel Multilevel Algorithm (TPMA) that has, as special cases, four of these fast algorithms is described. These four algorithms are Parallel Superconvergent Multigrid (PSMG), Robust Multigrid, the Fast Fourier Transformation (FFT) based Spectral Algorithm, and Parallel Cyclic Reduction. The algorithm TPMA, when described recursively, has four steps: (1) project to a collection of interlaced, coarser problems at the next lower level; (2) apply TPMA, recursively, to each of these lower level problems, solving directly at the lowest level; (3) interpolate these approximate solutions to the finer grid, and to verage them to form an approximate solution on this grid; and (4) refine this approximate solution with a defect-correction step, using a local approximate inverse. Choice of the projection operator (P), the interpolation operator (Q), and the smoother (S) determines the class of problems on which TPMA is most effective. There are special cases in which the first three steps produce an exact solution, and the smoother is not needed (e.g., constant coefficient operators).

Typical desktop workstations can be a severe bottleneck in the viewing and enhancement of imagery data. Due to the nature of many image processing algorithms, an effective method for alleviating this problem is through parallelism. Parallel hardware can come in many forms, from small clusters of workstations and workstations with many processors to dedicated hardware containing 10's, 100's and 1000's of processing nodes. One of the challenges is developing a portable parallel image processing library in such a potentially diverse environment. These issues led to the development of a Parallel Image Processing Toolkit (PIPT). The toolkit hides the detail of parallelization from the users of the PIPT and provides a uniform programming interface. In developing the toolkit the issues of advanced data handling, load, balancing and parallel visualization were addressed. In addition a specific computationally expensive High Resolution Video Stills algorithm was implemented within the PIPT. The important contributions that resulted from this work transcend the individual tasks that were undertaken. First, the general approach that was taken to implement the PIPT illustrates several important principles for the design and implementation of general purpose parallel libraries. in this regard, the PIPT design can serve as a design pattern for an extensible parallel library. Second, the design pattern of the current implementation of the PIPT contains some notable attempts at programming image processing tasks in a generic fashion.

The main accomplishments during this grant period are in the following areas: (1) Fast parallel algorithms for Legendre and spherical transforms. The accomplishments in this area effectively break down into two subareas, namely: (a) Development of fast algorithms for the discrete Legendre transform (FLT). (b) Development of factorizations of the Fourier transform (FFT) and the cosine transform (FCT) adapted for the use in spherical transforms. (2) Fast N-body algorithms. (3) Efficient parallel codes for electromagnetic field computations.

Parallel computing promises several orders of magnitude increase in our ability to solve realistic computationally-intensive problems, but relies on their efficient mapping and execution on large-scale multiprocessor architectures. Unfortunately, many important applications are irregular and dynamic in nature, making their effective parallel implementation a daunting task. Moreover, with the proliferation of parallel architectures and programming paradigms, the typical scientist is faced with a plethora of questions that must be answered in order to obtain an acceptable parallel implementation of the solution algorithm. In this paper, we consider three representative irregular applications: unstructured remeshing, sparse matrix computations, and N-body problems, and parallelize them using various popular programming paradigms on a wide spectrum of computer platforms ranging from state-of-the-art supercomputers to PC clusters. We present the underlying problems, the solution algorithms, and the parallel implementation strategies. Smart load-balancing, partitioning, and ordering techniques are used to enhance parallel performance. Overall results demonstrate the complexity of efficiently parallelizing irregular algorithms.

Two new parallel optimization algorithms based on the simplex method are described. They may be executed by a SIMD parallel processor architecture and be implemented in VLSI design. Several VLSI design implementations are introduced. An application example is reported to demonstrate that the algorithms are effective.

The convergence rate of standard multigrid algorithms degenerates on problems with stretched grids or anisotropic operators. The usual cure for this is the use of line or plane relaxation. However, multigrid algorithms based on line and plane relaxation have limited and awkward parallelism and are quite difficult to map effectively to highly parallel architectures. Newer multigrid algorithms that overcome anisotropy through the use of multiple coarse grids rather than relaxation are better suited to massively parallel architectures because they require only simple point-relaxation smoothers. In this paper, we look at the parallel implementation of a V-cycle multiple semicoarsened grid (MSG) algorithm on distributed-memory architectures such as the Intel iPSC/860 and Paragon computers. The MSG algorithms provide two levels of parallelism: parallelism within the relaxation or interpolation on each grid and across the grids on each multigrid level. Both levels of parallelism must be exploited to map these algorithms effectively to parallel architectures. This paper describes a mapping of an MSG algorithm to distributed-memory architectures that demonstrates how both levels of parallelism can be exploited. The result is a robust and effective multigrid algorithm for distributed-memory machines.

This contract developed and disseminated papers, ideas, algorithms, analysis, software, applications, and implementations for parallel programming environments for computer vision and for vision applications. The work has been widely reported and highly influential. The most significant work centered on the Butterfly Parallel Processor, the MaxVideo pipelined parallel image processor, and the development of the real-time computer vision laboratory. For the Butterfly, the Psyche multi-model operating system was developed and the CONSUL autoparallelizing compiler was designed. Much basic and influential performance monitoring and debugging work was completed, resulting in working systems and novel algorithms. There was also significant research in systems and applications using other parallel architectures in the laboratory, such as the MaxVideo parallel pipelined image processor. The contract developed a heterogeneous parallel architecture involving pipelined and MIMD parallelism and integrated it with a robot head.

A new algorithm for the multiprocessor computation of the multidimensional discrete Fourier transform is presented. The algorithm eliminates the need for interprocessor communication and is highly scalable. The cost of eliminating interprocessor communication by this method is that one addition must be performed at each processing element for every input loaded into the machine. The algorithm is based on a new multidimensional discrete Fourier transform algorithm that computes a d-dimensional discrete Fourier transform by a set of independent k-dimensional discrete Fourier transforms (kd); it is a reduction algorithm in the sense that it has lowered the dimension of the Fourier transforms that are computed. The k-dimensional discrete Fourier transforms are performed on data derived from the input using only additions, and produce k-dimensional hyperplanes of the output array. Multidimensional discrete fourier transform algorithms, Parallel algorithms.

Matrix multiplication is one of the most fundamental algorithmic problems in numerical linear algebra, distributed computing, scientific computing, and high-performance computing. Parallelization of matrix multiplication has been extensively studied (e.g., [21, 12, 24, 2, 51, 39, 36, 23, 45, 61]). It has been addressed using many theoretical approaches, algorithmic tools, and software engineering methods in order to optimize performance and obtain faster and more efficient parallel algorithms and implementations. To design efficient parallel algorithms, it is necessary not only to load balance the computation, but also to minimize the time spent communicating between processors. The interprocessor communication costs are in many cases significantly higher than the computational costs. Moreover, hardware trends predict that more problems will become communication-bound in the future [38, 35]. Even matrix multiplication, which is widely considered to be computation-bound, becomes communication-bound when a given problem is run on sufficiently many processors.

A graph-theoretic design process and software tool is presented for selecting a multiprocessing scheduling solution for a class of computational problems. The problems of interest are those that can be described using a dataflow graph and are intended to be executed repetitively on a set of identical parallel processors. Typical applications include signal processing and control law problems. Graph analysis techniques are introduced and shown to effectively determine performance bounds, scheduling constraints, and resource requirements. The software tool is shown to facilitate the application of the design process to a given problem.

This paper presents the first sublinear-time deterministic parallel algorithms for bipartite matching and several related problems, including maximal node-disjoint paths, depth-first search, and flows in zero-one networks. Our results are based on a better understanding of the combinatorial structure of the above problems, which leads to new algorithmic techniques. In particular, we show how to use maximal matching to extend, in parallel, a current set of node-disjoint paths and how to take advantage of the parallelism that arises when a large number of nodes are active during an execution of a push/relabel network flow algorithm. We also show how to apply our techniques to design parallel algorithms for the weighted versions of the above problems. In particular, we present sublinear-time deterministic parallel algorithms for dining a minimum-weight bipartite matching and for finding a minimum-cost flow in a network with zero-one capacities, if the weights are polynomially bounded integers.

We obtain fast parallel algorithms for several scheduling problems. Some of the problems considered are: scheduling to minimize the number of tardy jobs; job sequencing with deadlines; scheduling to minimize earliness and tardiness penalties; channel assignment; and minimizing the mean finish time. The shared memory model of parallel computers is used. (Author)

A rather comprehensive survey of parallel sorting algorithms is included herein. Parallel sorting algorithms are considered in two major categories - the internal parallel sorting algorithms and the external parallel sorting algorithms. Because external sorting algorithms are important to the database applications, considerable emphases are made in the motivation and analysis of the external parallel sorting algorithms surveyed in the report. In particular, the authors of this report have conducted research in external parallel sorting algorithms and made some important contributions. Their findings are also reported herein. (Author)

The principal focus of our research is a new systematic approach to design optimal control algorithms that may be implemented on parallel machines. This approach is based on a two-level parametrization of first-order optimality conditions. The first level of parametrization is concerned with the decrease of the overall amount of operations, and the second level is concerned with parallelism. By introducing parametrization matrices in the first level and then factoring those matrices to exhibit the amount of parallelism desired in the second level as a function of the number of processing elements to be used, the resulting optimality conditions may be tailored to the computing network on which the computations are to be performed. Algorithm, Parallelism, Optimal control, Computer systems, Fault tolerant. (jes)

This report describes development of a new hierarchical spectral basis appropriate for hp-finite element formulations on unstructured grids consisting of triangular and tetrahedral subdomains. The new multi-resolution basis has the following properties: (1) Jacobi polynomials of mixed weights, (2) Semi-orthogonality, leading to great sparsity, (3) Hierarchical structure, (4) Generalized tensor products, (5) Mixed order expansions, which provides great flexibility in adaptive discretizations, and 6) Gauss-Jacobi quadratures that minimize errors in complicated geometries. The accuracy of this method has been tested in two and three dimensions. Importantly, numerical results verified that the new hierarchical basis exhibits convergence even for highly distorted meshes.

We study efficient deterministic executions of parallel algorithms on restartable fail-stop CRCW PRAMs. We allow the PRAM processors to be subject to arbitrary stop failures and restarts, that are determined by on-line adversary, and that result in loss of private memory but do not affect shared memory. For this model, we define and justify the complexity measures of: completed work, where processors are charged for completed fixed-size update cycles, and overhead ratio, which amortizes the work over necessary work and failures. We observe that P = N restartable fail-stop processors, the Write-All problem requires omega(N log N) completed work, and this lower bound holds even under the additional assumption that processors can read and locally process the entire shared memory at unit cost. Under this unrealistic assumption we have a matching upperbound. The lower bound also applies to the expected completed work of randomized algorithms that are subject to on line adversaries. Finally, we describe a simple on-line adversary that causes inefficiency in may randomized algorithms.

For a variety of reasons, realistic computer rendering is an important technology; it creates a wide range of new possibilities for effectively communicating information. The crucial goal is to provide realistic images in a short period of time. Ray tracing is a powerful technique for rendering. It is conceptually simple, and can produce effects beyond the capability of some other more traditional methods. Unfortunately, ray tracing is rather expensive by comparison. This project is aimed at producing a reasonably fast and efficient ray tracer based on parallel ray tracing algorithms. The code is written in NESL, a data-parallel language developed by Guy Blelloch. It is supported on Cray YMP, Connection Machine CNI-2, and serial workstation platforms.... Realistic rendering, Ray tracing, Parallel ray tracing.

We consider algorithms for going from a "full" matrix to a condensed "band bidiagonal" form using orthogonal transformations. We use the framework of "algorithms by tiles". Within this framework, we study: (i) the tiled bidiagonalization algorithm BiDiag, which is a tiled version of the standard scalar bidiagonalization algorithm; and (ii) the R-bidiagonalization algorithm R-BiDiag, which is a tiled version of the algorithm which consists in first performing the QR factorization of the initial matrix, then performing the band-bidiagonalization of the R-factor. For both bidiagonalization algorithms BiDiag and R-BiDiag, we use four main types of reduction trees, namely FlatTS, FlatTT, Greedy, and a newly introduced auto-adaptive tree, Auto. We provide a study of critical path lengths for these tiled algorithms, which shows that (i) R-BiDiag has a shorter critical path length than BiDiag for tall and skinny matrices, and (ii) Greedy based schemes are much better than earlier proposed variants with unbounded resources. We provide experiments on a single multicore node, and on a few multicore nodes of a parallel distributed shared-memory system, to show the superiority of the new algorithms on a variety of matrix sizes, matrix shapes and core counts.

We present a new programming paradigm which can be useful, in particular, for implementing window interfaces and parallel algorithms. This paradigm allows a user to define operators which can contain nested operators. The new paradigm is called operator-oriented. One of the goals of this paradigm is to escape the complexity of objects definitions inherent in many object-oriented languages and to move to transparent algorithms definitions.

We present a new programming paradigm which can be useful, in particular, for implementing window interfaces and parallel algorithms. This paradigm allows a user to define operators which can contain nested operators. The new paradigm is called operator-oriented. One of the goals of this paradigm is to escape the complexity of objects definitions inherent in many object-oriented languages and to move to transparent algorithms definitions.

We present a new programming paradigm which can be useful, in particular, for implementing window interfaces and parallel algorithms. This paradigm allows a user to define operators which can contain nested operators. The new paradigm is called operator-oriented. One of the goals of this paradigm is to escape the complexity of objects definitions inherent in many object-oriented languages and to move to transparent algorithms definitions.

In this paper we introduce the design and implementation of two parallel algorithms for solving the general tridiagonal linear system of equations using two new parallel algorithms: Parallel splitting Gauss – Jordan and the general parallel splitting Gauss Jordan algorithms. These algorithms are very easily distributed over different number of processors. In addition our implementations are very efficient, generally a linear speed-up is obtained by increasing the number of processors

In this paper we introduce the design and implementation of two parallel algorithms for solving the general tridiagonal linear system of equations using two new parallel algorithms: Parallel splitting Gauss – Jordan and the general parallel splitting Gauss Jordan algorithms. These algorithms are very easily distributed over different number of processors. In addition our implementations are very efficient, generally a linear speed-up is obtained by increasing the number of processors

In this paper, we propose the new block collocation methods for solving stiff systems of ordinary differential equations with automatic step size, which initially are focused on the parallel architecture. The basic idea, which underlies the development of the proposed methods, is to obtain simultaneously the approximation of the exact solution in all the estimated points of the 

v. p. 28 cm

v. p. 28 cm

Book Source: Digital Library of India Item 2015.193949 dc.contributor.author: A.pavan Reddy dc.date.accessioned: 2015-07-08T03:38:55Z dc.date.available: 2015-07-08T03:38:55Z dc.date.digitalpublicationdate: 2005-09-27 dc.identifier.barcode: 1990010092229 dc.identifier.origpath: /rawdataupload/upload/0092/229 dc.identifier.copyno: 1 dc.identifier.uri: http://www.new.dli.ernet.in/handle/2015/193949 dc.description.scannerno: 14 dc.description.scanningcentre: IIIT, Allahabad dc.description.main: 1 dc.description.tagged: 0 dc.description.totalpages: 63 dc.format.mimetype: application/pdf dc.language.iso: English dc.publisher: Indian Institute Of Technology Kanpur dc.rights: Out_of_copyright dc.source.library: Indian Institute Of Technology Kanpur dc.subject.classification: Technology dc.subject.classification: Engineering. Technology In General dc.subject.classification: Computer Science & Engineering dc.title: Parallel Algorithms For Some Compu.geometry Problems

Book Source: Digital Library of India Item 2015.193949 dc.contributor.author: A.pavan Reddy dc.date.accessioned: 2015-07-08T03:38:55Z dc.date.available: 2015-07-08T03:38:55Z dc.date.digitalpublicationdate: 2005-09-27 dc.identifier.barcode: 1990010092229 dc.identifier.origpath: /rawdataupload/upload/0092/229 dc.identifier.copyno: 1 dc.identifier.uri: http://www.new.dli.ernet.in/handle/2015/193949 dc.description.scannerno: 14 dc.description.scanningcentre: IIIT, Allahabad dc.description.main: 1 dc.description.tagged: 0 dc.description.totalpages: 63 dc.format.mimetype: application/pdf dc.language.iso: English dc.publisher: Indian Institute Of Technology Kanpur dc.rights: Out_of_copyright dc.source.library: Indian Institute Of Technology Kanpur dc.subject.classification: Technology dc.subject.classification: Engineering. Technology In General dc.subject.classification: Computer Science & Engineering dc.title: Parallel Algorithms For Some Compu.geometry Problems

Book Source: Digital Library of India Item 2015.193949 dc.contributor.author: A.pavan Reddy dc.date.accessioned: 2015-07-08T03:38:55Z dc.date.available: 2015-07-08T03:38:55Z dc.date.digitalpublicationdate: 2005-09-27 dc.identifier.barcode: 1990010092229 dc.identifier.origpath: /rawdataupload/upload/0092/229 dc.identifier.copyno: 1 dc.identifier.uri: http://www.new.dli.ernet.in/handle/2015/193949 dc.description.scannerno: 14 dc.description.scanningcentre: IIIT, Allahabad dc.description.main: 1 dc.description.tagged: 0 dc.description.totalpages: 63 dc.format.mimetype: application/pdf dc.language.iso: English dc.publisher: Indian Institute Of Technology Kanpur dc.rights: Out_of_copyright dc.source.library: Indian Institute Of Technology Kanpur dc.subject.classification: Technology dc.subject.classification: Engineering. Technology In General dc.subject.classification: Computer Science & Engineering dc.title: Parallel Algorithms For Some Compu.geometry Problems

Book Source: Digital Library of India Item 2015.199421 dc.contributor.author: Sajith .g dc.date.accessioned: 2015-07-08T13:13:18Z dc.date.available: 2015-07-08T13:13:18Z dc.date.digitalpublicationdate: 2005-08-27 dc.identifier.barcode: 5990010101796 dc.identifier.origpath: /rawdataupload/upload/0101/798 dc.identifier.copyno: 1 dc.identifier.uri: http://www.new.dli.ernet.in/handle/2015/199421 dc.description.scannerno: 14 dc.description.scanningcentre: IIIT, Allahabad dc.description.main: 1 dc.description.tagged: 0 dc.description.totalpages: 61 dc.format.mimetype: application/pdf dc.language.iso: English dc.publisher: Indian Institute Of Technology Kanpur dc.rights: Out_of_copyright dc.source.library: Indian Institute Of Technology Kanpur dc.subject.classification: Technology dc.subject.classification: Computer Science And Engineering dc.title: Parallel Ram Algorithms For Colouring Graphs

Book Source: Digital Library of India Item 2015.199421 dc.contributor.author: Sajith .g dc.date.accessioned: 2015-07-08T13:13:18Z dc.date.available: 2015-07-08T13:13:18Z dc.date.digitalpublicationdate: 2005-08-27 dc.identifier.barcode: 5990010101796 dc.identifier.origpath: /rawdataupload/upload/0101/798 dc.identifier.copyno: 1 dc.identifier.uri: http://www.new.dli.ernet.in/handle/2015/199421 dc.description.scannerno: 14 dc.description.scanningcentre: IIIT, Allahabad dc.description.main: 1 dc.description.tagged: 0 dc.description.totalpages: 61 dc.format.mimetype: application/pdf dc.language.iso: English dc.publisher: Indian Institute Of Technology Kanpur dc.rights: Out_of_copyright dc.source.library: Indian Institute Of Technology Kanpur dc.subject.classification: Technology dc.subject.classification: Computer Science And Engineering dc.title: Parallel Ram Algorithms For Colouring Graphs

Book Source: Digital Library of India Item 2015.199421 dc.contributor.author: Sajith .g dc.date.accessioned: 2015-07-08T13:13:18Z dc.date.available: 2015-07-08T13:13:18Z dc.date.digitalpublicationdate: 2005-08-27 dc.identifier.barcode: 5990010101796 dc.identifier.origpath: /rawdataupload/upload/0101/798 dc.identifier.copyno: 1 dc.identifier.uri: http://www.new.dli.ernet.in/handle/2015/199421 dc.description.scannerno: 14 dc.description.scanningcentre: IIIT, Allahabad dc.description.main: 1 dc.description.tagged: 0 dc.description.totalpages: 61 dc.format.mimetype: application/pdf dc.language.iso: English dc.publisher: Indian Institute Of Technology Kanpur dc.rights: Out_of_copyright dc.source.library: Indian Institute Of Technology Kanpur dc.subject.classification: Technology dc.subject.classification: Computer Science And Engineering dc.title: Parallel Ram Algorithms For Colouring Graphs

We consider the channel ronting problem of a set of multi-terminal nets in the knock-knee model. We develop a new approach to route all the nets within d+ alpha tracks, where d is the channel density, and 0 alpha d, such that the corresponding layout can be realized with three layers. Both the routing and the layer assignment algorithms have linear time sequential implementations. In addition both can be implemented on the CREW-PRAM model in 0(n/p + logn) time, with p processors, 1 p n, and n is the size of the input.

Least mean square-partial parallel interference cancelation (LMS-PPIC) is a partial interference cancelation using adaptive multistage structure in which the normalized least mean square (NLMS) adaptive algorithm is engaged to obtain the cancelation weights. The performance of the NLMS algorithm is mostly dependent to its step-size. A fixed and non-optimized step-size causes the propagation of error from one stage to the next one. When all user channels are balanced, the unit magnitude is the principal property of the cancelation weight elements. Based on this fact and using a set of NLMS algorithms with different step-sizes, the parallel LMS-PPIC (PLMS-PPIC) method is proposed. In each iteration of the algorithm, the parameter estimate of the NLMS algorithm is chosen to match the elements' magnitudes of the cancelation weight estimate with unity. Simulation results are given to compare the performance of our method with the LMS-PPIC algorithm in three cases: balanced channel, unbalanced channel and time varying channel.

This document gives new parallel algorithms for integer sorting and undirected graph connectivity problems such as connected components and spanning forest. These algorithms cost only logarithmic time and are the first known that are optimal: the product of their time and processor bounds are bounded by a linear function of the input size. All previous known parallel algorithms for these problems required at least a linear number of processors to achieve logarithmic time bounds, and hence were nonoptimal by at least a logarithmic factor. The author assumes a parallel random access machine (RAM) model which allows both concurrent writes and concurrent reads of global memory. The algorithms are randomized; each processor is allowed an independent random number generator; however our stated resource bounds hold for worst case input with overwhelming likelihood as the input size grows. (Author)

Cell phones, smart cards, and health monitoring gadgets are just a few examples of the numerous battery-powered embedded systems utilized to access, alter, and store sensitive and complicated data today. Users are concerned about the protection of their identity credentials, their software packages, and their information. These systems make considerable use of cryptographic algorithms to implement security measures. Many cryptographic algorithms do calculations that are hard to compute and waste a huge amount of energy as a result. In this study, the energy consumption of serial and parallel cryptography algorithms is analyzed. Using an eight-core parallel system and Joule metre (Microsoft's Research Tool), we were able to reduce energy consumption in comparison to sequential algorithms with promising results. The study says that low-frequency symmetric multiprocessors have shown promising results and can make a big difference in green computing, which would be good for society as a whole.

The lattice Boltzmann method exhibits excellent scalability on current supercomputing systems and has thus increasingly become an alternative method for large-scale non-stationary flow simulations, reaching up to a trillion grid nodes. Additionally, grid refinement can lead to substantial savings in memory and compute time. These saving, however, come at the cost of much more complex data structures and algorithms. In particular, the interface between subdomains with different grid sizes must receive special treatment. In this article, we present parallel algorithms, distributed data structures, and communication routines that are implemented in the software framework waLBerla in order to support large-scale, massively parallel lattice Boltzmann-based simulations on non-uniform grids. Additionally, we evaluate the performance of our approach on two current petascale supercomputers. On an IBM Blue Gene/Q system, the largest weak scaling benchmarks with refined grids are executed with almost two million threads, demonstrating not only near-perfect scalability but also an absolute performance of close to a trillion lattice Boltzmann cell updates per second. On an Intel-based system, the strong scaling of a simulation with refined grids and a total of more than 8.5 million cells is demonstrated to reach a performance of less than one millisecond per time step. This enables simulations with complex, non-uniform grids and four million time steps per hour compute time.

Simulation-based optimization of acoustic liner design in a turbofan engine nacelle for noise reduction purposes can dramatically reduce the cost and time needed for experimental designs. Because uncertainties are inevitable in the design process, a stochastic optimization algorithm is posed based on the conditional value-at-risk measure so that an ideal acoustic liner impedance is determined that is robust in the presence of uncertainties. A parallel reduced-order modeling framework is developed that dramatically improves the computational efficiency of the stochastic optimization solver for a realistic nacelle geometry. The reduced stochastic optimization solver takes less than 500 seconds to execute. In addition, well-posedness and finite element error analyses of the state system and optimization problem are provided.

The primary objective was to compare the performance of state-of-the-art techniques for solving sparse systems with those that are currently available in the Computational Structural Mechanics (MSC) testbed. One of the first tasks was to become familiar with the structure of the testbed, and to install some or all of the SPARSPAK package in the testbed. A brief overview of the CSM Testbed software and its usage is presented. An overview of the sparse matrix research for the Testbed currently employed in the CSM Testbed is given. An interface which was designed and implemented as a research tool for installing and appraising new matrix processors in the CSM Testbed is described. The results of numerical experiments performed in solving a set of testbed demonstration problems using the processor SPK and other experimental processors are contained.

This paper reports on the performance of five parallel algorithms for simulating a fully associative cache operating under the LRU (Least-Recently-Used) replacement policy. Three of the algorithms are SIMD, and are implemented on the MasPar MP-2 architecture. Two other algorithms are parallelizations of an efficient serial algorithm on the Intel Paragon. One SIMD algorithm is quite simple, but its cost is linear in the cache size. The two other SIMD algorithm are more complex, but have costs that are independent on the cache size. Both the second and third SIMD algorithms compute all stack distances; the second SIMD algorithm is completely general, whereas the third SIMD algorithm presumes and takes advantage of bounds on the range of reference tags. Both MIMD algorithm implemented on the Paragon are general and compute all stack distances; they differ in one step that may affect their respective scalability. We assess the strengths and weaknesses of these algorithms as a function of problem size and characteristics, and compare their performance on traces derived from execution of three SPEC benchmark programs.

This Second Annual Technical Report covers the project activities during the period from October 1, 1987 through December 31, 1988. The objective of this project is to develop and implement, on highly parallel computers, vision algorithms that combine stereo, texture, and multi-resolution techniques for determining local surface orientation and depth. Such algorithms can serve as front-end components of autonomous land vehicle vision systems. During the second year of the project, efforts have concentrated on the following: first, implementing and testing on the Connection Machine the Parallel programming environment that will be used to develop, implement and test our parallel vision algorithms; second, implementing and testing primitives for the multi-resolution stereo and texture algorithms, in this environment. Also, we continued our efforts to refine techniques used in our texture algorithms, and to develop a system that integrates information from several shape-from-texture methods. This report describes the status and progress of these efforts. We describe first the programming environment implementation, and how to use it. We summarize the results for multi-resolution based depth interpolation algorithms on parallel architectures. Then, we present algorithms and test results for the texture algorithms. Finally the results of the efforts of integrating information from various shape-from-texture algorithms are presented.

The string matching problem is one of the most studied problems in computer science. While it is very easily stated and many of the simple algorithms perform very well in practice, numerous works have been published on the subject and research is still very active. In this paper we survey recent results on parallel algorithms for the string matching problem.

19 p. 28 cm

Greg Plaxton 1989B won the best paper award at SPAA for his recent work on three related problems, each highly fundamental: (1) Load balancing: given a distribution of tasks to processors, move the task tokens so each processor has an equal number of tasks; (2) Selection: Given n items and k between 1 and n, find the kth item in sorted order; and (3) Sorting: given n items distributed equally among p processors, sort the items.