Parallelization

In this paper we present a fine-mesh solver aimed at resolving in a coupled manner and at the pin cell level the neutronic and thermal-hydraulic fields. Presently, the tool considers Pressurized Water Reactor (PWR) conditions. The methods and implementation strategy are such that the coupled neutronic and thermal-hydraulic problem is formulated in a fully three-dimensional (3D) and fine mesh manner, and for steady-state situations. The solver is built on finite volume discretization schemes, matrix solvers and capabilities for parallel computing that are available in the open source C++ library foam-extend-3.0. The angular neutron flux is determined with a multigroup discrete ordinates method (S N), solved by a sweeping algorithm. The thermal-hydraulics is based on Computational Fluid Dynamics (CFD) models for the moderator/coolant mass, momentum, and energy equations, together with the fuel pin energy equation. The multiphysics coupling is solved by making use of an iterative algorithm, and convergence is ensured for both the separate equations and the coupled scheme. Since all the equations are implemented in the same software, all fields can be directly accessed in such a manner that external transfer and external mapping are avoided. The parallelization relies on a domain decomposition which is shared between the neutronics and the thermal-hydraulics. The latter allows to exchange the coupled data locally on each CPU, thus minimizing the data transfer. The code is tested on a quarter of a 15 Â 15 PWR fuel lattice. The results show that convergence is successfully reached, and correct physical behaviors of all fields can be achieved with a reasonable computational effort.

This paper describes a new parallel architectural system which we have called an MIMD-SIMD hybrid system. As the name implies, MIMD-SIMD hybrid system (also denoted as hybrid system in this paper) is a combination of both SIMD and MIMD systems working concurrently to produce an optimal architecture. This new parallel architecture has the capability of achieving speedup rates more than its corresponding MIMD architecture can achieve alone. We introduce our new SIMD concept and also show the contribution of the SIMD on this hybrid system. We have also developed a general formula for determining the speedup of the hybrid system so that accurate predictions can be made on the performance of the hybrid system. A MIMD-SIMD hybrid system was constructed and was used to implement on a visualization algorithm.

In this paper, we propose a new high-speed computation algorithm for solving a large N Â N matrix system using the MIMD-SIMD Hybrid System. The MIMD-SIMD Hybrid System (also denoted as Hybrid System in this paper) is a new parallel architecture consisting of a combination of Cluster of Workstations (COWs) and SIMD systems working concurrently to produce an optimal parallel computation. We first introduce our prototype SIMD system and our Hybrid System setup before presenting how it can be implemented to find the unknowns in a large N Â N linear matrix equation system using the Gauss-LU algorithm. This algorithm basically performs the ÔDivide and Conquer' approach by breaking down the large N Â N matrix system into a manageable 32 · 32 matrix for fast computation.

An Euler-Lagrange approach is developed for numerical simulations of cavitating flows. Within this approach the Navier-Stokes equations are solved for the Eulerian liquid/vapor-mixture. Supplementary equations for the bubble size and motion are solved for each of the bubbles/nuclei, composing a discrete vapor phase. Such an approach is computationally demanding when computational grids with several Mio cells and many ten thousand bubbles are considered. The paper reports the development and verification of an efficient hybrid MPI/OpenMP algorithm for coupled Euler-Lagrange simulations. The proposed algorithm facilitates cavitation predictions for challenging industrial applications, such as cavitating marine propellers, in a reasonable amount of wall-clock time.

This paper presents a novel evolutionary optimization strategy based on the derandomized evolution strategy with covariance matrix adaptation (CMA-ES). This new approach is intended to reduce the number of generations required for convergence to the optimum. Reducing the number of generations, i.e., the time complexity of the algorithm, is important if a large population size is desired: (1) to reduce the effect of noise;

