Beowulf Cluster Research Articles

IMPLEMENTASI PERLINDUNGAN HUKUM TERHADAP HAK KEKAYAAN INTELEKTUAL MASYARAKAT ASLI/TRADISIONAL DI KABUPATEN PURBALINGGA

The regulating of intellectual property rights u ntil now has not accommodate intellectual property of traditional/native societies . In Purbalingga, there are 9 traditional commodity cluster, with a number of industry as much as 150 UKM and from that number only 4 which has been registered as intellectual property rights. The r esearch w ill discuss t o implementation of protection of intellectual property rights and factors that tend to influence the protection of intellectual property rights in Purbalingga regency. The method that applicated in this research was juridical sociological. Based on the study, local government has made protection to intellectual property rights through socialization to the public. However, there were factors that tend to hamper the protection of intellectual property rights, including law enforcer/officer factors, media and facilities factors, community and cultural factors. In the research, researcher suggested that the local government made a cooperation with central of intellectual property rights in college, considering human resources still relatively didn't understand technical drafting of intellectual property rights registration. Keywords: legal protection, intellectual property rights, intellectual property of traditional / native societies

Analysis of voltages induced on power outlets due to atmospheric discharges on Radio Base Stations

For the first time, full-wave simulations regarding voltages induced on power outlets installed inside buildings, due to lightning strokes on a Radio Base Station located nearby, are performed. The scenario consists of nine buildings with outlets connected to low-voltage distribution lines, conductive ground, a Radio Base Station and grounding systems. Loads connected to the power outlets are also considered. This scenario was modeled with a computer software developed in this work that can numerically represent/model real-world complex structures with realistic parameters. In order to obtain realistic results, Maxwell’s equations are solved numerically by using the FDTD method, which generates full-wave solutions of the problems. Here, electrical conductors are represented with the aid of a thin-wire technique. The analyzed domain is truncated by using the UPML formulation. In order to deal with large tridimensional numerical models, a Beowulf cluster with 16 CPUs is used to accelerate the calculation process. The induced voltages at the energy sockets inside the buildings have been calculated initially without an electric grounding mesh connected to them. In a second moment, the calculation of these induced voltages has been performed for the same structure with a grounding mesh connected to it. In a third simulation, electric loads with resistive–inductive characteristics have been added to the scenario (connected to the energy sockets), simulating residential equipment.

Paralyzing Bioinformatics Applications Using Conducive Hadoop Cluster

Bioinformatics may be defined as the application of computer science to molecular biology in the form of statistics and analytics. The bioinformatics applications deal with bulk amount of data. Researchers are now facing problems with the analysis of such ultra large-scale data sets, a problem that will only increase at an alarming rate in coming years. More over big challenge is involved in processing, storing and analyzing these peta bytes of data without causing much delay. Most of the bioinformatics algorithms are sequential thus making situation rather worse. This implies that data manipulations by means of uniprocessor systems are impractical. However most of the biological problems have parallel nature. Hence a practical and effective approach involves the usage of parallel clusters of workstations. Hadoop can be used to tackle this class of problems with good performance and scalability. This technology could be the basis of a computational parallel platform for several problems in the context of bioinformatics applications. Normally, Hadoop is deployed over high performance computing systems which are expensive involving complex deployment scenarios that only big enterprises are able to make it possible. So for smaller research organizations where cost is an important factor cannot choose systems with high computational capabilities for cluster set up. Rocks cluster is a viable solution in such scenarios. Rocks Cluster Distribution originally called NPACI Rocks is a Linux distribution intended for high-performance computing clusters. This paper implements a cost-effective cluster for paralyzing bioinformatics applications by deploying Hadoop over rock cluster and Emphasizes on the usage of commodity clusters for paralyzing bioinformatics applications by providing necessary justifications. Results show that paralyzing bioinformatics application saves much time compared to stand alone mode of execution effectively under optimal cost considerations.

Parallel Bayesian inference of range and reflectance from LaDAR profiles

