A middleware architecture for distributed systems management

This paper presents a middleware solution for global management of any kind of distributed system, such as networks of PCs/workstations, clusters or server farms. Our approach lies in an object-oriented software architecture that models all kind of management information using the common information model (CIM) developed by the Distributed Management Task Force (DMTF). The classes and attributes obtained after the modeling process are mapped to a Lightweight Directory Access Protocol (LDAP) repository. This paper discusses the key features of our middleware that allows that any element (physical, logical, device, user or system) can be managed using a network-oriented and topology-independent approach. A representative example of management domain illustrates the procedures followed to build management applications using our middleware architecture.     

面向分布式信息服务平台的协调中间件系统

为了更好地满足用户对分布式信息服务平台的QoS要求，对一个异构的数据库簇进行了研究，提出了基于该簇的一个协调中间件的逻辑模型，并对其设计思想及实现方法进行了详细介绍。该模型将数据的新鲜度引入设计过程，用它作为事务处理的QoS参数来提高系统服务质量。     

Embracing dynamic evolution in distributed systems

Distributed systems aren't only more widespread than they used to be, but they've become more critical than ever, having moved from client-server systems to multitier heterogeneous systems. Many of these applications - such as telephone exchange systems - must be operational 24 hours a day, so shutting them down isn't a viable option for administrators who must make systemwide changes. As a system becomes larger and more complex, the likelihood of defects increases, which means a greater number of required fixes. Studies have found that nearly half the software development effort in complex distributed systems is devoted to maintenance. Furthermore, the industry currently favors iterative and incremental development approaches over the traditional waterfall approach in software engineering to flexibly handle requirements and reduce project risks by deploying smaller changes. These changes are regular and predictable. So, how can we build distributed systems to handle these kinds of changes? The answer, we argue, is dynamic evolution. From a business perspective, dynamic evolution permits frequent upgrades, which reduces the time between releases. Dynamic evolution also enhances flexibility in implementing changes to unforeseen and fluctuating business requirements. Many specialized distributed systems will benefit from factoring dynamic evolution into their designs. We can easily achieve dynamic evolution in a component-based distributed system. The abstraction of components and their connectors facilitates system structures to accommodate changes.     

Dynamic end-to-end QoS management middleware for distributed multimedia systems

In this paper, we present a separable, reusable middleware solution that provides coordinated, end-to-end QoS management over any type of service component, and can use existing (legacy) QoS management solutions (by using wrappers) in a distributed multimedia system. Our middleware solution incorporates strategic and tactical QoS managers, and supports protocols and messages between tactical managers and managed application components, and between QoS managers in the management hierarchy. Strategic QoS managers take a global view of QoS provided by a set of application components within the manager's policy domain. Tactical QoS managers provide local control over application components. We introduce the concept of QoS policy domains to scope the authority of a strategic QoS manager. We describe how the management hierarchy is dynamically configured and reconfigured based on runtime needs of the application.     

Communications-oriented development of component-based vehicular distributed real-time embedded systems

We propose a novel model- and component-based technique to support communications-oriented development of software for vehicular distributed real-time embedded systems. The proposed technique supports modeling of legacy nodes and communication protocols by encapsulating and abstracting the internal implementation details and protocols. It also allows modeling and performing timing analysis of the applications that contain network traffic originating from outside of the system such as vehicle-to-vehicle, vehicle-to-infrastructure, and cloud-based applications. Furthermore, we present a method to extract end-to-end timing models to support end-to-end timing analysis. We also discuss and solve the issues involved during the extraction of these models. As a proof of concept, we implement our technique in the Rubus Component Model which is used for the development of software for vehicular embedded systems by several international companies. We also conduct an application-case study to validate our approach.     

A Dynamic Load Balancing Mechanism for Distributed Systems

It is desirable in a distributed system to have the system load balanced evenly among the nodes so that the mean job response time is minimized.In this paper,we present a dynamic load balancing mechanism(DLB).It adopts a cntralized approach and is network topology independent.The DLB mechanism employs a set of threscholds which are automatically adjusted as the system load changes.It also provides a simple mechanism for the system to switch between periodic and instantaneous load balancing policies with ease.The performance of the proposed algorithm is evaluated by intensive simulations for various parameters.Te simulation results show that the mean job response time in a system implementing DLB algorithm is significantly lower than the same system without load balancings.Furthermore,compared with a previously proposed algorithm,DLB algorithm demonstrates improved performance,especially when the system is heavily loaded and the load is unevenly distributed.     