Retinex is an image restoration approach used to restore the original appearance of an image. Among various methods, a center/surround retinex algorithm is favorable for parallelization because it uses the convolution operations with large-scale sizes to achieve dynamic range compression and color/lightness rendition. This paper presents a GPURetinex algorithm, which is a data parallel algorithm accelerating a modified center/surround retinex with GPGPU/CUDA. The GPURetinex algorithm exploits the massively parallel threading and heterogeneous memory hierarchy of a GPGPU to improve efficiency. Two challenging problems, irregular memory access and block size for data partition, are analyzed mathematically. The proposed mathematical models help optimally choose memory spaces and block sizes for maximal parallelization performance. The mathematical analyses are applied to three parallelization issues existing in the retinex problem: block-wise, pixel-wise, and serial operations. The experimental results conducted on GT200 GPU and CUDA 3.2 showed that the GPURetinex can gain 74 times acceleration, compared with an SSE-optimized single-threaded implementation on Core2 Duo for the images with 4,096 × 4,096 resolution. The proposed method also outperforms the parallel retinex implemented with the nVidia Performance Primitives library. Our experimental results indicate that careful design of memory access and multithreading patterns for CUDA devices should acquire great performance acceleration for real-time processing of image restoration.

Multiple-Point Simulations (MPS) is a family of geostatistical tools that has received a lot of attention in recent years for the characterization of spatial phenomena in geosciences. It relies on the definition of training images to represent a given type of spatial variability, or texture. We show that the algorithmic tools used are similar in many ways to techniques developed in computer graphics, where there is a need to generate large amounts of realistic textures for applications such as video games and animated movies. Similarly to MPS, these texture synthesis methods use training images, or exemplars, to generate realistic-looking graphical textures.

A fast response technique is developed to investigate the short-term postprogram and post-erase discharge in Flash memory devices. The procedure is based on fast VTH-evaluation methods developed for bias temperature instability and provides the transient characteristics after 20 ms under the program or erase conditions. The following different structures are investigated: 1) SiO2/high-k stacks; 2) charge trap memories; 3) and floating gate memories. Dielectrics targeted for Flash memory applications are used as charge trap layers and interpoly di electrics. In this paper, we show results on Al2O3, DyScO, GdScO, and hexagonal and perovskite LuAlO. The postprogram and post-erase curves hold useful information about the dielectric properties and are used as a fast screening technique for alternative materials.

Linkage analysis uses information from family pedigrees to map genes and locate disease genes on particular chromosomes. A recombination fraction denoted as θ is estimated as a measure of crossing over between two loci. Genetic linkage calculations are very time-consuming particularly for large family pedigrees, a large number of θ values, and an increased number of markers. This paper reports

Microreactors can perform chemical reactions in tiny channels using continuous-flow processes. The microreactor team at Lonza has designed and tested a series of microstructured devices in continuousflow plants, and performed lab studies of pharmaceutical reactions with successful transfer to commercial production. Microreactor design and scale-up concept is guided by simple correlations, which are described here and displayed in comprehensive diagrams for hydraulic diameter over typical range of flow rate. This leads to a consistent and straightforward scale-up pathway for single-channel microreactors avoiding parallelization from lab development to pilot-scale production.

Hierarchical N-body methods, which are based on a fundamental insight into the nature of many physical processes, are increasingly being used to solve large-scale problems in a variety of scientific/engineering domains. Applications that use these methods are challenging to parallelize effectively, however, owing to their nonuniform, dynamically changing characteristics and their need for long-range communication.

MapReduce is a parallel programming model and an associated implementation introduced by Google. In the programming model, a user specifies the computation by two functions, Map and Reduce. The underlying MapReduce library automatically parallelizes the computation, and handles complicated issues like data distribution, load balancing and fault tolerance. Massive input, spread across many machines, need to parallelize. Moves the data, and provides scheduling, fault tolerance. The original MapReduce implementation by Google, as well as its open-source counterpart, Hadoop, is aimed for parallelizing computing in large clusters of commodity machines. Map Reduce has gained a great
popularity as it gracefully and automatically achieves fault tolerance. It automatically handles the gathering of results across the multiple nodes and returns a single result or set.

This paper gives an overview of MapReduce programming model and its applications. The author has described here the workflow of MapReduce process. Some important issues, like fault tolerance, are studied in more detail. Even the illustration of working of Map Reduce is given.

