FDR Explorer

Nowadays, service oriented architecture has been given strong attention as an important approach to integrate heterogeneous systems, in which complex services are created by composing simpler services offered by various systems. The correctness of composition requires techniques to verify if the composite service behaves properly. To this end, in this paper we propose a new method for runtime monitoring of composite services which uses Communicating Sequential Processes (CSP) to specify properties formally. Then, the CSP specification of properties is translated to a Labeled Transition System (LTS). In order to verify the safety of a composite service, we traverse the generated LTS at runtime. Existing methods almost use temporal logic to specify safety properties. There are two advantages in using CSP: 1) similarity of CSP operators and service composition patterns makes CSP straightforward to be used by users. 2) there are some properties which can not be specified by temporal logic, while they can be expressed using CSP.

Communicating Sequential Processes (CSP) has been widely applied to modeling and analyzing concurrent systems. There have been considerable efforts on enhancing CSP by taking data and other system aspects into account. For instance, CSPM combines CSP with a functional programming language whereas CSP# integrates high-level CSP-like process operators with low-level procedure code. Little work has been done to systematically compare these CSP extensions, which may have subtle and substantial differences. In this paper, we compare CSPM and CSP# not only on their syntax, but also operational semantics as well as their supporting tools such as FDR, ProB, and PAT. We conduct extensive experiments to compare the performance of these tools in different settings. Our comparison can be used to guide users to choose the appropriate CSP extension and verification tool based on the system characteristics.

The CSP (communicating sequential processes) method is useful for the development of sequence control mechanisms. From the specifications in CSP, one can investigate the nature and workings of a sequence control mechanism by the process composition calculation or algebra, prove deadlock absence by the algebra, and find the most suitable module structures of the control programs. In this paper, specifications of a silo system with concurrently working components are described in CSP, the movements are investigated by process composition calculations, and the deadlock absence of the system is proved by the calculations. Based on the discussions, specifications of a silo system with two source silos, two measuring hoppers, a mixer, two conveyors and two destination silos are described in CSP, and the system is implemented in the programming language Ada. The author's studies include the relation of CSP specifications to Ada programs. >

Communicating Sequential Processes (CSP) is a process algebra, designed for modeling and analyzing the behavior of concurrent systems. Several security protocols are modeled with CSP and verified using model-checking or theorem proving techniques successfully. Unlike other authentication protocols modeled using CSP, each of the Efficient Multi-chained Stream Signature (EMSS) protocol messages are linked to the previous messages, forming hash chains, which introduces difficulties for modeling and verification. In this paper, we model the EMSS stream authentication protocol using CSP and verify its authentication properties with model checking, by building an infinite state model of the protocol which is reduced into a finite state model.

Communicating Sequential Processes (CSP) is a language used to describe and reason about concurrent systems. It consists of a process algebra combined with a functional language. This combination poses unique problems when attempting to design a type checker. In this paper the differences between a conventional functional language type checker and a type checker for the CSP language are discussed. This type checker was developed to identify polymorphic types, an important first step towards the goal of automating data independence [4]. The result of this work has been incorporated into the Adelaide Refinement Checker [8] (ARC) - a CSP based tool suite for model checking concurrent systems.

This paper compares two models of concurrency, Milner's Calculus of Communicating Systems (CCS) and the failures model of Communicating Sequential Processes (CSP) developed by Hoare, Brookes and Roscoe. By adapting Milner's synchronisation trees to serve as notation for both CCS and CSP, we are able to define a representation mapping for CSP processes. We define an equivalence relation on synchronisation trees which corresponds precisely to the notion of failure equivalence. Milner's calculus is founded on a different notion, observation equivalence. We show how these two equivalences are related. Just as Milner's equivalence can be characterised as the smallest relation satisfying a set of axioms, we find a suitable set of axioms for the failures equivalence relation. This again makes explicit the differences between the two systems, as well as revealing that the semantic models underlying CCS and CSP are comparable.

