Abstract: In heterogeneous environments with performance variations present, multiple applications compete for and share a limited amount of system resources and suffer from variations in resource availability. These complex applications are desired to adapt themselves and to adjust their resource demands dynamically. On one hand, current adaptation mechanisms built within an application cannot preserve global properties such as fairness; on the other hand, adaptive resource management mechanisms built within the operating system are not aware of data semantics in the application. In this paper, we present a novel middleware control framework to enhance the effectiveness of quality-of-service (QoS) adaptation decisions by dynamic control and reconfiguration of internal parameters and functionalities of a distributed multimedia application. Our objective is to satisfy both system-wide properties (such as fairness among concurrent applications) and application-specific requirements (such as preserving the critical performance criteria). The framework is modeled by the task control model and the fuzzy control model, based on rigorous results from the control theory, and verified by the controllability and adaptivity of a distributed visual tracking application. The results show validation of the framework, i.e., critical application quality parameters can be preserved via controlled adaptation.

Abstract: As the software radio makes its transition from research to practice, it becomes increasingly important to establish provable properties of the software radio architecture on which product developers and service providers can base technology insertion decisions. Establishing provable properties requires a mathematical perspective on the software radio architecture. This paper contributes to that perspective by critically reviewing the fundamental concept of the software radio, using mathematical models to characterize this rapidly emerging technology in the context of similar technologies like programmable digital radios. The software radio delivers dynamically defined services through programmable processing capacity that has the mathematical structure of the Turing machine. The bounded recursive functions, a subset of the total recursive functions, are shown to be the largest class of Turing-computable functions for which software radios exhibit provable stability in plug-and-play scenarios. Understanding the topological properties of the software radio architecture promotes plug-and-play applications and cost-effective reuse. Analysis of these topological properties yields a layered distributed virtual machine reference model and a set of architecture design principles for the software radio. These criteria may be useful in defining interfaces among hardware, middleware, and higher level software components that are needed for cost-effective software reuse.

Abstract: With the emergence of the internet, independent applications are starting to be integrated with each other. This has created a need for technology for glueing together applications both within and across organizations, without having to re-engineer individual components. We propose an approach for developing this glue technology based on message flows and discuss the open research problems in realizing this approach.

Abstract: Today, CORBA architecture brings the major industrial solution for achieving the interoperability between distributed software components in heterogeneous environments. While the CORBA project attempts to federate distributed mechanisms within a unique architecture, its internal model is not very flexible and seems not to be suitable for future evolutions. In this paper, we present OpenCorba, a reflective open broker, enabling users to adapt dynamically the representation and the execution policies of the software bus. We first expose the reflective foundations underlying the implementation of OpenCorba: i) metaclasses which provide a better separation of concerns in order to improve the class reuse; ii) a protocol which enables the dynamic changing of metaclass in order to allow run-time adaptation of systems. Based on this reflective environment, OpenCorba enables the adaptability of the internal characteristics of the broker in order to change its run-time behavior (e.g. remote invocation, IDL type checking, IR error handling). OpenCorba gives a clear example of the benefits of reflective middleware.

Abstract: Distributed object computing forms the basis for next-generation application middleware. At the heart of distributed object computing are object request brokers (ORBs), which automate many tedious and error-prone distributed programming tasks. This article presents a case study of key patterns used to develop ORBs that can be dynamically configured and evolved for specific application requirements and network/end-system characteristics.

Abstract: Architecture definition languages (ADLs) enable the formalization of the architecture of software systems and the execution of preliminary analyses on them. These analyses aim at supporting the identification and solution of design problems in the early stages of software development. We have used ADLs to describe middleware-induced architectural styles. These styles describe the assumptions and constraints that middleware infrastructures impose on the architecture of systems. Our work originates from the belief that the explicit representation of these styles at the architectural level can guide designers in the definition of an architecture compliant with a pre-selected middleware infrastructure, or, conversely can support designers in the identification of the most suitable middleware infrastructure for a specific architecture. In this paper we provide an evaluation of ADLs as to their suitability for defining middleware-induced architectural styles. We identify new requirements for ADLs, and we highlight the importance of existing capabilities. Although our experimentation starts from an attempt to solve a specific problem, the results we have obtained provide general lessons about ADLs, learned from defining the architecture of existing, complex, distributed, running systems.

