Cluster Of Workstations Research Articles

Communication and memory optimal parallel data cube construction

Data cube construction is a commonly used operation in data warehouses. Because of the volume of data that is stored and analyzed in a data warehouse and the amount of computation involved in data cube construction, it is natural to consider parallel machines for this operation. This paper addresses a number of algorithmic issues in parallel data cube construction. First, we present an aggregation tree for sequential (and parallel) data cube construction, which has minimally bounded memory requirements. An aggregation tree is parameterized by the ordering of dimensions. We present a parallel algorithm based upon the aggregation tree. We analyze the interprocessor communication volume and construct a closed form expression for it. We prove that the same ordering of the dimensions in the aggregation tree minimizes both the computational and communication requirements. We also describe a method for partitioning the initial array and prove that it minimizes the communication volume. Finally, in the cases when memory may be a bottleneck, we describe how tiling can help scale sequential and parallel data cube construction. Experimental results from implementation of our algorithms on a cluster of workstations show the effectiveness of our algorithms and validate our theoretical results.

A parallel 3D particle-in-cell code with dynamic load balancing

A parallel 3D electrostatic Particle-In-Cell (PIC) code including an algorithm for modelling Space Charge Limited (SCL) emission [E. Gjonaj, T. Weiland, 3D-modeling of space-charge-limited electron emission. A charge conserving algorithm, Proceedings of the 11th Biennial IEEE Conference on Electromagnetic Field Computation, 2004] is presented. A domain decomposition technique based on orthogonal recursive bisection is used to parallelize the computation on a distributed memory environment of clustered workstations. For problems with a highly nonuniform and time dependent distribution of particles, e.g., bunch dynamics, a dynamic load balancing between the processes is needed to preserve the parallel performance. The algorithm for the detection of a load imbalance and the redistribution of the tasks among the processes is based on a weight function criterion, where the weight of a cell measures the computational load associated with it. The algorithm is studied with two examples. In the first example, multiple electron bunches as occurring in the S-DALINAC [A. Richter, Operational experience at the S-DALINAC, Proceedings of the Fifth European Particle Accelerator Conference, 1996] accelerator are simulated in the absence of space charge fields. In the second example, the SCL emission and electron trajectories in an electron gun are simulated.

Temporal fringe pattern analysis with parallel computing

Temporal fringe pattern analysis is invaluable in transient phenomena studies but necessitates long processing times. Here we describe a parallel computing strategy based on the single-program multiple-data model and hyperthreading processor technology to reduce the execution time. In a two-node cluster workstation configuration we found that execution periods were reduced by 1.6 times when four virtual processors were used. To allow even lower execution times with an increasing number of processors, the time allocated for data transfer, data read, and waiting should be minimized. Parallel computing is found here to present a feasible approach to reduce execution times in temporal fringe pattern analysis.

MAPFS: A flexible multiagent parallel file system for clusters

The emergence of applications with greater processing and speedup requirements, such as Grand Challenge Applications (GCA), involves new computing and I/O needs. Many of these applications require access to huge data repositories and other I/O sources, making the I/O phase a bottleneck in the computing systems, due to its poor performance. In this sense, parallel I/O is becoming one of the major topics in the area of high-performance systems. Existing data-intensive GCA have been used in several domains, such as high energy physics, climate modeling, biology or visualization. Since the I/O problem has not been solved in this kind of applications, new approaches are required in this case. This paper presents MAPFS, a multiagent architecture, whose goal is to allow applications to access data in a cluster of workstations in an efficient and flexible fashion, providing formalisms for modifying the topology of the storage system, specifying different data access patterns and selecting additional functionalities.

User-Friendly Parallel Computations with Econometric Examples

This paper shows how a high-level matrix programming language may be used to perform Monte Carlo simulation, bootstrapping, estimation by maximum likelihood and GMM, and kernel regression in parallel on symmetric multiprocessor computers or clusters of workstations. The implementation of parallelization is done in a way such that an investigator may use the programs without any knowledge of parallel programming. A bootable CD that allows rapid creation of a cluster for parallel computing is introduced. Examples show that parallelization can lead to important reductions in computational time. Detailed discussion of how the Monte Carlo problem was parallelized is included as an example for learning to write parallel programs for Octave.

