Algebraic specification of ABP protocol using different time constraints

Modern day computer architectures offer ever-increasing support for parallel processing, still it turns out to be quite difficult for programmers and therefore programs to tap into these parallel resources. To benefit from real general-purpose parallel computing we claim that it is likely that a paradigm shift is needed in the way we think about programming. This change of thought in turn will need to be reflected in future programming languages as well. We think that the field of process algebra provides thorough insight in how to reason about the construction of software for concurrent systems and will be one of the enabling technologies supporting this transition. The wish to connect process algebra, a mathematical theory, to the world of computer-readable and executable specifications led to the development of PSF (Process Specification Formalism). PSF is an implementation of the process algebra ACP (Algebra of Communicating Processes) integrating ASF (Algebraic Specification Formalism) to specify algebraic data types. One of the first publications on PSF appeared in Fundamenta Informaticae in 1990. Here we stated as the first sentence of the abstract: "Traditional methods for programming sequential machines are inadequate for specifying parallel systems". Unfortunately, though some advancements have been made since 1990, we can still uphold this statement 20 years later. This current report documents the developments that lead to the construction of PSF and the 1990 publication and moreover it also documents how PSF and its tools have evolved since 1990 taking the conclusion and the outlook for future work from the original article as a reference point. Using the knowledge gained both in constructing tools for PSF and in using PSF to specify concurrent systems, we will judge, discuss and criticise the design decisions taken and show paths for future developments.

Traditional methods for programming sequential machines are inadequate for specifying parallel systems. Because debugging of parallel programs is hard, due to e.g. non-deterministic execution, verification of program correctness becomes an even more important issue. The Algebra of Communicating Processes (ACP) is a formal theory which emphasizes verification and can be applied to a large domain of problems ranging from electronic circuits to CAM architectures. The manual verification of specifications of small size has already been achieved, but this cannot easily be extended to the verification of larger industrially relevant systems. To deal with this problem we need computer tools to help with the specification, simulation, verification and implementation. The first requirement for building such a set of tools is a specification language. In this paper we introduce PSFd (Process Specification Formalism – draft) which can be used to formally express processes in ACP. In order to meet the modern requirements of software engineering, like reusability of software, PSFd supports the modular construction of specifications and parameterization of modules. To be able to deal with the notion of data, ASF (Algebraic Specification Formalism) is embedded in our formalism. As semantics for PSFd a combination of initial algebra semantics and operational semantics for concurrent processes is used. A comparison with programming languages and other formal description techniques for the specification of concurrent systems is included.

In this chapter we outline a process algebra, whose name — Petri Box Calculus (PBC) — arises from its original Petri net semantics [6, 7]. PBC combines a number of features taken from other process algebras, such as COSY (Concurrent Systems notation, [62]), CCS (Calculus of Communicating Systems, [80, 81]), SCCS (Synchronous CCS, [81]), CSP (Communicating Sequential Processes, [58]), TCSP (Theoretical CSP, [59]) and ACP (Algebra of Communicating Processes, [2]). However, there are some fundamental differences with each of these process algebras since PBC has been designed with two specific objectives in mind: To support a compositional Petri net semantics, together with an equivalent — more syntax-oriented — structured operational semantics (SOS) [89]. To provide as flexible as possible a basis for developing a compositional semantics of high-level concurrent specification and programming languages with full data and control features.

Several new operators are introduced on top of the algebra of communicating processes (ACP) from [BK 84] in order to incorporate stable signals in process algebra. Semantically this involves assigning labels to nodes of process graphs in addition to the actions that serve as labels of edges. The labels of nodes are called signals. In combination with the operators of BPA, two signal insertion operators allow to describe each finite tree labeled with actions and signals. In the context of parallel processes there is a new feature connected with signals: the signal observation mechanism. This mechanism is organised on basis of a signal observation function in very much the same way as the communication mechanism of ACP is organised around a communication function. Also, we discuss conditionals on signals and processes, and make much use of them in our examples. 1980 Mathematics Subject Classification (1985 revision): 68Q10, 68Q55, 68Q45, 68Q40. 1987 CR Categories: F.1.2, F.3.2, D.1.3, D.3.1, D.4.1.

OSPF is a commonly used link state routing protocol in order to interconnect network devices inside an Autonomous System. This paper focuses on achieving a detailed modelling for OSPF by performing manual algebraic derivations according to Algebra of Communicating Processes (ACP) axioms. The aim of this detailed model is to get a realistic approach of OSPF dynamics by applying the timers involved and by describing the full Link State Advertisement (LSA) exchange process.DOI: http://dx.doi.org/10.5755/j01.eie.24.4.21484

A communication protocol is first presented as a set of rules that determine the behaviour of a communication system in terms of the exchange of messages between communication entities. Then a protocol is also described as an artificial language which specifies this behaviour. The concepts of the abstract and the transfer syntax of protocol messages are explained and the importance of the rules for the behaviour of protocol entities is emphasised. The difference between informal and formal specification is explained, and the importance of the formal description techniques to assure nonambiguous specifications is emphasised. The basic techniques for informal and formal specification are presented. The difference between the functionality specifications that are based on the finite state machine model, and those which are based on process algebras, is pointed out. Then some of the most important formal languages are overviewed: ACT ONE and ASN.1 for message specification, SDL, Estelle and LOTOS for protocol specification, and also UML, MSC and TTCN for communication protocols design. The chapter contains five figures.

