Internal Design of the DSS

This technical report describes the implementation of the DSS middleware with focus on the design of the abstract entity interface and the coordination layer. Key concepts are highlighted and described, on the level of C++ classes

Comparison of DCOM and CORBA distributed computing

The movement of distributed applications from 2-tier to n-tier architectures have enabled systems to be scaled to meet the demands of an ever increasing population of users. Two middleware architectures have come to the forefront: Microsoft\u27s DCOM and the OMG\u27s CORBA. These are not the only possible architectures for n-tier distributed applications, but they are currently the only two which offer a degree of platform independence and the flexibility of using different programming languages for development. CORBA provides platform independence because it provides a middle layer between the client and the server and services client requests using its internal naming service to identify server objects and then expose methods to the client through it\u27s object adapter (POA). CORBA is a self contained middleware that operates independent of the underlying operating system. CORBA offers the potential of ease of maintainability since server objects can be changed and the new methods can be discovered at runtime by the client using CORBAs Dynamic Invocation Interface. Client code would therefore not have be recompiled as it would using static IDL mappings and client and server stubs. DCOM, in contrast is a platform dependent solution that can only be used on Windows machines, although ports for other platforms are in the works. It relies on the Windows registry to identify objects and the operating system to assist in runtime control of objects. Because DCOM is nothing more of a remote extension to the already established Common Object Model which all contemporary Windows operating systems and applications are built upon, it may provide the easiest path to distributed applications for Windows developers that are already familiar with the Common Object Model

Towards Grid-Wide Modeling and Simulation

