Figure 2 - uploaded by John Derrick
Content may be subject to copyright.
Source publication
![Figure 12: Structure splitting tree of [a,[[b, c, d], { c, a, d } , [a,...](profile/John-Derrick/publication/228980629/figure/fig5/AS:300842008760320@1448737732023/Structure-splitting-tree-of-a-b-c-d-c-a-d-a-a-c-a-b-c-b_Q320.jpg)
When verifying Erlang programs in the process algebra µCRL specification, if there exists over-lapping between patterns in the Erlang source codes, the problem of overlapping in pattern matching occurs when translating the Erlang codes into the µCRL specification. This paper investigates the problem and proposes an approach to overcome it. The prop...
Context in source publication
Citations
... This work transforms the pattern matching clauses into a binary format. To do so, the technique [4] proposed to eliminate overlapping between patterns are applied. Specifically, pattern match clauses in a function are replaced by a series of called functions, each of which is guarded by the pattern match function. ...
... A data type called the Structure Splitting Tree (SST) [4] is defined and applied for pattern evaluation, and its use guarantees the pattern match clauses being represented in binary formats. ...
This paper studies the structural testing of Erlang applications. A program transformation is proposed that represents the
program under test as a binary tree. The challenge of achieving structural coverage can thus be interpreted as a tree-search
procedure. We have developed a testing-technique that takes advantage of this tree-structure, which we demonstrate with respect
to a small case study of an Erlang telephony system.
... For example, Erlang makes extensive use of pattern matching in its function definitions, and overlapping between patterns could lead to the system being represented by a faulty model in µCRL. This work transforms Erlang programs using the techniques discussed in [15] where pattern matching clauses in a function are replaced with a series of calling functions, each of which being guarded by the function patterns match. ...
... For example, the function handle request is transformed as shown above. A data structure, called a Structure Splitting Tree (SST) [15], is applied for pattern evaluation, and the use of such an SST for pattern evaluation guarantees the elimination of overlapping between patterns in the transformed program. ...
Verification is an important process in the development of Erlang systems. A recent strand of work has studied the verification
of Erlang applications using the process algebra μCRL. The general idea is that Erlang programs are translated into a μCRL specification, upon which the standard model checkers can be applied for checking the system’s properties. In this paper,
we pull together some of the existing work and investigate the verification of an Erlang telecommunication system in μCRL. This case study uses a server-client structure and incorporates timing restrictions and is designed and implemented using
a number of Erlang/OTP components. We show how this system is translated into a μCRL specification by using the defined rules, after which system properties are checked via the toolset CADP. Through studying
the verification of such an application, we aim to validate the effectiveness of the translation rules in an integrated way.
... In [15], the verification of OTP FSM programs using μCRL has been studied, and a model is proposed to support the translation of an Erlang FSM program into μCRL. In order to define the correct translation, and techniques proposed in [16] are applied to deal with the presence of overlapping patterns in pattern matching. ...
... A solution to the problem of overlapping in pattern matching was discussed by Benac-Earle [5], however, the solution was not implemented in the toolset etomcrl. Subsequently, Guo et al. [16] proposed a different solution, whereby an Erlang program with overlapping patterns is transformed into a counterpart program without overlapping patterns. The rewriting operation rewrites all pattern matching clauses in the original code into some calling functions. ...
... To eliminate any potential overlapping between patterns, techniques proposed in [16] are applied. Specifically, pattern matching clauses in the program are replaced by a series of case functions. ...
Recent work has looked at how Erlang programs could be model- checked via translation into the process algebra µCRL. Rules for translating Erlang programs and OTP components intoµCRL have been defined and investigated. However, in the existing work, no rule is defined for the translation of timeout events into µCRL. This could degrade the usability of the existing work as in some real applications, timeout events play a significant role in the system development. In this paper, by extending the existing work, we investigate the verification of timed Erlang/OTP components in µCRL. By using an explicit tick action in the µCRL specification, a discrete-time timing model is defined to support the translation of timed Erlang functions into µCRL. Two small examples are presented, which demonstrates the applications of the proposed approach. Categories and Subject Descriptors D.2.4 (Software Engineer- ing): Software/Program Verification
... we use a simple stack to simulate the management of FSM states and data. In order to define the correct translation we use techniques proposed in [16] which are needed to deal with the presence of overlapping patterns in pattern matching. The rest of this paper is organized as follows: Section 2 introduces the Erlang programming language; Section 3 describes the process algebra µCRL; Section 4 reviews the related work for the translation of Erlang programs into µCRL; Section 5 investigates the translation of Erlang FSM programs into µCRL; Section 6 evaluates the proposed model with two case studies; conclusions are finally drawn in Section 7. ...
... If there exists overlapping between patterns, the problem of overlapping in pattern matching occurs, which could lead to the system being represented by a faulty model. The problem of overlapping in pattern matching was studied in [16]. An approach was proposed where an Erlang program with overlapping patterns is transformed into a counterpart program without overlapping patterns. ...
... By the end, the function returns a tuple with the form of tuple(next state, tuple(new data, tuplenil(index))) where next state returns the next state, new data the updated state data and index the index of the action sequence that needs to be performed. To eliminate any potential overlapping between patterns, techniques proposed in [16] are applied. Specifically, pattern matching clauses in the program are replaced by a series of case functions. ...
Erlang is a concurrent functional programming language with explicit support for real-time and fault-tolerant distributed systems. Generic components encapsulated as design patterns are provided by the Open Telecom Platform (OTP) library. Although Erlang has many high-level features, verification is still non-trivial. One (existing) approach is to perform an abstraction of an Erlang program into the process algebra μ CRL, upon which standard verification tools can be applied. In this paper we extend this work and propose a model that supports the translation of an OTP finite state machine design pattern into a μ CRL specification. Then a standard toolset such as CADP can be applied in order to check properties that should hold for the system under development. Two small examples are presented, which experimentally show how the proposed model assists in model checking Erlang OTP components in μ CRL.
Model checking as a verification technique has proved effective at the system design and hardware level, and is now beginning
to be applied to program code. In this paper, we study the application of model checking techniques in the development of
Erlang systems. Erlang is a concurrent functional language with specific support for the development of distributed, fault-tolerant
systems with soft real-time requirements. It was designed from the start to support a concurrency-oriented programming paradigm
and large distributed implementations that this supports. The methodology we describe in this paper consists of abstracting
the behaviour of Erlang and OTP components into a process algebraic specification, specifically an mCRL2 specification, upon
which the standard model checker CADP can be used to verify the system’s properties. In addition to rules that model the Erlang
syntax, a translation mechanism for the OTP modules gen_server, supervisor and gen_fsm, and the timeout event are defined. A tool-set etomcrl2 has been developed to automate the process of translation. A small illustrative example is used to evaluate the effectiveness
of the proposed techniques, and its results show that the proposed techniques are effective in both verifying properties as
well as distinguishing between correct and faulty implementations of the design.
The paper studies a distributed implementation method for the BIP (Behavior, Interaction, Priority) component framework for modeling heterogeneous systems. BIP offers two powerful mechanisms for describing composition of components by combining interactions and priorities. A system model is layered. The lowest layer contains atomic components; the second layer, describes possible interactions between atomic components; the third layer includes priorities between the interactions. The current implementation of BIP is based on global state operational semantics. An Engine directly interprets the operational semantics rules and computes the possible interactions between atomic components from global states. The implementation method is a translation from BIP models into distributed models involving two steps. The first translates BIP models into partial state models where are known only the states of the components which are ready to communicate. The second implements interactions in the partial state model by using message passing primitives.