Abstract: Adopting a new hierarchical checkpointing architecture, the authors develop a single I/O address space for building highly available clusters of computers. They propose a systematic approach to achieving a single system image by integrating existing middleware support with the newly developed features.

Abstract: A method for on-line monitoring and testing the behavior of middleware based, distributed application software during run-time of such software is disclosed. In order to automatize the monitoring of the behavior of the application software, the monitoring method comprises: defining events capturing the behavior of the software execution, the events being based on an abstraction of the application software, the abstraction being provided by middleware; using code generating means and an instrumentation technique for automatically adding code to the implementation of the software code suitable for generating traces suitable to be sent to an observer, the information carried by the added code including information on the order of occurrence of the events and on the application software part location where each event occurs; and using a monitoring mechanism based on sending of trace reports to the observer, which ensures or takes into account the time order of the reported traces. In order to automatize testing of the behavior of the application software, the testing method comprises monitoring the behavior of the software during run-time thereof by the above mentioned method, and using a checking mechanism using the information monitored at runtime for checking whether the behavior is violating or has violated predefined properties or constraints.

Abstract: Discusses the Address Resolution Protocol (ARP) and the problem of ARP cache poisoning. ARP cache poisoning is the malicious act, by a host in a LAN, of introducing a spurious IP address to MAC (Ethernet) address mapping in another host's ARP cache. We discuss design constraints for a solution: the solution needs to be implemented in middleware, without any access or change to any operating system source code, it needs to be backward-compatible with the existing protocol and to be asynchronous. We present our solution and implementation aspects of it in a Streams-based networking subsystem. Our solution comprises two parts: a "bump in the stack" Streams module, and a separate Stream with a driver and user-level application. We also present the algorithm that is executed in the module and application to prevent ARP cache poisoning where possible, and to detect and raise alarms otherwise. We then discuss some limitations with our approach and present some preliminary performance figures for our implementation.

Abstract: Presents the software framework SMARTSOFT to implement sensorimotor systems. SMARTSOFT not only contains software components to support a modularized implementation but also structural rules and templates. These ensure that the implementation of modules is conforming with an overall multilayer system architecture. Since the provided structures allow the exact specification of the external behavior of modules in terms of interfaces and dependencies, the interaction with a symbolic task execution layer is explicitly supported. SMARTSOFT significantly eases the implementation and integration of new modules into a complex sensorimotor system which for example provides the opportunity even to compare and reuse different modules on a mobile platform. SMARTSOFT has already proven its usefulness within the collaborative research center (SFB 527) "Integration of Symbolic and Subsymbolic Information Processing in Adaptive Sensorimotor Systems".

Abstract: Traditionally, most definitions seeking to characterize middleware suggest that it is the software that facilitates remote database access and systems transactions. More recently, the term has come to be associated-somewhat limitingly-with distributed platforms such as the Open Software Foundation's Distributed Computing Environment (DCE) and the Object Management Group's Common Object Request Broker Architecture (CORBA). And some have loosely applied it to systems as diverse as workflow support environments and even to the Web itself. We believe the essential role of middleware is to manage the complexity and heterogeneity of distributed infrastructures and thereby provide a simpler programming environment for distributed-application developers. It is therefore most useful to define middleware as any software layer that is placed above the distributed system's infrastructure-the network OS and APIs-and below the application layer.

Abstract: Method and apparatus for remote peripheral software installation. A software system running in a local computer system used by a system administrator can install drivers, network utilities, and other peripheral software on a remote system connected to a network. The software system gathers system information from the remote system including the locations and names of system files. The software system also provides for the stopping and restarting of services which are associated with the peripheral software. In this way, installation can be completed without rebooting, or otherwise disrupting the operation of the remote system. Additionally, no special software is needed on the remote system, and no user need be logged into the remote system.

