Recent changes to Home

WikiPage Home modified by wuxiaobin4000

wuxiaobin4000 — Mon, 07 Nov 2011 14:29:26 -0000

--- v25 
+++ v26 
@@ -55,6 +55,6 @@
    * Pengcheng Zhang, Researcher, http://seg.nju.edu.cn/people/~pchzhang/
    * Henry Muccini, Research, http://www.henrymuccini.com/
    * Andrea Polini, Research, http://www1.isti.cnr.it/~polini/
-   * Xiaobing Wu, Master Student,
+   * Xiaobin Wu, Master Student,
 
 ##Past Contributors##

WikiPage Home modified by billy

billy — Mon, 07 Nov 2011 12:50:53 -0000

--- v24 
+++ v25 
@@ -56,4 +56,5 @@
    * Henry Muccini, Research, http://www.henrymuccini.com/
    * Andrea Polini, Research, http://www1.isti.cnr.it/~polini/
    * Xiaobing Wu, Master Student,
+
 ##Past Contributors##

WikiPage Home modified by pchzhang

pchzhang — Mon, 07 Nov 2011 12:42:47 -0000

--- v23 
+++ v24 
@@ -52,8 +52,8 @@
 
 ##Contributors##
 
-   * Pengcheng Zhang, Researcher, 
-   * Henry Muccini, Research, http://unicam.it/~francesco.deangelis/
+   * Pengcheng Zhang, Researcher, http://seg.nju.edu.cn/people/~pchzhang/
+   * Henry Muccini, Research, http://www.henrymuccini.com/
    * Andrea Polini, Research, http://www1.isti.cnr.it/~polini/
    * Xiaobing Wu, Master Student,
 ##Past Contributors##

WikiPage Home modified by pchzhang

pchzhang — Mon, 07 Nov 2011 12:40:14 -0000

--- v22 
+++ v23 
@@ -1,3 +1,6 @@
+#CASSANDRAOSGI: a Failure Prediction Framework for Dynamically Evolving OSGi Systems#
+CASSANDRA is a novel proactive monitoring and verification technique aimed at predicting near future failures in dynamically evolving systems. CASSANDRA, by combining design-time and run-time information,looks k steps ahead of the current execution state, in order to predict future failures.
+
 ##Introduction##
 
 For current software systems that can dynamically change during run-time, such as service-based and component-based, existing verification techniques are inadequate to prevent failures to happen. Traditional design-time verification techniques (like model checking) have been revised in order to cope with evolution but they alone cannot fully support the analysis of run-time evolving systems. Run-time verification techniques, based on system monitoring approaches, have become fundamental to ensure the correctness of run-time evolving systems. However, they have the ability to detect errors only too late, that is, when a failure happens. What is desirable is instead a technique that, while applied to run-time evolving systems, can predict potential errors that may happen in the near future.

WikiPage Home modified by pchzhang

pchzhang — Mon, 07 Nov 2011 12:33:22 -0000