A delegation-based approach for the unanticipated dynamic evolution of distributed objects

Large information systems are typically distributed and cater to several client programs, with different needs. Traditional approaches to software development and deployment cannot handle situations where (i) the needs of one client application evolve over time, diverging from the needs of others, and (ii) when the server application cannot be shutdown for maintenance. In this paper, we propose an experimental framework for the unanticipated dynamic evolution of distributed objects that enables us to: (i) extend the behavior of distributed objects during run-time, requiring no shutdown, and (ii) offer different functionalities to different applications simultaneously. In our approach, new client programs can invoke behavioral extensions to server objects that are visible only to them, while legacy applications may continue to use the non-extended versions of the server. Our approach has the advantage of: (i) requiring no changes to the host programming language or to the virtual machine, and (ii) providing a transparent programming model to the developer. In this paper, we describe the problem of unanticipated dynamic evolution of distributed objects, the principles underlying our approach, and our prototype implementations for Java and C#. We conclude by discussing related work, and the extent to which our approach can be used to support industrial strength unanticipated evolution.     

A framework for automated distributed implementation of component-based models

Although distributed systems are widely used nowadays, their implementation and deployment are still time-consuming, error-prone, and hardly predictable tasks. In this paper, we propose a method for producing automatically efficient and correct-by-construction distributed implementations from a model of the application software in Behavior, Interaction, Priority (BIP). BIP is a well-founded component-based framework encompassing high-level multi-party interactions for synchronizing components (e.g., rendezvous and broadcast) and dynamic priorities for scheduling between interactions. Our method transforms an arbitrary BIP model into a Send/Receive BIP model that is directly implementable on distributed execution platforms. The transformation consists in (1) breaking the atomicity of actions in components by replacing synchronous multiparty interactions with asynchronous Send/Receive interactions; (2) inserting distributed controllers that coordinate the execution of interactions according to a user-defined partition of interactions, and (3) adding a distributed algorithm for handling conflicts between controllers. The obtained Send/Receive BIP model is proven observationally equivalent to its corresponding initial model. Hence, all functional properties of the initial BIP model are preserved by construction in the implementation. Moreover, the obtained Send/Receive BIP model can be used to automatically derive distributed executable code. The proposed method is fully implemented. Currently, it is possible to generate C++ implementations for (1) TCP sockets for conventional distributed communication, (2) MPI for multi-processor platforms, and (3) POSIX threads for deployment on multi-core platforms. We present four case studies and report experimental results for different design choices including partition of interactions and choice of algorithm for distributed conflict resolution.     

A component-based approach to build a portable and flexible middleware for metacomputing

The huge amount of computing resources in the Internet makes it possible to build metacomputers for solving large-scale problems. Despite the great availability of software infrastructures for managing such systems, metacomputer programming is often based on models that do not appear to be suitable to run applications on wide-area, unreliable, highly-variable networks of computers. In this paper, we present a customisable, Java-based middleware which provides programmers with a portable and flexible framework to run applications over a hierarchical, virtual network architecture. The middleware is designed according to a component-based approach that enables the execution behaviour of each computing node to be customised in order to satisfy application needs. The paper shows some examples of programming model customisation and demonstrates that flexibility can be achieved without significantly compromising performance.     

Synthesis of decentralized and concurrent adaptors for correctly assembling distributed component-based systems

Building a distributed system from third-party components introduces a set of problems, mainly related to compatibility and communication. Our existing approach to solve such problems is to build a centralized adaptor which restricts the system’s behavior to exhibit only deadlock-free and desired interactions. However, in a distributed environment such an approach is not always suitable. In this paper, we show how to automatically generate a distributed adaptor for a set of black-box components. First, by taking into account a specification of the interaction behavior of each component, we synthesize a behavioral model for a centralized glue adaptor. Second, from the synthesized adaptor model and a specification of the desired behavior that must be enforced, we generate one local adaptor for each component. The local adaptors cooperatively behave as the centralized one restricted with respect to the specified desired interactions.     