Abstract: Software architectures promote development focused on modular building blocks and their interconnections. Since architecture-level components often contain complex functionality, it is reasonable to expect that their interactions will also be complex. Modeling and implementing software connectors thus becomes a key aspect of architecture-based development. Software interconnection and middleware technologies such as RMI, CORBA, ILU, and ActiveX provide a valuable service in building applications from components. The relation of such services to software connectors in the context of software architectures, however, is not well understood. To understand the tradeoffs among these technologies with respect to architectures, we have evaluated several off-the-shelf middleware technologies and identified key techniques for utilizing them in implementing software connectors. Our platform for investigation was C2, a component- and message-based architectural style. By encapsulating middleware functionality within software connectors, we have coupled C2's existing benefits such as component interchangeability, substrate independence and structural guidance with new capabilities of multi-lingual, multi-process and distributed application development in a manner that is transparent to architects.

Abstract: The emerging electronic commerce and rapidly changing business environments place strong requirements on a next-generation supply-chain analyzer to simulate the flow of goods through the entire supply chain in a timely manner. Such requirements include scalable and efficient model execution and support for flexible future extensibility based on an open industry standard. This paper presents design considerations for a supply chain modeling and simulation environment to execute in a parallel and distributed manner on a DEVS/CORBA run time infrastructure. We recall that DEVS (Discrete Event System Specification) is a sound formal modeling and simulation framework based on generic dynamic systems concepts that can integrate into a parallel and distributed run time infrastructure. CORBA (Common Object Request Broker Architecture) is an open standard that is rapidly gaining universal business acceptance. It can be employed as middleware to support a heterogeneous, network-centric, distributed computing environment that includes modeling and simulation as well as other business objects. Implementing a distributed supply chain simulator in a DEVS/CORBA execution environment not only may significantly improve execution speed but also may provide an advanced supply chain model development capability based on the DEVS modeling and simulation framework.

Abstract: A software architecture framework for the soft set top box. A Set Top software architecture (200, 1000) allows the consideration of Set Top application and middleware software functionality (120) independent from the operating system (110) and hardware (100). Various types of functionality can be supported, such as multiple users, secure controlled access of resources, application download, registration, start, stop, and monitoring, resource download, registration, start, stop, and monitoring, and management of audio, video, and data presentations.

Abstract: Communication services that provide enhanced Quality of Service (QoS) guarantees related to dependability and real time are important for many applications in distributed systems. This paper presents real-time dependable (RTD) channels, a communication-oriented abstraction that can be configured to meet the QoS requirements of a variety of distributed applications. This customization ability is based on using CactusRT, a system that supports the construction of middleware services out of software modules called micro-protocols. Each micro-protocol implements a different semantic property or property variant and interacts with other micro-protocols using an event-driven model supported by the CactusRT runtime system. In addition to RTD channels CactusRT and its implementation are described. This prototype executes on a cluster of Pentium PCs running the OpenGroup/RI MK 7.3 Mach real-time operating system and CORDS, a system for building network protocols based on the x-kernel.

Abstract: Many fault-tolerant distributed applications can be structured as one or more groups of objects that cooperate by multicasting invocations on member objects. The building of group based applications is considerably simplified if the members of a group can multicast reliably and have a mutually consistent view of the order in which events (such as invocations, host machine failures) have taken place. With this observation in mind, this paper describes the design and implementation of a CORBA middleware service for managing object groups. The object group service is portable and intended for a wide variety of applications; objects can simultaneously belong to many groups, group size could be large, and objects could be geographically widely separated. The service can provide causality preserving total order delivery to members of a group, ensuring that total order delivery is preserved even for multi-group objects. Both symmetric and asymmetric total order protocols are supported, permitting a member to use say symmetric version in one group and asymmetric version in another group simultaneously. The service is both dynamic and fault-tolerant: ordering and liveness is preserved even if membership changes occur due to (real or suspected) member failures, voluntary member departures and new group formations.

