38325345
Specifying adaptation semantics
Computer software must dynamically adapt to changing conditions. In order to fully realize the benefit of dynamic adaptation, it must be performed correctly. The correctness of adaptation cannot be properly addressed without precisely specifying the requirements for adaptation. This paper introduces an approach to formally specifying adaptation requirements in temporal logic. We introduce A-LTL, an adaptation-based extension to linear temporal logic, and use this logic to specify three commonly used adaptation semantics. Neighborhood composition and sequential composition techniques are developed and applied to A-LTL to construct the specification of an adaptive system. We introduce adaptation semantics graphs to visually present the adaptation semantics. Specifications for adaptive systems can be automatically generated from adaptation semantics graphs.
13958128
Towards Re-engineering Legacy Systems for Assured Dynamic Adaptation
Increasingly, software must adapt its behavior in response to changes in the supporting computing, communication infrastructure, and in the surrounding physical environment. Since most existing software was not designed to adapt, research on technique to make legacy software dynamically adaptive has gained increasing interest. Assurance is crucial for adaptive software to fulfill its intended purpose. Correctness is even more critical if it is to be applied in high assurance systems. This paper proposes a model-driven approach to introduce dynamic adaptation to non-adaptive legacy systems while maintaining assurance properties. An aspect-oriented technique is applied to achieve separation of concerns in the implementation.
21312091
Optimizing the Java Piped I/O Stream Library for Performance
The overall performance of Java programs has been significantly improved since Java emerged as a mainstream programming language. However, these improvements have revealed a second tier of performance bottlenecks. In this paper, we address one of these issues: the performance of Java piped I/O stream library. We analyze commonly used data transfer patterns in which one reader thread and one writer thread communicate via Java piped I/O streams. We consider data buffering and synchronization between these two threads, as well as the thread scheduling policy used in the Java virtual machine. Based on our observations, we propose several optimization techniques that can significantly improve Java piped I/O stream performance. We use these techniques to modify the Java piped I/O stream library. We present performance results for seven example programs from the literature that use the Java piped I/O stream library. Our methods improve the performance of the programs by over a factor of 4 on average, and by a factor of 27 in the best case.
7309958
Using temporal logic to specify adaptive program semantics
Abstract Computer software must dynamically adapt to changing conditions. In order to fully realize the benefit of dynamic adaptation, it must be performed correctly. The correctness of adaptation cannot be properly addressed without precisely specifying the requirements for adaptation. This paper introduces an approach to formally specifying adaptation requirements in temporal logic. We introduce A-LTL, an adaptation-based extension to linear temporal logic, and use this logic to specify three commonly used adaptation semantics. Composition techniques are developed and applied to A-LTL to construct the specification of an adaptive program. We introduce adaptation semantics graphs to visually represent the adaptation semantics, which can also be used to automatically generate specification for adaptive programs.
207159067
Model-based development of dynamically adaptive software
Increasingly, software should dynamically adapt its behavior at run-time in response to changing conditions in the supporting computing and communication infrastructure, and in the surrounding physical environment. In order for an adaptive program to be trusted, it is important to have mechanisms to ensure that the program functions correctly during and after adaptations. Adaptive programs are generally more difficult to specify, verify, and validate due to their high complexity. Particularly, when involving multi-threaded adaptations, the program behavior is the result of the collaborative behavior of multiple threads and software components. This paper introduces an approach to create formal models for the behavior of adaptive programs. Our approach separates the adaptation behavior and non-adaptive behavior specifications of adaptive programs, making the models easier to specify and more amenable to automated analysis and visual inspection. We introduce a process to construct adaptation models, automatically generate adaptive programs from the models, and verify and validate the models. We illustrate our approach through the development of an adaptive GSM-oriented audio streaming protocol for a mobile computing application.
13273680
Modular verification of dynamically adaptive systems
Cyber-physical systems increasingly rely on dynamically adaptive programs to respond to changes in their physical environment; examples include ecosystem monitoring and disaster relief systems. These systems are considered high-assurance since errors during execution could result in injury, loss of life, environmental impact, and/or financial loss. In order to facilitate the development and verification of dynamically adaptive systems, we separate functional concerns from adaptive concerns. Specifically, we model a dynamically adaptive program as a collection of (non-adaptive) steady-state programs and a set of adaptations that realize transitions among steady state programs in response to environmental changes. We use Linear Temporal Logic (LTL) to specify properties of the non-adaptive portions of the system, and we use A-LTL (an adapt-operator extension toLTL) to concisely specify properties that hold during the adaptation process. Model checking offers an attractive approach to automatically analyzing models for adherence to formal properties and thus providing assurance. However, currently, model checkers are unable to verify properties specified using A-LTL. Moreover, as the number of steady-state programs and adaptations increase, the verification costs (in terms of space and time) potentially become unwieldy. To address these issues, we propose a modular model checking approach to verifying that a formal model of an adaptive program satisfies its requirements specified in LTL and A-LTL, respectively.
27476005
Novel view generation from two reference images based on the same optical axis
As hopping and walking through different cylindrical panoramic viewpoints, we can feel the view-field jumping between the former and the subsequent view. Based on the same optical axis in the general planar-pinhole camera model, an algorithm is proposed for generating novel views from the two reference images in this paper. On the supposition that the two reference images have the same intrinsic parameter matrix, a warping equation is derived to map points from a reference image to a desired image. The point correspondences can be determined between the two reference images by using the method based on the pairs of feature line segments. The sequence of warping images from each reference image can be computed. Then the corresponding warping images are cross-dissolved to generate the novel views. The problems such as seams, holes, folds and irregular points are analyzed and resolved to generate convincing novel views.
4744078
X-warehouse: building query pattern-driven data
In this paper, we propose an approach to materialize XML data warehouses based on the frequent query patterns discovered from historical queries issued by users. The schemas of integrated XML documents in the warehouse are built using these frequent query patterns represented as Frequent Query Pattern Trees (FreqQPTs). Using hierarchical clustering technique, FreqQPTs are clustered and merged to produce a specified number of integrated XML documents for actual data feeding. Maintenance issue of the data warehouse is also treated in this paper.
62240401
A model-based approach to adding autonomic capabilities to network fault management system
Adding autonomic capabilities to network management systems provides great promise in delivering high QoS while lowering operation and maintenance cost. In this paper, we present a model-based approach to adding autonomic capabilities to a fault management system for cellular networks. We propose the use of modeling techniques to specify software failures and their dispositions at the model level for the target system. This facilitates the deployment of a control loop for adding autonomic capabilities into the system architecture, which include self-monitoring, self-healing, and self-adjusting. Our case study on the intelligent network fault management system illustrates the proposed approach by adding and deploying these autonomic capabilities derived from self-model specifications, to mitigate the risk of specified failures and maintain the level of healthiness of the system, dynamically and effectively.
39806803
Model-Driven Adaptive Self-healing for Autonomic Computing
Self-healing is a vital property that an autonomic system must possess in order to provide robust performance and survivability. The promise of self-healing depends on other properties that the system should provide, which include self-monitoring and self-configuring. Autonomic systems further require self-healing behavior to adapt to changes in user needs, business goals, and environmental conditions such that self-healing decisions are made dynamically and adaptively according to the system context. In this paper, we propose a model-driven approach that leverages modeling techniques, reliability engineering methodologies, and aspect-oriented development to realize an adaptive self- healing paradigm for autonomic computing.
45109672
Dynamic Terrain LOD with Region Preservation in 3D Game Engine
In the outdoor 3D game, the terrain can be modified because of interaction. This brings two new complexities to render terrain in 3D game. The first lies in the real-time visualization of dynamic terrain, and the second is that the modified terrain surface need to be preserved. We present an algorithm for dynamic terrain LOD(DT LOD) with preserving region in 3D game engine. The algorithm uses a DAG to represent dependency relationship of vertices which split triangles, and employs an active vertices set to update triangles in two consecutive frames for improving rendering performance. The region LOD can be constructed according to the view direction and the distance between the viewpoint and regions. The results of experiments show that our algorithm has a effective performance during rendering terrain.