Adaptive divisible load scheduling strategies for workstation clusters with unknown network resources

Conventional divisible load scheduling algorithms attempt to achieve optimal partitioning of massive loads to be distributed among processors in a distributed computing system in the presence of communication delays in the network. However, these algorithms depend strongly upon the assumption of prior knowledge of network parameters and cannot handle variations or lack of information about these parameters. In this paper, we present an adaptive strategy that estimates network parameter values using a probing technique and use them to obtain optimal load partitioning. Three algorithms, based on the same strategy, are presented in the paper, incorporating the ability to cope with unknown network parameters. Several illustrative numerical examples are given. Finally, we implement the adaptive algorithms on an actual network of processor nodes using MPI implementation and demonstrate the feasibility of the adaptive approach.

Dynamic load‐balancing mechanism for distributed Java applications

AbstractProgram environments or operating systems generally leave the decision on the allocation of program entities to the developer, offering either placement directives, or tools available through the manipulation of a graphical interface. These approaches cannot always take into account the dynamic behavior of applications, dynamicity in the execution environment or the heterogeneity of the execution platform. Transparent deployment algorithms are necessary for automizing and optimizing application distribution. The Adaptive Distributed Applications in Java (ADAJ) project deals with placement and migration of Java objects. It automatically deploys parallel Java applications on a cluster of workstations using monitoring information about the application behavior. The transparency obtained through the integration of these tools in the middleware makes such an environment easy to use and improves efficiency. Copyright © 2005 John Wiley & Sons, Ltd.

Communication-optimal parallel parenthesis matching

We provide the first non-trivial lower bound, p - 3 p · n p , where p is the number of the processors and n is the data size, on the average-case communication volume, σ, required to solve the parenthesis matching problem, assuming problem instances are uniformly distributed, and present a parallel algorithm that takes linear (optimal) computation time and optimal expected message volume, σ + p. The kernel of the algorithm is to solve the all nearest smaller values problem. Provided n p = Ω ( p ) , we present an algorithm that achieves optimal sequential computation time and uses only a constant number of communication phases, with the message volume in each phase bounded above by ( n p + p ) in the worst case and p in the average case. Experiments have been performed on two clusters: an SGI Intel Linux Cluster and a Sun cluster of workstations, both showing low communication overhead and good speedups.

Parallel dynamic programming on clusters of workstations

The standard DP (dynamic programming) algorithms are limited by the substantial computational demands they put on contemporary serial computers. In this work, the theory behind the solution to serial monadic dynamic programming problems highlights the theory and application of parallel dynamic programming on a general-purpose architecture (cluster or network of workstations). A simple and well-known technique, message passing, is considered. Several parallel serial monadic DP algorithms are proposed, based on the parallelization in the state variables and the parallelization in the decision variables. Algorithms with no interpolation are also proposed. It is demonstrated how constraints introduce load unbalance which affect scalability and how this problem is inherent to DP.

Sensor network software update management: a survey

AbstractSoftware management is a critical task in the system administration of enterprise‐scale networks. Enterprise‐scale networks that have traditionally comprised of large clusters of workstations are expanding to include low‐power ad hoc wireless sensor networks (WSN). The existing tools for software updates in workstations cannot be used with the severely resource‐constrained sensor nodes. In this article, we survey the software update techniques in WSNs. We base our discussion around a conceptual model for the software update tools in WSNs. Three components of this model that we study are the execution environment at the sensor nodes, the software distribution protocol in the network and optimization of transmitted updates. We present the design space of each component and discuss in‐depth the trade‐offs that need to be considered in making a particular design choice. The discussion is interspersed with references to deployed systems that highlight the design choices. Copyright © 2005 John Wiley & Sons, Ltd.

PARALLEL NUMERICAL MODELLING OF SHORT LASER PULSE COMPRESSION