Modeling and simulation permeate all areas of business, science and engineering. With the increase in the scale and complexity of simulations, large amounts of computational resources are required, and collaborative model development is needed, as multiple parties could be involved in the development process. The Grid provides a platform for coordinated resource sharing and application development and execution. In this paper, we survey existing technologies in modeling and simulation, and we focus on interoperability and composability of simulation components for both simulation development and execution. We also present our recent work on an HLA-based simulation framework on the Grid, and discuss the issues to achieve composability.Singapore-MIT Alliance (SMA

MULTI-AGENT INFRASTRUCTURES FOR OBJECTIVE AND SUBJECTIVE COORDINATION

Coordination in MAS can be conceived as either an agent activity (the subjective viewpoint) or an activity over agents (the objective viewpoint). The two viewpoints have generated two diverging and often contrasting lines of research, as well as different and non-compatible technologies: however, their integration is mandatory for modelling and engineering complex MAS. In this paper, we explore the issue of integration at both the model and the technology levels. First, by taking FIPA agents and coordination artifacts as reference notions for subjective and objective approaches, respectively, we sketch a framework where agent interactions with coordination artifacts are modelled as physical acts, deliberated and executed by agents analogously to communicative actions. Then, we show how the JADE infrastructure for FIPA-compliant agents, and the TuCSoN infrastructure providing agents with coordination artifacts can be integrated at the technology level, allowing JADE agents to access TuCSoN tuple centres through JADE services

DRAFT: work in progress - - - comments solicited evolving Mach 3.0 to use migrating threads

technical reportLike most operating systems, Mach 3.0 views threads as statically associated with a single task. An alternative model is that of migrating threads, in which a single thread abstraction moves between tasks with the logical flow of control, and "server" code is passively executed. We have compatibly replaced Mach's static threads with migrating threads, isolating that aspect of operating system design and implementation. The key element of our design is a decoupling of the thread abstraction into the controllable execution context and the schedulable thread of control, consisting of a chain of contexts. A key element of our implementation is that threads are now "based" in the kernel, and temporarily make excursions into tasks via upcalls. The new system provides cleaner and more powerful semantics for thread manipulation, allows scheduling and accounting attributes to follow threads, simplifies both kernel and server code, and improves RPC performance. We have retained the old thread and IPC interfaces for backwards compatibility, with no changes required to existing client programs and only a minimal change to servers, as demonstrated by a functional Unix single server and clients. Code size along the critical RPC path has been reduced by a factor of three, while its logical complexity has been reduced by an order of magnitude. Initial timings show that the performance of local RPC, doing normal marshaling, has also improved by a factor of three. We conclude that a migrating thread model is superior to a static model, and that it is feasible to improve existing operating systems in this manner

A middleware service for fault-tolerant group communications

PhD ThesisMany distributed applications require multicast group communication services, enabling an entity to interact with a group of other entities. Providing the reliability and ordering guarantees required by group based applications is not a trivial task in distributed systems where computation and communication delays might not be known accurately. Furthermore, the approaches available to support these guarantees are diverse. The choice of approach may significantly effect the performance of an application and/or may not be suitable for some application types. Nowadays, distributed applications are frequently built as a Middleware service. The Thesis develops techniques for providing group communication support in Middleware environments. A group communication service has been designed and implemented in such a way as not to hinder the interoperability/portability of applications built using it. The service provides a variety of functions that may be tailored to suit many different types of applications. Group communication protocols are presented that ensure reliability and ordering guarantees. Furthermore, the reliability and ordering guarantees of such protocols may be tailored to suit a wide variety of applications. Mechanisms that provide a variety of approaches to inter-member and inter-group interactions that are suitable for satisfying the requirements of many different types of applications (e.g., fault- tolerant, collaborative) are also supported. The service can work over local and wide area networks (Internet).Hewlett Packard laboratories Engineering and Physical Science Research Counci

Quire: Lightweight Provenance for Smart Phone Operating Systems

Smartphone apps often run with full privileges to access the network and sensitive local resources, making it difficult for remote systems to have any trust in the provenance of network connections they receive. Even within the phone, different apps with different privileges can communicate with one another, allowing one app to trick another into improperly exercising its privileges (a Confused Deputy attack). In Quire, we engineered two new security mechanisms into Android to address these issues. First, we track the call chain of IPCs, allowing an app the choice of operating with the diminished privileges of its callers or to act explicitly on its own behalf. Second, a lightweight signature scheme allows any app to create a signed statement that can be verified anywhere inside the phone. Both of these mechanisms are reflected in network RPCs, allowing remote systems visibility into the state of the phone when an RPC is made. We demonstrate the usefulness of Quire with two example applications. We built an advertising service, running distinctly from the app which wants to display ads, which can validate clicks passed to it from its host. We also built a payment service, allowing an app to issue a request which the payment service validates with the user. An app cannot not forge a payment request by directly connecting to the remote server, nor can the local payment service tamper with the request

Porting of an Existing Software From the Sun Workstations to A Personal Computer Environment

The purpose of this study was to port an existing software component, which has been designed for Sun workstations, to a Personal Computer environment. The software component involves the access of remote objects through Java networking. The ported software was tested on various machines housing different file servers of the Oklahoma State University Computing and Information Services Department. A new user interface was developed for the ported software component and a number of enhanced features were introduced. The software worked fairly well on all of the test machines. The new feature (i.e., finding out the time taken to look for a remote server) resulted in a more user-informative environment. Other user friendly features such as information about the current server, the reset feature, and the option of returning to the default server were also introduced. The amount of time taken to look for a method located on a specified server is more when the server is searched for the first time compared to the time taken to relocate the same server. This can be attributed to the Registry mechanism of Java, which is like a simple register containing the information of all the successfully located servers. This mechanism makes a record of all the servers that are accessed, and every lookup for a remote server is first searched across the registry. Thus, it reduces the total lookup time for already accessed servers.Computer Scienc

The migration process of mobile agents: implementation, classification, and optimization

Mobile Agenten stellen ein neues faszinierendes Design-Paradigma für den Aufbau und die Programmierung von verteilten Systemen dar. Ein mobiler Agent ist eine Software-Entität, die von ihrem Besitzer mit einem Auftrag auf einem Knoten eines verteilten Systems gestartet wird und dann zur Laufzeit auf andere Knoten des Netzwerkes migriert. Diese Arbeit konzentriert sich auf den Migrationsprozess für mobile Agenten, dem in der Literatur bisher wenig Aufmerksamkeit geschenkt wurde, obwohl er die Ausführungsgeschwindigkeit eines Agenten entscheidend beeinflusst. Eine detaillierte Analyse der Netzbelastung von mobilen Agenten im Vergleich zum traditionellen Client-Server Ansatz in mehreren typischen Anwendungsszenarien zeigt das Potential von mobilen Agenten zur Verringerung von Verarbeitungszeiten. Allerdings zeigt die Analyse ebenso die Nachteile der in heutigen Agentensystemen verwendenten sehr einfachen Migrationstechniken. Es wird ein neues Migrationsmodell mit Namen Kalong vorgestellt, das den Nachteil der fehlenden Anpassbarkeit heutiger Agentensysteme beseitigt und dem Programmierer eines mobilen Agenten eine sehr flexible Technik für die Migration zur Verfügung stellt

Approach for Highly Dependable Software-Intensive Systems

Author-contributed print itemhe objectives of the proposal are creating new methods and tools for effective constructing software-intensive systems based on multiple perspectives that are used to reflect differing stakeholder's concerns. The models and methods will incorporate rapid prototyping, explicit architecting and consistent engineering techniques into a synthesis approach for highly dependable software-intensive systems (HDSIS)