The data locality issue in heterogeneous environments can noticeably reduce the Map Reduce performance. In this paper, the author has addressed the illustration of data across nodes in a way that each node has a balanced data processing load stored in a parallel manner. Given a data intensive
application running on a Hadoop Map Reduce cluster, the auhor has exemplified how data placement is done in Hadoop architecture and the role of Map Reduce in the Hadoop Architecture. The amount of data stored in each node to achieve improved data-processing performance is explained here.

This paper describes our research on using Genetic Programming to obtain transition rules for Cellular Automata, which are one type of massively parallel computing system. Our purpose is to determine the existence of a limit of chaos for three dimensional Cellular Automata, empirically demonstrated for the two dimensional case. To do so, we must study statistical properties of 3D Cellular Automata over long simulation periods. When dealing with big three dimensional meshes, applying the transition rule to the whole structure can become a extremely slow task. In this work we decompose the Automata into pieces and use OpenMp to parallelize the process. Results show that using a decomposition procedure, and distributing the mesh between a set of processors, 3D Cellular Automata can be studied without having long execution times.

With the increase in frequency and severity of flash flood events in major cities around the world, the infrastructure and people living in those urban areas are exposed continuously to high risk levels of pluvial flooding. The situation is likely to be exacerbated by the potential impact of future climate change. A fast flood model could be very useful for flood risk analysis. One-dimensional (1D) models provide limited information about the flow dynamics whereas two-dimensional (2D) models require substantial computational time and cost, a factor that limits their use. This paper presents an alternative approach using cellular automata (CA) for 2D modelling. The model uses regular grid cells as a discrete space for the CA setup and applies generic rules to local neighbourhood cells to simulate the spatio-temporal evolution of pluvial flooding. The proposed CA model is applied to a hypothetical terrain and a real urban area. The synchronous state updating rule and inherent nature o...

Software engineers now face the difficult task of refactoring serial programs for parallel execution on multicore processors. Currently, they are offered little guidance as to how much benefit may come from this task, or how close they are to the best possible parallelization. This paper presents Kismet, a tool that creates parallel speedup estimates for unparallelized serial programs. Kismet differs from previous approaches in that it does not require any manual analysis or modification of the program. This difference allows quick ...

The paper describes several efficient parallel implementations of the one-sided hyperbolic Jacobi-type algorithm for computing eigenvalues and eigenvectors of Hermitian matrices. By appropriate blocking of the algorithms an almost ideal load balancing between all available processors/cores is obtained. A similar blocking technique can be used to exploit local cache memory of each processor to further speed up the process. Due to diversity of modern computer architectures, each of the algorithms described here may be the method of choice for a particular hardware and a given matrix size. All proposed block algorithms compute the eigenvalues with relative accuracy similar to the original non-blocked Jacobi algorithm.

Variable Neighborhood Search (VNS) is a recent and effective metaheuristic for solving combinatorial and global optimization problems. It is capable of escaping from the local optima by systematic changes of the neighborhood structures within the search. In this paper several parallelization strategies for VNS have been proposed and compared on the large instances of the p-median problem.

This paper introduces a quick, efficient and simple algorithm for drawing straight lines with antialiasing on discrete devices like printers or CRTs. It is based on the DDA algorithm. It uses 32 bits fixed-point arithmetic. This is a pipelined, parallelized and scalable SIMD version. It may be hardware implemented. It is suitable for MMX or Streaming SIMD Pentium 1 III instructions. The algorithm allows drawing true colour lines using a brush 3 pixels high and 1 pixel wide in parallel. The computing cost is very low and only integer arithmetic is used. This algorithm takes into account that the real width of the line remains constant always and it does not depend on its slope. Given that the total radiation emitted by a line is proportional to its real surface, total emitted light also increases with its slope.

With the advent of digitization and growing abundance of graphic and image processing tools, use cases for clipping using circular windows have grown considerably. This paper presents an efficient clipping algorithm for line segments using geometrical features of circle and vector calculus. Building upon the research with rectangular windows, this method is proposed with the belief that computations are more expensive (heavy) than other computations. Execution time can be drastically improved if we replace expensive computations with cheaper computations. The cheaper computations can be computed even more efficiently using parallelization thus improving time complexity.