In this paper we investigate parallel numerical algorithms for solution of the transient stimulated scattering processes. A new symmetrical splitting scheme is proposed and a parallel version is given. The efficiency of the parallel algorithm is investigated for two cases. The first one describes a case when the computation region is constant during the whole time of computations. The second one describes the initial phase of the process, when the computational region increases linearly in time. In order to distribute more evenly jobs between processors a dynamical the grid redistribution algorithm is is used. We also give a proof of one result about optimal static grid distribution in the case of linearly increased problem complexity. The results of computations are presented. They were obtained on different parallel computers and clusters of workstations. Nagrinejamas priverstines Brijueno sklaidos fokusuotuose pluoštuose uždavinio lygiagretusis skaitinis sprendimo algoritmas. Sukonstruota simetrinio skaidymo baigtiniu skirtumu schema, kurios tikslumas yra antrosios eiles. Lygiagretusis algoritmas gautas naudojant duomenu lygiagretumo paradigma. Detaliai nagrinejamas dinamiškai didejančio sudetingumo uždavinys, modeliuojantis Brijueno sklaidos procesa, kai neužduodama kraštine salyga Stokso bangai. Irodyta hipoteze apie vieno stacionaraus blokinio duomenu paskirstymo algoritmo op‐timaluma. Eksperimentiškai ištirtas dinaminis duomenu perskirstymo algoritmas, patvirtintas jo efektyvumas net ir fiksuoto dydžio uždaviniams. Darbe pateikti skaitinio eksperimento, atlikto naudojant VGTU 20 procesoriu klasteri, rezultatai. Jie patvirtino gautuosius teorinius rezultatus, išsam us fizikiniai rezultatai bus išspausdinti kituose darbuose.

An MPI prototype for compiled communication on Ethernet switched clusters

Compiled communication has recently been proposed to improve communication performance for clusters of workstations. The idea of compiled communication is to apply more aggressive optimizations to communications whose information is known at compile time. Existing MPI libraries do not support compiled communication. In this paper, we present an MPI prototype, CC- MPI, that supports compiled communication on Ethernet switched clusters. The unique feature of CC- MPI is that it allows the user to manage network resources such as multicast groups directly and to optimize communications based on the availability of the communication information. CC- MPI optimizes one-to-all, one-to-many, all-to-all, and many-to-many collective communication routines using the compiled communication technique. We describe the techniques used in CC- MPI and report its performance.The results show that communication performance of Ethernet switched clusters can be significantly improved through compiled communication.

Implicit Parallel FEM Analysis of Shallow Water Equations

The velocity field in the Wu River at Chongqing was simulated using the shallow water equation implemented on clustered workstations. The parallel computing technique was used to increase the computing power. The shallow water equation was discretized to a linear system of equations with a direct parallel generalized minimum residual algorithm (GMRES) used to solve the linear system. Unlike other parallel GMRES methods, the direct GMRES method does not alter the sequential algorithm, but bases the parallelization on basic operations such as the matrix-vector product. The computed results agree well with observed results. The parallel computing technique significantly increases the solution speed for this large-scale problem.

Parallel Image Convolution Processing with Replicas in a Network of Workstations

Data accessed by many sites are replicated in distributed environments for performance and availability. In this paper, replication schemes are examined in parallel image convolution processing. This paper presents a system architecture that we have developed with CORBA (Common Object Request Broker Architecture) for the processing. Employing CORBA enables us to make use of a cluster of workstations, each of which has a different level of computing power. The paper also describes a parallel and distributed image convolution processing model using replicas stored in a network of workstations, and reports some experimental results showing that our analytical model can agree with practical situations.

Data-partitioning using the Hilbert space filling curves: Effect on the speed of convergence of Fuzzy ARTMAP for large database problems

The Fuzzy ARTMAP algorithm has been proven to be one of the premier neural network architectures for classification problems. One of the properties of Fuzzy ARTMAP, which can be both an asset and a liability, is its capacity to produce new nodes (templates) on demand to represent classification categories. This property allows Fuzzy ARTMAP to automatically adapt to the database without having to a priori specify its network size. On the other hand, it has the undesirable side effect that large databases might produce a large network size (node proliferation) that can dramatically slow down the training speed of the algorithm. To address the slow convergence speed of Fuzzy ARTMAP for large database problems, we propose the use of space-filling curves, specifically the Hilbert space-filling curves (HSFC). Hilbert space-filling curves allow us to divide the problem into smaller sub-problems, each focusing on a smaller than the original dataset. For learning each partition of data, a different Fuzzy ARTMAP network is used. Through this divide-and-conquer approach we are avoiding the node proliferation problem, and consequently we speedup Fuzzy ARTMAP's training. Results have been produced for a two-class, 16-dimensional Gaussian data, and on the Forest database, available at the UCI repository. Our results indicate that the Hilbert space-filling curve approach reduces the time that it takes to train Fuzzy ARTMAP without affecting the generalization performance attained by Fuzzy ARTMAP trained on the original large dataset. Given that the resulting smaller datasets that the HSFC approach produces can independently be learned by different Fuzzy ARTMAP networks, we have also implemented and tested a parallel implementation of this approach on a Beowulf cluster of workstations that further speeds up Fuzzy ARTMAP's convergence to a solution for large database problems.