With the commercial development of multicore processors, the challenges of writing multithreaded programs to take advantage of these new hardware architectures are becoming more and more pertinent. Concurrent programming is necessary to achieve the performance that the hardware offers. Traditional approaches present concurrency as an advanced topic: they have proven difficult to use, reason about with confidence, and scale up to high levels of concurrency. This article reviews process-oriented design , based on Hoare's algebra of Communicating Sequential Processes (CSP), and proposes that this approach to concurrency leads to solutions that are manageable by novice programmers; that is, they are easy to design and maintain, that they are scalable for complexity, obviously correct , and relatively easy to verify using formal reasoning and/or model checkers. These solutions can be developed in conventional programming languages (through CSP libraries) or specialized ones (such as occam-π) in a manner that directly reflects their formal expression. Systems can be developed without needing specialist knowledge of the CSP formalism, since the supporting mathematics is burnt into the tools and languages supporting it. We illustrate these concepts with the Santa Claus problem , which has been used as a challenge for concurrency mechanisms since 1994. We consider this problem as an example control system, producing external signals reporting changes of internal state (that model the external world). We claim our occam-π solution is correct-by-design , but follow this up with formal verification (using the FDR model checker for CSP) that the system is free from deadlock and livelock, that the produced control signals obey crucial ordering constraints, and that the system has key liveness properties.

The Pilot library is a new method for programming MPI-enabled clusters in C, targeted at novice parallel programmers. Formal elements from Communicating Sequential Processes (CSP) are used to realize a process/channel model of parallel computation that reduces opportunities for deadlock and other communication errors. This simple model, plus an application programming inter-face (API) styled after C's formatted I/O, are designed to make the library easy to learn. The Pilot library exists as a thin layer on top of any standard Message Passing Interface (MPI) implementation, preserving MPI's portability and efficiency, with little per-formance overhead arising as result of Pilot's additional features.

In order to achieve a ubiquitous ad-hoc environment suitable for any kind and number of compute devices, information concerning device usability must be stored and manipulated. Take, for example the home where a large number of devices - heating, cooking, lighting, entertainment, security all cooperate to provide a suitable environment for a home resident. This paper proposes a representation of home devices as OWL-S (Web service ontology) services, capable of being implemented by means of the formal algebra CSP (communication sequential process). Because of the ontological nature of OWL-S and the possibility of translating CSP equations to lightweight implementations, this proposal allows a rich semantic description of services capable of being hosted by a wide range of devices, including such ones with low computational resources. The paper describes the procedure of developing a service in OWL-S, its translation to CSP and its implementation in occam, an efficient CSP-based language

Information systems are now widely used to automate the manage and execution of judicial business processes. However, the design of a judicial information system is in nature complex, and it is difficult to ensure its correctness and trustworthiness, including the security and integrity of the data about the evidence and the conformance to laws, regulation and rules of practice, in the design and the execution of judicial workflows. In this paper, we focus on how to improve the correctness and trustworthiness of the information system through the development of models of workflows at different levels of abstraction and in different degrees of formality. The final model before the implementation is a formal model which can be formally validated and its implementation is provable correctly. Our proposed method starts with informal use case modeling and gradually transforms to formal Communicating Sequential Process (CSP) modeling. To transform use case models into a model in CSP, the specified use cases are refined into use case sequence diagrams and the relationships between use cases are represented as the case model. Our method combine the advantages of informal models and formal models. It support the modeler to communicate with domain users and experts. With the formal model in CSP, designers are capable of identifying errors during designing of the workflow, and thus able to correct them before the implementation phase. We illustrate the method with the workflow of the civil litigation in China as a case study.