Bayesian analysis using reversible jump Markov chain Monte Carlo (RJMCMC) algorithms improves the measurement accuracy, resolution and sensitivity of full waveform laser detection and ranging (LaDAR), but at a significant computational cost. Parallel processing has the potential to significantly reduce the processing time, but although there have been several strategies for Markov chain Monte Carlo (MCMC) parallelization, adaptation of these strategies to RJMCMC may degrade parallel performance.In this paper, we describe an approach to parallel RJMCMC processing that combines data and sampling parallelism in a single framework. This approach, Data Parallel State Space Decomposed RJMCMC (DP SSD-RJMCMC), can be adapted to different parallel cluster size, improve sampling efficiency and maintain parameter estimation accuracy. Formally, it forms a group of parallel chains by decomposing the state space into subsets of parameter space. Each subset has different but restricted dimensionality, and is assigned with an independent chain of variable length. To further improve load balancing, we also employ data decomposition, forming a task queue and conducting dynamic task allocation. The MPI-based implementation on a 32-node Beowulf cluster leads to significant speedup, typically of the order of 15–25 times, while maintaining the estimation accuracy.

Optimizing Latency in Beowulf Clusters


 
 
 This paper discusses how to decrease and stabilize network latency in a Beowulf system. Having low latency is particularly important to reduce execution time of High Perfor- mance Computing applications. Optimization opportunities are identified and analyzed over the different system components that are integrated in compute nodes, including device drivers, operating system services and kernel parameters.
 This work contributes with a systematic approach to optimize communication latency, provided with a detailed checklist and procedure. Performance impacts are shown through the figures of benchmarks and mpiBLAST as a real-world application. We found that after applying different techniques the default Gigabit Ethernet latency can be reduced from about 50 μs into nearly 20 μs.
 
 

Fast and Accurate Simulation of the Cray XMT Multithreaded Supercomputer

Irregular applications, such as data mining or graph-based computations, show unpredictable memory/network access patterns and control structures. Massively multithreaded architectures with large processor counts, like the Cray MTA-1, MTA-2, and XMT, appear to address irregular application requirements better than commodity clusters. However, the research on massively multithreaded systems is currently limited by the lack of adequate architectural simulation infrastructures due to issues such as size of the machines, memory footprint, simulation speed, accuracy, and customization. At the same time, Shared Memory MultiProcessors (SMPs) with multicore processors have become an attractive platform to simulate large-scale systems. This paper introduces a cycle-level simulator of the massively multithreaded Cray XMT supercomputer. The simulator runs unmodified XMT applications. We discuss how we tackled the challenges posed by its development, detailing the techniques implemented to obtain high-simulation speed while maintaining a high accuracy. By mapping XMT processors (ThreadStorm with 128 hardware threads) to host computing cores, the simulation speed remains constant as the number of simulated processors increases, up to the number of available host cores. The simulator supports zero-overhead switching among different accuracy levels at runtime and includes a parametric network and memory model that takes into account contention and hot spotting. On a modern 48-core SMP host, the proposed infrastructure simulates a large set of irregular applications 500 to 2,000 times slower than real time when compared to a 128-processor XMT, with an accuracy error under 10 percent. Emulation is only from 25 to 200 times slower than real time. The paper also presents a case study, where the simulation infrastructure is used to identify bottlenecks in the current XMT architecture and to estimate the performance scaling of a possible multicore design with next generation memory and network interconnect.

A Two-Level Parallel Decomposition Approach for Transient Stability Constrained Optimal Power Flow

Transient stability constrained optimal power flow (TSCOPF) is able to reduce costs while keeping the operation point away from the stability boundary. While especially useful in modern power system operations, TSCOPF problems are practically very hard to solve; unacceptable computational time is considered to be one of the largest barriers in applying TSCOPF-based solutions. Based on the reduced-space interior point method (RIPM)-which takes advantage of the relatively few degrees of freedom and shows promising potential for solving large-scale TSCOPF problems-this paper introduces a parallel RIPM algorithm with high computing efficiency for multi-contingency TSCOPF problems. A two-level parallelism is developed to fully utilize the computing power of a Beowulf cluster equipped with multi-core CPUs. First, several compute-intensive steps of the TSCOPF algorithm are decomposed according to different contingencies with mathematical equivalent transformations, the corresponding computing tasks are assigned, stored, and processed on different nodes. Second, the distributed computing task is accelerated using elemental decomposition on Jacobian matrices, and then high performance multithreaded mathematical libraries are employed to fully exploit the multi-core CPUs on each node. The effectiveness of the proposed parallel algorithm is benchmarked on a Beowulf cluster with 16 computing nodes with 128 CPU cores using a series of test cases including up to 2746 buses and 16 contingencies. The results of the case studies indicate that the proposed parallel decomposition approach inherits the optimal solution and convergence properties of the original serial interior point method (IPM) approach and shows great capacity in accelerating TSCOPF solution.