--- v21 
+++ v22 
@@ -1,146 +1,56 @@
- 
-
-
-
- 
-
- 
-
-
-
-
-
-
-
-
- 
-  
-
- CASSANDRAOSGI: a Failure Prediction Framework for Dynamically Evolving OSGi Systems
-
-			
-CASSANDRA is a novel proactive monitoring and verification technique aimed at predicting near future failures in dynamically evolving systems. CASSANDRA, by combining design-time and run-time information,looks k steps ahead of the current execution state, in order to predict future failures.
-
-
-
-
-
- 
-
-ISSUES AND MOTIVATION
-For current software systems that can dynamically change during run-time, such as 
-service-based and component-based, existing verification techniques are inadequate to 
-prevent failures to happen.
-
-
-Traditional design-time verification techniques (like model checking) have been revised in
-order to cope with evolution but they alone cannot fully support the analysis of run-time 
-evolving systems.
-
-Run-time verification techniques, based on system monitoring approaches, have become 
-fundamental to ensure the correctness of run-time evolving systems. However, they have the 
-ability to detect errors only too late, that is, when a failure happens.
-
-What is desirable is instead a technique that, while applied to run-time evolving systems, 
-can predict potential errors that may happen in the near future.
-
-SOLUTION FRAMEWORK
-
-Towards this research goal, this paper proposes CASSANDRA, a novel proactive monitoring 
-approach to predict potential failures by looking ahead the current execution state.
-
-To this end, CASSANDRA combines design-time and run-time information for proactive run-time
-verification of dynamic component-based systems.
-
-The proposed proactive monitoring and verification technique uses run-time information to 
-identify the current execution state, and checks whether the projection of a design-time
-
-model k steps ahead of the current state satisfies a set of wanted/unwanted properties. The 
-execution state is captured by run-time traces obtained by monitoring the component-base 
-system execution. Each component equips with a design-time model in the form of interface 
-automata. The properties we considered are interaction temporal properties among different 
-components.
-
-RESEARCH APPROACH
-The CASSANDRA approach stands on the following assumptions:
-
-Each component to be integrated is augmented with a model of the interface suitable to be 
-used for run-time checking;
-
-It is possible to map observed run-time events with the ones included in the formal model 
-used for the run-time checking;
-
-The execution of one exploration step by the run-time checking algorithm is faster than the
-execution of the corresponding step by the real system. This assumption is necessary to 
-keep the exploration synchronized with the real execution.
-
-CASSANDRA is then based on a run-time checking algorithm that takes in input the interface automata for the various components, the look-ahead value k, the temporal property that should not be violated by the system:
-
-The interface automata of the various components are composed on the fly to construct the 
-tree of possible paths of length smaller than k,
-
-When a system interaction event is detected the exploration is moved ahead of one step. In 
-particular:
-
-All the subtrees rooted in a next state linked by an event different from the one detected
-are discarded;
-
-
-For each leaf in the subtree rooted in the next state linked by the detected event, the 
-exploration is pushed ahead of one step;
-
-In case a property is violated an alert event is generated specifying the trace leading to
-the property violation.
-
-We customize CASSANDRA into the OSGi component model and framework(See Fig. 1). In OSGi, components (coming in the form of bundles for deployment) can be remotely installed, started, stopped, updated and uninstalled without requiring a reboot. The “Hot-Deployment feature” enables to add new bundles to the platform without affecting the running services:
-
-The OSGi bundle developers provide the architecture with a set of wrappers of bundles (each
-wrapper is equipped with source code, the corresponding interface automata model and the 
-Aspect codes).
-
-
-The developers also provide a set of wanted/unwanted properties represented through the 
-Property Sequence Chart (PSC) formalism.
-

-During runtime we take k steps looking ahead at the interface automata models to construct 
-the temporary Global State Machine (GSM) according to the current run-time information. We 
-on-the-fly construct the GSM with k steps looking ahead.
-
-The approach can proactively check at step k whether possible failures could happen in the 
-future k+x steps. Consequently, the application users can take measures to avoid these 
-failures.
-
-FUTURE PLAN
-Apply CASSANDRA to real OSGi-based run-time evolving applications,
-
-Measure the performance and overhead in large case study and further compare to our 
-previous non-proactive monitoring tool,
-
-
-Study how much to look ahead, in order to derive a completely useful theory that could be
-used to guide how to monitor real systems,
-
-
-Manage time and probability in the interface automata, so to be able to predict more precise
-failures limited by timing and probabilistic properties.
-
-
-			
-
-				
-
-			
-
-			
-
-			
-
-
-
-
-
-
-
+##Introduction##
+
+For current software systems that can dynamically change during run-time, such as service-based and component-based, existing verification techniques are inadequate to prevent failures to happen. Traditional design-time verification techniques (like model checking) have been revised in order to cope with evolution but they alone cannot fully support the analysis of run-time evolving systems. Run-time verification techniques, based on system monitoring approaches, have become fundamental to ensure the correctness of run-time evolving systems. However, they have the ability to detect errors only too late, that is, when a failure happens. What is desirable is instead a technique that, while applied to run-time evolving systems, can predict potential errors that may happen in the near future.
+
+Towards this research goal, this paper proposes CASSANDRA, a novel proactive monitoring approach to predict potential failures by looking ahead the current execution state. To this end, CASSANDRA combines design-time and run-time information for proactive run-time verification of dynamic component-based systems. The proposed proactive monitoring and verification technique uses run-time information to identify the current execution state, and checks whether the projection of a design-time model k steps ahead of the current state satisfies a set of wanted/unwanted properties. The execution state is captured by run-time traces obtained by monitoring the component-base system execution. Each component equips with a design-time model in the form of interface automata. The properties we considered are interaction temporal properties among different components.
+
+The CASSANDRA approach stands on the following assumptions:
+
+  * Each component to be integrated is augmented with a model of the interface suitable to   
+    be used for run-time checking;
+  * It is possible to map observed run-time events with the ones included in the formal model  
+    used for the run-time checking;
+  * The execution of one exploration step by the run-time checking algorithm is faster than the 
+    execution of the corresponding step by the real system. This assumption is necessary to 
+    keep the exploration synchronized with the real execution. 
+
+CASSANDRA is then based on a run-time checking algorithm that takes in input the interface automata for the various components, the look-ahead value 𝑘, the temporal property that should not be violated by the system:
+
+  * The interface automata of the various components are composed on the fly to construct the 
+    tree of possible paths of length smaller than k,
+  * When a system interaction event is detected the exploration is moved ahead of one step. In 
+    particular:
+
+     * All the subtrees rooted in a next state linked by an event different from the one  
+       detected  are discarded;
+     * For each leaf in the subtree rooted in the next state linked by the detected event, the    
+       exploration is pushed ahead of one step;
+
+
+   * In case a property is violated an alert event is generated specifying the trace leading to 
+     the property violation 
+
+##Implementation##
+
+We customize CASSANDRA into the OSGi component model and framework. In OSGi, components (coming in the form of bundles for deployment) can be remotely installed, started, stopped, updated and uninstalled without requiring a reboot. The “Hot-Deployment feature” enables to add new bundles to the platform without affecting the running services:
+
+   * The OSGi bundle developers provide the architecture with a set of wrappers of bundles 
+     (each wrapper is equipped with source code, the corresponding interface automata model and  
+     the Aspect codes).
+   * The developers also provide a set of wanted/unwanted properties represented through the 
+     Property Sequence Chart (PSC) formalism. 
+   * During runtime we take k steps looking ahead at the interface automata models to construct 
+     the temporary Global State Machine (GSM) according to the current run-time information. We 
+     on-the-fly construct the GSM with k steps looking ahead.
+   * The approach can proactively check at step k whether possible failures could happen in the 
+     future k+x steps. Consequently, the application users can take measures to avoid these   
+     failures.
+
+
+##Contributors##
+
+   * Pengcheng Zhang, Researcher, 
+   * Henry Muccini, Research, http://unicam.it/~francesco.deangelis/
+   * Andrea Polini, Research, http://www1.isti.cnr.it/~polini/
+   * Xiaobing Wu, Master Student,
+##Past Contributors##