Model driven middleware: A new paradigm for developing distributed real-time and embedded systems

Distributed real-time and embedded (DRE) systems have become critical in domains such as avionics (e.g., flight mission computers), telecommunications (e.g., wireless phone services), tele-medicine (e.g., robotic surgery), and defense applications (e.g., total ship computing environments). These types of system are increasingly interconnected via wireless and wireline networks to form systems of systems. A challenging requirement for these DRE systems involves supporting a diverse set of quality of service (QoS) properties, such as predictable latency/jitter, throughput guarantees, scalability, 24x7 availability, dependability, and security that must be satisfied simultaneously in real-time. Although increasing portions of DRE systems are based on QoS-enabled commercial-off-the-shelf (COTS) hardware and software components, the complexity of managing long lifecycles (often ∼15-30 years) remains a key challenge for DRE developers and system integrators. For example, substantial time and effort is spent retrofitting DRE applications when the underlying COTS technology infrastructure changes.This paper provides two contributions that help improve the development, validation, and integration of DRE systems throughout their lifecycles. First, we illustrate the challenges in creating and deploying QoS-enabled component middleware-based DRE applications and describe our approach to resolving these challenges based on a new software paradigm called Model Driven Middleware (MDM), which combines model-based software development techniques with QoS-enabled component middleware to address key challenges faced by developers of DRE systems — particularly composition, integration, and assured QoS for end-to-end operations. Second, we describe the structure and functionality of CoSMIC (Component Synthesis using Model Integrated Computing), which is an MDM toolsuite that addresses key DRE application and middleware lifecycle challenges, including partitioning the components to use distributed resources effectively, validating software configurations, assuring multiple simultaneous QoS properties in real-time, and safeguarding against rapidly changing technology.     

A mobile agent platform for distributed network and systems management

The mobile agent (MA) technology has been proposed for the management of networks and distributed systems as an answer to the scalability problems of the centralized paradigm. Management tasks may be assigned to an agent, which delegates and executes management logic in a distributed and autonomous fashion. MA-based management has been a subject of intense research in the past few years, reflected on the proliferation of MA platforms (MAPs) expressly oriented to distributed management. However, most of these platforms impose considerable burden on network and system resources and also lack of essential functionality, such as security mechanisms, fault tolerance, strategies for building network-aware MA itineraries and support for user-friendly customization of MA-based management tasks. In this paper, we discuss the design considerations and implementation details of a complete MAP research prototype that sufficiently addresses all the aforementioned issues. Our MAP has been implemented in Java and optimized for network and systems management applications. The paper also presents the evaluation results of our prototype in real and simulated networking environments.     

A new dynamic voting algorithm for distributed database systems

We consider the problem of keeping a distributed database system that has been partitioned because of site or communication link failures partially operable while ensuring data consistency. A dynamic-voting-consistency algorithm is proposed, and its correctness is demonstrated. The proposed algorithm results in improved efficiency in executing read requests by not requiring a read quorum. This algorithm is effective in environments where the majority of user requests are “read” types of requests. Furthermore, the proposed algorithm results in efficient recovery by avoiding updating those data objects that are still current. Under the proposed algorithm, the majority partition would be available even if changes in the network topology take place at a higher rate than the update rate, as long as only simple partitioning takes place     

A model-driven process for the modernization of component-based systems

Software modernization is critical for organizations that need cost-effective solutions to deal with the rapid obsolescence of software and the increasing demand for new functionality. This paper presents the XIRUP modernization methodology, which proposes a highly iterative process, structured into four phases: preliminary evaluation, understanding, building and migration. This modernization process is feature-driven, component-based, focused on the early elicitation of key information, and relies on a model-driven approach with extensive use of experience from the previous projects. XIRUP has been defined in the European IST project MOMOCS, which has also built a suite of support tools. This paper introduces the process using a case study that illustrates its activities, related tools and results. The discussion highlights the specific characteristics of modernization projects and how a customized methodology can take advantage of them.