Challenges in analysing and visualizing large-scale molecular dynamics simulations: domain and defect formation in lung surfactant monolayers

Molecular dynamics simulations have rapidly grown in size and complexity, as computers have become more powerful and molecular dynamics software more efficient. Using coarse-grained models like MARTINI system sizes of the order of 50 nm × 50 nm × 50 nm can be simulated on commodity clusters on microsecond time scales. For simulations of biological membranes and monolayers mimicking lung surfactant this enables large-scale transformation and complex mixtures of lipids and proteins. Here we use a simulation of a monolayer with three phospholipid components, cholesterol, lung surfactant proteins, water, and ions on a ten microsecond time scale to illustrate some current challenges in analysis. In the simulation, phase separation occurs followed by formation of a bilayer fold in which lipids and lung surfactant protein form a highly curved structure in the aqueous phase. We use Voronoi analysis to obtain detailed physical properties of the different components and phases, and calculate local mean and Gaussian curvatures of the bilayer fold.

An Improved Adaptive Space-Sharing Scheduling Policy for Non-dedicated Heterogeneous Cluster Systems

Adaptive space-sharing scheduling algorithms tend to improve the performance of clusters by allocating processors to jobs based on the current system load. The focus of existing adaptive algorithms is on dedicated homogeneous and heterogeneous clusters. However commodity clusters are naturally non-dedicated and tend to be heterogeneous over the time as cluster hardware is usually upgraded and new fast machines are also added to improve cluster performance. The existing adaptive policies for dedicated cluster systems are not suitable for such conditions. Moreover existing adaptive policies use First-come-first-serve (FCFS) which is known to be sensitive of variance in service demand, as a job-selection policy for processor allocation. FCFS allocation of processors to jobs results in a situation where small jobs could be blocked by an earlier arrived large job. This paper fills these gaps by designing an efficient adaptive space-sharing scheduling algorithm for non-dedicated heterogeneous cluster systems. Evaluation results show that the proposed algorithm provide substantial improvement over existing algorithms at moderate to high system utilizations.

Parallel transitive closure algorithm

Abstract Using the BSP/CGM model, with $$p$$ processors, where $$p \ll n$$ , we present a parallel algorithm to compute the transitive closure of a digraph $$D$$ with $$n$$ vertices and $$m$$ edges. Our algorithm uses $$\log p + 1$$ communication rounds if the input is an acyclic directed graph labeled using a linear extension. For general digraphs, the algorithm requires $$p$$ communication rounds in the worst case. In both cases, $$O(M/p)$$ local computation is performed per round, where $$M$$ is the amount of computation needed to compute a sequential transitive closure of a digraph. The presented algorithm can be implemented using any sequential algorithm that computes the transitive closure of a digraph $$D$$ . We have implemented the algorithm using the Warshall transitive closure algorithm on two Beowulf clusters using MPI. The implementation results show its efficiency and scalability. It also compares favorably with other parallel implementations. The worst case (communication rounds) for a digraph was derived through an artificially elaborated example. However, in all our test cases, the algorithm never requires more than $$\log p + 1$$ communication rounds and presents very promising implementation results. The algorithm also can be applied to any $$n \times n$$ matrix that represents a binary relation.

Designing Next-Generation Massively Multithreaded Architectures for Irregular Applications

Massively multithreaded architectures like the Cray XMT address the needs of irregular data-intensive applications better than commodity clusters. A proposed evolution of the XMT integrates multicore processors and next-generation interconnects, along with memory reference aggregation to optimize network utilization.

Lattice Boltzmann simulations on GPUs with ESPResSo