Communicating Sequential Processes (CSP) is a paradigm for communication and synchronization among distributed processes. The alternative construct is a key feature of CSP that allows nondeterministic selection of one among several possible communicants. A generalized version of Hoare's original alternative construct that allows output commands to be included in guards has been proposed. Previous algorithms for this construct assume a message passing architecture and are not appropriate for multiprocessor systems that feature shared memory. This paper describes a distributed algorithm for the generalized alternative construct that exploits the capabilities of a parallel computer with shared memory. A correctness proof of the proposed algorithm is presented to show that the algorithm conforms to somesatefy andliveness criteria. Extensions to allow termination of processes and to ensure fairness in guard selection are also given.

Test is important part of every industrial flow. Therefore preparation of it is in the early phase of development. An effective method is to use User Requirements Notation (URN) for it. It contains two parts: Goal‐oriented Requirement Language (GRL) and Use Case Maps (UCM). It can give the test goals with the help of and GRL and it can provide exact formal description for test generation with the help of UCM. Finally it can link to other mathematical formal models like Communicating Sequential Processes (CSP) or Control Signal CSP (CSCSP). A test system that is described by CSP, a modified CSP that is called CSCSP and a test aspect of URN is combined in this paper. The whole method becomes more useful with the combination of these three solutions, because it can be used in the area of test from the beginning to the end.

In cryptography it is common to evaluate the security of cryptographic primitives and protocols in a computational model, with an attacker trying to break the primitive or protocol in question. To do so formalisation languages like CASPER or CSP (Communication Sequential Processes) and model checkers like FDR (Failures-Divergences Refinement) are used for automatic or semi-automatic machine-based security verification.Here we transfer the idea of machine-based verification of the security of communication protocols from cryptography to the domain of digital watermarking based media security protocols. To allow for such a mainly automatic verification approach, we introduce and illustrate in this paper a six step procedure for the modelling and verification of watermark communication protocols based on application scenario descriptions.The six steps are: First, a modelling of the used communication network and application scenario (as a task) in XML-structures, second, a path search comparing the network and the task and identifying possible watermarking channels, third, a path selection selecting one watermarking channel from the identified alternatives for the protocol realisation, fourth, an automatic CASPER protocol generation from the selected alternative followed by manual adjustments (if necessary), fifth, the CASPER compilation into CSP and sixth, the protocol security(confidentiality, integrity and authenticity) verification via the FDR model checker.

The Requirements to Design to Code (R2D2C) project of NASA's Software Engineering Laboratory is based on inferring a formal specification, currently using Communicating Sequential Processes (CSP), from system requirements supplied in the form of scenarios, a user-friendly medium often used to describe the behavior of computer systems under development. The scenarios are first converted into an intermediate form, CSP traces, from which are derived CSP specifications. This work, called Mise en Scene, defines a new medium (Scenario Notation Language, SNL) suitable for control-dominated systems, coupled with a two-stage process for automatic translation of scenarios to a new trace medium (Trace Notation Language, TNL) which encompasses CSP traces. A survey of the scenario concept and a small case study are also presented.

With the rapid expansion of Internet of Things (IoT), Constrained Application Protocol (CoAP) is developed to enable those devices with small memory, constrained computing power and limited ability to communicate with other nodes in the network. Meanwhile, group communication is very useful for managing and controlling a set of homogeneous devices in many IoT scenarios. Thus, many scholars are devoted to expanding CoAP to enable group communication. Furthermore, because CoAP is widely applicated in transportation, health care, industrial and many other areas, the security and consistency of data is of great importance. In this paper, we adopt Communicating Sequential Processes (CSP) to model group communication CoAP, and we use model checker Process Analysis Toolkit (PAT) to verify six properties of our model, including deadlock freedom, divergence freedom, data reachability, data leakage, client faking and entity manager faking. The verification results show that the original architecture has the security risk of data leakage. So we enhance it by adding message authentication code in the process. In the light of the new verification results, it can be found that we succeed in eliminating the possibility of data leakage.KeywordsGroup communicationCoAPCSPModelingVerification