WikiPage Home modified by pchzhang

pchzhang — Mon, 07 Nov 2011 08:51:07 -0000

--- v20 
+++ v21 
@@ -14,7 +14,7 @@
 
 
 
-
+

WikiPage Home modified by pchzhang

pchzhang — Mon, 07 Nov 2011 08:41:19 -0000

--- v19 
+++ v20 
@@ -1,159 +1,138 @@
-       
-
-
+ 
+
 
 
-
-
- 
-
-
+ 
+
+ 
+
+
+
 
 
 
 
 
-
-
-
-
-
-
-	 
-	
- 
-		

-
-	
-
-	
-
-		
-
-		
-
-CASSANDRAOSGI: a Failure Prediction Framework for Dynamically Evolving OSGi Systems
-
-			
-
-CASSANDRA is a novel proactive monitoring and verification technique aimed at predicting near future failures in dynamically evolving systems. CASSANDRA, by combining design-time and run-time information,looks k steps ahead of the current execution state, in order to predict future failures.
-
-


-
-
-
-		
-
-		
-
-				
-
-		
-
+ 
+  
+
+ CASSANDRAOSGI: a Failure Prediction Framework for Dynamically Evolving OSGi Systems
+
+			
+CASSANDRA is a novel proactive monitoring and verification technique aimed at predicting near future failures in dynamically evolving systems. CASSANDRA, by combining design-time and run-time information,looks k steps ahead of the current execution state, in order to predict future failures.
+
+
+
+
+
+ 
 
 ISSUES AND MOTIVATION
 For current software systems that can dynamically change during run-time, such as 
 service-based and component-based, existing verification techniques are inadequate to 
 prevent failures to happen.
 
 
 Traditional design-time verification techniques (like model checking) have been revised in
 order to cope with evolution but they alone cannot fully support the analysis of run-time 
 evolving systems.
 
 Run-time verification techniques, based on system monitoring approaches, have become 
 fundamental to ensure the correctness of run-time evolving systems. However, they have the 
 ability to detect errors only too late, that is, when a failure happens.
 
 What is desirable is instead a technique that, while applied to run-time evolving systems, 
 can predict potential errors that may happen in the near future.
 
 SOLUTION FRAMEWORK
 
 Towards this research goal, this paper proposes CASSANDRA, a novel proactive monitoring 
 approach to predict potential failures by looking ahead the current execution state.
 
 To this end, CASSANDRA combines design-time and run-time information for proactive run-time
 verification of dynamic component-based systems.
 
 The proposed proactive monitoring and verification technique uses run-time information to 
 identify the current execution state, and checks whether the projection of a design-time
 
 model k steps ahead of the current state satisfies a set of wanted/unwanted properties. The 
 execution state is captured by run-time traces obtained by monitoring the component-base 
 system execution. Each component equips with a design-time model in the form of interface 
 automata. The properties we considered are interaction temporal properties among different 
 components.
 
 RESEARCH APPROACH
 The CASSANDRA approach stands on the following assumptions:
 
 Each component to be integrated is augmented with a model of the interface suitable to be 
 used for run-time checking;
 
 It is possible to map observed run-time events with the ones included in the formal model 
 used for the run-time checking;
 
 The execution of one exploration step by the run-time checking algorithm is faster than the
 execution of the corresponding step by the real system. This assumption is necessary to 
 keep the exploration synchronized with the real execution.
 
 CASSANDRA is then based on a run-time checking algorithm that takes in input the interface automata for the various components, the look-ahead value k, the temporal property that should not be violated by the system:
 
 The interface automata of the various components are composed on the fly to construct the 
 tree of possible paths of length smaller than k,
 
 When a system interaction event is detected the exploration is moved ahead of one step. In 
 particular:
 
 All the subtrees rooted in a next state linked by an event different from the one detected
 are discarded;
 
 
 For each leaf in the subtree rooted in the next state linked by the detected event, the 
 exploration is pushed ahead of one step;
 
 In case a property is violated an alert event is generated specifying the trace leading to
 the property violation.
 
 We customize CASSANDRA into the OSGi component model and framework(See Fig. 1). In OSGi, components (coming in the form of bundles for deployment) can be remotely installed, started, stopped, updated and uninstalled without requiring a reboot. The “Hot-Deployment feature” enables to add new bundles to the platform without affecting the running services:
 
 The OSGi bundle developers provide the architecture with a set of wrappers of bundles (each
 wrapper is equipped with source code, the corresponding interface automata model and the 
 Aspect codes).
 
 
 The developers also provide a set of wanted/unwanted properties represented through the 
 Property Sequence Chart (PSC) formalism.
 

 During runtime we take k steps looking ahead at the interface automata models to construct 
 the temporary Global State Machine (GSM) according to the current run-time information. We 
 on-the-fly construct the GSM with k steps looking ahead.
 
 The approach can proactively check at step k whether possible failures could happen in the 
 future k+x steps. Consequently, the application users can take measures to avoid these 
 failures.
 
 FUTURE PLAN
 Apply CASSANDRA to real OSGi-based run-time evolving applications,
 
 Measure the performance and overhead in large case study and further compare to our 
 previous non-proactive monitoring tool,
 
 
 Study how much to look ahead, in order to derive a completely useful theory that could be
 used to guide how to monitor real systems,
 
 
 Manage time and probability in the interface automata, so to be able to predict more precise
 failures limited by timing and probabilistic properties.
 
 
 			
 
 				
 