For the dynamics of macromolecules in solution, hydrodynamic interactions mediated by the solvent molecules often play an important role, although one is not interested in the dynamics of the solvent itself. In computer simulations one can therefore save a large amount of computer time by replacing the solvent with a lattice fluid. The macromolecules are propagated by Molecular Dynamics (MD), while the fluid is governed by the fluctuating Lattice-Boltzmann (LB) equation. We present a fluctuating LB implementation for a single graphics card (GPU) coupled to a MD simulation running on conventional processors (CPUs). Particular emphasis lies on the optimization of the combined code. In our implementation, the LB update is performed in parallel with the force calculation on the CPU, which often completely hides the additional computational cost of the LB. Compared to our parallel LB implementation on a conventional quad-core CPU, the GPU LB is 50 times faster, and we show that a whole commodity cluster with Infiniband interconnnect cannot outperform a single GPU in strong scaling. The presented code is part of the open source simulation package ESPResSo (http://www.espressomd.org).

Parallel computing strategies in the analysis of the inhibiting effect of price limits on futures prices

ABSTRACTIn futures markets with price limits, trading halts are triggered by limit hits. Limit hits are rarely observed, perhaps because traders avoid bid‐ask quotes that cause them. If this explanation is true, futures prices would cluster in a narrow region close to the limits. We test this empirically for currency futures contracts and find results consistent with the explanation. The tests require calculations of all combinations of a computationally intensive time series, which are extremely time consuming on a sequential machine and hence limit the practicality of the analysis. Consequently, we investigate parallel computing strategies in partitioning the datasets and solving them in parallel on a high‐end Beowulf cluster. We discuss two different partitioning strategies of the given datasets on the cluster and elaborate the results. Copyright © 2012 John Wiley & Sons, Ltd.

LogBase

Numerous applications such as financial transactions (e.g., stock trading) are write-heavy in nature. The shift from reads to writes in web applications has also been accelerating in recent years. Write-ahead-logging is a common approach for providing recovery capability while improving performance in most storage systems. However, the separation of log and application data incurs write overheads observed in write-heavy environments and hence adversely affects the write throughput and recovery time in the system. In this paper, we introduce LogBase -- a scalable log-structured database system that adopts log-only storage for removing the write bottleneck and supporting fast system recovery. It is designed to be dynamically deployed on commodity clusters to take advantage of elastic scaling property of cloud environments. LogBase provides in-memory multiversion indexes for supporting efficient access to data maintained in the log. LogBase also supports transactions that bundle read and write operations spanning across multiple records. We implemented the proposed system and compared it with HBase and a disk-based log-structured record-oriented system modeled after RAMCloud. The experimental results show that LogBase is able to provide sustained write throughput, efficient data access out of the cache, and effective system recovery.

Parallel File System Analysis Through Application I/O Tracing

Input/Output (I/O) operations can represent a significant proportion of the run-time of parallel scientific computing applications. Although there have been several advances in file format libraries, file system design and I/O hardware, a growing divergence exists between the performance of parallel file systems and the compute clusters that they support. In this paper, we document the design and application of the RIOT I/O toolkit (RIOT) being developed at the University of Warwick with our industrial partners at the Atomic Weapons Establishment and Sandia National Laboratories. We use the toolkit to assess the performance of three industry-standard I/O benchmarks on three contrasting supercomputers, ranging from a mid-sized commodity cluster to a large-scale proprietary IBM BlueGene/P system. RIOT provides a powerful framework in which to analyse I/O and parallel file system behaviour—we demonstrate, for example, the large file locking overhead of IBM's General Parallel File System, which can consume nearly 30% of the total write time in the FLASH-IO benchmark. Through I/O trace analysis, we also assess the performance of HDF-5 in its default configuration, identifying a bottleneck created by the use of suboptimal Message Passing Interface hints. Furthermore, we investigate the performance gains attributed to the Parallel Log-structured File System (PLFS) being developed by EMC Corporation and the Los Alamos National Laboratory. Our evaluation of PLFS involves two high-performance computing systems with contrasting I/O backplanes and illustrates the varied improvements to I/O that result from the deployment of PLFS (ranging from up to 25× speed-up in I/O performance on a large I/O installation to 2× speed-up on the much smaller installation at the University of Warwick).

Scalable shot boundary detection

In a Content-based Video Retrieval system, the shot boundary detection is an unavoidable stage. Such a high demanding task needs a deep study from a computational point of view to allow finding suitable optimization strategies. This paper presents different strategies implemented on both a shared-memory symmetric multiprocessor and a Beowulf cluster, and the evaluation of two different programming paradigms: shared-memory and message passing. Several approaches for video segmentation as well as data access are tested in the experiments that also consider load balancing issues.

ES-MPICH2: A Message Passing Interface with Enhanced Security

An increasing number of commodity clusters are connected to each other by public networks, which have become a potential threat to security sensitive parallel applications running on the clusters. To address this security issue, we developed a Message Passing Interface (MPI) implementation to preserve confidentiality of messages communicated among nodes of clusters in an unsecured network. We focus on M PI rather than other protocols, because M PI is one of the most popular communication protocols for parallel computing on clusters. Our MPI implementation-called ES-MPICH2-was built based on MPICH2 developed by the Argonne National Laboratory. Like MPICH2, ES-MPICH2 aims at supporting a large variety of computation and communication platforms like commodity clusters and high-speed networks. We integrated encryption and decryption algorithms into the MPICH2 library with the standard MPI interface and; thus, data confidentiality of MPI applications can be readily preserved without a need to change the source codes of the MPI applications. MPI-application programmers can fully configure any confidentiality services in MPICHI2, because a secured configuration file in ES-MPICH2 offers the programmers flexibility in choosing any cryptographic schemes and keys seamlessly incorporated in ES-MPICH2. We used the Sandia Micro Benchmark and Intel MPI Benchmark suites to evaluate and compare the performance of ES-MPICH2 with the original MPICH2 version. Our experiments show that overhead incurred by the confidentiality services in ES-MPICH2 is marginal for small messages. The security overhead in ES-MPICH2 becomes more pronounced with larger messages. Our results also show that security overhead can be significantly reduced in ES-MPICH2 by high-performance clusters. The executable binaries and source code of the ES-MPICH2 implementation are freely available at http:// www.eng.auburn.edu/~xqin/software/es-mpich2/.

An efficient computational framework for the analysis of whole slide images: Application to follicular lymphoma immunohistochemistry

Follicular lymphoma (FL) is one of the most common non-Hodgkin lymphoma in the United States. Diagnosis and grading of FL is based on the review of histopathological tissue sections under a microscope and is influenced by human factors such as fatigue and reader bias. Computer-aided image analysis tools can help improve the accuracy of diagnosis and grading and act as another tool at the pathologist's disposal. Our group has been developing algorithms for identifying follicles in immunohistochemical images. These algorithms have been tested and validated on small images extracted from whole slide images. However, the use of these algorithms for analyzing the entire whole slide image requires significant changes to the processing methodology since the images are relatively large (on the order of 100k×100k pixels). In this paper we discuss the challenges involved in analyzing whole slide images and propose potential computational methodologies for addressing these challenges. We discuss the use of parallel computing tools on commodity clusters and compare performance of the serial and parallel implementations of our approach.

Accelerating Relevance‐Vector‐Machine‐Based Classification of Hyperspectral Image with Parallel Computing

Benefiting from the kernel skill and the sparse property, the relevance vector machine (RVM) could acquire a sparse solution, with an equivalent generalization ability compared with the support vector machine. The sparse property requires much less time in the prediction, making RVM potential in classifying the large‐scale hyperspectral image. However, RVM is not widespread influenced by its slow training procedure. To solve the problem, the classification of the hyperspectral image using RVM is accelerated by the parallel computing technique in this paper. The parallelization is revealed from the aspects of the multiclass strategy, the ensemble of multiple weak classifiers, and the matrix operations. The parallel RVMs are implemented using the C language plus the parallel functions of the linear algebra packages and the message passing interface library. The proposed methods are evaluated by the AVIRIS Indian Pines data set on the Beowulf cluster and the multicore platforms. It shows that the parallel RVMs accelerate the training procedure obviously.

Parallelism, hybridism and coevolution in a multi‐level ABC‐GA approach for the protein structure prediction problem

SUMMARYThis paper reports the hybridization of the artificial bee colony (ABC) and a genetic algorithm (GA), in a hierarchical topology, a step ahead of a previous work. We used this parallel approach for solving the protein structure prediction problem using the three‐dimensional hydrophobic‐polar model with side‐chains (3DHP‐SC). The proposed method was run in a parallel processing environment (Beowulf cluster), and several aspects of the modeling and implementation are presented and discussed. The performance of the hybrid‐hierarchical ABC‐GA approach was compared with a hybrid‐hierarchical ABC‐only approach for four benchmark instances. Results show that the hybridization of the ABC with the GA improves the quality of solutions caused by the coevolution effect between them and their search behavior. Copyright © 2011 John Wiley & Sons, Ltd.