Abstract: Networked computers are finding their way into a broader range of environments, from corporate offices to schools, homes, and shirt pockets. This new computing model fosters the development of distributed software components that communicate with one another across the underlying networked infrastructure. A distributed software component can be plugged into distributed applications that may not have existed when it was created. The intention is that many developers will reuse distributed software components to build new systems. An interface definition language usually is used to describe a distributed software component's interface. However, a notable limitation of current IDLs is that they generally only describe the names and type signatures of the component's attributes and operations. Current IDLs don't formally specify the behavior of the software component's operations. To help solve these problems, the authors have developed Biscotti (behavioral specification of distributed software component interfaces), a Java extension that enhances Java remote method invocation interfaces with Eiffel-style preconditions, postconditions, and invariants.

Abstract: Scheduling in metacomputing environments is an active field of research as the vision of a Computational Grid becomes more concrete. An important class of Grid applications are long-running parallel computations with large numbers of somewhat independent tasks (Monte-Carlo simulations, parameter-space searches, etc.). A number of Grid middleware projects are available to implement such applications but scheduling strategies are still open research issues. This is mainly due to the diversity of both Grid resource types and of their availability patterns. The purpose of this work is to develop and validate a general adaptive scheduling algorithm for task farming applications along with a user interface that makes the algorithm accessible to domain scientists. Our algorithm is general in that it is not tailored to a particular Grid middleware and that it requires very few assumptions concerning the nature of the resources. Our first testbed is NetSolve as it allows quick and easy development of the algorithm by isolating the developer from issues such as process control, I/O, remote software access, or fault-tolerance.

Abstract: Distributed multimedia applications require a variety of communication services. These services and different application requirements have to be provided and supported within: (1) end-systems in an efficient and integrated manner, combining the precise specification of quality-of-service (QoS) requirements, application interfaces, multicast support, and security features and (2) the network. The Da CaPo++ system presented in this paper provides an efficient end-system middleware for multimedia applications, capable of handling various types of applications in a modular fashion. Application needs and communication demands are specified by values in terms of QoS attributes and functional properties, such as encryption requirements or multicast support. Da CaPo++ automatically configures suitable communication protocols, provides for an efficient runtime support, and offers an easy-to-use, object-oriented application programming interface. While its applicability to real-life applications was shown by prototype implementations, performance evaluations have been carried out yielding practical experiences and numerical results.

Abstract: Communication middleware systems provide a solid basis for the construction of distributed applications. Unfortunately they usually lack the mechanisms for runtime reconfiguration. The performance of distributed applications is greatly affected by dynamic changes on the characteristics of the environment such as memory, CPU, and network availability. Existing communication middleware does not react in front of these changes. Most of the time, applications have enough knowledge to decide what to do in front of an environmental change, but they cannot use that knowledge because the middleware does not allow on-the-fly reconfiguration. We developed dynamicTAO, a CORBA-compliant reflective ORB that supports runtime reconfiguration. DynamicTAO maintains an explicit representation of its own internal structure and uses it to carry out dynamic customization safely.

Abstract: Production of reliable and flexible distributed applications is a growing area of interest and research. Various middleware technologies are often used as the communication infrastructure and as a practical ease to the network programming problem. Among them, message-oriented middleware (MOM) are known to provide reliable and flexible communication through asynchronous message passing. This kind of middleware is of particular interest when coordinating components that are not designed for simultaneous execution. Usually MOM focus on the communication layer with a programming interface, charge to the external components to adapt to the MOM communication model. We introduce a distributed programming model based on autonomous software entities called agents. Agents act as the glue software components and they offer reliable and flexible properties like atomic execution or migration from node to node. The combination of both a MOM and agents has been implemented in the AAA platform presented in the second part of the paper.