-			
+

WikiPage Home modified by pchzhang

pchzhang — Mon, 07 Nov 2011 08:15:39 -0000

--- v18 
+++ v19 
@@ -40,126 +40,116 @@
 
 


 
-
-
-			
-
-			
-
+
+
 		
 
 		
 
 				
 
-			
+		
 
 
 ISSUES AND MOTIVATION
 For current software systems that can dynamically change during run-time, such as 
 service-based and component-based, existing verification techniques are inadequate to 
 prevent failures to happen.
 
 
 Traditional design-time verification techniques (like model checking) have been revised in
 order to cope with evolution but they alone cannot fully support the analysis of run-time 
 evolving systems.
 
 Run-time verification techniques, based on system monitoring approaches, have become 
 fundamental to ensure the correctness of run-time evolving systems. However, they have the 
 ability to detect errors only too late, that is, when a failure happens.
 
 What is desirable is instead a technique that, while applied to run-time evolving systems, 
 can predict potential errors that may happen in the near future.
 
 SOLUTION FRAMEWORK
 
 Towards this research goal, this paper proposes CASSANDRA, a novel proactive monitoring 
 approach to predict potential failures by looking ahead the current execution state.
 
 To this end, CASSANDRA combines design-time and run-time information for proactive run-time
 verification of dynamic component-based systems.
 
 The proposed proactive monitoring and verification technique uses run-time information to 
 identify the current execution state, and checks whether the projection of a design-time
 
 model k steps ahead of the current state satisfies a set of wanted/unwanted properties. The 
 execution state is captured by run-time traces obtained by monitoring the component-base 
 system execution. Each component equips with a design-time model in the form of interface 
 automata. The properties we considered are interaction temporal properties among different 
 components.
 
 RESEARCH APPROACH
 The CASSANDRA approach stands on the following assumptions:
 
 Each component to be integrated is augmented with a model of the interface suitable to be 
 used for run-time checking;
 
 It is possible to map observed run-time events with the ones included in the formal model 
 used for the run-time checking;
 
 The execution of one exploration step by the run-time checking algorithm is faster than the
 execution of the corresponding step by the real system. This assumption is necessary to 
 keep the exploration synchronized with the real execution.
 
 CASSANDRA is then based on a run-time checking algorithm that takes in input the interface automata for the various components, the look-ahead value k, the temporal property that should not be violated by the system:
 
 The interface automata of the various components are composed on the fly to construct the 
 tree of possible paths of length smaller than k,
 
 When a system interaction event is detected the exploration is moved ahead of one step. In 
 particular:
 
 All the subtrees rooted in a next state linked by an event different from the one detected
 are discarded;
 
 
 For each leaf in the subtree rooted in the next state linked by the detected event, the 
 exploration is pushed ahead of one step;
 
 In case a property is violated an alert event is generated specifying the trace leading to
 the property violation.
 
 We customize CASSANDRA into the OSGi component model and framework(See Fig. 1). In OSGi, components (coming in the form of bundles for deployment) can be remotely installed, started, stopped, updated and uninstalled without requiring a reboot. The “Hot-Deployment feature” enables to add new bundles to the platform without affecting the running services:
 
 The OSGi bundle developers provide the architecture with a set of wrappers of bundles (each
 wrapper is equipped with source code, the corresponding interface automata model and the 
 Aspect codes).
 
 
 The developers also provide a set of wanted/unwanted properties represented through the 
 Property Sequence Chart (PSC) formalism.
 

 During runtime we take k steps looking ahead at the interface automata models to construct 
 the temporary Global State Machine (GSM) according to the current run-time information. We 
 on-the-fly construct the GSM with k steps looking ahead.
 
 The approach can proactively check at step k whether possible failures could happen in the 
 future k+x steps. Consequently, the application users can take measures to avoid these 
 failures.
 
 FUTURE PLAN
 Apply CASSANDRA to real OSGi-based run-time evolving applications,
 
 Measure the performance and overhead in large case study and further compare to our 
 previous non-proactive monitoring tool,
 
 
 Study how much to look ahead, in order to derive a completely useful theory that could be
 used to guide how to monitor real systems,
 
 
 Manage time and probability in the interface automata, so to be able to predict more precise
 failures limited by timing and probabilistic properties.
 
 
