Qianxiang Wang

A Runtime Model Based Monitoring Approach for Cloud

Monitoring plays a significant role in improving the quality of service in cloud computing. It helps clouds to scale resource utilization adaptively, to identify defects in services for service developers, and to discover usage patterns of numerous end users. However, due to the heterogeneity of components in clouds and the complexity arising from the wealth of runtime information, monitoring in clouds faces many new challenges. In this paper, we propose a runtime model for cloud monitoring (RMCM), which denotes an intuitive representation of a running cloud by focusing on common monitoring concerns. Raw monitoring data gathered by multiple monitoring techniques are organized by RMCM to present a more intuitive profile of a running cloud. We applied RMCM in the implementation of a flexible monitoring framework, which can achieve a balance between runtime overhead and monitoring capability via adaptive management of monitoring facilities. Our experience of utilizing the monitoring framework on a real cloud demonstrates the feasibility and effectiveness of our approach.

An Online Monitoring Approach for Web Service Requirements

Web service technology aims to enable the interoperation of heterogeneous systems and the reuse of distributed functions in an unprecedented scale and has achieved significant success. There are still, however, challenges to realize its full potential. One of these challenges is to ensure the behavior of Web services consistent with their requirements. Monitoring events that are relevant to Web service requirements is, thus, an important technique. This paper introduces an online monitoring approach for Web service requirements. It includes a pattern-based specification of service constraints that correspond to service requirements, and a monitoring model that covers five kinds of system events relevant to client request, service response, application, resource, and management, and a monitoring framework in which different probes and agents collect events and data that are sensitive to requirements. The framework analyzes the collected information against the prespecified constraints, so as to evaluate the behavior and use of Web services. The prototype implementation and experiments with a case study shows that our approach is effective and flexible, and the monitoring cost is affordable.

ABC/ADL: An ADL Supporting Component Composition

Architecture Description Language (ADL) is one of the keys to software architecture research, but most attention was paid to the description of software structure and high-level analysis of some system properties, while the ability to support refinement and implementation of Software Architecture (SA) models was ignored. In this paper, we present the ABC/ADL, an ADL supporting component composition. Besides the capability of architecting software systems, it provides support to the automated application generation based on SA model via mapping rules and customizable connectors.

A component‐based approach to online software evolution

Many software systems need to provide services continuously and uninterruptedly. Meanwhile, these software systems need to keep evolving continuously to fix bugs, add functions, improve algorithms, adapt to new running environments and platforms, or prevent potential problems. This situation makes online evolution an important issue in the field of software maintenance and evolution. This paper proposes a component-based approach to online software evolution. Nowadays component technology has been widely adopted. Component technology facilitates software evolution, but also introduces some new issues. In our approach, an application server is used to evolve the application, without special support from the compiler or operating system. The implementation and performance analysis of our approach are also covered. Copyright

Towards a rule model for self-adaptive software

Most self-adaptive software use rules explicitly or implicitly to decide how to react to monitored events. Meanwhile, rules are usually scattered in different procedures, which makes procedures more complex. This paper proposes a Rule Model, which is used to extract scattered rules from different procedures, so as to enhance the self-adaptive ability of software. The paper presents what is Rule Model, including: three key concepts (event, parameter, and rule), hierarchical organization, role in application, and XML-based representation. The paper also introduces how to map declarative rules inside one deployable application to executable rules inside one rule engine, based on one J2EE-compliant application server.

Runtime software architecture based software online evolution

Runtime environment of software are becoming more and more dynamic and changeful, while pervasive computing and Web services further this situation. Software systems are not only becoming larger, more complex, and also more rigid, which make it difficult to evolve software. This paper focuses on online evolution, more exactly, how to make online evolution process convenient and smart, with help of runtime software architecture (RSA). Following issues are discussed in this paper: types of software environment changes, the incarnation of RSA, retrieval and manipulation of RSA, the relation between RSA and the runtime system, and a visual tool to show RSA, and make evolution process more easy and intuitionist.

An application server to support online evolution

Most online evolution of an application depends on its runtime environment. This paper addresses how to support online evolution by an application server, which is considered as a third kind of system software, besides OS and DBMS. From the view of requirements, evolutions of software can be divided into four categories: evolutions that do not alter requirements, evolutions that alter functional requirements, evolutions that alter local constraint requirements, and evolutions that alter global constraint requirements. All changes at the requirement level should be mapped to changes at the implementation level. In our approach implementation level entities, such as components and interceptors are responsible for online evolution. Evolutions in implementation level include adding, removing, updating, and reconfiguring the entities. One of the keys to our approach is to carefully distinguish states of components and interceptors, that is, whether they are in a ready, active, executing or evolving state. A well-designed architecture and feasible mechanisms for runtime instance loading are also keys to the solution. Based on this approach, an application server prototype, named PKUAS, has been implemented and is introduced in our paper.

Formal framework for adaptive multi-agent systems

Evolution of software challenges multi-agent systems to be adaptive and the adaptation capabilities should be provided at both the agent level and the system level. In this paper, we study the adaptation of multi-agent systems from the system level and describe a formal framework for multi-agent systems with adaptation capabilities. In the framework, agents are indirectly interconnected via roles and interaction protocols are defined as entities independent of agents and roles. Thus, agents, roles, and interaction protocols involved in multi-agent systems need not always adjust their behaviors or specifications to adapt to the changes of system structures and interaction protocols.

CEclipse: An Online IDE for Programing in the Cloud

Due to the benefits of cloud computing, many desktop applications have been migrated into the cloud. In order to program in the cloud, lots of IDEs are also moved into the cloud at recent years. Although online IDE can bring developers a lot of convenience for their developing process, some tough problems are still less touched. This paper summarized three main kinds of actual problems from three aspects (Function implementation, Security guarantee, Advanced utilization) encountered when using the online IDE, and proposed three solutions (Services composition, Program behavior analysis, Program behavior mining) to handle these according problems. Finally, this paper introduce a real online IDE (CEclipse) developed by our research group and apply the three solutions in this online IDE.

Iterative mining of resource-releasing specifications

Software systems commonly use resources such as network connections or external file handles. Once finish using the resources, the software systems must release these resources by explicitly calling specific resource-releasing API methods. Failing to release resources properly could result in resource leaks or even outright system failures. Existing verification techniques could analyze software systems to detect defects related to failing to release resources. However, these techniques require resource-releasing specifications for specifying which API method acquires/releases certain resources, and such specifications are not well documented in practice, due to the large amount of manual effort required to document them. To address this issue, we propose an iterative mining approach, called RRFinder, to automatically mining resource-releasing specifications for API libraries in the form of (resource-acquiring, resource-releasing) API method pairs. RRFinder first identifies resource-releasing API methods, for which RRFinder then identifies the corresponding resource-acquiring API methods. To identify resource-releasing API methods, RRFinder performs an iterative process including three steps: model-based prediction, call-graph-based propagation, and class-hierarchy-based propagation. From heterogeneous information (e.g., source code, natural language), the model-based prediction employs a classification model to predict the likelihood that an API method is a resource-releasing method. The call-graph-based and class-hierarchy-based propagation propagates the likelihood information across methods. We evaluated RRFinder on eight open source libraries, and the results show that RRFinder achieved an average recall of 94.0% with precision of 86.6% in mining resource-releasing specifications, and the mined specifications are useful in detecting resource leak defects.