Abstract: To support the quality-of-service (QoS) requirements of embedded multimedia applications off-the-shelf middleware like common object request broker architecture (CORBA) must be flexible, efficient, and predictable. Moreover, stringent memory constraints imposed by embedded system hardware necessitates a minimal footprint for middleware that supports multimedia applications. This paper provides three contributions toward developing efficient object request broker's (ORBs) middleware to support embedded multimedia applications. First, we describe optimization principle patterns used to develop a time and space-efficient CORBA inter-ORB protocol (IIOP) interpreter for the adaptive communication environment (ACE)-ORB (TAO), which is our high-performance, real-time ORB. Second, we describe the optimizations applied to TAO's interface definition language (IDL) compiler to generate efficient and small stubs/skeletons used in TAO's IIOP protocol engine. Third, we empirically compare the performance and memory footprint of interpretive (de)marshaling versus compiled (de)marshaling for a wide range of IDL data types. Applying our optimization principle patterns to TAO's IIOP protocol engine improved its interpretive (de)marshaling performance to the point where it is now comparable to the performance of compiled (de)marshaling. Moreover, our IDL compiler optimizations generate interpreted stubs/skeletons whose footprint is substantially smaller than compiled stubs/skeletons. Our results illustrate that careful application of optimization principle patterns can yield both time and space-efficient standards-based middleware.

Abstract: An agent of an automatic call distribution system which requires a plurality of software applications employs a server which profiles a software applications usage pattern and preloads a set of software applications based upon the profile of most commonly used applications. One or more computer servers sends one or more requesting computers a most likely predicted-to-be selected software application by forming an association from the software usage profile between a first application and a second application.

Abstract: In this paper, we consider the evolution of hypermedia system architectures from the monolithic systems of the 1980’s to the middleware-oriented component-based open systems of today. We look at the various problems that users and system designers encountered with systems at various stages of this development, focusing particularly on problems that were solved or caused by moving toward a more middleware-oriented approach. Although we cast our discussion in terms of specific hypermedia systems, we believe that many of our observations on the advantages and challenges of our current middleware approach may be helpful to those in other areas of system research.

Abstract: This paper presents an overview of the Grasshopper agent platform, developed by GMD FOKUS and IKV++ GmbH, which provides a powerful middleware for the implementation of agent-based telecommunication services, such as advanced network management, intelligent network, and mobile communications applications. The main target is to enable the dynamic deployment of management and control services inside the network nodes, thereby making the telecommunication networks active. Besides a general overview of the Grasshopper platform features and its usage within some European ACTS research and development projects, we will briefly illustrate the usage of Grasshopper for the implementation of an Active Broadband Intelligent Network environment. This network environment is currently realised within the ACTS project MARINE (Mobile Agent-Based Intelligent Network Environment).

Abstract: This paper describes a technique that allows an MPI code to be encapsulated into a component. Our technique is based on an extension to the Common Object Request Broker Architecture (CORBA) from the OMG (Object Management Group). The proposed extensions do not modify the CORBA core infrastructure (the Object Request Broker) so that it can fully co-exist with existing CORBA applications. An MPI code is seen as a new kind of CORBA object that hides most of the cumbersome problems when dealing with parallelism. Such technique can be used to connect MPI codes to existing CORBA software infrastructures which are now being developed in the framework of several research and development projects such as JACO3, JULIUS or TENT from DLR. To illustrate the concept of parallel CORBA object, we present a virtual reality application that is made of the coupling of a light simulation application (radiosity) and a visualisation tool using VRML and Java.

Abstract: The proliferation of the Internet and intranets, advances in wireless and satellite networks, and the availability of asymmetric, high-bandwidth links to the home, have fueled the development of a wide range of new “dissemination-based” applications. These applications involve the timely distribution of data to a large set of consumers, and include stock and sports tickers, traffic information systems, electronic personalized newspapers, and entertainment delivery. Dissemination-oriented applications have special characteristics that render traditional client-server data management approaches ineffective. These include: tremendous scale, significant overlap in user data needs, and asymmetric data flow from sources to consumers. The mismatch between the data access characteristics of these applications and the technology used to implement them on the WWW results in scalability problems [Fran98]. For example, WWW based applications employ the HTTP protocol which uses a request-response (or client-server), unicast method of data delivery. Using request-response, each user sends requests for data to the server. The large audience for a popular event can generate huge spikes in the load at servers, resulting in long delays and overloaded servers. Compounding the situation is that users must continually poll the server to obtain the most current data, resulting in multiple requests for the same data items from each user. In an application such as an election result server, where the interests of a large part of the population are known a priori,