3,454 research outputs found
A model-based approach to automated test generation and error localization for Simulink/Stateflow
Simulink/Stateflow is a popular commercial model-based development tool for many industrial domains. For safety and security concerns, verification and testing must be performed on the Simulink/Stateflow designs and the generated code. We present an automatic test generation approach for Simulink/Stateflow based on its translation to a formal model, called Input/Output Extended Finite Automata (I/O-EFA), that is amenable to formal analysis such as test generation. The approach automatically identifies a set of input-output sequences to activate all executable computations in the Simulink/Stateflow diagram by applying three different techniques, model checking, constraint solving and reachability reduction & resolution. These tests (input-output sequences) are then used for validation purposes, and the failed versus passed tests are used to localize the fault to plausible Simulink/Stateflow blocks. The translation and test generation approaches are automated and implemented in a toolbox that can be executed in Matlab that interfaces with NuSMV
Utilizing the blackboard paradigm to implement a workflow engine
Workflow management has evolved into a mature field with numerous workflow management systems with scores of
features. These systems are designed to automate business processes of organisations. However, many of these workflow
engines struggle to support complex workflows. There has been relatively little research into building a workflow engine
utilizing the blackboard paradigm. The blackboard paradigm can be characterized as specialists interacting with and
updating a centralized data structure, namely the blackboard, with partial and complete solutions. The opportunistic
control innate to the blackboard paradigm can be leveraged to support the execution of complex workflows. Furthermore,
the blackboard architecture can be seen to accommodate comprehensive workflow functionality. This research aims to
verify whether or not the blackboard paradigm can be used to build a workflow engine. To validate this research, a
prototype was designed and developed following stringent guidelines in order to remain true to the blackboard paradigm.
Four main perspectives of workflow management namely the functional, behavioural, informational and operational
aspects with their quality indicators and requirements were used to evaluate the prototype. This evaluation approach was
chosen since it is universally applicable to any workflow engine and thereby provides a common platform on which the
prototype can be judged and compared against other workflow engines. The two most important quality indicators are the
level of support a workflow engine can provide for 20 main workflow patterns and 40 main data patterns. Test cases based
on these patterns were developed and executed within the prototype to determine the level of support. It was found that
the prototype supports 85% of all the workflow patterns and 72.5% of all the data patterns. This reveals some functional
limitations in the prototype and improvement suggestions are given that can boost these scores to 95% and 90% for
workflow and data patterns respectively. The nature of the blackboard paradigm only prevents support of only 5% and
10% of the workflow and data patterns respectively. The prototype is shown to substantially outperform most other
workflow engines in the level of patterns support. Besides support for these patterns, other less important quality
indicators provided by the main aspects of workflow management are also found to be present in the prototype. Given the
above evidence, it is possible to conclude that a workflow engine can be successfully built utilizing the blackboard
paradigm
The Evolution of complexity in self-maintaining cellular information processing networks
We examine the role of self-maintenance (collective autocatalysis) in the evolution of computational biochemical networks. In primitive proto-cells (lacking separate genetic machinery) self-maintenance is a necessary condition for the direct reproduction and inheritance of what we here term Cellular Information Processing Networks (CIPNs). Indeed, partially reproduced or defective CIPNs may generally lead to malfunctioning or premature death of affected cells. We explore the interaction of this self-maintenance property with the evolution and adaptation of CIPNs capable of distinct information processing abilities. We present an evolutionary simulation platform capable of evolving artificial CIPNs from a bottom-up perspective. This system is an agent-based multi-level selectional Artificial Chemistry (AC) which employs a term rewriting system called the Molecular Classifier System (MCS). The latter is derived from the Holland broadcast language formalism. Using this system, we successfully evolve an artificial CIPN to improve performance on a simple pre-specified information processing task whilst subject to the constraint of continuous self-maintenance. We also describe the evolution of self-maintaining, crosstalking and multitasking, CIPNs exhibiting a higher level of topological and functional complexity. This proof of concept aims at contributing to the understanding of the open-ended evolutionary growth of complexity in artificial systems
Challenges and Directions in Formalizing the Semantics of Modeling Languages
Developing software from models is a growing practice and there exist many model-based tools (e.g., editors, interpreters, debuggers, and simulators) for supporting model-driven engineering. Even though these tools facilitate the automation of software engineering tasks and activities, such tools are typically engineered manually. However, many of these tools have a common semantic foundation centered around an underlying modeling language, which would make it possible to automate their development if the modeling language specification were formalized. Even though there has been much work in formalizing programming languages, with many successful tools constructed using such formalisms, there has been little work in formalizing modeling languages for the purpose of automation. This paper discusses possible semantics-based approaches for the formalization of modeling languages and describes how this formalism may be used to automate the construction of modeling tools
Diagrammatic Languages and Formal Verification : A Tool-Based Approach
The importance of software correctness has been accentuated as a growing number of safety-critical systems have been developed relying on software operating these systems. One of the more prominent methods targeting the construction of a correct program is formal verification. Formal verification identifies a correct program as a program that satisfies its specification and is free of defects. While in theory formal verification guarantees a correct implementation with respect to the specification, applying formal verification techniques in practice has shown to be difficult and expensive. In response to these challenges, various support methods and tools have been suggested for all phases from program specification to proving the derived verification conditions. This thesis concerns practical verification methods applied to diagrammatic modeling languages.
While diagrammatic languages are widely used in communicating system design (e.g., UML) and behavior (e.g., state charts), most formal verification platforms require the specification to be written in a textual specification language or in the mathematical language of an underlying logical framework. One exception is invariant-based programming, in which programs together with their specifications are drawn as invariant diagrams, a type of state transition diagram annotated with intermediate assertions (preconditions, postconditions, invariants). Even though the allowed program statesâcalled situationsâare described diagrammatically, the intermediate assertions defining a situationâs meaning in the domain of the program are still written in conventional textual form. To explore the use of diagrams in expressing the intermediate assertions of invariant diagrams, we designed a pictorial language for expressing array properties. We further developed this notation into a diagrammatic domain-specific language (DSL) and implemented it as an extension to the Why3 platform. The DSL supports expression of array properties. The language is based on Reynoldsâs interval and partition diagrams and includes a construct for mapping array intervals to logic predicates.
Automated verification of a program is attained by generating the verification conditions and proving that they are true. In practice, full proof automation is not possible except for trivial programs and verifying even simple properties can require significant effort both in specification and proof stages. An animation tool which supports run-time evaluation of the program statements and intermediate assertions given any user-defined input can support this process. In particular, an execution trace leading up to a failed assertion constitutes a refutation of a verification condition that requires immediate attention. As an extension to Socos, a verificion tool for invariant diagrams built on top of the PVS proof system, we have developed an execution model where program statements and assertions can be evaluated in a given program state. A program is represented by an abstract datatype encoding the program state, together with a small-step state transition function encoding the evaluation of a single statement. This allows the programâs runtime behavior to be formally inspected during verification. We also implement animation and interactive debugging support for Socos.
The thesis also explores visualization of system development in the context of model decomposition in Event-B. Decomposing a software system becomes increasingly critical as the system grows larger, since the workload on the theorem provers must be distributed effectively. Decomposition techniques have been suggested in several verification platforms to split the models into smaller units, each having fewer verification conditions and therefore imposing a lighter load on automatic theorem provers. In this work, we have investigated a refinement-based decomposition technique that makes the development process more resilient to change in specification and allows parallel development of sub-models by a team. As part of the research, we evaluated the technique on a small case study, a simplified version of a landing gear system verification presented by Boniol and Wiels, within the Event-B specification language.Vikten av programvaras korrekthet har accentuerats dÄ ett vÀxande antal sÀkerhetskritiska system, vilka Àr beroende av programvaran som styr dessa, har utvecklas. En av de mer framtrÀdande metoderna som riktar in sig pÄ utveckling av korrekt programvara Àr formell verifiering. Inom formell verifiering avses med ett korrekt program ett program som uppfyller sina specifikationer och som Àr fritt frÄn defekter. Medan formell verifiering teoretiskt sett kan garantera ett korrekt program med avseende pÄ specifikationerna, har tillÀmpligheten av formella verifieringsmetod visat sig i praktiken vara svÄr och dyr. Till svar pÄ dessa utmaningar har ett stort antal olika stödmetoder och automatiseringsverktyg föreslagits för samtliga faser frÄn specifikationen till bevisningen av de hÀrledda korrekthetsvillkoren. Denna avhandling behandlar praktiska verifieringsmetoder applicerade pÄ diagrambaserade modelleringssprÄk.
Medan diagrambaserade sprĂ„k ofta anvĂ€nds för kommunikation av programvarudesign (t.ex. UML) samt beteende (t.ex. tillstĂ„ndsdiagram), krĂ€ver de flesta verifieringsplattformar att specifikationen kodas medelst ett textuellt specifikationsspĂ„k eller i sprĂ„ket hos det underliggande logiska ramverket. Ett undantag Ă€r invariantbaserad programmering, inom vilken ett program tillsammans med dess specifikation ritas upp som sk. invariantdiagram, en typ av tillstĂ„ndstransitionsdiagram annoterade med mellanliggande logiska villkor (förvillkor, eftervillkor, invarianter). Ăven om de tillĂ„tna programtillstĂ„ndenâsk. situationerâbeskrivs diagrammatiskt Ă€r de logiska predikaten som beskriver en situations betydelse i programmets domĂ€n fortfarande skriven pĂ„ konventionell textuell form. För att vidare undersöka anvĂ€ndningen av diagram vid beskrivningen av mellanliggande villkor inom invariantbaserad programming, har vi konstruerat ett bildbaserat sprĂ„k för villkor över arrayer. Vi har dĂ€refter vidareutvecklat detta sprĂ„k till ett diagrambaserat domĂ€n-specifikt sprĂ„k (domain-specific language, DSL) och implementerat stöd för det i verifieringsplattformen Why3. SprĂ„ket lĂ„ter anvĂ€ndaren uttrycka egenskaper hos arrayer, och Ă€r baserat pĂ„ Reynolds intevall- och partitionsdiagram samt inbegriper en konstruktion för mappning av array-intervall till logiska predikat.
Automatisk verifiering av ett program uppnÄs genom generering av korrekthetsvillkor och Ätföljande bevisning av dessa. I praktiken kan full automatisering av bevis inte uppnÄs utom för trivial program, och Àven bevisning av enkla egenskaper kan krÀva betydande anstrÀngningar bÄde vid specifikations- och bevisfaserna. Ett animeringsverktyg som stöder exekvering av sÄvÀl programmets satser som mellanliggande villkor för godtycklig anvÀndarinput kan vara till hjÀlp i denna process. SÀrskilt ett exekveringspÄr som leder upp till ett falskt mellanliggande villkor utgör ett direkt vederlÀggande (refutation) av ett bevisvillkor, vilket krÀver omedelbar uppmÀrksamhet frÄn programmeraren. Som ett tillÀgg till Socos, ett verifieringsverktyg för invariantdiagram baserat pÄ bevissystemet PVS, har vi utvecklat en exekveringsmodell dÀr programmets satser och villkor kan evalueras i ett givet programtillstÄnd. Ett program representeras av en abstrakt datatyp för programmets tillstÄnd tillsammans med en small-step transitionsfunktion för evalueringen av en enskild programsats. Detta möjliggör att ett programs exekvering formellt kan analyseras under verifieringen. Vi har ocksÄ implementerat animation och interaktiv felsökning i Socos.
Avhandlingen undersöker ocksÄ visualisering av systemutveckling i samband med modelluppdelning inom Event-B. Uppdelning av en systemmodell blir allt mer kritisk dÄ ett systemet vÀxer sig större, emedan belastningen pÄ underliggande teorembe visare mÄste fördelas effektivt. Uppdelningstekniker har föreslagits inom mÄnga olika verifieringsplattformar för att dela in modellerna i mindre enheter, sÄ att varje enhet har fÀrre verifieringsvillkor och dÀrmed innebÀr en mindre belastning pÄ de automatiska teorembevisarna. I detta arbete har vi undersökt en refinement-baserad uppdelningsteknik som gör utvecklingsprocessen mer kapabel att hantera förÀndringar hos specifikationen och som tillÄter parallell utveckling av delmodellerna inom ett team. Som en del av forskningen har vi utvÀrderat tekniken pÄ en liten fallstudie: en förenklad modell av automationen hos ett landningsstÀll av Boniol and Wiels, uttryckt i Event-B-specifikationsprÄket
Adapting modeling environments to domain specific interactions
Software tools are being used by experts in a variety of domains. There are numerous
software modeling environments tailored to a specific domain expertise. However, there is no
consistent approach to generically synthesize a product line of such modeling environments
that also take into account the user interaction and experience adapted to the domain. The
focus of my thesis is the proposal of a solution to explicitly model user interfaces and interaction
of modeling environments so that they can be tailored to the habits and preferences
of domain experts. We extend current model-driven engineering techniques that synthesize
graphical modeling environments to also take interaction models into account. The formal
semantics of our language framework is based on statecharts. We define a development process
for generating such modeling environments to maximize reuse through a novel statechart
refinement technique.Les outils logiciels sont utilisĂ©s par des experts dans une variĂ©tĂ© de domaines. Il existe de nombreux environnements de modĂ©lisation logicielle adaptĂ©s ĂĄ une expertise spĂ©cifique. Cependant, il nâexiste pas dâapproche cohĂ©rente pour synthĂ©tiser gĂ©nĂ©riquement une ligne de produits de tels environnements de modĂ©lisation qui prennent Ă©galement en compte lâinteraction et lâexpĂ©rience utilisateur adaptĂ©es au domaine. Lâobjectif de ma thĂ©se est la proposition dâune solution pour modĂ©liser explicitement les interfaces utilisateur et lâinteraction des environnements de modĂ©lisation afin quâils puissent Ă©tre adaptĂ©s aux habitudes et aux prĂ©fĂ©rences des experts du domaine. Nous Ă©tendons les techniques dâingĂ©nierie actuelles pilotĂ©es par un modĂ©le qui synthĂ©tisent des environnements de modĂ©lisation graphique pour prendre Ă©galement en compte les modĂšles dâinteraction. La sĂ©mantique formelle de notre cadre linguistique est basĂ©e sur des statecharts. Nous dĂ©finissons un processus de dĂ©veloppement pour gĂ©nĂ©rer de tels environnements de modĂ©lisation afin de maximiser la rĂ©utilisation Ă travers une nouveau technique de raffinement de statecharts
Improving performance of blackboard systems
In this thesis, we deal with blackboard system performance issues. We show that
blackboard system performance can be improved using parallel processing strategies
and a novel blackboard architecture.We study traditional blackboard architectures using a novel performance frameÂŹ
work. This is a useful tool for directing system optimisation efforts. We present the
analysis of four blackboard systems present in the literature.nalysis of four blackboard systems present in the literature.
Besides localised optimisation efforts, one of the most promising approaches for
improving blackboard system performance is the use of parallel processing techniques.
However, traditional blackboard architectures present both data and control contention
when implemented in parallel.In this thesis we present a novel blackboard architecture, the Active Blackboard
Architecture (ABB). We based ABB on a novel variation of the traditional "Blackboard
and Experts" metaphor, called "Blackboard, Experts and Desks". This new metaphor
introduces a new element, the desks, used by the experts to perform their work.The ABB architecture is based on an active blackboard, capable of processing on its
own, and a decentralised control model. This avoids control contention and bottlenecks.
We describe this architecture using the Z specification language, and implemented
and evaluated in the EPCC Meiko Computing Surface, a multi-transputer distributed
memory parallel machine.The ABB Parallel prototype is an object oriented implementation of the ABB model
that overcomes both data and control bottlenecks by having a distributed blackboard
and using the ABB control model. Based on a series of experiments, we show that the
new architecture allows to achieve much greater effective parallelism in a blackboard
system. We also present some ways in which the system can be tailored to specific
application needs, improving in this way its overall performance
Event-Oriented Dynamic Adaptation of Workflows: Model, Architecture and Implementation
Workflow management is widely accepted as a core technology to support long-term business processes in heterogeneous and distributed environments. However, conventional workflow management systems do not provide sufficient flexibility support to cope with the broad range of failure situations that may occur during workflow execution. In particular, most systems do not allow to dynamically adapt a workflow due to a failure situation, e.g., to dynamically drop or insert execution steps. As a contribution to overcome these limitations, this dissertation introduces the agent-based workflow management system AgentWork. AgentWork supports the definition, the execution and, as its main contribution, the event-oriented and semi-automated dynamic adaptation of workflows. Two strategies for automatic workflow adaptation are provided. Predictive adaptation adapts workflow parts affected by a failure in advance (predictively), typically as soon as the failure is detected. This is advantageous in many situations and gives enough time to meet organizational constraints for adapted workflow parts. Reactive adaptation is typically performed when predictive adaptation is not possible. In this case, adaptation is performed when the affected workflow part is to be executed, e.g., before an activity is executed it is checked whether it is subject to a workflow adaptation such as dropping, postponement or replacement. In particular, the following contributions are provided by AgentWork: A Formal Model for Workflow Definition, Execution, and Estimation: In this context, AgentWork first provides an object-oriented workflow definition language. This language allows for the definition of a workflow\u92s control and data flow. Furthermore, a workflow\u92s cooperation with other workflows or workflow systems can be specified. Second, AgentWork provides a precise workflow execution model. This is necessary, as a running workflow usually is a complex collection of concurrent activities and data flow processes, and as failure situations and dynamic adaptations affect running workflows. Furthermore, mechanisms for the estimation of a workflow\u92s future execution behavior are provided. These mechanisms are of particular importance for predictive adaptation. Mechanisms for Determining and Processing Failure Events and Failure Actions: AgentWork provides mechanisms to decide whether an event constitutes a failure situation and what has to be done to cope with this failure. This is formally achieved by evaluating event-condition-action rules where the event-condition part describes under which condition an event has to be viewed as a failure event. The action part represents the necessary actions needed to cope with the failure. To support the temporal dimension of events and actions, this dissertation provides a novel event-condition-action model based on a temporal object-oriented logic. Mechanisms for the Adaptation of Affected Workflows: In case of failure situations it has to be decided how an affected workflow has to be dynamically adapted on the node and edge level. AgentWork provides a novel approach that combines the two principal strategies reactive adaptation and predictive adaptation. Depending on the context of the failure, the appropriate strategy is selected. Furthermore, control flow adaptation operators are provided which translate failure actions into structural control flow adaptations. Data flow operators adapt the data flow after a control flow adaptation, if necessary. Mechanisms for the Handling of Inter-Workflow Implications of Failure Situations: AgentWork provides novel mechanisms to decide whether a failure situation occurring to a workflow affects other workflows that communicate and cooperate with this workflow. In particular, AgentWork derives the temporal implications of a dynamic adaptation by estimating the duration that will be needed to process the changed workflow definition (in comparison with the original definition). Furthermore, qualitative implications of the dynamic change are determined. For this purpose, so-called quality measuring objects are introduced. All mechanisms provided by AgentWork include that users may interact during the failure handling process. In particular, the user has the possibility to reject or modify suggested workflow adaptations. A Prototypical Implementation: Finally, a prototypical Corba-based implementation of AgentWork is described. This implementation supports the integration of AgentWork into the distributed and heterogeneous environments of real-world organizations such as hospitals or insurance business enterprises
- âŠ