Extending conventional languages by distributed/concurrent exception resolution

The state of art in handling and resolving concurrent exceptions is discussed and a brief outline of all research in this area is given. Our intention is to demonstrate that exception resolution is a very useful concept which facilitates joint forward error recovery in concurrent and distributed systems. To do this, several new arguments are considered. We understand resolution as reaching an agreement among cooperating participants of an atomic action. It is provided by the underlying system to make it unified and less error prone, which is important for forward error recovery, complex by nature. We classify atomic action schemes into asynchronous and synchronous ones and discuss exception handling for schemes of both kinds. The paper also deals with introducing atomic action schemes based on exception resolution into existing concurrent and distributed languages, which usually have only local exceptions. We outline the basic approach and demonstrate its applicability by showing how exception resolution can be used in Ada 83, Ada 95 (for both concurrent and distributed systems) and Java. A discussion of ways to make this concept more object-oriented and, with the help of reflection, more flexible and useful, concludes the paper.     

一种新的并行Java程序的监护模型

提出了一种新的并行Java程序异常处理的监护模型。该模型针对并行Java程序异步信息传递方式进行异常处理。当并行Java程序的某个线程出现异常时,该线程的监护模块把检测到的异常情况的信息传递到其它线程的监护模块,每个线程根据当前事项与异常事项的向量时钟关系,对当前事项进行回滚或停止操作,以达到对并行Java程序的保护。过去一些并行程序的监护方案是在信息交换的基础上把并行程序结构化为许多原子行为,把多个并行异常当作单个异常进行处理,具有较大的局限性。提出的监护模型是从全局上对并行Java程序的异常情况进行处理,并指导每个线程根据自身情况作出相应反映。实验证明提出的新的并行Java程序监护模型具有较强的实际操作性,并能有效地保护并行Java程序。     

Robust data types

Summary Data types with total operations and exceptions are proposed as basic building blocks for the construction of modular robust software. A notation for specifying such data types is presented and the issues underlying their correct implementation in a programming language supporting data abstraction and exception handling are discussed and illustrated by examples. New light is shed on some important aspects of exception handling such as the identification and specification of exceptions, the precise detection of exception occurrences, recovery of consistent states after exception detections and verification of the correct implementation of specified exceptional effects for operations.     

Functional semantics of programs with exceptions

Linguistic mechanisms for exception handling facilitate the production of reliable software and play an important role in fault tolerant computing. This paper describes the functional semantics of a Pascal-like language which supports exception handling and data abstraction. A program with exceptions is considered as having a standard semantics, as well as an exceptional semantics for each exception that may be signaled during its execution. Standard functional semantics methods provide rules to obtain the function representing the standard semantics. In this paper, we provide rules to determine the functions representing the exceptional semantics. We also describe a method for specifying and verifying the correctness of implementation of data types with exceptions.     

Unveiling and taming liabilities of aspects in the presence of exceptions: A static analysis based approach

As aspects extend or replace existing functionality at specific join points in the code, their behavior may raise new exceptions, which can flow through the program execution in unexpected ways. Assuring the reliability of exception handling code in aspect-oriented (AO) systems is a challenging task. Testing the exception handling code is inherently difficult, since it is tricky to provoke all exceptions during tests, and the large number of different exceptions that can happen in a system may lead to the test-case explosion problem. Moreover, we have observed that some properties of AO programming (e.g., quantification, obliviousness) may conflict with characteristics of exception handling mechanisms, exacerbating existing problems (e.g., uncaught exceptions). The lack of verification approaches for exception handling code in AO systems stimulated the present work. This work presents a verification approach based on a static analysis tool, called SAFE, to check the reliability of exception handling code in AspectJ programs. We evaluated the effectiveness and feasibility of our approach in two complementary ways (i) by investigating if the SAFE tool is precise enough to uncover exception flow information and (ii) by applying the approach to three medium-sized ApectJ systems from different application domains.     

As-if-serial exception handling semantics for Java futures

Exception handling enables programmers to specify the behavior of a program when an exceptional event occurs at runtime. Exception handling, thus, facilitates software fault tolerance and the production of reliable and robust software systems. With the recent emergence of multi-processor systems and parallel programming constructs, techniques are needed that provide exception handling support in these environments that are intuitive and easy to use. Unfortunately, extant semantics of exception handling for concurrent settings is significantly more complex to reason about than their serial counterparts.In this paper, we investigate a similarly intuitive semantics for exception handling for the future parallel programming construct in Java. Futures are used by programmers to identify potentially asynchronous computations and to introduce parallelism into sequential programs. The intent of futures is to provide some performance benefits through the use of method-level concurrency while maintaining as-if-serial semantics that novice programmers can easily understand — the semantics of a program with futures is the same as that for an equivalent serial version of the program. We extend this model to provide as-if-serial exception handling semantics. Using this model our runtime delivers exceptions to the same point it would deliver them if the program was executed sequentially. We present the design and implementation of our approach and evaluate its efficiency using an open source Java virtual machine.     

