Refine
Year of publication
Document Type
- conference proceeding (article) (17)
- Part of a Book (7)
- Article (3)
- Part of Periodical (2)
- Book (1)
Is part of the Bibliography
- no (30)
Keywords
- Higher-Order Components (3)
- AI (2)
- Concurrent computing (2)
- CoreGRID Component Model (GCM) & Fractal (2)
- Forschung (2)
- Forschungsbericht (2)
- Java (2)
- Web Services (2)
- smart city (2)
- Adaptable Code (1)
Institute
Begutachtungsstatus
- peer-reviewed (11)
We consider the development of software systems that integrate collaborative real-time modeling and distributed computing. Our main goal is user-orientation: we need a collaborative workspace for geographically dispersed users with a seamless access of every user to high-performance servers. This paper presents a particular prototype, Clayworks, that allows modeling of virtual clay objects and running computation-intensive deformation simulations for objects crashing into each other. In order to integrate heterogeneous computational resources, we adopt modern Grid middleware and provide the users with an intuitive graphical interface. Simulations are parallelized using a higher-order component (HOC) which abstracts over the web service resource framework (WSRF) used to interconnect our worksuite to the computation server. Clayworks is a representative of a large class of demanding systems which combine collaborative, user-oriented modeling with performance-critical computations, e.g., crash-tests or simulations of biological population evolution.
We suggest that parallel software components used for grid computing should be adaptable to application-specific requirements, instead of developing new components from scratch for each particular application. As an example, we take a parallel farm component which is “embarrassingly parallel”, i. e., free of dependencies, and adapt it to the wavefront processing pattern with dependencies that impact its behavior. We describe our approach in the context of Higher-Order Components (HOCs), with the Java-based system Lithium as our implementation framework. The adaptation process relies on HOCs’ mobile code parameters that are shipped over the network of the grid. We describe our implementation of the proposed component adaptation method and report first experimental results for a particular grid application — the alignment of DNA sequence pairs, a popular, time-critical problem in computational molecular biology.
Report Datenmigration
(2010)
Mehrere Terabyte Daten aus einem auf dem Mainframe laufenden COBOL-Programm auf eine SOA-Architektur unter Linux zu migrieren, stellt besondere Anforderungen an die Werkzeuge und Entwickler. Geschickte Kombination vorhandener Tools und effizienter Strategien vermeiden Stillstandszeiten und beschleunigen den Datentransfer.
While high-level software components simplify the programming of grid applications and Web services increase their interoperability, developing such components and configuring the interconnecting services is a demanding task. In this paper, we consider the combination of Higher-Order Components (HOCs) with the Fractal component model and the ProActive library.
HOCs are parallel programming components, made accessible on the grid via Web services that use a special class loader enabling code mobility: executable code can be uploaded to a HOC, allowing one to customize the HOC. Fractal simplifies the composition of components and the ProActive library offers a generator for automatically creating Web services from components composed with Fractal, as long as all the parameters of these services have primitive types.
Taking all the advantages of HOCs, ProActive and Fractal together, the obvious conclusion is that composing HOCs using Fractal and automatically exposing them as Web services on the grid via ProActive minimizes the required efforts for building complex grid systems. In this context, we solved the problem of exchanging code-carrying parameters in automatically generated Web services by integrating the HOC class loading mechanism into the ProActive library.
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.
In this paper, we present a new Hybrid Genetic Search (HGS) algorithm for solving the Capacitated Vehicle Routing Problem for Pickup and Delivery (CVRPPD) as it is required for public transport in rural areas. One of the biggest peculiarities here is that a large area has to be covered with as few vehicles as possible. The basic idea of this algorithm is based on a more general version of HGS, which we adopted to solve the CVRPPD in rural areas. It also implements improvements that lead to the acceleration of the algorithm and, thereby, to a faster generation of a fastest route. We tested the algorithm on real road data from Roding, a rural district in Bavaria, Germany. Moreover, we designed an API for converting data from the Openrouteservice, so that our algorithm can be applied on real world examples as well.
This paper deals with the problem of application programming for grid systems that combine heterogeneous data and computational resources via the Internet. We argue that grid programming is still too complex because of the big gap between the currently used and anticipated grid middleware, (e.g., Globus or WSRF) and the application level. We suggest that this gap needs to be closed in future-generation grids and propose a novel approach to bridging the gap by using Higher-Order Components (HOCs) — recurring patterns of parallel behaviour that are provided to the user as program building blocks with pre-packaged implementation and middleware setup. The presentation is illustrated with a simple case study of computing fractal images. Our experiments demonstrate that HOCs can simplify grid application programming significantly, without serious performance loss.
HOC-SA
(2004)
The current efforts on programming grid applications often rely on service-oriented approaches like grid services. This work presents HOC-SA -a service architecture for higher-order components, which provides the programmer with reusable and composable patterns of parallelism and is interoperable with the latest Globus toolkit implementations. We describe our implementation of HOC-SA using OGSA-DAI, a framework for integrating grids with distributed databases. We present a simple example application and report first measurements on our grid testbed.
Computer-based Improvements of waste collection and public transport procedures are often a part of smart city initiatives. When we envision an ideal bus network, it will primarily connect the most crowded bus stops. Similarly, an ideal waste collection vehicle will arrive at every container exactly at the time when it is fully loaded. Beyond doubt, this will reduce traffic and support environmentally friendly intentions like waste separation, as it will make more containers manageable. A difficulty of putting that vision into practice is that vehicles cannot always be where they are needed. Knowing the best time for arriving at a position is not insufficient for finding the optimal route. Therefore, we compare four different approaches to optimized routing: Regensburg, Christchurch, Malaysia, and Bangalore. Our analysis shows that the best schedules result from adapting field-tested routes frequently based on sensor measurements and route optimizing computations.