The purpose of NetSolve is to create the middleware necessary to provide a seamless bridge between the simple, standard programming interfaces and desktop systems that dominate the work of computational scientists and the rich supply of services supported by the emerging Grid architecture, so that the users of the former can easily access and reap the benefits (shared processing, storage, software, data resources, etc.) of using the latter.
Computational grids are emerging as the new generation computing paradigm for tackling large scale hard problems in a wide range of scientific fields. Grids are highly complex distributed systems (involving multiple organizations with different goals and policies) which aim at providing computing services without the users need to know the location and features of the required resources. While the current and previous research efforts have been mainly concentrated on architectures and protocols, this paper deals with quantitative methods for grid resource management. In particular, three main issues are considered: performance forecasting, local scheduling (i.e., job scheduling within a single administrative domain) and distributed mechanisms for coordinating grid resources within several administrative domains. For each such a topic, the current literature is reviewed and new research avenues are highlighted.
Resource discovery is a key issue in Grid environments, since applications are usually constructed by composing hardware and software resources that need to be found and selected. Classical approaches to Grid resource discovery, based on centralized or hierarchical approaches, do not guarantee scalability in large-scale, dynamic Grid environments. On the other hand, the Peer-to-Peer (P2P) paradigm is emerging as a convenient model to achieve scalability in distributed systems and applications. This chapter describes a protocol and an architecture that adopt a pure-decentralized P2P approach to support resource discovery in OGSA-compliant Grids. In particular, the chapter describes a modified Gnutella protocol, named Gridnut, which uses appropriate message buffering and merging techniques to make Grid Services effective as a way to exchange discovery messages in P2P fashion. We present the design of Gridnut, and compare Gnutella and Gridnut performances under different network and load conditions. The chapter presents also an architecture for resource discovery that adopts the Gridnut approach to extend the model of the Globus Toolkit 3 information service.
The increasing computation and data requirements of scientific applications, especially in the areas of bioinformatics, astronomy, high energy physics, and earth sciences, have necessitated the use of distributed resources owned by collaborating parties. While existing distributed systems work well for compute-intensive applications that require limited data movement, they fail in unexpected ways when the application accesses, creates, and moves large amounts of data over wide-area networks. Existing systems closely couple data movement and computation, and consider data movement as a side effect of computation. In this chapter, we propose a framework that de-couples data movement from computation, allows queuing and scheduling of data movement apart from computation, and acts as an I/O subsystem for distributed systems. This system provides a uniform interface to heterogeneous storage systems and data transfer protocols; permits policy support and higher-level optimization; and enables reliable, efficient scheduling of compute and data resources.
Today many DataGrid applications need to manage and process a very large amount of data distributed across multiple grid nodes and stored into heterogeneous databases. Grids encourage and promote the publication, sharing and integration of scientifica data (distributed across several Virtual Organizations) in a more open manner than is currently the case, and many e-Science pojects have an urgent need to interconnect legacy and independently operated databases through a set os data access and integration services. The complexity of data management within a Computational Grid comes from the distribution, scale and heterogeneity of data sources. A set of dynamic and adaptive services could address specific issues related to automatic data management providing high performance and transparency as well as fully exploiting a grid infrastructure. These services should involved data migration and integration, discovery of data sources and so on, providing a transparent and dynamic layer of data virtualization. In this pape we introduce the Grid-DBMS concept, a framework for dynamic data management in a grid enviroment, highlighting its requirements, architecture, components and services. We also present an overview about the Grid Relational Catalog Project (GRelC) developed at the CACT/ISUFI of the University of Lecce, which represents a partial implementation of a Grid-DBMS for the Globus Community.
MIND (Memory, Intelligence, and Network Device) is an advanced parallel computer architecture for high performance computing and scalable embedded processing. It is a Processor-in-Memory (PIM) architecture integrating both DRAM bit cells and CMOS logic devices on the same silicon die. MIND is multicore with multiple memory/processor nodes on each chip and supports global shared memory across systems of MIND components. MIND is distinguished from other PIM architectures in that it incorporates mechanisms for efficient support of a global parallel execution model based on the semantics of message-driven multithreaded split-transaction processing. MIND is designed to operate either in conjunction with other conventional microprocesors or in standalone arrays of like devices. It also incorporates mechanisms for fault tolerance, real time execution, and active power management. This paper describes the major elements and operational methods of the MIND architecture.
Grid Computing promises an efficient sharing of world-wide distributed resources, ranging from hardware, software, expert knowledge to special I/O devices. However, although the main Grid mechanisms are already developed or are currently addressed by tremendous research effort, the Grid environment still suffers from a low acceptance in different user communities. Beside difficulties regarding an intuitive and comfortable resource access, various problems related to the reliability and the Quality-of-Service while using the Grid exist. Users should be able to rely, that their jobs will have certain priority at the remote Grid site and that they will be finished upon the agreed time regardless of any provider problems. Therefore, QoS issues have to be considered in the Grid middleware but also in the local resource management systems at the Grid sites. However, most of the currently used resource management systems are not suitable for SLAs, as they do not support resource reservation and do not offer mechanisms for job checkpointing/migration respectively. The latter are mandatory for Grid providers as rescue anchor in case of system failures or system overload. This paper focuses on SLA-aware job migration and presents a work, which is being performed in the EU supported project HPC4U.
In this paper a general model for instruction-level distributed computing is described. This model provides an explicit description of instruction-level concurrency and allows for scalable implementations of various types of wide-issue multiprocessors. The model is based on microthreading, a hardware-supported multithreading paradigm that schedules small fragments of code dynamically. This model is a replacement for out-of-order issue, currently used in superscalar processors, in order to expose higher levels of concurrent instruction issue. The model describes parametric concurrency, based on loops, and produces schedule-independent binary code. Moreover, this model can be implemented in a fully scalable manner and it is shown here that the instruction issue logic, the distributed register-files and communication structures all scale linearly with issue width. Out-of-order issue has the distinct advantage of backward compatibility in binary code execution as the concurrency is implicit but the scalability disadvantages will eventually outweight this; in the out-of-orderissue model there is a square-law scaling in the size of issue logic with issue width and a cube law scaling of the global register-file with issue width. Microthreading does not yield concurrency unless existing code is recompiled using the concurrency controls introduced by this model. However, backward compatibility is still possible and some speedup on legacy code may be achieved by binary-code translation.
Skeletons are common patterns of parallelism, such as farm and pipeline, that can be abstracted and offered to the application programmer as programming primitives. We describe the use and implementation of skeletons on emerging computational grids, with the skeleton system Lithium, based on Java and RMI, as our reference programming syttem. Our main contribution is the exploration of optimization techniques for implementing skeletons on grids based on an optimized, future-based RMI mechanism, which we integrate into the macro-dataflow evaluation mechanism of Lithium. We discuss three optimizations: 1) a lookahead mechanism that allows to process multiple tasks concurrently at each grid server and thereby increases the overall degree of parallelism, 2) a lazy taskbinding technique that reduces interactions between grid servers and the task dispatcher, and 3) dynamic improvements that optimize the collecting of results and the work-load balancing. We report experimental results that demonstrate the improvements due to our optimizations on various testbeds, including a heterogeneous grid-like environment.
Computational grids are appealing platforms for the execution of large scale applications among the scientific and engineering communities. However, designing new applications and deploying existing ones with the capability of exploiting this potential still remains a challenge. Computational grids are characterized by their dynamic, non-dedicted, and heterogeneous nature. Novel application-level and middleware-level techniques are needed to allow applications to reconfigure themselves and adapt automatically to their underlying execution environments. In this paper, we introduce a new software framework that enhances the performance of Message Passing Interface (MPI) applications through an adaptive middleware for load balancing that includes process checkpointing and migration. Fields as diverse as fluid dynamics, materials science, biomechanics, and ecology make use of parallel adaptive computation. Target architectures have tradititionally been supercomputers and tightly coupled clusters. This framework is a first step in allowing these computations to use computational grids efficiently.
Several efforts to design globally distributed computing systems have converged to the principles of message-centric, service-oriented architectures. As realized through several Web Service specifications, these provide the scaling, robustness, and reliability for delivering distributed capabilities that collectively form virtual organizations. Service architectures are based a clean separation between service implementations and their communication patterns. In this article, we examine several consequences of this separation. First, services should exist on a general purpose, software messaging substrate. Services (and their containers) inherit various qualities of service directly from this substrate: we implement message level security, reliability, events, and notifications in the message routing middleware. Second, all communications involving services should be treated as messages. This applies not only to remote procedure call-style messages and notifications, but to streaming data as well. Finally, services are often domain-specific, but collective applications are cross-domain. Using message-based Geographical Information Systems as an example, we illustrate how a Grid of services is really a Grid of Grids: a composition of capabilities developed independently of specific end applications.
Film archives—particularly those storing video material on all kinds of news items—are important information sources for TV stations. Each TV station creates and maintains its own archive by storing video material received via satellite and/or internet on tapes in analogue and/or digital form. It cannot be predicted in advance which of this archived material will actually be used. Thus all material received must be catalogued and stored. On average only a small percentage of the material stored is actually used. Due to the increase in data volumes the cost of maintaining such repositories and retrieving particular stored items has become prohibitive. To-day digital videos are increasingly replacing analogue material. Digital videos offer the advantage that the can be stored in distributed databases and then be transferred without loss of quality to the transmitting station. Such digital archives can be made accessible to many TV stations, thus spreading the maintenance cost. Individual stations can retrieve only the material they actually need for particular news casts. In this paper a grid architecture for distributed video archives for news broadcasts is proposed. A crucial aspect of such a grid approach is that advanced methods for retrieving data must be available.
The UNICORE Grid-technology provides a seamless, secure and intuitive access to distributed Grid resources. In this paper we present the recent evolution from project results to production Grids. At the beginning UNICORE was developed as a prototype software in two projects funded by the German research ministry (BMBF). Over the following years, in various European-funded projects, UNICORE evolved to a full-grown and well-tested Grid middleware system, which today is used in daily production at many supercomputing centers worldwide. Beyond this production usage, the UNICORE technology serves as a solid basis in many European and International research projects, which use existing UNICORE components to implement advanced features, high level services, and support for applications from a growing range of domains. In order to foster these ongoing developments, UNICORE is available as open source under BSD licence at Source Forge, where new releases are published on a regular basis. This paper is a review of the UNICORE achievements so far and gives a glimpse on the UNICORE roadmap.
Grid computing, in the commercial space, builds upon a set of management disciplines, which aims at mapping available resource capabilities to application workloads, according to requirements these workloads depend upon and to business goals they must fulfill. This paper illustrates innovative technologies, developed at IBM Research, that address key issues found in commercial grid environments. These technologies fall into four main areas, workload virtualization, information virtualization, provisioning and orchestration, and application development.
This paper presents a suite of tools and techniques for efficient storage, retrieval, and processing of multi-dimensional, multi-resolution biomedical image datasets on parallel and distributed storage systems. We present the implementation of various services using these tools. We demonstrate the coordinated use of the services to support biomedical image analysis applications that access subsets of terabyte scale multi-resolution datasets and that make use of a variety of image processing algorithms on large-scale digitized microscopy slides.
This chapter discusses the occasion of JvN's 100th Birthday that was organized by scientific community on 28 December 2003. On this occasion, his achievements as an outstanding mathematician and creator of game theory are reminded, but even more that he laid the very conceptional foundations of the digital computer. The exponential growth of the power of microchips, every 18 months, the integration density of transistors on the chips is doubling is steering, the also exponential growth of computer power. The top computers have surpassed the teraflops level by far, at present, targeting toward 100 teraflops or even petaflops. The computer has become ubiquitous, and protagonists of robotics, and artificial intelligence are tempted to attribute to it omnipotent capabilities that will lead to autonomous “humanoids.” The predictions of the semiconductor industry tell that “Moore's law” describing the exponential evolution in microelectronics might remain valid for other 10 to 15 years. Beyond Moore's law, quantum effects will definitely end the orderly functioning of “classical” circuits. Experimentalists work on different physical concepts to realize quantum computation, for instance, quantum dots, trapped ions, superconducting devices, and NMR (nuclear magnetic resonance) technology have been shown to provide the principles and the technology to build quantum computers.
The architecture of the parallel machine plays an important role in the success of visualization techniques. In parallel isosurfacing since any processor can randomly access the entire dataset, the dataset must be available to each processor. Nonetheless, there is fairly high locality in the dataset for any particular processor. As a result, a shared memory or distributed shared memory machine, such as the SGI (Silicon Graphics. Inc) origin, is ideally suited for this application. The load balancing mechanism also requires a fine-grained low-latency communication mechanism for synchronizing work assignments and returning completed image tiles. With an attached graphics engine, one can display images at high frame rates without network bottlenecks. Ray tracing can be a practical alternative to explicit isosurface extraction for very large datasets. As data sets get larger, and as general purpose processing hardware becomes more powerful, it become a very attractive method for visualizing large scale scalar data both in terms of speed and rendering accuracy. For cluster-based volume rendering, a cluster-aware MPI (message passing interface) version demonstrated to perform far better than simply replacing the underlying shared graphics library with a parallelized library. There are several advantages of developing cluster-aware visualization tools.
Parallel applications in the area of scientific computing are often designed in a data parallel SPMD (single program multiple data) style based on the MPI (message passing interface) standard. The advantage of this method is a clear programming model but on large parallel platforms or cluster systems, the speedup and scalability can be limited especially when collective communication operations are used frequently. The combination of task and data parallelism can improve the scalability of many applications but requires a more intricate program development. The combination of task and data parallelism can lead to an improvement of speedup and scalability for parallel applications on distributed memory machines. To support a systematic design of mixed task and data parallel programs, the TwoL model has been introduced. A key feature of this model is the development support for applications, using multiprocessor tasks on top of data parallel modules. This chapter discusses implementation issues of the TwoL model as an open framework. It focuses on the design of the framework and its internal algorithms and data structures. As examples, fast parallel matrix multiplication algorithms are discussed to illustrate the applicability of approach.
This chapter discusses distributed process networks. Process networks are networks of sequential processes connected by channels behaving like FIFO (first in, first out) queues. These are used in signal and image processing applications that need to run in bounded memory for infinitely long periods of time dealing with possibly infinite streams of data. This chapter discusses distributed implementation of this computation model. The implementation of a distributed process network by using distributed FIFOs to build the distributed application is discussed. The platform used to support this is the common object request broker architecture (CORBA) middleware. Indeed, each process of the process network can be written in a different language and run on a different hardware, provided that these are supported by the chosen object request broker (ORB). In addition of the heterogeneity, implementation presents the following characteristics; automation of data transfer between distributed processes, dynamic and interactive linking of the processes to form the data flow, hybrid data-driven, demand-driven data transfer protocol, with thresholds for load balancing, and the implementation was carried out, such as to enable a distributed or local execution without any change to the program source. A process network deployment and distributed execution is described. The transfer strategies (demand and data driven) are detailed.
This chapter describes data race backend developed for DIOTA (Dynamic Instrumentation, Optimization and Transformation of Applications). DIOTA is generic instrumentation tool, and this tool uses so-called backend to use the information gathered using the instrumentation. Data race backend uses innovative technologies like multilevel bitmaps, snooped matrix clocks, and segment merging in order to limit the amount of memory used. The tool was implemented for Linux systems running on IA32 processors and is fully operational. In the future, if one wants to improve the speed of the data race backend in several ways, one technique is to remove redundant checks of addresses; once an address has been written to once in a segment, all subsequent read and write operations to the same address are irrelevant as far as data race detection is concerned. Therefore, it is possible to greatly optimize the instrumentation. Simple testing has shown that for e.g., the Mozilla web browser, 60% of the memory accesses use the same address as the previous memory access. Also when looking at loops, it is possible to move a lot of instrumentation code out of the loop body, e.g., the instrumentation of the write operations to loop counters.
The development of scalable parallel database systems requires the design of efficient algorithms, especially for join, which is the most frequent and expensive operation in relational database systems. Join is also the most vulnerable operation to data skew and to the high cost of communication in distributed architectures. Moreover, for multi-join queries, the problem of data-skew is more complicated because the imbalance of intermediate results is unknown during static query optimization. This chapter discusses the join algorithms that can be applied efficiently in various parallel execution strategies making it possible to exploit not only intra-operator parallelism, but also inter-operator parallelism. These algorithms minimize the communication and synchronization costs, while guaranteeing a perfect load balancing during each stage of join computation even for highly skewed data. The pipelined version of osfa join is currently implemented within a parallel database prototype, in the framework of the CARAML grid project.
This chapter describes an original taxonomy of memory consistencies based on the programmer approach. This classification shows the interest of a new consistency relaxing un-useful memory management costs. The hierarchical group consistency proposes to group together processes that frequently access the same shared data. This model allows a gain in performance without denying DSM (distributed shared memory) programmability. The group consistency model implemented in DOSMOS (distributed objects shared memory system) is an original approach for improving DSM systems. It allows the system to be adapted to the environment, under which it performs (type of processors, communication network, application patterns, and object size). Depending on the environment, the policy concerning replication of objects will not be the same and consequently the group structure will be different. The hierarchical group consistency is well suited for large scale systems and could perfectly fit for multi-cluster and grid applications. This model fits perfectly the requirements of various kinds of networks. Depending on the latency, the bandwidth or other criteria, an accurate group structure in order to reach the best compromise between replication and availability suited for the studied network can be designed.
This chapter discusses operational semantics schema that is used to describe both functional and parallel behavior of skeletal programs in a uniform way. This schema is basically a labeled transition system (LTS), which is parametric with respect to an oracle function. The oracle function provides the LTS with a configurable label generator that establishes a mapping between data and computation and system resources. The Lithium, a skeletal language exploiting both task and data parallelism as a test-bed for the semantics schema is used. This chapter explains how the semantics (built according to the schema) enables the analysis of several facets of Lithium programs, such as: the description of functional semantics, the comparison in performance and resource usage between functionally equivalent programs, the analysis of maximum parallelism achievable with infinite or finite resources. The proposed schema of semantics represents a handy framework to prove the correctness and validate different rewriting rules. These can be used to transform a skeleton program into a functionally equivalent but possibly faster version.
This chapter describes the distributed active tree, a programming model, which allows for an object-oriented, data parallel formulation of a whole class of parallel and distributed tree structured algorithms. It provides collective communication with varying synchronization conditions and shared address space through accessible objects, representing the nodes accessed within a communication operation. A Java implementation is developed and employed in the parallelization of nested benders decomposition, a solution technique for large stochastic programming problems, such as multistage decision problems. The optimization algorithm is a part of a high performance decision support tool for asset and liability management, the Aurora Financial Management System. The chapter discusses the architecture and coordination layer of implementation and present experimental results obtained on a Beowulf SMP-cluster and on a network of workstations, including a comparison of a synchronous and an asynchronous version of the algorithm.
This chapter discusses the design of the core of a parallel programming language called concrete data structure (CDS). It is based on explicitly-distributed concrete data structures and features compositional semantics, higher-order functions and explicitly distributed objects. The denotation semantics is outlined, the (equivalent) operational semantics is presented and a new realization of the latter is given as a rewriting system. The formal operational semantics of CDS is defined, which is fully abstract with respect to the denotational semantics. The operational semantics manipulates memo terms, terms that memorize parts of their evaluation. A memo term is a CDS program term, some of whose syntactic nodes are tagged with tables. The global data structure is a multi-set of tasks together with a function (set of pairs) mapping syntactic nodes of the term being evaluated to tables. There are two main forms of tasks. The first component of tasks is the name of a cell together with the term whose type contains it. The last component of tasks is always a mode, either a value computed for the given cell, a failure marker to indicate that the cell could not be filled, or a request mode.
The foundation of the HARNESS experimental metacomputing system is the concept of dynamic reconfigurability of networked computing frameworks. This reconfigurability goes beyond, simply involving the computers and networks that comprise the virtual machine, and includes the capabilities of the VM itself. These characteristics may be modified under user control by accessing a set of Java based kernels and via an object oriented “plug-in” mechanism that is the central feature of the system. This chapter provides an overview of the HARNESS system architecture. It explains how HARNESS supports user controlled migration of multi-threaded tasks. The chapter describes how one can implement a migration independent RMI-like method invocation. The cornerstones of implementation are the capabilities of the arena HARNESS plugin. This plug-ins keeps track of the state and location of the migratable components, leveraging the event services provided by the HARNESS system. The current star based implementation of the HARNESS event service may pose scalability problems for more than five hundred events per second. However, the plug-in based architecture of HARNESS allows substituting the current implementation with a more performant one if the need arises.
The bulk synchronous parallel ML (BSML) is a functional language for bulk synchronous parallel (BSP) programming, on top of the sequential functional language Objective Caml. It is based on an extension of the λ-calculus by parallel operations on a parallel data structure named parallel vector, which is given by intention. The Objective Caml language is a functional language but it also offers imperative features. This chapter presents formal semantics of BSML with references, assignment and dereferencing. The BSML allows direct mode Bulk Synchronous Parallel programming. The semantics of BSML were pure functional semantics. Nevertheless, the current implementation of BSML is the BSMLlib library for Objective Caml which offers imperative features. The safe communication of references has been investigated, and for this particular point, the presented semantics conforms to the implementation. To ensure safety, communications may be needed in case of assignment (but in this case the cost model is no longer compositional) or references may contain additional information used dynamically to ensure that dereferencing of references pointing to local values will give the same value on all processes.
This chapter describes the use of genetic algorithms, which are integrated into a commercial system in such a way that, the entire computer aided engineering (CAE-systems) functions can be used for evaluation and data processing. To reduce runtime, a parallelization of the fitness evaluation routine based on the common object request broker architecture (CORBA) technology is presented. This architecture offers a possibility to communicate with different processes of the CAE-system, even on different operating systems. The disadvantages of the quite time-consuming CAE-tools for the fitness evaluation could be compensated by the parallelization and the use of a neural network for the fitness evaluation. The system shows that it is possible to use optimization methods at an early stage of the design process without having to consult an optimization and software specialist with just using the already available hardware.
This chapter discusses a unified model to describe data and task parallelism in an object oriented language. The approach allows compile-time and run-time techniques to be combined. Statements, expressions, types, declarations, formal parameters, and the entire program can be annotated with pragmas. Spar provides a general annotation mechanism. An annotation consists of a list of pragmas. These pragmas allow the user to give the compiler information about the program, and give hints for efficient compilation. By convention, a pragma does not influence the behavior of a program; it only improves the efficiency of the program in terms of execution time, memory use, or any other measure. To help the compiler with the parallelization of a program, the user may annotate a program with pragmas to specify the distribution of data, or the place where a block of code is executed. Titanium provides vectors, multidimensional arrays, iteration ranges, and a foreach statement comparable to those in Spar. In most cases, the Spar version of these constructs is more general. They explicitly state that their foreach is not intended for parallelization. Titanium supports iterations over arbitrary sets; moreover these iteration ranges are “first-class citizens”, they can be handled and modified independent of any loop statements. Spar's iteration ranges are more general than the rectangular iteration sets of Titanium, and can be implemented just as efficiently.
Each element in the outermost array of a two dimensional native Java array is an object reference, while the inner is an array of primitive elements. Each inner array can have its own size. This chapter describes how to utilize this flexibility of native Java arrays for sparse matrix computations. The use of Java arrays is discussed for storing matrices and particularly two different storage schemes for sparse matrices: the compressed row storage and a profile or skyline storage structure and the implementations in Java. The storage schemes for sparse matrices are discussed on the basis of performance, memory, and flexibility on several basic algorithms. Numerical results show that the efficiency is not lost using the more flexible data structures compared to classical data structure for sparse matrices. This flexibility can be utilized for high performance computing (HPC).
Bulk synchronous parallel ML (BSML) is an extension of ML for programming direct-mode parallel to bulk synchronous parallel (BSP) algorithms as functional programs. A BSP algorithm is said to be in direct mode when its physical process structure is made explicit. Such algorithms offer predictable and scalable performances, and BSML expresses them with a small set of primitives taken from the confluent BSA (body surface area) calculus: a constructor of parallel vectors, asynchronous parallel function application, synchronous global communications, and a synchronous global conditional. A BSP program is executed as a sequence of super-steps, each one divided into (at most) three successive and logically disjoint phases. The chapter discusses a bulk synchronous parallel zinc abstract machine (BSP ZAM), which is an extension of the zinc abstract machine used in the Objective Caml implementation. This BSP ZAM implementation will be the basis of a parallel programming environment developed from the Caml-light language and environment
This chapter discusses JToe, an API (application programming interface) dedicated to the exchange of Java objects in the context of high performance computing. Even though Java RMI (remote method invocation) provides a good framework for distributed objects in general, it is known to be quite inefficient, mainly due to the Java serialization process. Many projects have already improved RMI, either by redesigning and reimplementing it or by reimplementing the serialization process. Both approaches are missing a clear and high level API for the exchange of objects. JToe proposes a new simple API that focuses on the exchange of objects. This API is flexible enough to allow, for instance, direct copy of byte streams representation of JVM (Java virtual machine) objects over a specialized transport layer, such as Myrinet or LAPI. Remote method invocation frameworks, such as Java RMI can then be implemented over JToe with good performance enhancement perspectives.
The modular approach of DeWiz allows parallel and distributed program analysis based on a set of independent analysis modules. The target representation of program behavior is the abstract event graph model, which allows a wide variety of analysis activities for different kinds of programs on different levels of abstraction. The analysis modules may be arbitrarily distributed across a set of available resources, which allows to process even large amounts of program state data in reasonable time. The latter is especially interesting with respect to grid computing, which may be just the right environment for a future DeWiz grid debugging service.
This chapter discusses the first step toward a computational steering environment based on CORBA (common object request broker architecture). This environment, called EPSN, allows the control, the data exploration and the data modification for numerical simulations, involving an iterative process. In order to be as generic as possible, an abstract model of steerable simulations is introduced. This abstraction allows building steering clients independently of a given simulation. This model is described with XML syntax and is used in the simulation by some source code annotations. EPSN takes advantage of the CORBA technology to design a communication infrastructure with portability, interoperability, and network transparency. In addition, the in-progress parallel CORBA objects give a framework for extending the steering to parallel and distributed simulations. The prototype Epsilon reveals itself as a really light and easy to use steering platform, providing great capabilities of interaction. Epsilon validates the model of integration based on both a source code annotation and a XML description. The developments of EPSN are now oriented on the integration of parallel and distributed simulations with irregular data distributions.
This chapter discusses the parallel decimation of 3d meshes for efficient web-based isosurface extraction. Isosurface extraction is a basic operation that permits to implement many type of queries on volumetric data. The result of a query for a particular isovalue is a triangulated irregular network (TIN) that may contain huge number of points and of triangles, depending on the size of the original data set. In distributed environment, due to the limits of bandwidth availability and/or to the characteristics of the client, it may be necessary to visualize the result of the query with lower resolution. The simplification process is costly, especially for huge data sets. The problem of efficiently parallelize this process is discussed using a cluster of COTS (commercial, off-the-shelf) PCs for a Web-based parallel isosurface extraction system. The advantages of this approach are due to the minimization of the communications number and size between processes and the reduction of the sequential part of the algorithm.
To show the advantages of an implementation of MPI on top of a distributed shared memory, this chapter describes MPISH, an implementation of MPI on top of DVSA, a package to emulate a shared memory on distributed memory architecture. DVSA structures the shared memory as a set of variable size areas and defines a set of operations each involving a whole area. The various kinds of data to implement MPI— that is, to handle a communicator, a point to point or a collective communication, are mapped onto these areas, such that a large degree of concurrency, and hence a good performance, can be achieved. Performance figures show that the proposed approach may achieve better performances than more traditional implementations of collective communication. To enhance the portability of the MPI support across distinct physical architectures supporting DVSA, the implementation of MPISH exploits the DVSA constructs only. As an example, MPI non blocking communications are defined through DVSA non blocking primitives, even if a thread mechanism supported by the architecture might be more efficient.
Porting a parallel application from a distributed memory system to a shared memory multiprocessor can be done by reusing the existing MPI (message passing interface) code or by parallelizing the serial version with OpenMP directives. These two routes are compared for the case of the climate model ECHAM5 on a IBM pSeries690 system. It is shown that in both cases modifications of computation and communication patterns are needed for high parallelization efficiency. The best OpenMP version is superior to the best MPI version, and has the further advantage of allowing a very efficient load balancing. With minor changes, the same program on a 32 processor pSeries690, using IBM's shared memory MPI implementation sped up to only 14. Further results concerning the comparison of the parallelization on IBM RS6000/SP and IBM pSeries690 and the efficiency of hybrid MPI / OpenMP parallelization on IBM RS6000/SP can be found in.
This chapter describes two skeletons to solve optimization problems using the branch-and-bound technique. Sequential and parallel code of the invariant part of the solvers is provided. The implementation of the skeletons is in C++, and is divided into two different parts: one, that implements the resolution pattern provided by the library, and the second part, which the user has to complete with the particular characteristics of the problem to solve. This second part is used by the resolution pattern and acts as a link. Required classes are used to store the basic data of the algorithm. The solvers are implemented by provided classes. There is one skeleton in the class hierarchy, which is implemented using MPI, and another one using OpenMP. Once the user has represented the problem, two parallel solvers are obtained without any additional effort: one, using the message passing paradigm, and other with the shared memory one. An algorithm for the resolution of the classic 0–1 knapsack problem has been implemented using the skeleton proposed. The obtained computational results using an Origin 3000 are discussed in the chapter.
This chapter describes the term “overlapped block-matching” and experimentally evaluate the performance of the corresponding sequential implementation. Overlapped block-matching motion compensation (OBMC) enhances the prediction results of classical non-overlapped block-matching in the context of video compression significantly and is especially well suited for wavelet-based video coding. However, this is achieved at a high additional computational cost. The possibilities for parallelization of two classical OBMC algorithms and the performance of implementations using MPI and OpenMP are investigated. Classical block-matching (BM) is a standard technique in video compression. A frame is divided into a grid of pixel blocks, and for each block a motion vector (MV) is computed. The result is a motion vector field (MVF) for each frame. The MVs are used to translate blocks of pixels from the previous frame into the current frame when decoding the video sequence. The MPI implementation on the hpcLine exhibited a communication overhead, which made it perform below the results of the MPI implementations on the origin, which has shared memory, and on the SR8000, with shared memory for 8 processors on a node.
This chapter discusses several possibilities for the parallel implementation of a two-layer artificial neural network on a symmetric multiprocessor (SMP). Thread-parallel implementations based on OpenMP and process-parallel implementations based on the MPI communication library are compared. Different data and work partitioning strategies are investigated and the performance of all implementations is evaluated on a Sun Fire 6800. Symmetric multiprocessors (SMPs) represent an important parallel computer class. In this chapter, several CPUs and memories are closely coupled by a system bus or by a fast interconnect. SMPs are used as stand-alone parallel systems with up to about 64 CPUs or as high-performance compute nodes of clusters. SMPs offer a short latency and a very high memory bandwidth (several 100 Mbyte/s). Thus, they seem to be well suited for a communication-intensive neuron-parallel neural network implementation. Two different important parallel programming paradigms that are available for current SMPs are compared: OpenMP for the generation of parallel threads and the communication library MPI.
Subscription journal
[3043 journals]