-				
+

WikiPage Home modified by pchzhang

pchzhang — Mon, 07 Nov 2011 08:13:38 -0000

--- v17 
+++ v18 
@@ -1,105 +1,177 @@
        
-#CASSANDRAOSGI: a Failure Prediction Framework for Dynamically Evolving OSGi Systems#
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+	 
+	
+ 
+		

+
+	
+
+	
+
+		
+
+		
+
+CASSANDRAOSGI: a Failure Prediction Framework for Dynamically Evolving OSGi Systems
+
+			
+
 CASSANDRA is a novel proactive monitoring and verification technique aimed at predicting near future failures in dynamically evolving systems. CASSANDRA, by combining design-time and run-time information,looks k steps ahead of the current execution state, in order to predict future failures.
- 
-       
-##ISSUES AND MOTIVATION##
-
-
-  For current software systems that can dynamically change during run-time, such as 
-  service-based and component-based, existing verification techniques are inadequate to 
-  prevent failures to happen.
-
-  Traditional design-time verification techniques (like model checking) have been revised in
-  order to cope with evolution but they alone cannot fully support the analysis of run-time 
-  evolving systems.
-
-  Run-time verification techniques, based on system monitoring approaches, have become 
-  fundamental to ensure the correctness of run-time evolving systems. However, they have the 
-  ability to detect errors only too late, that is, when a failure happens.
-
-  What is desirable is instead a technique that, while applied to run-time evolving systems, 
-  can predict potential errors that may happen in the near future.
-
-##SOLUTION FRAMEWORK##
-
-  Towards this research goal, this paper proposes CASSANDRA, a novel proactive monitoring 
-  approach to predict potential failures by looking ahead the current execution state. 
-
-  To this end, CASSANDRA combines design-time and run-time information for proactive run-time
-  verification of dynamic component-based systems.
-
-  The proposed proactive monitoring and verification technique uses run-time information to 
-  identify the current execution state, and checks whether the projection of a design-time  
-  model k steps ahead of the current state satisfies a set of wanted/unwanted properties. The 
-  execution state is captured by run-time traces obtained by monitoring the component-base 
-  system execution. Each component equips with a design-time model in the form of interface 
-  automata. The properties we considered are interaction temporal properties among different 
-  components.
-
-##RESEARCH APPROACH##
-
-The CASSANDRA approach stands on the following assumptions:
-
-  Each component to be integrated is augmented with a model of the interface suitable to be 
-  used for run-time checking;
-
-  It is possible to map observed run-time events with the ones included in the formal model 
-  used for the run-time checking;
-
-  The execution of one exploration step by the run-time checking algorithm is faster than the
-  execution of the corresponding step by the real system. This assumption is necessary to 
-  keep the exploration synchronized with the real execution. 
-
-CASSANDRA is then based on a run-time checking algorithm that takes in input the interface automata for the various components, the look-ahead value k, the temporal property that should not be violated by the system: 
-
-  The interface automata of the various components are composed on the fly to construct the 
-  tree of possible paths of length smaller than k,
-
-  When a system interaction event is detected the exploration is moved ahead of one step. In 
-  particular:
-
-  All the subtrees rooted in a next state linked by an event different from the one detected
-  are discarded;
-
-  For each leaf in the subtree rooted in the next state linked by the detected event, the 
-  exploration is pushed ahead of one step;
-
-  In case a property is violated an alert event is generated specifying the trace leading to
-  the property violation.
- 
-We customize CASSANDRA into the OSGi component model and framework(See Fig. 1). In OSGi, components (coming in the form of bundles for deployment) can be remotely installed, started, stopped, updated and uninstalled without requiring a reboot. The “Hot-Deployment feature” enables to add new bundles to the platform without affecting the running services:
-
-  The OSGi bundle developers provide the architecture with a set of wrappers of bundles (each
-  wrapper is equipped with source code, the corresponding interface automata model and the 
-  Aspect codes).
-
-  The developers also provide a set of wanted/unwanted properties represented through the 
-  Property Sequence Chart (PSC) formalism. 
-
-  During runtime we take k steps looking ahead at the interface automata models to construct 
-  the temporary Global State Machine (GSM) according to the current run-time information. We 
-  on-the-fly construct the GSM with k steps looking ahead.
-
-  The approach can proactively check at step k whether possible failures could happen in the 
-  future k+x steps. Consequently, the application users can take measures to avoid these 
-  failures.
-
-##FUTURE PLAN##
-
-  Apply CASSANDRA to real OSGi-based run-time evolving applications,
-
-  Measure the performance and overhead in large case study and further compare to our 
-  previous non-proactive monitoring tool, 
-
-  Study how much to look ahead, in order to derive a completely useful theory that could be
-  used to guide how to monitor real systems, 
-
-  Manage time and probability in the interface automata, so to be able to predict more precise
-  failures limited by timing and probabilistic properties.
-
-
-
-
-
+
+


