Event-based communication is useful in many application domains, ranging from small centralised applications to large distributed systems. Many different event models have been developed to address the requirements of different application domains. One such model is the ECO (events, constraints, objects) model, which was designed to support distributed virtual world applications. Like many other event models, ECO has event-filtering capabilities that are meant to improve scalability by decreasing the network traffic in a distributed implementation. Our recent work in event-based systems has included building a fully-distributed version of the ECO model, including event-filtering capabilities. This paper describes the results of our evaluation of filters as a means of achieving increased scalability in the ECO model. The evaluation is empirical, and real data gathered from an actual event-based system is used. The findings show that: (i) filters are highly valuable in making distributed implementations of the model scale, (ii) multicasting contributes to the scalability and, perhaps most significantly, (iii) multicast groups can be dynamically generated from filters using local (per-node) knowledge rather than global knowledge of the distributed application.
In order to obtain efficiency, current practice in distributed software systems design often suffers from a lack of abstraction. An object-oriented design technique based on UML notations and a special type of high-level Petri nets is used to demonstrate how designs can be kept sufficiently abstract to be platform independent and re-usable but still support design alternatives and their evaluation WRT availability and principle system performance.
This paper presents a theoretical and practical framework for constructing and reasoning about mobile agents. The framework is formulated as a process calculus and has two contributions. One of the contributions can model not only individual mobile agents but also a group of mobile agents because the calculus allows more than one mobile agent to be dynamically organized into a single mobile agent. The other contribution can exactly model many features of actual mobile agents, such as mobility and marshaling, which are often ignored in other existing frameworks but may seriously affect the correctness of mobile agents. To demonstrate the utility of the calculus, we constructed a practical mobile agent system whose agents can be naturally and strictly specified and verified in the calculus. The system also offers a security mechanism for mobile agents by using well-defined properties of the calculus.
Component software is a promising approach for dealing with the problem of large scale distributed system development, because it decreases development costs and increases software quality. One of the central issues for component software in distributed systems is the location of components. In large scale distributed systems trading is already used as a service location mechanism. This is considered the only way to manage services in large scale distributed systems where complete knowledge of the system is both unreasonable and unrealistic. Providing trading mechanisms appropriate for component development requires a move from appearance based (interface) to behaviour based (semantic) trading. We present a semantically enhanced component trading architecture that enables this move
Java threads are synchronised through primitives based upon monitor concepts developed in the early 1970s. The semantics of Java's primitives have only been presented in natural language-this paper remedies this with a simple and formal CSP model. In view of the difficulties encountered in reasoning about any non-trivial interactions between Java threads, being able to perform that reasoning in a formal context (where careless errors can be highlighted by mechanical checks) should be a considerable confidence boost. Further automated model-checking tools can be used to root out dangerous states (such as deadlock and livelock), find overlooked race hazards and prove equivalence between algorithms (e.g. between optimised and unoptimised versions). A case study using the CSP model to prove the correctness of the JCSP channel implementation (which is built in terms of standard Java monitor synchronisations) is presented.
This paper presents an approach to formalize coherence protocols for shared virtual memories as multiset rewriting systems. The global state of the protocol is represented as a multiset and rewriting rules are used to describe state changes. Invariants are expressed as properties on the cardinality of subsets, which characterize specific relations. We present an automatic algorithm to check that a property is an invariant of a protocol. Both the formalization and the verification steps are illustrated on the Li and Hudak single-writer/multiple-readers coherence protocol.
It has long been argued that developing distributed software is a difficult and error-prone activity. Based on previous work on design patterns and skeletons, this paper proposes a template-based approach for the high-level design and implementation of distributed virtual environments (DVEs). It describes a methodology and its associated tool, which includes a user interface, a performance analyser and an automatic code generation facility. It also discusses some preliminary results on a surgical training system.
Presents a flexible, CORBA-compliant middle-tier server architecture which is capable of adding dependability (i.e. reliability, availability and performability) to an existing service. The architecture provides a flexible and cost-effective framework for building fault-tolerant applications via straightforward integration of legacy software. In a typical scenario, the service would be originally provided by some legacy server, which is integrated in the new system with no changes being made to it. This has two main advantages. First, the development effort is minimized, since full reuse of existing software is achieved. Second, backward compatibility is preserved since it is possible to integrate new clients with existing applications and databases, protecting the investment in legacy systems. The architecture we propose is novel, although it builds upon redundancy techniques which have already been implemented in a massive number of designs for traditional fault-tolerant applications.
Exploratory Visualization is an approach for helping users learn about distributed computations without requiring users to examine source code. Instead, visualizations provide intuition about the program's behavior and serve as an interface through which the programs are controlled. We have developed an exploratory visualization system with the goals of providing an intuitive and user-friendly user interface and developing an infrastructure that minimizes perturbation. We present a case study to describe how a naive user can interact with the system to learn about and experiment with the running computation.
To support multimedia applications in mobile environments, it will be necessary for applications to be aware of the underlying environmental conditions, and also to be able to adapt their behavior and that of the underlying platform as such conditions change. Many existing distributed systems platforms support such adaptation only in a rather ad hoc manner. This paper presents a principled approach to supporting adaptation-using reflection. More specifically, the paper introduces a language-independent, component-based reflective architecture featuring a per-component meta-space, the use of meta-models to structure meta-space, and a consistent use of component graphs to represent composite components. The paper also reports on a quality of service management framework, providing sophisticated support for monitoring and adaptation functions. Finally, the paper describes a prototype implementation of this architecture using the object-oriented programming language Python.
This paper describes aspects of a research project in the area of distributed object technology. The focus of the research is the use of this technology within the domains of Groupware and Multimedia applications. As part of this research an Internet based Virtual Store has been developed as a test-bed for an enhanced object event service. The Virtual Store was designed using UML and uses an enhanced implementation of the CORBA Event Service for communication of state changes within the store and for distribution of multimedia notifications to users of the store.
The field of distributed parallel programming is predominated by tools such as the Parallel Virtual Machine (PVM) and the Message Passing Interface (MPI). On the other hand, mainly standards like the Common Object Request Broker Architecture (CORBA), Remote Method Invocation (RMI), and the Distributed Component Object Model (DCOM) are used for distributed computing. In this paper, we examine the suitability of CORBA-based solutions for meeting application requirements in the field of parallel programming. We outline concepts defined within CORBA which are helpful for the development of parallel applications. Subsequently, we present our design of an object group service and a join service which facilitate the development of CORBA-based distributed and parallel software applications by transparently encapsulating typical forking and joining mechanisms often needed in that context
This paper presents a novel approach to monitoring end-user application activity in a distributed, component-based application. Such monitoring can support the visualization of user and application activity, system auditing, monitoring of system performance, and the provision of feedback. A framework is provided which, by means of reflection, allows the insertion of proxies into a three-tier component-based system. Proxies are inserted dynamically in between the user and the graphical user-interface and between the client application and the rest of the distributed, component-based system. The paper describes: how the monitoring is effected, how information produced by this monitoring can be used to provide a visualization of application activity, and how this mechanism enables the enhancement and tailoring of feedback throughout the software development life cycle. The viability of this approach is demonstrated by means of a prototype implementation.
We are beginning to see distributed dynamic workflow management systems being implemented using CORBA services. However, these systems do not use events as the mechanism for co-ordinating workflows. Instead, workflow components use messages to communicate with each other, thereby resulting in tightly coupled systems. We investigate the use of events as the co-ordinating mechanism for implementing dynamic event-based workflow solutions using existing CORBA services. This paper shows the limitations of the CORBA Event Service for dynamic workflow solutions based on a prototype implementation and proposes a more specialised Workflow Event Channel (WEC) that overcomes these limitations. A CORBA implementation of the WEC design enables event-based workflow execution environments within a CORBA framework.
Scalability is recognised as a primary factor to be considered in the design of distributed systems. The scalability of object-oriented middleware CORBA is becoming a major concern as it has emerged as a standard architecture for distributed object computing. In this paper, a systematic scalability analysis of the basic components of the CORBA specification is attempted. From this analysis, the Portable Object Adapter (POA) and the Implementation Repository (IR) are identified to influence the scale of a CORBA-based system. The specification of the POA provides enough feasibility for the application designer to handle scalability. The existing implementations of IR have a tradeoff between scalability and object migration. A scalable design of the IR is proposed which allows individual objects to migrate without compromising scalability. A performance comparison of the proposed model with existing IR designs is made using a simulation study
The number of security-breaking attempts originating inside organizations is increasing steadily. Attacks made in this way, usually done by "authorized" users of the system, cannot be immediately located. As the idea of filtering the traffic at the "entrance door" (by firewalls, for instance) is not completely successful the use of other technologies should be considered to increase the defense capacity of a site. Therefore, the introduction of mobile agents to provide computational security by constantly moving around within the internal infoways of an organization is presented as a natural solution to prevent both external and internal sources of intrusion. This work presents an evaluation of the use of mobile agent mechanisms to add mobility features to the process of monitoring intrusion in computational systems. A modular approach is proposed, where independent small agents will monitor the communication paths. This approach presents significant advantages in terms of minimizing overhead, increasing scalability and flexibility and providing fault tolerance.
The concept of software architecture (also called system structure or system configuration) is especially important in the design of complex software systems, providing a model of the large-scale structural properties of systems. Module interconnection languages (MILs) introduce the idea of creating program modules and connecting them to form larger structures. However, MILs do not support the description of important architectural elements. A new class of description languages, referred to as architectural description languages (ADLs), have recently emerged. Most ADLs, however, support only the description of static software architectures and not dynamic or reconfigurable software architectures. A further limitation of current ADLs is that they focus mainly on the formal notation and usually do not offer proof systems and tools to enable designers to formably verify the properties of their designs. We have developed the ZCL framework, which is a formal framework, specified in Z, to describe and reason about dynamic distributed software architectures. In this paper, we use a simple case study-the client-server system-to demonstrate how our formal framework ZCL can be used to specify and verify reconfigurable software architectures.
The aim of this paper is to describe a generic interface through which a planning tool or design aid can be connected to a telecommunications network. In today's complex and ever changing networks, network operators need to plan their networks very accurately and rapidly. Sacrificing accuracy generally has severe impacts on the scalability and maintainability of the network at a later stage. A proliferation of planning algorithms/tools exists in both the literature and industry today. These implement advanced algorithms and supply complex answers. It has been our experience that these calculations seldom have any direct use in reducing network costs through optimizing network configuration in practice. It is our opinion that the key to unlocking the benefits of these planning algorithms lies in making the network planning process a generic, open standards-based and closed loop process, through the implementation of generic interfaces which abstract the information required away from the physical network details.This paper describes the design of such an interface, which was then implemented in a conceptual evaluation environment in order to gauge the complexity and practicality of the interface concept. We use the capabilities of Java and CORBA to achieve the necessary scalability and portability. The Generic Network Planning Interface (GNPI) concept is shown to be powerful enough to abstract the network information into generic network objects and provide standard method calls to access these objects in a distributed environment.
Validation, a crucial stage in the development cycle of embedded systems, is normally carried out using static analysis based on scheduling techniques. In high performance embedded systems, where several tasks with high computing requirements are working on input and output signals with high sampling rates, parallel and distributed processing is a valuable design alternative in order for the system to achieve the fulfillment of its real-time constraints. When the validation of parallel and distributed embedded systems is considered, many simplifications are made in order to make analysis tractable. This means that even if the system can be statically validated, the real behavior of the system in execution may be different enough from its theoretical behavior to make it invalid. Thus, conservative designs that lead to over-dimensioned systems with partially wasted resources are commonly adopted. Although static analysis is the only alternative in case of critical embedded systems, where the fulfillment must be always guaranteed, dynamic analysis, based on measurement, is an interesting alternative for validation of non-critical embedded systems.This paper describes a methodology for performance debugging of parallel and distributed embedded systems with non-critical end-to-end deadlines. The methodology is based on the measurement of a prototype of the system in execution and is supported by a behavioral model. The main components of the model are the sequences of activities through out the system tasks (transactions), which are carried out in response to input events, causing the corresponding output events. Thus, the temporal behavior of the system is viewed as a set of real-time transactions competing for the available resources. The paper also includes experimental results corresponding to the performance debugging of a well-known case study.
Component based programming is a current trend in the development of software. The application is created using components and binding their interfaces appropriately at the configuration level. This is especially interesting for applications that, for availability reasons, claim for dynamic reconfiguration. This paper describes an approach for dynamic reconfiguration of applications based on CORBA components running in an environment called LuaSpace that is composed by the dynamically typed language Lua and a set of tools based on Lua. Components, scripts and glue code are the elements that form an application expressed in Lua. LuaSpace provides support for both programmed and ad-hoc reconfiguration.
