Data-oriented exception handling

Exception handling mechanisms were added to programming languages to segregate normal algorithmic processing from error processing. However, handlers which are typically associated with exceptions through a program's control features, clutter source text when features are nested or when different objects require different responses to exceptions. The authors describe a method for associating handlers with data objects in declarations that better segregates algorithmic and error processing. They call their notion data-oriented exception handling to distinguish it from more conventional, control-oriented mechanisms. Empirical studies of Ada programs indicate that conventional exception handling mechanisms are more complex than necessary and that data-oriented exception handling can be used to produce programs that are smaller, better structured, and easier to understand and modify     

Toward modular verifiable exception handling

Recognizing that an error condition is an intrinsic part of the abstract type to which the operation that detects the condition belongs, an attempt is made to specify and implement error condition detection and handling within the framework of the Alphard form, a construct for encapsulation of data type specification and implementation. The essence of the problem is this: while error condition detection is done by the operation in the form, only the user of the type can determine the meaning of the condition with respect to the way the type is used. Thus, the user must be able to specify the handler. Unfortunately, programming the handler often requires access to encapsulated implementation details which are hidden from the user.After discussing the general issues of exception handling, modularity, and abstract data types, this paper proposes a solution for one category of exceptions, namely errors. Specifically an externally visible condition name is the link between an error's occurrence and some externally visible but internally programmed handler for it. Issues raised by this partial solution, including those of proof rules, are discussed.     

一种异常处理机制的设计与实现

异常处理是一种用来检测异常并时其进行处理的技术。异常处理机制已作为现代程序设计语言的一个重要的特性被广泛地采纳,以增强系统运行的可靠性,提高软件的健壮性。对异常处理在程序语言的实现进行了一般性研究,分析比较几种异常处理机制及其实现方法,提出了一种新的异常处理机制的实现方法。     

Schedulability-analyzable exception handling for fault-tolerant real-time languages

Exceptions add a significant element of robustness and fault-tolerance to an application. In real-time systems, however, we require not only semantic correctness, robustness, and fault-tolerance, but also timely behavior. For restricted languages, schedulability analysis can be made efficient through use of polynomial-time analyses and transformations. In this paper, we show how a reasonable level of exception handling can be added to such a language. Specifically, we present an exception mechanism which reasonably provides for (1) guaranteed schedulability, (2) fine granularity of exception handling, (3) possibility of non-termination of the process that raises the exception, (4) reuse of exception handlers within the program, (5) information hiding in exception handlers, (6) exceptions as first-class objects, (7) casting or binding of exceptions, and (8) deadline modification. Furthermore, the mechanism allows for easy specification of multi-mode operation, and permits program component assignment using expected behavior while enabling schedulability analysis of worst-case (often exceptional) behavior. While adding features to exception handler semantics can create new analysis problems while solving expressivity problems, we show that the exception handling features described above are desirable, that the complexity of static schedulability analysis in the presence of these features is manageable, and that existing language provides all these desirable features.Marlowe is visiting the Real-Time Computing Laboratory from the Department of Mathematics and Computer Science, Seton Hall University, South Orange, NJ 07079 USA.At the time of the paper, Masticola was with the Department of Computer Science, Rutgers University.     

Static analysis of exception handling in Ada

Since the signature of an Ada subprogram does not specify the set of exceptions that the subprogram can propagate, computing the set of exceptions that a subprogram may encounter is not a trivial task. This is a source of error in large Ada systems: for example, a subprogram may not be prepared to handle an exception propagated from another subprogram several layers lower in the call-tree. In a large system, the number of paths in exceptional processing is so great that it is unlikely that testing will uncover all errors in inter-procedural exception handling. Nor are compilers or code inspections likely to locate all such errors. Exception handling is an area where static analysis has a high potential payoff for systems with high reliability requirements. We discuss fundamental notions in computing exception propagation and describe an analysis tool that has proved to be effective in detecting inconsistencies in the exception-handling code of Ada applications.     

测试Java异常处理机制的方法

异常处理机制能增强程序运行的可靠性,提高软件的健壮性.然而,如果异常处理机制使用不当,会带来许多潜在的错误,因而很有必要对程序的异常处理结构进行测试.提出了一种识别被测程序中的所有异常变量"定义-使用"关系的方法,并使用一个异常的定义-捕获度量来计算异常定义-使用链的测试覆盖.最后设计了一种异常分析及测试的原型工具.     

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.     