+
+
+
+			
+
+			
+
+		
+
+		
+
+				
+
+			
+
+
+ISSUES AND MOTIVATION
+For current software systems that can dynamically change during run-time, such as 
+service-based and component-based, existing verification techniques are inadequate to 
+prevent failures to happen.
+
+
+Traditional design-time verification techniques (like model checking) have been revised in
+order to cope with evolution but they alone cannot fully support the analysis of run-time 
+evolving systems.
+
+Run-time verification techniques, based on system monitoring approaches, have become 
+fundamental to ensure the correctness of run-time evolving systems. However, they have the 
+ability to detect errors only too late, that is, when a failure happens.
+
+What is desirable is instead a technique that, while applied to run-time evolving systems, 
+can predict potential errors that may happen in the near future.
+
+SOLUTION FRAMEWORK
+
+Towards this research goal, this paper proposes CASSANDRA, a novel proactive monitoring 
+approach to predict potential failures by looking ahead the current execution state.
+
+To this end, CASSANDRA combines design-time and run-time information for proactive run-time
+verification of dynamic component-based systems.
+
+The proposed proactive monitoring and verification technique uses run-time information to 
+identify the current execution state, and checks whether the projection of a design-time
+
+model k steps ahead of the current state satisfies a set of wanted/unwanted properties. The 
+execution state is captured by run-time traces obtained by monitoring the component-base 
+system execution. Each component equips with a design-time model in the form of interface 
+automata. The properties we considered are interaction temporal properties among different 
+components.
+
+RESEARCH APPROACH
+The CASSANDRA approach stands on the following assumptions:
+
+Each component to be integrated is augmented with a model of the interface suitable to be 
+used for run-time checking;
+
+It is possible to map observed run-time events with the ones included in the formal model 
+used for the run-time checking;
+
+The execution of one exploration step by the run-time checking algorithm is faster than the
+execution of the corresponding step by the real system. This assumption is necessary to 
+keep the exploration synchronized with the real execution.
+
+CASSANDRA is then based on a run-time checking algorithm that takes in input the interface automata for the various components, the look-ahead value k, the temporal property that should not be violated by the system:
+
+The interface automata of the various components are composed on the fly to construct the 
+tree of possible paths of length smaller than k,
+
+When a system interaction event is detected the exploration is moved ahead of one step. In 
+particular:
+
+All the subtrees rooted in a next state linked by an event different from the one detected
+are discarded;
+
+
+For each leaf in the subtree rooted in the next state linked by the detected event, the 
+exploration is pushed ahead of one step;
+
+In case a property is violated an alert event is generated specifying the trace leading to
+the property violation.
+
+We customize CASSANDRA into the OSGi component model and framework(See Fig. 1). In OSGi, components (coming in the form of bundles for deployment) can be remotely installed, started, stopped, updated and uninstalled without requiring a reboot. The “Hot-Deployment feature” enables to add new bundles to the platform without affecting the running services:
+
+The OSGi bundle developers provide the architecture with a set of wrappers of bundles (each
+wrapper is equipped with source code, the corresponding interface automata model and the 
+Aspect codes).
+
+
+The developers also provide a set of wanted/unwanted properties represented through the 
+Property Sequence Chart (PSC) formalism.
+