Regarding increasing popularity of Ad hoc networks, the routing protocols employed in these networks should be validated before deployment. Formal methods are used nowadays to find defects in protocols specification. In this paper, we explain different methods of formal modeling and verification of routing protocols of ad hoc networks. We derive the key concepts that are vital in modeling ad hoc network protocols and then modify process algebra, appropriate for verifying protocols at network layer. This process algebra implements mobility behaviors of underlying infrastructure implicitly in the semantics of broadcasting. The semantics of broadcast communication also abstracts away the services provided by MAC layer.

The correct implementation of security protocols is a challenging task. To achieve a high degree of confidence in an implementation, as with any software, ideally one requires both: (i) a formal specification that has been subjected to verification, and (it) tool support to generate an implementation from the verified specification. The formal specification and verification of security protocols has attracted considerable attention, with corresponding advances. However, the state of the art in the generation of implementations has not progressed beyond relatively simple protocols. This paper presents a case study on the implementation of a deterministically fair non-repudiation protocol. Such protocols are among the most complex of security protocols. Sub-protocols are typically required to guarantee timely termination. A trusted third party must be involved to guarantee fairness. Finally, to satisfy requirements such as non-repudiable audit, significant infrastructure support is needed. The case study demonstrates an improved approach to protocol implementation. Starting with a formal specification, a rigorous process with considerable tool support leads to the deployment of a protocol implementation in a flexible Web services-based execution framework. The paper concludes with an evaluation of the approach.

Existing approaches to formal protocol specification and verification suffer from great difficulty in constructing correct specifications for practical problems. The objective of this paper is to advocate a top-down step-wise refinement approach in the construction of correct protocol specification, from the given requirement (a service specification). It is aimed at making formal specification a practical means to protocol design. The paper demonstrates the feasibility of the methodology by working on a non-trivial problem using a powerful specification formalism.

During the recent development of a next-generation Intel processor, the project's formal verification team verified a new coherence protocol and portions of its RTL implementation against the protocol's specification within project deadlines. Typically, FV teams apply formal property verification (FPV) after RTL is coded and, though it continues to be an effective complement to pre-silicon validation, this late application prevents it from keeping pace with the continual complexity increases in hardware designs. Our discussion centers around how applying FV early in the development cycle of this processor enabled continual verification as the design progressed, culminating with the targeted RTL verification. We also present the languages and methodologies used, the reasons behind the choices, and where improvements can be made.

Using binary decision diagrams for representation and analysis of communication protocols

The authors report on an experiment whose main purpose was to identify the difficulties of integrating formal verification with conventional VLSI CAD (computer-aided design) methodology. The investigation was conducted using the Tamarack microprocessor designed for concrete experimentation. The authors decided to construct an implementation of Tamarack using GENESIL, a silicon compiler, in order to investigate the issues involved in the transition between a formal specification and the notation required as input to this VLSI CAD tool. The main conclusion is that the most effective use of formal hardware verification will be at the higher levels of VLSI system design, with lower levels best handled by conventional VLSI CAD tools. >

Quality of service considerations have to be included in the whole protocol engineering cycle. The authors present an integrated approach for the design of communication protocols, including: performance enhanced formal specification of communication protocols, formal requirement specification, statistical performance analysis out of the enhanced formal specification, and verification of bounded performance properties out of the formal specification. >

Protocol design, development and standardisation still follow the lines of rough consensus and running code. This approach yields fast and impressive results in a sense that protocols are actually implemented and shipped, but comes at a price: protocol specifications, which are mainly written in natural languages without presenting a formal specification , are (excessively) long, ambiguous, underspecified and erroneous. These shortcomings are neither new nor surprising, and well documented. It is the purpose of this paper to provide further evidence that formal methods in general and process algebras in particular can overcome these problems. They provide powerful tools that help to analyse and evaluate protocols, already during the design phase. To illustrate this claim, I report how a combination of pen-and-paper analysis, model checking and interactive theorem proving has helped to perform a formal analysis of the Ad hoc On-Demand Vector (AODV) routing protocol.

SummaryToday, service composition is emerging paradigm on the communication networks such as cloud environments, internet of things, wireless sensor network, and software‐defined network. The goal of service composition method is to provide the interactions between user requirements and smart objects of intelligent communication systems. There have been many efforts to use formal verification and behavioral modeling methods to evaluate the service composition mechanisms. Up to now, there is not a comprehensive analysis research on this topic. Therefore, this paper focuses on several formal verification approaches that are performed to confirm the service composition correctness in communication networks. The objective of this paper is to comprehensively categorize and examine current research techniques on formal verification of the service composition. This research analysis provides an overview of recent service composition approaches according to structural and functional properties. Comparison results show that most of the verification approaches in explanation of the service composition correctness are semantic‐aware approach with 43%. The most used verification method for the service composition is model checking with 69%. The process algebra is used 29%, and some theorem proving methods are applied in 9% of the investigated mechanism. Moreover, most widely used modeling tools are NuSMV (22%), SPIN (17%), CPN (12%), UPPAAL (12%), Event‐B (10%), and PAT (5%).