An exception handling framework for case management

Software and Systems Modeling - In order to achieve their business goals, organizations heavily rely on the operational excellence of their business processes. In traditional scenarios, business...     

The exception handling effectiveness of POSIX operating systems

Operating systems form a foundation for robust application software, making it important to understand how effective they are at handling exceptional conditions. The Ballista testing system was used to characterize the handling of exceptional input parameter values for up to 233 POSIX functions and system calls on each of 15 widely used operating system (OS) implementations. This identified ways to crash systems with a single call, ways to cause task hangs within OS code, ways to cause abnormal task termination within OS and library code, failures to implement defined POSIX functionality, and failures to report unsuccessful operations. Overall, only 55 percent to 76 percent of the exceptional tests performed generated error codes, depending on the operating system being tested. Approximately 6 percent to 19 percent of tests failed to generate any indication of error despite exceptional inputs. Approximately 1 percent to 3 percent of tests revealed failures to implement defined POSIX functionality for unusual, but specified, situations. Between 18 percent and 33 percent of exceptional tests caused the abnormal termination of an OS system call or library function, and five systems were completely crashed by individual system calls with exceptional parameter values. The most prevalent sources of these robustness failures were illegal pointer values, numeric overflows, and end-of-file overruns     

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.     

User responsibility and exception handling in decision support systems

The role of user responsibility in decision support systems (DSS) has been omitted in recent studies of some important issues. One such important issue is exception handling. In this short note, the role of user responsibility in exception handling is examined. The importance of user responsibility is emphasized, a possible approach is outlined which supports user responsibility in exception handling through the consideration of mental models.     

A mechanism for exception handling and its verification rules

This paper presents a control structure designed for an exception handling mechanism based on Goodenough's proposal. The aim is to provide a recovery mechanism as a basic component of any procedure-oriented language, which can handle any kind of error, ranging from design errors to occasional malfunctioning of hardware components.The semantics of the structure is described formally by means of Hoare type verification rules.     

Analysis and testing of programs with exception handling constructs

Analysis techniques, such as control flow, data flow, and control dependence, are used for a variety of software engineering tasks, including structural and regression testing, dynamic execution profiling, static and dynamic slicing, and program understanding. To be applicable to programs in languages such as Java and C++, these analysis techniques must account for the effects of exception occurrences and exception handling constructs; failure to do so can cause the analysis techniques to compute incorrect results and, thus, limit the usefulness of the applications that use them. This paper discusses the effects of exception handling constructs on several analysis techniques. The paper presents techniques to construct representations for programs with explicit exception occurrences-exceptions that are raised explicitly through throw statements-and exception handling constructs. The paper presents algorithms that use these representations to perform the desired analyses. The paper also discusses several software engineering applications that use these analyses. Finally, the paper describes empirical results pertaining to the occurrence of exception handling constructs in Java programs and their effect on some analysis tasks     

Concurrent exception handling and resolution in distributed object systems

We address the problem of how to handle exceptions in distributed object systems. In a distributed computing environment, exceptions may be raised simultaneously in different processing nodes and thus need to be treated in a coordinated manner. Mishandling concurrent exceptions can lead to catastrophic consequences. We take two kinds of concurrency into account: 1) Several objects are designed collectively and invoked concurrently to achieve a global goal and 2) multiple objects (or object groups) that are designed independently compete for the same system resources. We propose a new distributed algorithm for resolving concurrent exceptions and show that the algorithm works correctly even in complex nested situations, and is an improvement over previous proposals in that it requires only O(n/sub max/N/sup 2/) messages, thereby permitting quicker response to exceptions.     

组合服务事务的异常处理机制研究

服务组合目前已成为业界研究的热点,它为组织问应用集成提供了一种新的解决方案.在完全开放的Internet环境中,组合服务需要Web服务事务处理机制来保证其可靠性,而Web服务事务处理需要一种异常处理机制的支持.针对节点故障引起的异常给出多种异常处理策略,对其进行形式化描述,并给出了异常处理的算法.最后在此基础上提出一个可定制补偿操作及相关补偿规则的灵活的组合服务事务异常处理模型,并对其实现.     

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.