+During runtime we take k steps looking ahead at the interface automata models to construct 
+the temporary Global State Machine (GSM) according to the current run-time information. We 
+on-the-fly construct the GSM with k steps looking ahead.
+
+The approach can proactively check at step k whether possible failures could happen in the 
+future k+x steps. Consequently, the application users can take measures to avoid these 
+failures.
+
+FUTURE PLAN
+Apply CASSANDRA to real OSGi-based run-time evolving applications,
+
+Measure the performance and overhead in large case study and further compare to our 
+previous non-proactive monitoring tool,
+
+
+Study how much to look ahead, in order to derive a completely useful theory that could be
+used to guide how to monitor real systems,
+
+
+Manage time and probability in the interface automata, so to be able to predict more precise
+failures limited by timing and probabilistic properties.
+
+
+				
+
+				
+
+			
+
+			
+
+			
+
+
+
+
+
+

WikiPage Home modified by pchzhang

pchzhang — Mon, 07 Nov 2011 06:49:39 -0000

--- v16 
+++ v17 
@@ -1,84 +1,101 @@
-          
-#CASSANDRAOSGi#
-
-       
+       
+#CASSANDRAOSGI: a Failure Prediction Framework for Dynamically Evolving OSGi Systems#
+CASSANDRA is a novel proactive monitoring and verification technique aimed at predicting near future failures in dynamically evolving systems. CASSANDRA, by combining design-time and run-time information,looks k steps ahead of the current execution state, in order to predict future failures.
+ 
+       
 ##ISSUES AND MOTIVATION##
 
 
-* For current software systems that can dynamically change during run-time, such as 
+  For current software systems that can dynamically change during run-time, such as 
   service-based and component-based, existing verification techniques are inadequate to 
   prevent failures to happen.
-* Traditional design-time verification techniques (like model checking) have been revised in
+
+  Traditional design-time verification techniques (like model checking) have been revised in
   order to cope with evolution but they alone cannot fully support the analysis of run-time 
   evolving systems.
-* Run-time verification techniques, based on system monitoring approaches, have become 
+
+  Run-time verification techniques, based on system monitoring approaches, have become 
   fundamental to ensure the correctness of run-time evolving systems. However, they have the 
   ability to detect errors only too late, that is, when a failure happens.
-* What is desirable is instead a technique that, while applied to run-time evolving systems, 
+
+  What is desirable is instead a technique that, while applied to run-time evolving systems, 
   can predict potential errors that may happen in the near future.
 
 ##SOLUTION FRAMEWORK##
 