Very large scientific datasets are increasingly becoming available in XML formats. At the same time, multi-core processing is increasingly becoming available on desktop- and laptop-class computing machines. Unfortunately, most XML parsers are still using algorithms that are inherently serial, which show little improvement on newer computing hardware. The current XML implementation landscape does not adequately meet the performance requirements of large scale applications. Thus far, applications using Web services (in the grid community, for example) have largely focused on XML protocol standardization and tool building efforts, and not on addressing the performance bottlenecks when dealing with large volumes of XML data. Generic parallel parsing has been studied in depth over the past thirty years. However, as yet, these results have not been applied to the problem of XML parsing. XML documents have some structural properties that make it more amenable to parallelized parsing than general context-free languages. As has been previously shown, XML parsers spend a large percentage of time tokenizing the input in aninherently serial process, typically running a deterministic finite automaton on the input. Our initial approach, described here, separates the process of parsing the XML from the process of reading the input. We take a well-known high performance parser, Piccolo, and apply two different strategies, Runahead and Piped, and examine the timing of the file read time and hence the overall time to parse large scientific XML files. Under the conditions tested here, performance decreases.

The size of simulation grids used for numerical models has increased by many orders of magnitude in the past years, and this trend is likely to continue. Efficient pixel-based geostatistical simulation algorithms have been developed, but for very large grids and complex spatial models, the computational burden remains heavy. As cluster computers become widely available, using parallel strategies is a natural step for increasing the usable grid size and the complexity of the models. These strategies must profit from of the possibilities offered by machines with a large number of processors. On such machines, the bottleneck is often the communication time between processors. We present a strategy distributing grid nodes among all available processors while minimizing communication and latency times. It consists in centralizing the simulation on a master processor that calls other slave processors as if they were functions simulating one node every time. The key is to decouple the sending and the receiving operations to avoid synchronization. Centralization allows having a conflict management system ensuring that nodes being simulated simultaneously do not interfere in terms of neighborhood. The strategy is computationally efficient and is versatile enough to be applicable to all random path based simulation methods.

This paper presents a novel method to construct a dynamic single assignment (DSA) form of array intensive, pointer free C programs. A program in DSA form does not perform any destructive update of scalars and array elements; that is, each element is written at most once. As DSA makes the dependencies between variable references explicit, it facilitates complex analyses and optimizations of programs. Existing transformations into DSA perform a complex data flow analysis with exponential analysis time, and they work only for a limited class of input programs. Our method removes irregularities from the data flow by adding copy assignments to the program, so that it can use simple data flow analyses. The presented DSA transformation scales very well with growing program sizes and overcomes a number of important limitations of existing methods. We have implemented the method and it is being used in the context of memory optimization and verification of those optimizations. Experiments sh...

In this paper the performance of the Chandy-Misra algorithm in distributed simulation has been studied in the context of a particular simulation application: a cellular network. The logical process structure under the algorithm is modified in such a way that the excessive synchronisation caused by the algorithm can be avoided. The synchronisation is minimised by reducing the number of connections between logical processes (LP). The concept of a neighbourhood of an LP is defined in such way that an LP is connected via logical channels only to those LPs that belong to its neighbourhood. A broadcast messages method is proposed to solve the communication between nonconnected logical processes, i.e. those outside the neighbourhood. Simulation experiments are carried out in a previously implemented distributed simulation environment, Diworse. A GSM network is used as a simulation application where target of the simulation is to obtain estimates for the channel utilisation. Carrier per interference (C/I) values for GSM channels are used for determining the need for handovers. Execution time of the simulation and deviations in the C/I values are measured for completely connected and broadcast message methods in order to find out the effect of connection reduction. The results indicate that the broadcast messages method enables significantly faster simulation. With the GSM application the proposed method has only a negligible distorting effect to the simulation.

Spectral element methods allow for effective implementation of numerical techniques for partial differential equations on parallel architectures. We present two implementations of the parallel algorithm where the communications are performed using MPI. In the first implementation, each processor deals with one element. It leads to a natural parallelization. In the second implementation certain number of spectral elements are allocated to each processor. In this article, we describe how communications are implemented and present results and performance of the code on two architectures: a PC-Cluster and an IBM-SP3.

