A formal architectural model for exception handling coordination

Practical exception handling and resolution in concurrent programs

A comparative study of exception handling mechanisms for building dependable object-oriented software

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.

Exception handling in a complex concurrent and distributed system (e.g. one involving cooperating rather than just competing activities) is often a necessary, but a very difficult, task. No widely accepted models or approaches exist in this area. The object-oriented paradigm, for all its structuring benefits, and real-time requirements each add further difficulties to the design and implementation of exception handling in such systems. In this paper, we develop a general structuring framework based on the coordinated atomic (CA) action concept for handling exceptions in an object-oriented distributed system, in which exceptions in both the value and the time domain are taken into account. In particular, we attempt to attack several difficult problems related to real-time system design and error recovery, including action-level timing constraints, time-triggered CA actions, and time-dependent exception handling. The proposed framework is then demonstrated and assessed using an industrial real-time application-the Production Cell III case study.

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.

Two complementary techniques have evolved for providing fault-tolerance in software: forward error recovery and backward error recovery. Few implementations permit both approaches to be combined within a particular application. Fewer techniques are available for the construction of fault-tolerant software for systems involving concurrent processes and multiple processors. Many schemes for supporting forward or backward recovery are based on some concept of an atomic action. The authors propose a mechanism for supporting an atomic action in a system of communicating sequential processes (CSP). The atomic action is used as the basic unit for providing fault-tolerance. The atomic action is called an FT-action, and both forward and backward error recovery are performed in the context of an FT-action.

Multi-core processors are present in everyone's daily life. Consequently, concurrent programming has reemerged as a pressing concern for everyone interested in exploring all the potential computational power in these machines. But, the emergence of new concurrency models and programming languages also brings new challenges in terms of how one can deal with abnormal occurrences, much due to the heterogenous parallel control flow. Unexpectedly, sequential Exception Handling models remain as the most used tool for robustness, even in the most recent concurrent programming languages. Though, the appearance of more complex models, such as programming languages with implicit concurrency, might pose a challenge too big for these sequential mechanisms. In this article we will provide evidences why such models are not generally suited to deal with faults in programs with implicit concurrency and, in the light of more recent advances in concurrent Exception Handling, we will discuss the attributes of a model for addressing this problem.

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 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.

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.

Component-based software systems built out of reusable software components are being used in a wide range of applications which have high dependability requirements. In order to accomplish the required levels of dependability, it is necessary to incorporate into these complex systems means for to cope with software faults. Exception handling is a well-known technique for adding forward error recovery to software systems supported by various mainstream programming languages. However, exception handling for component-based applications at the architectural level introduces new challenges which are not addressed by traditional exception handling systems, such as unavailability of source code, specially when off-the-shelf components are employed. In this paper, we present an exception handling system which adds fault tolerance to component-based systems at the architectural level. Our solution considers issues which are specific to component-based applications, such as unavailability of source code. We also present a framework which implements the proposed exception handling system for applications built using the C2 architectural style.KeywordsService RequestException HandlingArchitectural LevelDependable SoftwareClient ComponentThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Service-oriented software systems are inherently complex and have to cope with an increasing number of exceptional conditions in order to meet the system’s dynamic requirements. This work proposes an architecture framework which has exception handling capability. This framework ensures the credibility of service-oriented software, during the architectural stage, by adding exception handling-related architecture elements and modeling exception handling process. It allows a clear separation of concerns between the business function and the exception handling unit, using reflection mechanism. It plays an important guiding role for achieving reliable service-oriented system.

Usually complex systems are controlled by an operator co-operating with a computer-based controller. The controlling software runs in continuous interaction with the operator and constantly reacts on operator’s interruptions by dynamically adapting system behaviour. Simultaneously it catches the exceptions signalling about errors in the system components and performs error recovery. Since interruptions are asynchronous signals they might concurrently co-exist and conflict with exceptions. To ensure dependability of a dynamically adaptable system, we propose a formal approach for resolving conflicts and designing robust interruption and exception handlers. We present a formal specification pattern for designing components of layered control systems that contain interruption and exception handlers as an intrinsic part of the specification. We demonstrate how to develop a layered control system by recursive application of this pattern.

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 this paper, we first discuss the various algebraic approaches to exception handling specification. We show that none of them is completely satisfactory, and we explain why the algebraic specification of exception handling (error introduction, error propagation and error recovery) must not be made using only equations, but also "declarations". We present an approach allowing all forms of error handling, and at the same time keeping specifications well-structured and easily understandable.KeywordsOperational SemanticError MessageError RecoveryException HandlingGround TermThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.