-* Towards this research goal, this paper proposes CASSANDRA, a novel proactive monitoring 
+  Towards this research goal, this paper proposes CASSANDRA, a novel proactive monitoring 
   approach to predict potential failures by looking ahead the current execution state. 
-* To this end, CASSANDRA combines design-time and run-time information for proactive run-time
+
+  To this end, CASSANDRA combines design-time and run-time information for proactive run-time
   verification of dynamic component-based systems.
-* The proposed proactive monitoring and verification technique uses run-time information to 
+
+  The proposed proactive monitoring and verification technique uses run-time information to 
   identify the current execution state, and checks whether the projection of a design-time  
   model k steps ahead of the current state satisfies a set of wanted/unwanted properties. The 
   execution state is captured by run-time traces obtained by monitoring the component-base 
   system execution. Each component equips with a design-time model in the form of interface 
   automata. The properties we considered are interaction temporal properties among different 
   components.
 
 ##RESEARCH APPROACH##
 
 The CASSANDRA approach stands on the following assumptions:
 
-* Each component to be integrated is augmented with a model of the interface suitable to be 
+  Each component to be integrated is augmented with a model of the interface suitable to be 
   used for run-time checking;
-* It is possible to map observed run-time events with the ones included in the formal model 
+
+  It is possible to map observed run-time events with the ones included in the formal model 
   used for the run-time checking;
-* The execution of one exploration step by the run-time checking algorithm is faster than the
+
+  The execution of one exploration step by the run-time checking algorithm is faster than the
   execution of the corresponding step by the real system. This assumption is necessary to 
   keep the exploration synchronized with the real execution. 
 
 CASSANDRA is then based on a run-time checking algorithm that takes in input the interface automata for the various components, the look-ahead value k, the temporal property that should not be violated by the system: 
 
-* The interface automata of the various components are composed on the fly to construct the 
+  The interface automata of the various components are composed on the fly to construct the 
   tree of possible paths of length smaller than k,
-* When a system interaction event is detected the exploration is moved ahead of one step. In 
+
+  When a system interaction event is detected the exploration is moved ahead of one step. In 
   particular:
-* All the subtrees rooted in a next state linked by an event different from the one detected
+
+  All the subtrees rooted in a next state linked by an event different from the one detected
   are discarded;
-* For each leaf in the subtree rooted in the next state linked by the detected event, the 
+
+  For each leaf in the subtree rooted in the next state linked by the detected event, the 
   exploration is pushed ahead of one step;
-* In case a property is violated an alert event is generated specifying the trace leading to
+
+  In case a property is violated an alert event is generated specifying the trace leading to
   the property violation.
  
 We customize CASSANDRA into the OSGi component model and framework(See Fig. 1). In OSGi, components (coming in the form of bundles for deployment) can be remotely installed, started, stopped, updated and uninstalled without requiring a reboot. The “Hot-Deployment feature” enables to add new bundles to the platform without affecting the running services:
 
-* The OSGi bundle developers provide the architecture with a set of wrappers of bundles (each
+  The OSGi bundle developers provide the architecture with a set of wrappers of bundles (each
   wrapper is equipped with source code, the corresponding interface automata model and the 
   Aspect codes).
-* The developers also provide a set of wanted/unwanted properties represented through the 
+
+  The developers also provide a set of wanted/unwanted properties represented through the 
   Property Sequence Chart (PSC) formalism. 
-* During runtime we take k steps looking ahead at the interface automata models to construct 
+
+  During runtime we take k steps looking ahead at the interface automata models to construct 
   the temporary Global State Machine (GSM) according to the current run-time information. We 
   on-the-fly construct the GSM with k steps looking ahead.
-* The approach can proactively check at step k whether possible failures could happen in the 
+
+  The approach can proactively check at step k whether possible failures could happen in the 
   future k+x steps. Consequently, the application users can take measures to avoid these 
   failures.
 
 ##FUTURE PLAN##
 
-* Apply CASSANDRA to real OSGi-based run-time evolving applications,
-* Measure the performance and overhead in large case study and further compare to our 
+  Apply CASSANDRA to real OSGi-based run-time evolving applications,
+
+  Measure the performance and overhead in large case study and further compare to our 
   previous non-proactive monitoring tool, 
-* Study how much to look ahead, in order to derive a completely useful theory that could be
+
+  Study how much to look ahead, in order to derive a completely useful theory that could be
   used to guide how to monitor real systems, 
 
-* Manage time and probability in the interface automata, so to be able to predict more precise
+  Manage time and probability in the interface automata, so to be able to predict more precise
   failures limited by timing and probabilistic properties.