With the proliferation of multicore processors, there is an urgent need for tools and methodologies supporting parallelization of existing applications. In this paper, we present a novel tool for aiding programmers in parallelizing programs. The tool, Embla, is based on the Valgrind framework, and allows the user to discover the data dependences in a sequential program, thereby exposing opportunities for parallelization. Embla performs an off-line dynamic analysis, and records dependences as they arise during program execution. It reports an optimistic view of parallelizable sequences, and ignores dependences that do not arise during execution. Moreover, since the tool instruments the machine code of the program, it is largely language independent.

In theoretical computer science, researchers usually distinguish between feasible problems (that can be solved in polynomial time) and problems that require more computation time. A natural question is: can we use new physical processes, processes that have not been used in modern computers, to make computations drastically faster { e.g., to make intractable problems feasible? Such a possibility would occur if a physical process provides a super-polynomial (= faster than polynomial) speed-up. In this direction, the most active research is undertaken in quantum computing. It is well known that quantum processes can drastically speed up computations; however, there are no proven super-polynomial quantum speedups of the overall computation time. Parallelization is another potential source of speedup. In Euclidean space, parallelization only leads to a polynomial speedup. We show that in quantum space-time, parallelization could potentially lead to (provably) super-polynomial speedup of...

We present a novel multilevel algorithm which computes N roots of the secular equation in O(CN) computer operations, where C depends on the desired accuracy. Since current methods of solution require O(N 2) operations, this algorithm can drastically reduce the computational effort in various applications, including updating the singular value decomposition and symmetric eigenvalue problems, and solving constrained least squares problems. The algorithm is based on the multilevel approach for fast evaluation of integral transforms. It has been adapted for the efficient solution of the secular equation. We have also incorporated discontinuous kernel softening, a technique which improves the implementation of multilevel summation algorithms toward theoretical optimality. We present and discuss numerical results, parallelization, and other related applications of the multilevel approach, including a possible substitute for current symmetric tridiagonal eigenbasis solvers (such as the Divide and Conquer method).

Many machine learning tasks are just too hard to be solved with a single processor machine, no matter how efficient algorithms we use and how fast our hardware is. Luckily genetic programming is well suited for parallelization compared to standard serial algorithms. This paper describes the first parallel implementation of an AIM-GP system creating the potential for an extremely fast system. The system is tested on three problems and several variants of demes and migration are evaluated. Most of the results are applicable to both linear and tree based systems.

Recently, graphics processors (GPUs) have been increasingly leveraged in a variety of scientific computing applications. However, architectural differences between CPUs and GPUs necessitate the development of algorithms that take advantage of GPU hardware. As sparse matrix vector multiplication (SPMV) operations are commonly used in finite element analysis, a new SPMV algorithm and several variations are developed for unstructured finite element meshes on GPUs. The effective bandwidth of current GPU algorithms and the newly proposed algorithms are measured and analyzed for 15 sparse matrices of varying sizes and varying sparsity structures. The effects of optimization and differences between the new GPU algorithm and its variants are then subsequently studied. Lastly, both new and current SPMV GPU algorithms are utilized in the GPU CG Solver in GPU finite element simulations of the heart. These results are then compared against parallel PETSc finite element implementation results. The effective bandwidth tests indicate that the new algorithms compare very favorably with current algorithms for a wide variety of sparse matrices and can yield very notable benefits. GPU finite element simulation results demonstrate the benefit of using GPUs for finite element analysis, and also show that the proposed algorithms can yield speedup factors up to 12-fold for real finite element applications. A New Sparse Matrix Vector Multiplication GPU Algorithm 2/35

The problem of writing software for multicore processors is greatly simplified if we could automatically parallelize sequential programs. Although auto-parallelization has been studied for many decades, it has succeeded only in a few application areas such as dense matrix computations. In particular, auto-parallelization of irregular programs, which are organized around large, pointer-based data struc- tures like graphs, has seemed intractable.

Materials science simulations are among the leading applications for scientific supercomputing. Discrete dislocation dynamics (DDD) is a numerical tool used to model the plastic behavior of crystalline materials using the elastic theory of dislocations. DDD simulations require very long running times to produce meaningful scientific results. This paper presents early experiences and results on improving the running time of Micromegas, an application code for three-dimensional DDD simulations. We used open source profiling and tracing tools to analyze the behavior and performance, as well as to identify the performance bottlenecks of Micromegas. The major performance bottleneck of Micromegas, amounts to 68% of the total sequential run time and is parallelized using OpenMP. Evaluation and validation tests conducted on a Nehalem quad-core processor show 50% improvement in the simulation time for 3-D DDD over 100,000 time steps. The correctness of the scientific data produced by the parallel Micromegas are successfully validated against those of the serial version.

Microreactors can perform chemical reactions in tiny channels using continuous-flow processes. The microreactor team at Lonza has designed and tested a series of microstructured devices in continuousflow plants, and performed lab studies of pharmaceutical reactions with successful transfer to commercial production. Microreactor design and scale-up concept is guided by simple correlations, which are described here and displayed in comprehensive diagrams for hydraulic diameter over typical range of flow rate. This leads to a consistent and straightforward scale-up pathway for single-channel microreactors avoiding parallelization from lab development to pilot-scale production.

Loop parallelization is an important issue in the acceleration of the execution of scientific programs. To exploit parallelism in loops a system of equations representing the dependencies between the loop iterations and a system of non-equations indicating the loop boundary conditions has to be solved. This is a NP-Complete problem. Our major contribution in this paper has been to apply genetic algorithm to solve system of equation and non-equation resulted from loop dependency analysis techniques to find two dependent loop iterations. We use distance vector to find the rest of dependencies.

Loop tiling is an efficient loop transformation, mainly applied to detect coarse-grained parallelism in loops. It is a difficult task to apply n-dimensional nonrectangular tiles to generate parallel loops. This paper offers an efficient scheme to apply non-rectangular n-dimensional tiles in non-rectangular iteration spaces, to generate parallel loops. In order to exploit wavefront parallelism efficiently, all the tiles with equal sum of coordinates are assumed to reside on the same wavefront. Also, in order to assign parallelepiped tiles on each wavefront to different processors, an improved block scheduling strategy is offered in this paper.

We describe the implementation of some parallelization schemes for a relativistic four-component Dirac-Kohn-Sham program (BERTHA). The coulomb matrix construction has been parallelized by block-distributing the two-electron integral calculation, while for the exchange-correlation the numerical integration grid was distributed. Both schemes yield excellent performance results in terms of speed-up and scalability. The results obtained widen considerably the range of applicability of the method.

The segmentation of tissue regions in highresolution microscopy is a challenging problem due to both the size and appearance of digitized pathology sections. The two point correlation function (TPCF) has proved to be an effective feature to address the textural appearance of tissues. However the calculation of the TPCF functions is computationally burdensome and often intractable in the gigapixel images produced by slide scanning devices for pathology application. In this paper we present several approaches for accelerating deterministic calculation of point correlation functions using theory to reduce computation, parallelization on distributed systems, and parallelization on graphics processors. Previously we show that the correlation updating method of calculation offers an 8-35x speedup over frequency domain methods and decouples efficient computation from the select scales of Fourier methods. In this paper, using distributed computation on 64 compute nodes provides a further 42x speedup. Finally, parallelization on graphics processors (GPU) results in an additional 11-16x speedup using an implementation capable of running on a single desktop machine.

This paper proposes a partial parallelization for the Successive Projections Algorithm (SPA), which is a variable selection technique designed for use with Multiple Linear Regression. This implementation is aimed at improving the computational efficiency of SPA, without changing the outcome of the algorithm. For this purpose, a new strategy of inverse matrix calculation is employed. The advantage of the proposed implementation is demonstrated in an example involving large matrixes. In this example, gains of speedup were obtained.

We show how to use the parallelized kangaroo method for computing invariants in real quadratic function fields. Specifically, we show how to apply the kangaroo method to the infrastructure in these fields. We also show how to speed up the computation by using heuristics on the distribution of the divisor class number, and by using the relatively inexpensive baby steps in the real quadratic model of a hyperelliptic function field. Furthermore, we provide examples for regulators and class numbers of hyperelliptic function fields of genus 3 that are larger than those ever reported before.