Running Large-Scale Applications on Cluster Grids

Grid computing enables the enormous, but often poorly utilized, computing resources existing on the Internet to be harnessed in order to solve large-scale problems. However, if they want to solve the problems of configuration and performance optimization of their large-scale applications, programmers wishing to exploit such computing resources have to deal with highly variable communication delays, security threats, machine and network failures, and the distributed ownership of the computing resources. On the other hand, Parallel Virtual Machine (PVM) is still widely used to develop high performance parallel applications on high performance/cost ratio computing platforms, such as workstation clusters. However, workstations belonging to networked clusters cannot often be exploited since they are provided with private IP addresses, being hidden from the Internet by publicly addressable IP front-end machines. This paper presents an extension of PVM that enables such clustered machines hidden from the Internet to take part in a PVM computation as host machines. This way, programmers can exploit low-cost, networked computing resources, such as collections of clusters, widely available within departmental organizations, in a well-known programming environment, such as PVM, without having to tackle the problems affecting grid computing, which often ends up turning the development of parallel applications into a burdensome activity as well as penalizing application performance.

Parallel and Symbolic Model Checking for Fixpoint Logic with Chop

We consider the model checking problem for FLC, a modal fixpoint logic capable of defining non-regular properties. This paper presents a refinement of a symbolic model checker and discusses how to parallelise this algorithm. It reports on a prototype implementation of the algorithm in Glasgow Parallel Haskell (GpH) and its performance on a cluster of workstations.

UppDMC: A Distributed Model Checker for Fragments of the μ-Calculus

We present UppDMC, a distributed model-checking tool. It is tailored for checking finite-state systems and μ-calculus specifications with at most one alternation of minimal and maximal fixed-point operators. This fragment is also known as Lμ2. Recently, efficient game-based algorithms for this logic have been outlined.We describe the implementation of these algorithms within UppDMC and study their performance on practical examples. Running UppDMC on a simple workstation cluster, we were able to check liveness properties of the largest examples given in the VLTS Benchmark Suite, for which no answers were previously known.

Parallelization of Fuzzy ARTMAP to improve its convergence speed: The network partitioning approach and the data partitioning approach

One of the properties of FAM, which can be both an asset and a liability, is its capacity to produce new neurons (templates) on demand to represent classification categories. This property allows FAM to automatically adapt to the database without having to arbitrarily specify network structure. We provide two methods for speeding up the FAM algorithm. The first one, referred to as the data partitioning approach, partitions the data into subsets for independent processing. The second one, referred to as the network partitioning approach, uses a pipeline to distribute the work between processes during training. We provide experimental results on a Beowulf cluster of workstations for both approaches that confirm the speedup of the modifications.

Efficient trigger-broadcasting in heterogeneous clusters

Broadcasts in parallel computing environments are often used to trigger “personal” computations at the processors (or, nodes) that comprise the system. (The qualifier “personal” means that the triggered computations may differ in type and complexity at each node.) We present an algorithm for trigger-broadcasting in a node-heterogeneous cluster of workstations, which comes predictably close to minimizing the time for completing both the broadcast and the computations it triggers. The algorithm orchestrates its broadcast taking account of: the speeds of the cluster's constituent workstations, the speed of the cluster's network, and the complexities of the computations that the broadcast triggers. The algorithm is within a constant factor of optimal when the speeds of the cluster's workstations and of its network are independent of the number of workstations. The algorithm is exactly optimal when the cluster is homogeneous—no matter how diverse the “personal” computations are.