Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based
“Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based Systems” Nazareno Aguirre, Tom Maibaum Electronic Notes in Theoretical Computer Science 108 (2004) 69? 1 1월 13일 Software Engineering Lab. 석사 1기 허 석 1
Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based Systems – 석사 1기 허 석 Content 1. Introduction 2. A Temporal Specification Language 1. Describing Components 2. Describing Interactions 3. A Notation for Subsystems 4. Complex Subsystems 5. Conclusion 2 Sung. Kyun. Kwan University Software Engineering Lab.
Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based Systems – 석사 1기 허 석 1. Introduction < Software architectures can be regarded as a branch of software engineering that puts emphasis on the high level structure of systems. < An architecture of a system is described in terms of components, which can interact via defined connectors. < A topic that gained attention in the past few years is the possibility of changing the architecture of a system at run time, a feature often called dynamic reconfiguration. 4 the wide acceptance of object oriented modelling and programming 4 Several architecture description languages (ADLs) support reconfiguration, through the definition of reconfiguration operations. 3 Sung. Kyun. Kwan University Software Engineering Lab.
Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based Systems – 석사 1기 허 석 1. Introduction < Problem 4 < Proposal 4 < However, those ADLs with support for reconfiguration and formal semantics generally allow only for operational (as opposed to declarative) descriptions. We proposed a declarative formalism based on temporal logic, for the description of reconfigurable software architectures. Merit 4 The abstraction gained by using a declarative framework allows us to study possible more sophisticated abstract ways of describing software architectures. 4 Sung. Kyun. Kwan University Software Engineering Lab.
Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based Systems – 석사 1기 허 석 1. Introduction < < The main characteristics of this formalism are: 4 it has direct support for reasoning, due to its logical nature, 4 it is expressive enough to allow for the description of components in a property oriented way, 4 components and configurations are uniformly represented by logical theories, which allows us to build hierarchical organisations of systems. This paper argues about some important advantages of hierarchical organisations of component based systems, by using the notion of subsystem, and proposes an extension to a previously introduced prototypical specification language to cope with hierarchical subsystems. 5 Sung. Kyun. Kwan University Software Engineering Lab.
Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based Systems – 석사 1기 허 석 2. A Temporal Specification Language < It is intended to be just a means to study more abstract and declarative ways of describing software architectures, and to probe the capabilities of our proposed formalism. < The main characteristics of this logic are: 4 first-order 4 time is linear, discrete 4 connectives and quantifiers 4 temporal operators § ○ (“next”), □ (“always in the future”), ◇ (“eventually in the future”) and U (“strong until ”) 4 some function and predicate symbols (called flexible) are interpreted in a state dependent way, although there also exist functions and predicates with state independent interpretations (called rigid). 6 Sung. Kyun. Kwan University Software Engineering Lab.
Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based Systems – 석사 1기 허 석 2. A Temporal Specification Language < This logic is a variant of the Manna-Pnueli logic, in which the flexible symbols, i. e. , those whose interpretation is state dependent, have been generalised. < The logic, with a certain kind of language translation, constitutes a πinstitution. 4 This implies a useful structural property, that enables us to promote properties from the lower layers of a system to their including subsystems. 7 Sung. Kyun. Kwan University Software Engineering Lab.
Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based Systems – 석사 1기 허 석 2. 1 Describing Components < The lowest layer of the language is composed of a specification ADT of datatypes. < Signature < 4 The state of a component is determined by its attributes, which are like variables of imperative programming languages. 4 Read variables are simply special attributes, out of the control of the component and used as “entry points”, for implementing communication. 4 Actions represent parameterised instantaneous operations of the component. Temporal axioms 4 datatypes specified in ADT , 4 read variables and attributes as flexible 0 -ary function symbols, 4 actions as flexible predicate symbols, 4 a special 0 -ary flexible predicate, which denotes the activeness of the component. 8 Sung. Kyun. Kwan University Software Engineering Lab.
Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based Systems – 석사 1기 허 석 2. 1 Describing Components < Suppose we want to specify a network of “units” that can interchange messages. 4 < Let us call these units cells. The activeness of the component is represented, as we previously indicated, by the flexible predicate named after the class name, i. e. , predicate Cell. Intuitively, the truth of predicate Cell at an instant of time should be interpreted as the component being active, or “live” during that instant. < By contrast, if predicate Cell is not true at an instant of time, then the component is not active, or “dead”, at that instant. < 9 Sung. Kyun. Kwan University Software Engineering Lab.
Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based Systems – 석사 1기 허 석 2. 1 Describing Components 10 Sung. Kyun. Kwan University Software Engineering Lab.
Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based Systems – 석사 1기 허 석 2. 1 Describing Components < A class specification C is interpreted as a temporal theory presentation. < The axioms of the presentation are obtained by putting together: 4 The axioms explicitly provided as part of the class definition C 4 The axioms given for the datatype specification ADT 4 A special implicit “frame axiom”, called locality axiom, and expressing that a component must change its state only by means of its defined actions. 11 Sung. Kyun. Kwan University Software Engineering Lab.
Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based Systems – 석사 1기 허 석 2. 2 Describing Interactions < We choose to define class definitions as closed independent units. < This is an important point, since from a logical point of view it allows us to reason about component properties independently of the rest of the system. 4 But, of course, we need ways of making components interact. < We achieve communication between components by using the useful concept of coordination. < To make components interact we define associations. 12 Sung. Kyun. Kwan University Software Engineering Lab.
Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based Systems – 석사 1기 허 석 3. A Notation for Subsystems < In the previous section, we showed how component and connector types can be declaratively defined, by means of classes and associations, respectively. < We need now to compose these specifications in order to build architectures of interacting components. < We proposed to do so by defining what we called subsystems. 4 A subsystem is a new unit of modularisation, which encapsulates a dynamically reconfigurable set of interacting components. 13 Sung. Kyun. Kwan University Software Engineering Lab.
Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based Systems – 석사 1기 허 석 3. A Notation for Subsystems < Classes are templates of components whose internal structure is basic, composed simply of their attributes; subsystems on the other hand, or more precisely, subsystem instances, can have a complex internal structure, composed of their internal live components and their interconnections. < We defined subsystems as complex components whose internal state is dynamic, and is built out of instances of classes (i. e. , components) related by means of instances of associations (i. e. , connectors). < We want now to extend that, to allow subsystems not only to be composed of instances of classes, but also to subsume instances of simpler subsystems, thus allowing for hierarchical organisations of systems. < This is feasible thanks to the fact that the semantics of basic components and aggregations are defined in a similar way, by means of temporal theories 4 there are no technical restrictions for iterating the process of defining aggregations 14 Sung. Kyun. Kwan University Software Engineering Lab.
Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based Systems – 석사 1기 허 석 3. A Notation for Subsystems < Let ADTNAME be a conservative extension of ADT with an extra sort NAME and a sufficiently large set of constants of this sort. 4 < Constants of sort NAME are used to represent identifiers of components of the lower layers. Signature 4 a name 4 finite sets of basic attributes and basic read variables, typed by a sort of ADTNAME 4 a finite set of operations, whose arguments are typed by sorts of ADTNAME. < Attributes are part of the internal state of a subsystem. < Read variables will serve the purpose of allowing a subsystem to communicate with others. < Operations in subsystems can modify the architectural structure of the subsystem, by creating or deleting instances of components, and creating or deleting connections between them. 4 Reconfiguration operations 15 Sung. Kyun. Kwan University Software Engineering Lab.
Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based Systems – 석사 1기 허 석 3. A Notation for Subsystems < Axioms 4 the extended datatype specification ADTNAME 4 the flexible function and predicate symbols resulting from class definitions and other more basic subsystems, adding to all of them an extra parameter of sort NAME 4 a flexible predicate symbol R : NAME, . . . , NAME for each association definition R with k participants 4 a flexible predicate symbol a : S 1, . . . , Sk for each subsystem action of type a(x 1 : S 1, . . . , xk : Sk). 16 Sung. Kyun. Kwan University Software Engineering Lab.
Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based Systems – 석사 1기 허 석 3. A Notation for Subsystems < Axioms 6 and 10 use the “dot notation” (borrowed from object orientation) to denote the “instances” to which attributes or actions correspond to (see, for instance, the expression n. address in Axiom 6). 17 Sung. Kyun. Kwan University Software Engineering Lab.
Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based Systems – 석사 1기 허 석 3. A Notation for Subsystems < < The temporal theory for a subsystem Sub is constructed from: 4 The axioms explicitly provided as part of the Sub specification 4 The axioms in ADTNAME 4 The axioms of the classes or subsystems of the lower layer, relativised by universally quantifying the extra argument of sort NAME added to read variables, attributes and actions. The process of relativisation has a nice property: 4 We incorporate the relativisation of the axioms of the lower layers definitions into the including subsystem, all theorems (i. e. , properties) of the lower layer components are promoted into the including subsystem. 18 Sung. Kyun. Kwan University Software Engineering Lab.
Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based Systems – 석사 1기 허 석 4. Complex Subsystems < In the previous section, we allowed subsystems to be defined in terms of simpler subsystems. < An important restriction is that the definition of subsystems cannot be cyclic. 4 The semantics of a subsystem is based on the relativisation and inclusion of the presentations of the classes and subsystems of the lower layers, which of course is not possible if the subsystem dependency is cyclic. 19 Sung. Kyun. Kwan University Software Engineering Lab.
Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based Systems – 석사 1기 허 석 4. Complex Subsystems < It is clear from this example how the languages of the more basic subsystems and components are incorporated and used in a higher level subsystem. < The structurality property of the logic allows us to promote theorems from the lower layers of a specification to the upper layers. < We can then combine reasoning at different levels of a hierarchical specification to prove properties of the whole system. 20 Sung. Kyun. Kwan University Software Engineering Lab.
Hierarchical Temporal Specifications of Dynamically Reconfigurable Component Based Systems – 석사 1기 허 석 5. Conclusion < We have presented an extension to a prototypical temporal specification language for specifying dynamic software architectures. 4 The objective of the extension is to allow for hierarchical organisations of systems specifications, in terms of reconfigurable subsystems. < One of the main characteristics of the formalism, which partially motivated our work, is the possibility of describing reconfigurable systems declaratively. < Since components are hierarchically described, using classes and subsystems, as closed independent units, proofs can be localised to the relevant subparts of a specification. < At the moment, we are experimenting with the use of the Stanford Temporal Prover(STe. P) in order to assist in the proofs in our logic. 21 Sung. Kyun. Kwan University Software Engineering Lab.
- Slides: 21