C++程序中异常处理的分析与测试技术研究

异常处理机制是一种运行时错误通知机制，将程序的正常控制代码和错误处理代码分离．然而异常机制的引入使得程序控制信息变得更为复杂；且开发人员一般难以熟练使用它，导致程序中会潜伏许多异常错误．扩展已有的显式异常分析技术，对隐式异常也进行了全面的分析并提出了过程间（内）控制流图的构造方法，并以此为基础给出了一个C＋＋程序健壮性改进模型．同时还提出了针对异常的两种动态测试策略：基于约束求解的异常测试策略和统计结构性异常测试策略．最后实现了一个初步的异常分析与测试原型工具并进行了初步实验分析，其结果表明本文提出的分析与测试方法对程序质量有较大程度的提高．     

Automatic detection and masking of nonatomic exception handling

The development of robust software is a difficult undertaking and is becoming increasingly more important as applications grow larger and more complex. Although modern programming languages such as C++ and Java provide sophisticated exception handling mechanisms to detect and correct runtime error conditions, exception handling code must still be programmed with care to preserve application consistency. In particular, exception handling is only effective if the premature termination of a method due to an exception does not leave an object in an inconsistent state. We address this issue by introducing the notion of failure atomicity in the context of exceptions. We propose practical techniques to automatically detect and mask the nonatomic exception handling situations encountered during program execution. These techniques can be applied to applications written in various programming languages that support exceptions. We perform experimental evaluation on both C++ and Java applications to demonstrate the effectiveness of our techniques and measure the overhead that they introduce.     

A rule-based approach to proactive exception handling in business processes

Effectively handling exceptions in business process is an important capability of enterprises in the current global market environment, since their business processes are becoming more complex. Effective exception handling requires systematic support for the entire scope of exception handling: from exception prediction to exception prevention, and from exception detection to exception resolution. Most existing research approaches to exception handling in business process management and workflow areas have focused on reactive exception handling which resolves exceptions only after their occurrences. Therefore, a proactive exception handling approach is required to predict and prevent business process exceptions as early as possible before they occur, and detect and resolve exceptions as soon as possible after they occur. This paper presents comprehensive behavioral, functional, and informational requirements for proactive exception handling from the lifecycle perspective. Then, it proposes a rule language for proactive exception handling based on the requirements. The proposed rule language will enable effective and flexible exception handling by providing the information required for the entire scope of exception handling, especially, for exception prediction and prevention. Finally, the paper illustrates and validates the rule language with an example of exception prevention and a prototype system.     

Improving reliability of cooperative concurrent systems with exception flow analysis

Developers of fault-tolerant distributed systems need to guarantee that fault tolerance mechanisms they build are in themselves reliable. Otherwise, these mechanisms might in the end negatively affect overall system dependability, thus defeating the purpose of introducing fault tolerance into the system. To achieve the desired levels of reliability, mechanisms for detecting and handling errors should be developed rigorously or formally. We present an approach to modeling and verifying fault-tolerant distributed systems that use exception handling as the main fault tolerance mechanism. In the proposed approach, a formal model is employed to specify the structure of a system in terms of cooperating participants that handle exceptions in a coordinated manner, and coordinated atomic actions serve as representatives of mechanisms for exception handling in concurrent systems. We validate the approach through two case studies: (i) a system responsible for managing a production cell, and (ii) a medical control system. In both systems, the proposed approach has helped us to uncover design faults in the form of implicit assumptions and omissions in the original specifications.     

一种基于异常处理的并发程序容错机制

当前并发程序容错机制处理方式单一、效率较低。为此,提出一种适用于多种并发程序错误处理的容错机制。通过在编译及运行过程中对程序进行异常处理,并在异常发生时根据设置的检查点对程序进行回滚和防错误处理,以实现并发程序容错。实验结果表明,该容错机制可有效检测并发程序中的错误,在不增加程序总体运行时间的情况下达到比较理想的容错效果。     

一种静态分析C^＋＋异常处理的方法

