Stefan Craß

Algebraic foundation of a data model for an extensible space-based collaboration protocol

Space-based computing middleware offers a data driven style for the coordination of processes. The interaction requirements between these processes can be complex, and the template matching coordination law of the Linda and JavaSpaces model is not sufficient. Moreover, the usage should not be limited to a single platform. Several authors have proposed coordination extensions, but besides the suggestion to use XML or RDF based query facilities, a formalization of a general and extensible space-based coordination model has not yet been realized. In this paper we present the algebraic data structures and the coordination model based on a navigational query language for the extensible virtual shared memory architecture, and show how they can be adapted to support arbitrary coordination laws by the introduction of user-definable matchmaker and selector functions. The platform independence is achieved through a language independent communication protocol. The formal specification of the data model is the necessary basis for this protocol.

Peer-Based Programming Model for Coordination Patterns

Modern distributed software systems must integrate in near-time parallel processes and heterogeneous information sources provided by active, autonomous software systems. Such lively information sources are e.g. sensory data, weather data, traffic data, or booking data, operated by independent distributed sites. The complex integration requires the coordination of these data flows to guarantee consistent global semantics. Design, implementation, analysis and control of distributed concurrent systems are notoriously complex tasks. Petri Nets are widely used to model concurrent activities. However, a higher-level programming abstraction is needed. We propose a new programming model for modeling concurrent coordination patterns, which is based on the idea of “peer workers” that represent re-usable coordination and application components. These components encapsulate behavior, structure distributed data and control flow, and allow integration of pre-existing service functions. A domain-specific language is presented. The usability of the peer-based programming model is evaluated with the Split/Join pattern.

A space-based generic pattern for self-initiative load clustering agents

Load clustering is an important problem in distributed systems, which proper solution can lead to a significant performance improvement. It differs from load balancing as it considers a collection of loads, instead of normal data items, where a single load can be described as a task. Current approaches that treat load clustering mainly lack of provisioning a general framework and autonomy. They are neither agent-based nor configurable for many topologies. In this paper we propose a generic framework for self-initiative load clustering agents (SILCA) that is based on autonomous agents and decentralized control. SILCA is a generic architectural pattern for load clustering. The SILCA framework is the corresponding implementation and thus supports exchangeable policies and allows for the plugging of different algorithms for load clustering. It is problem independent, so the best algorithm or combination of algorithms can be found for each specific problem. The pattern has been implemented on two levels: In its basic version different algorithms can be plugged, and in the extended version different algorithms can be combined. The flexibility is proven by means of nine algorithms. Further contributions are the benchmarking of the algorithms, and the working out of their best combinations for different topologies.

A coordination-based access control model for space-based computing

Shared tuple spaces serve as coordination medium for independent processes to exchange data and messages in a flexible way. If communication takes place over the Internet, security becomes an important issue. It must be forbidden that unauthorized processes get access to protected data. In this paper, we present an authorization model for a space-based middleware that uses its own coordination mechanisms for defining fine-grained access control policies. By integrating coordination and security mechanisms into one single concept, the model allows for flexible and secure distributed collaboration.

A Decentralized Access Control Model for Dynamic Collaboration of Autonomous Peers

Distributed applications are often composed of autonomous components that are controlled by different stakeholders. Authorization in such a scenario has to be enforced in a decentralized way so that administrators retain control over their respective resources. In this paper, we define a flexible access control model for a data-driven coordination middleware that abstracts the collaboration of autonomous peers. It supports the definition of fine-grained policies that depend on authenticated subject attributes, content properties and context data. To enable peers to act on behalf of others, chained delegation is supported and permissions depend on trust assumptions about nodes along this chain. Besides access to data, also service invocations, dynamic behavior changes and policy updates can be authorized in a unified way. We show how this access control model can be integrated into a secure middleware architecture and provide example policies for simple coordination patterns.

A generic load balancing framework for cooperative ITS applications

The deployment of cooperative ITS applications is due to start as soon as 2015. Large investments in the roadside unit (RSU) infrastructure will be necessary to create a dense network and accommodate an increasing number of services, leading to a discussion about the trade-off between distributed processing and storage solutions on the RSU nodes and the centralized alternative. A strictly central solution might not be scalable, whereas the decentralized approach faces the problem that load in the form of CPU and memory usage may be unequally distributed among the nodes, causing performance bottlenecks on some of the RSUs. This work presents a solution for this problem, in form of a generic framework that balances the load between the nodes and reduces in this way the RSU costs. The interactions are based on a flexible coordination pattern for load balancing that is realized using customizable containers provided by a distributed systems middleware. This mechanism is applied to a probe data collection scenario in which individual messages are aggregated by RSU nodes, causing both CPU and memory load. Simulation results illustrate the operation in dynamic load situations.

Modeling a Flexible Replication Framework for Space-Based Computing

Large-scale distributed systems often require complex interaction among dynamically joining and leaving participants. Compared to classical approaches coordinated by a central authority, peer-to-peer systems have been shown to provide a highly scalable and flexible architecture for such scenarios. Coordination middleware like tuple spaces can help to unburden developers from coping with the complexity of distributed coordination by offering simple abstractions for the decoupled interaction of autonomous peers. However, a fault-tolerant peer-to-peer system can only be built if replication mechanisms exist to persist data on several peers at once. To enrich space-based middleware with a flexible replication mechanism, we have designed a generic, plugin-based replication framework that supports easy adaptation via configurable replication schemes. The framework may act as a testbed to analyze the efficiency and reliability of different replication strategies. Its architecture is built via highly composable coordination patterns that internally interact via space containers. Using the generic framework, this paper shows how different variants of multi-master replication can be realized and how they can be adapted for various scenarios.