39 research outputs found
Recommended from our members
Applications of lattice theory to model checking
textSociety is increasingly dependent on the correct operation of concurrent and distributed software systems. Examples of such systems include computer networks, operating systems, telephone switches and flight control systems. Model checking is a useful tool for ensuring the correctness of such systems, because it is a fully automatic technique whose use does not require expert knowledge. Additionally, model checking allows for the production of error trails when a violation of a desired property is detected. Error trails are an invaluable debugging aid, because they provide the programmer with the sequence of events that lead to an error. Model checking typically operates by performing an exhaustive exploration of the state space of the program. Exhaustive state space exploration is not practical for industrial use in the verification of concurrent systems because of the well-known phenomenon of state space explosion caused by the exploration of all possible interleavings of concurrent events. However, the exploration of all possible interleavings is not always necessary for verification. In this dissertation, we show that results from lattice theory can be applied to ameliorate state space explosion due to concurrency, and to produce short error trails when an error is detected. We show that many CTL formulae exhibit lattice-theoretic structure that can be exploited to avoid exploring multiple interleavings of a set of concurrent events. We use this structural information to develop efficient model checking techniques for both implicit (partial order) and explicit (interleaving) models of the state space. For formulae that do not exhibit the required structure, we present a technique called predicate filtering, which uses a weaker property with the desired structural characteristics to obtain a reduced state space which can then be exhaustively explored. We also show that lattice theory can be used to obtain a path of shortest length to an error state, thereby producing short error trails that greatly ease the task of debugging. We provide experimental results from a wide range of examples, showing the effectiveness of our techniques at improving the efficiency of verifying and debugging concurrent and distributed systems. Our implementation is based on the popular model checker SPIN, and we compare our performance against the state-of-the-art state space reduction strategies implemented in SPIN.Electrical and Computer Engineerin
Dynamic slicing of concurrent specification languages
This is the author’s version of a work that was accepted for publication in Parallel Computing. Changes resulting from the publishing process, such as peer review, editing, corrections, structural formatting, and other quality control mechanisms may not be reflected in this document. Changes may have been made to this work since it was submitted for publication. A definitive version was subsequently published in Parallel Computing, 53, 1-22., (2016). DOI 10.1016/j.parco.2016.01.006.[EN] Dynamic slicing is a technique to extract the part of the program (called slice) that influences or is influenced, in a particular execution, by a given point of interest in the source code (called slicing criterion). Since a single execution is considered, the technique often uses a trace of this execution to analyze data and control dependencies. In this work we present the first formulation and implementation of dynamic slicing in the context of CSP. Most of the ideas presented can be directly applied to other concurrent specification languages such as Promela or CCS, but we center the discussion and the implementation
on CSP. We base our technique on a new data structure to represent CSP computations called track. A track is a data structure which represents the sequence of expressions that have been evaluated during the computation, and moreover, it is labeled with the location of these expressions in the specification. The implementation of a dynamic slicer for CSP is useful for debugging, program comprehension, and program specialization, and it is also interesting from a theoretical perspective because CSP introduces difficulties such as heavy concurrency and non-determinism, synchronizations, frequent absence of data dependence, etc.
© 2016 Elsevier B.V. All rights reservedThis work has been partially supported by the EU (FEDER) and the Spanish Ministerio de Economia y Competitividad under Grant TIN2013-44742-C4-1-R and by the Generalitat Valenciana under Grant PROMETEOII/2015/013 (SmartLogic). Salvador Tamarit was partially supported by Madrid regional projects N-GREENS Software-CM (S2013/ICE-2731), and by European Union project POLCA (STREP FP7-ICT-20133.4 610686).Llorens Agost, ML.; Oliver Villarroya, J.; Silva, J.; Tamarit Muñoz, S. (2016). Dynamic slicing of concurrent specification languages. Parallel Computing. 53:1-22. https://doi.org/10.1016/j.parco.2016.01.006S1225
Static slicing of explicitly synchronized languages
Static analysis of concurrent languages is a complex task due to the non-deterministic execution of processes. If the concurrent language being studied allows process synchronization, then the analyses are even more complex (and thus expensive), e.g., due to the phenomenon of deadlock. In this work we introduce a static analysis technique based on program slicing for concurrent and explicitly synchronized languages in general, and CSP in particular. Concretely, given a particular point in a specification, our technique allows us to know what parts of the specification must necessarily be executed before this point, and what parts of the specification could be executed before it. Our technique is based on a new data structure that extends the Synchronized Control Flow Graph (SCFG). We show that this new data structure improves the SCFG by taking into account the context in which processes are called and, thus, it makes the slicing process more precise. The technique has been implemented and tested with real specifications, producing good results. After formally defining our technique, we describe our tool, its architecture, its main applications and the results obtained from several experiments conducted in order to measure the performance of the tool. © 2012 Elsevier Inc. All rights reserved.This work has been partially supported by the Spanish Ministerio de Economia y Competitividad (Secretaria de Estado de Investigacion, Desarrollo e Innovacion) under grant TIN2008-06622-C03-02 and by the Generalitat Valenciana under grant PROMETEO/2011/052. Salvador Tamarit was partially supported by the Spanish MICINN under FPI grant BES-2009-015019.Leuschel ., M.; Llorens Agost, ML.; Oliver Villarroya, J.; Silva Galiana, JF.; Tamarit Muñoz, S. (2012). Static slicing of explicitly synchronized languages. Information and Computation. 214:10-46. https://doi.org/10.1016/j.ic.2012.02.005S104621
LF : a language for reliable embedded systems
Thesis (MSc)--University of Stellenbosch, 2001.ENGLISH ABSTRACT: Computer-aided verification techniques, such as model checking, are often considered essential
to produce highly reliable software systems. Modern model checkers generally require models to
be written in eSP-like notations. Unfortunately, such systems are usually implemented using
conventional imperative programming languages. Translating the one paradigm into the other is
a difficult and error prone process.
If one were to program in a process-oriented language from the outset, the chasm between implementation
and model could be bridged more readily. This would lead to more accurate models
and ultimately more reliable software.
This thesis covers the definition of a process-oriented language targeted specifically towards embedded
systems and the implementation of a suitable compiler and run-time system.
The language, LF, is for the most part an extension of the language Joyce, which was defined by
Brinch Hansen. Both LF and Joyce have features which I believe make them easier to use than
other esp based languages such as occam. An example of this is a selective communication
primitive which allows for both input and output guards which is not supported in occam.
The efficiency of the implementation is important. The language was therefore designed to be
expressive, but constructs which are expensive to implement were avoided. Security, however, was
the overriding consideration in the design of the language and runtime system.
The compiler produces native code. Most other esp derived languages are either interpreted or
execute as tasks on host operating systems. Arguably this is because most implementations of
esp and derivations thereof are for academic purposes only. LF is intended to be an implementation
language.
The performance of the implementation is evaluated in terms of practical metries such as the
time needed to complete communication operations and the average time needed to service an
interrupt.AFRIKAANSE OPSOMMING: Rekenaar ondersteunde verifikasietegnieke soos programmodellering, is onontbeerlik in die ontwikkeling
van hoogs betroubare programmatuur. In die algemeen, aanvaar programme wat modelle
toets eSP-agtige notasie as toevoer. Die meeste programme word egter in meer konvensionele
imperatiewe programmeertale ontwikkel. Die vertaling vanuit die een paradigma na die ander is
'n moelike proses, wat baie ruimte laat vir foute.
Indien daar uit die staanspoor in 'n proses gebaseerde taal geprogrammeer word, sou die verwydering
tussen model en program makliker oorbrug kon word. Dit lei tot akkurater modelle en
uiteindelik tot betroubaarder programmatuur.
Die tesis ondersoek die definisie van 'n proses gebaseerde taal, wat gemik is op ingebedde programmatuur.
Verder word die implementasie van 'n toepaslike vertaler en looptyd omgewing ook
bespreek.
Die taal, LF, is grotendeels gebaseer op Joyce, wat deur Brinch Hansen ontwikkel is. Joyce en op
sy beurt LF, is verbeterings op ander esp verwante tale soos occam. 'n Voorbeeld hiervan is 'n
selektiewe kommunikasieprimitief wat die gebruik van beide toevoer- en afvoerwagte ondersteun.
Omdat 'n effektiewe implementasie nagestreef word, is die taalontwerp om so nadruklik moontlik
te wees, sonder om strukture in te sluit wat oneffektief is om te implementeer. Sekuriteit was egter
die oorheersende oorweging in die ontwerp van die taal en looptyd omgewing.
Die vertaler lewer masjienkode, terwyl die meeste ander implementasies van eSP-agtige tale
geinterpreteer word of ondersteun word as prosesse op 'n geskikte bedryfstelsel- die meeste
eSP-agtige tale word slegs vir akademiese doeleindes aangewend. LF is by uitstek ontwerp
as implementasie taal.
Die evaluasie van die stelsel se werkverrigting is gedoen aan die hand van praktiese maatstawwe
soos die tyd wat benodig word vir kommunikasie, sowel as die gemiddelde tyd benodig vir die
hantering van onderbrekings
Formal analysis of security protocols based on web services
This thesis examines the use of multi-stack pushdown automata to model the behaviour and properties of Web services based cryptographic protocols. The protocols are modelled in Promela and verified using the Spin model checker. The Simple Message Exchange Protocol and the Security Token Protocol are protocols that underlie the WS-Security and WS-Trust specifications, respectively. These two protocols are tested for correctness in the presence of an intruder that conforms to the Dolev-Yao model, i.e., it is tested whether the required properties the protocols hold in the presence of a Dolev-Yao intruder. The thesis also extends the Dolev-Yao intruder model to encompass attacks targeted specifically at Web services. An intruder model in Promela is created based on the Dolev-Yao abstraction which is extended to incorporate an XML injection attack model. The behaviour and properties of the Simple Message Exchange Protocol and the Security Token Protocol are then examined when subjected to an XML injection attack using this extended Dolev-Yao model