异常处理是现代程序设计语言提供的用来提高软件健壮性的一种机制。由于在C^＋＋的函数界面中并不要求声明该函数所能传播出的异常的类型，所以要想提高系统的健壮性，必须清楚在程序的执行过程中可能引发的异常、异常的传播路径等。然而在大型系统中，要想确定这些信息是非常困难的。本文针对C^＋＋的异常处理机制，首先提出了一个描述C^＋＋异常结构信息的模型，并把该模型应用于递归函数中。然后，描述了一个基于该模型的分析C^＋＋程序异常结构信息的工具CETool。该工具能提供所有显式引发异常的有关信息，为系统中异常处理结构的改进和程序的结构测试提供有价值的信息。最后给出了该工具的实现方法和应用实例。     

工作流系统中的一种异常处理机制

文中通过对工作流系统可能出现的异常情况进行较详细的分析，提出了利用规则库进行异常处理的模型，并对异常处理规则的数据结构进行了较深入的探讨。     

面向服务软件中基于着色Petri网的异常处理模型

面向服务软件异常处理的开发工作量大且程序逻辑复杂。若只在设计阶段后期或是编码阶段考虑异常处理功能的开发,则可能由于没有充分、完整、系统地考虑待处理的异常而严重影响软件整体可靠性。针对面向服务软件中异常处理机制的特点,提出一种基于着色Petri网的异常处理模型。通过对异常处理组成元素和异常处理模式分别进行形式化描述,可提供可重用的异常处理模型元素。设计者根据面向服务软件中异常处理的实际需求,使用异常处理模式连接异常处理组成元素,形成一个完整的异常处理模型。利用该模型可以精确描述面向服务软件中异常处理总体方案,便于辅助设计人员检测异常处理设计方案中的缺陷。     

移动代理系统中的异常处理方法

在分析移动代理环境中的异常分类的基础上,提出了一种移动代理环境的异常处理模型,它的主要特点是在一个特殊的代理环境中,通过设置一个监测代理实现对代理群中所有的异常处理和监测其它代理的运行状态,并给出了应用在该模型的异常处理策略.最后以Aglet移动代理作为实验平台,用一个实例验证了该方法的有效性.     

Verification of Real Time Operating System Exception Management Based on SPARCv8

Exception management,as the lowest level function module of the operating system,is responsible for making abrupt changes in the control flow to react to exception events in the system.The correctness of the exception management is crucial to guaranteeing the safety of the whole system.However,existing formal verification projects have not fully considered the issues of exceptions at the assembly level.Especially for real-time operating systems,in addition to basic exception handling,there are nested exceptions and task switching by exceptions service routine.In our previous work,we used high-level abstraction to describe the basic elements of the exception management and verified correctness only at the requirement layer.Building on earlier work,this paper proposes EMS(Exception Management SPARCv8),a practical Hoare-style program framework to verify the exception management based on SPARCv8(Scalable Processor Architecture Version 8) at the design layer.The framework describes the low-level details of the machine,such as registers and memory stack.It divides the execution logic of the exception management into six phases for comprehensive formal modeling.Taking the executing scenario of the real-time operating system SpaceOS on the Beidou-3 satellite as an example,we use the EMS framework to verify the exception management.All the formalization and proofs are implemented in the interactive theorem prover Coq.     

Web interface-driven cooperative exception handling in ADOME workflow management system

Exception handling in workflow management systems (WFMSs) is a very important problem since it is not possible to specify all possible outcomes and alternatives. Effective reuse of existing exception handlers can greatly help in dealing with workflow exceptions. On the other hand, cooperative support for user-driven computer supported resolution of unexpected exceptions and workflow evolution at run-time is vital for an adaptive WFMS. We have been developing ADOME-WFMS as a comprehensive framework in which the problem of workflow exception handling can be adequately addressed. In this article, we present an adaptive exception manager and its web-based interface for ADOME-WFMS with procedures for supporting the following: reuse of exception handlers, thorough and automated resolution of expected exceptions, effective management of Problem Solving Agents, cooperative exception handling, user-driven computer supported resolution of unexpected exceptions, and workflow evolution.     

Exception handling in robotics

The construction of robust and reliable robot systems able to handle errors arising from abnormal operating conditions is addressed. It is assumed that the robot program is logically correct but fails due to hardware or external state errors. The error-handling technique called exception handling is treated. The type of errors that can occur in a robot system and their error-handling requirements are described, and approaches to error handling and recovery are reviewed. Exception-handling facilities in Ada and AML/X are mentioned, and Exceptional C, the language chosen for exposition, is described. The use of exception-handling facilities is illustrated with two examples