Exception Handling Mechanisms Research Articles

Verification of Control System Runtime Using an Executable Semantic Model

The paper outlines a methodology for validating the accuracy of a control system’s runtime implementation. The runtime takes the form of a virtual machine executing portable code compliant with IEC 61131-3 standards. A formal model, comprising denotational semantics equations, has been devised to specify machine instruction decoding and operations, including arithmetic functions across various data types, arrays, and subprogram calls. The model also encompasses exception-handling mechanisms for runtime errors, such as division by zero and invalid array index access. This denotational model is translated into executable form using the functional F ♯ language. Verification involves comparing the actual implementation of the virtual machine against this executable model. Any disparities between the model and implementation indicate deviations from the specification. Implemented within the CPDev engineering environment, this approach ensures consistent and predictable control program execution across different target platforms.

ResourceNet: a collaboration network among decentralised manufacturing resources for autonomous exception‐handling in smart manufacturing

The fast-changing market and increasing demand for customised products have imposed manufacturers to improve the flexibility and robustness of their manufacturing execution systems. The ability to recover from exceptional events is fundamental to autonomous manufacturing systems in the era of smart manufacturing. Currently, the various types of manufacturing exceptions remain unclear. This research investigated the typical exceptions and proposed a general framework that supports the autonomous exception-handling and resource discovery in dynamic environments. A multi-layer peer-to-peer network is used to model the resources, services, and events in decentralised manufacturing systems. The exception-handling mechanism is designed that incorporates rule-based reactions, matching of features, recording of behaviour patterns etc. The feasibility of the proposed methods is also discussed, which shows many exceptions that were ignored in previous scheduling models can be timely identified and easily handled. This research explores the complex relations among manufacturing resources and provides an intelligent overall framework for self-organising manufacturing with self-diagnose capabilities.

Approaches for resilience and antifragility in collaborative business ecosystems

Contemporary business ecosystems are continuously challenged by unexpected disruptive events, which are increasing in their frequency and effects. A critical question is why do some organizations collapse in face of extreme events, while others not? On the other hand, current engineering and socio-technical systems were designed to operate in “mostly stable” situations; sporadic instability and disturbances are at best captured by exception handling mechanisms, focusing on reliability and robustness. Recent and more ambitious design goals, however, aim at building systems that are expected to cope with severe disruptions, and survive or even thrive in a context of volatility and uncertainty. This led to an increasing attention to the concepts of resilience and antifragility. As such, this article introduces the findings of a comprehensive literature survey aimed at shedding light on emerging concepts and approaches to handle disruptions in business ecosystems. Main contributions include a clarification of related concepts, identification and classification of disruption sources and drivers, and extensive lists of strategies and underlying capabilities to cope with disruptions. Related perspectives and approaches developed in multiple knowledge areas are also analysed and synthesized. Finally, a collection of engineered systems implementing promising approaches to increase resilience and antifragility are presented.

Dependency safety for Java – Implementing and testing failboxes

• We present a testing framework tailor-made for testing how multi-threaded Java programs handle asynchronous exceptions. • We explain how failboxes can be used in practice to produce multi-threaded Java programs that guarantee dependency safety. • We present a number of possible implementations of the failbox concept, in order of their robustness. • For each implementation, we discuss its weaknesses, and demonstrate these via tests performed with our testing framework. • Our final implementation is robust w.r.t. asynchronous exceptions. It is the first one that provides this guarantee. Exception mechanisms help to ensure that a program satisfies the important robustness criterion of dependency safety: if an operation fails in an execution sequence, any code depending on the successful completion of this operation should also fail in a controlled way. However, the exception handling mechanisms available in languages like Java do not provide a structured way to achieve dependency safety. The language extension failbox provides dependency safety in a compositional manner. Asynchronous exceptions occurring inside the failbox code are a serious challenge in achieving dependency safety. In this article we present a Java implementation which deals with this challenge by developing failboxes incrementally, through four increasingly robust iterations. For each incremental implementation step we analyze the vulnerabilities and argue the remedies in the next implementation. We also present a testing approach to investigate whether the vulnerabilities are realistic and the remedies proposed are effective. This testing approach enables us to generate asynchronous exceptions in a controlled manner for concurrent programs and the tests are repeatable in that they give the same results for runs that may differ in scheduling, even on different platforms.

Design of Remote Terminal of Air Compressor Based on STM32 and GPRS

In this paper, a remote terminal of air compressor based on STM32 and GPRS is designed, which is used to collect data of air compressor in real time and upload data to server end through GPRS network. The power and signal physical isolation hardware design, to ensure the safety of equipment and terminal isolation, software using the exception handling and heartbeat mechanism, improve the stability of the remote terminal connected to the server. The data transmission protocol to streamline the security to improve the real-time and reliability of GPRS network transmission. The operation results show that the air compressor remote terminal has strong anti-interference ability, and the automatic dropping of the line can be automatically reconnected, and the comprehensive packet loss rate is about 0.23%, and the expected results can be achieved.

Do android developers neglect error handling? a maintenance-Centric study on the relationship between android abstractions and uncaught exceptions

Abstract All the mainstream programming languages in widespread use for mobile app development provide error handling mechanisms to support the implementation of robust apps. Android apps, in particular, are usually written in the Java programming language. Java includes an exception handling mechanism that allows programs to signal the occurrence of errors by throwing exceptions and to handle these exceptions by catching them. All the Android-specific abstractions, such as activities and asynctasks, can throw exceptions when errors occur. When an app catches the exceptions that it or the libraries upon which it depends throw, it can resume its activity or, at least, fail in a graceful way. On the other hand, uncaught exceptions can lead an app to crash, particularly if they occur within the main thread. Previous work has shown that, in real Android apps available at the Play Store, uncaught exceptions thrown by Android-specific abstractions often cause these apps to fail. This paper presents an empirical study on the relationship between the usage of Android abstractions and uncaught exceptions. Our approach is quantitative and maintenance-centric. We analyzed changes to both normal and exception handling code in 112 versions extracted from 16 software projects covering a number of domains, amounting to more than 3 million LOC. Change impact analysis and exception flow analysis were performed on those versions of the projects. The main finding of this study is that, during the evolution of the analyzed apps, an increase in the use of Android abstractions exhibits a positive and statistically significant correlation with the number of uncaught exception flows. Since uncaught exceptions cause apps to crash, this result suggests that these apps are becoming potentially less robust as a consequence of exception handling misuse. Analysis of multiple versions of these apps revealed that Android developers usually employ abstractions that may throw exceptions without adding the appropriate handlers for these exceptions. This study highlights the need for better testing and verification tools with a focus on exception handling code and for a change of culture in Android development or, at least, in the design of its APIs.

PreX: A predictive model to prevent exceptions

The exception handling mechanism has been one of the most used reliability tools in programming languages in the last decades. However, this model has not changed much with time, in spite of advances in programming languages, which include concurrent programming and a shift towards more reactive paradigms, the basic principle remains the same - an exception occurs, and the mechanism reacts. We propose a new paradigm, inspired by Online Failure Prediction (OFP), to predict exceptions and possibly avert them by triggering the execution of preventive actions. The proposed model - PreX - is, thus, proactive, operating in a much finer-grained level than any other form of online failure prediction. OFP has shown promising results in predicting failures at a higher level, but has never been available to the developer, being mainly a system level technique. Thus, PreX will offer developers a new range of revitalization strategies. In this work, we describe the model and evaluate its performance by applying it to a real e-commerce solution, demonstrating how it is capable of predicting and preventing exceptions at run-time. Furthermore, we also show that PreX increases the overall availability and performance of the system under the same conditions.

Another look at estimators for intermittent demand

In this paper we focus on forecasting for intermittent demand data. We propose a new aggregation framework for intermittent demand forecasting that performs aggregation over the demand volumes, in contrast to the standard framework that employs temporal (over time) aggregation. To achieve this we construct a transformed time series, the inverse intermittent demand series. The new algorithm is expected to work best on erratic and lumpy demand, as a result of the variance reduction of the non-zero demands. The improvement in forecasting performance is empirically demonstrated through an extensive evaluation in more than 8000time series of two well-researched spare parts data sets from the automotive and defence sectors. Furthermore, a simulation is performed so as to provide a stock-control evaluation. The proposed framework could find popularity among practitioners given its suitability when dealing with clump sizes. As such it could be used in conjunction with existing popular forecasting methods for intermittent demand as an exception handling mechanism when certain types of demand are observed.

Mutation Analysis Approach to Develop Reliable Object-Oriented Software

In general, modern programs are large and complex and it is essential that they should be highly reliable in applications. In order to develop highly reliable software, Java programming language developer provides a rich set of exceptions and exception handling mechanisms. Exception handling mechanisms are intended to help developers build robust programs. Given a program with exception handling constructs, for an effective testing, we are to detect whether all possible exceptions are raised and caught or not. However, complex exception handling constructs make it tedious to trace which exceptions are handled and where and which exceptions are passed on. In this paper, we address this problem and propose a mutation analysis approach to develop reliable object-oriented programs. We have applied a number of mutation operators to create a large set of mutant programs with different type of faults. We then generate test cases and test data to uncover exception related faults. The test suite so obtained is applied to the mutant programs measuring the mutation score and hence verifying whether mutant programs are effective or not. We have tested our approach with a number of case studies to substantiate the efficacy of the proposed mutation analysis technique.

Cost‐aware execution of transactional web services using labelled transition systems

Recently web service composition has become a very cost-effective way to develop business applications. However, owing to the unreliable nature of web services, providing the transactional support in execution of a service composition is an important design requirement. To guarantee the transactional execution of service compositions, a fault-handling routine has to be started once a service failure occurs in order to undo the effect of previously completed services by calling their corresponding compensation operations. Currently this fault-handling mechanism is implemented by means of low-level programming constructs such as exception-handling mechanism in languages such as WS-BPEL. However, since the logic of handling service failures might become very complex in some applications, this concern should be separated from the normal flow of the composition workflow based on the separation of concerns principle. To achieve this, in this study we have proposed an orchestration pattern for building a transactional service composition in which the failure-recovery logic is imposed on the composition workflow by a Labelled Transition System (LTS) as a separate module. It is assumed that each service within the composition is associated with two known transactional properties: (i) a rollback cost that indicates the cost of undoing (compensating) the service and (ii) a failure probability. The transactional logic of the service composition is also specified using the rollback dependencies represented in a rollback graph. An LTS then is generated to schedule the execution of services within the composition based on the composition transactional logic and properties such that upon a service failure, a recovery path with the lowest cost is followed.

Exception Throwing Analysis and Exception Handling Method for BPEL

Business developer needs to develop fault-tolerant process, but fault-tolerant process development based on exception handling mechanism provided by BPEL costs much time and is easy to make mistake. We analyze application exception throw chain theory of service-oriented system. Exception throwing of BPEL process is broadcasted among component layer, service layer and process layer. We also propose an application exception handling method for BPEL by using EHPDL-P. EHPDL-P can separate normal business logic and exception business logic, and thus it can enhance BPEL fault-tolerance ability.

On expanding protocol conformance checking to exception handling

Components or services must often be compliant to organizatorial or legal regulations. Furthermore, they should avoid unwanted behaviour such as abortion of the execution of a service without notification of the client. Violation of both might happen due to unintended uses of services. In general, the intention is specified by contracts. In this work, we consider a special form of contracts: service protocols. These specify for a service legal sequences of operation calls. We propose an approach for checking whether such protocols are obeyed in a service composition. For this, it is necessary to define a conservative abstraction of the behaviour of service-oriented systems and a contract based on interactions (named service protocol) to be verified. In our previous work, we have modelled unbound concurrency, unbound recursion, and synchronization. This article briefly presents the previous results and extends them by exception handling mechanisms. In particular, it takes into account that the execution of service may raise an exception and allows the clients to react on the exception.

Exception Handling in Service-Based Business Processes by Applying Adaptation Planning Graph

This paper proposes an exception handling mechanism based on Adaptation Planning Graph for service-based business processes. A three-layer representation model of service-based business process is introduced firstly. And then, Logic Model of Service-based Business Process and Adaptation Planning Graph are introduced to enforce reliability of composite Web Services at run-time. Simulations prove that this approach can efficiently guarantee the reliability of composite services at run-time.

An Exception Handling Approach for Service-Based Business Processes

This paper proposes an exception handling mechanism for running reliable service-based business processes. With Smart Process-based Application Model that we have proposed, a smart process is generated automatically according to the execution of composite web services to better meet user’s individual requirements. However, the loosely-coupled nature of the smart process introduces more exceptions during its running. This paper will mainly focus on the failures of a smart process, and give an approach to handle exceptions. Based on Execution Transition Diagram(ETD) and several execution states we define in this paper, exceptions can be handled automatically by selecting rational transitions in the ETD during the execution of a smart process.

Selected dynamic issues in software model checking

Software model checking has come of age. After one and a half decade, several successful model checking tools have emerged. One of the most prominent approaches is the virtual machine-based approach, pioneered by Java PathFinder (jpf). And although the virtual machine-based approach has been rather successful, it lags behind classic model checking in terms of speed and memory consumption. Fortunately, with respect to the implementation of virtual-based model checkers, there is still ample room for innovation and optimizations. This paper presents three novel (optimization) techniques that have been implemented into MoonWalker, a software model checker for .Net programs. (a) .Net specifies an exception handling mechanism called structured exception handling (seh). seh is one of the most sophisticated and fine-grained exception handling mechanisms for application platforms. Its implementation within MoonWalker is the most sophisticated in a model checker to date. (b) To decrease memory use within MoonWalker, a collapsing scheme has been developed for collapsing the metadata used by stateful dynamic partial order reduction. The reduction of memory is—in some cases—more than a factor of two. (c) Finally, to decrease the verification time, the memoised garbage collection (mgc) algorithm has been developed. It has a lower time-complexity than the often used Mark & Sweep garbage collector. Its main idea is that it only traverses changed parts of the heap instead of the full heap. The average time reduction is up to 25%. We have used the Java Grande Forum benchmark suite to compare MoonWalker against jpf and observed that the average performance of MoonWalker is on par with jpf.

Petri Net Based Specification in the Design of Logic Controllers with Exception Handling Mechanism

Petri Net Based Specification in the Design of Logic Controllers with Exception Handling Mechanism Hierarchical Petri nets beside UML state machine diagrams, sequentional function charts (SFC) and hierarchical concurrent state machines are common solution for specification of logic controllers. These specification formats provide both concurrency and modeling on multi levels of abstraction (hierarchic approach). But only state machine diagrams supports exceptions handling in direct way. Program model presented in form of state machine diagram may be later transformed into a program in the SFC language or transformed in the Petri Net and implemented in the FPGA structure. Similarity between SFC language and Petri Nets give us lot of tools for analysis such control system. Article presents new approach for exceptions handling in hierarchical Petri nets as formal specification for logic controllers. Proposed method of specification can be used independently or as a part of dual specification (correlated state machine diagram and hierarchical configurable Petri Net).

Semantics-Based Aspect-Oriented Management of Exceptional Flows in Business Processes

Enriching business process models with semantic annotations that are taken from an ontology has become a crucial need in service provisioning, integration and composition, and business processes management. We represent semantically annotated business processes as part of an Web ontology lanuage knowledge base that formalizes the business process structure, the business domain, a set of criteria that describe correct semantic annotations, and a set of constraints that describe requirements on the business process itself. In this paper, we show how the Semantic Web representation and reasoning techniques can be 1) exploited by our aspect-oriented approach to modularize exception-handling (as well as other crosscutting) mechanisms and 2) effectively applied to formalize and automatically verify constraints on the management of exceptional flows (as well as other relevant flows) in business processes. The benefits of the Semantic Web and the aspect-oriented technologies are illustrated in a case study, where exceptional flows are modularized separately and managed at the semantic level due to the proposed approach.

Safe locking for multi-threaded Java with exceptions

There are many mechanisms for concurrency control in high-level programming languages. In Java, the original mechanism for concurrency control, based on synchronized blocks, is lexically scoped. For more flexible control, Java 5 introduced non-lexical lock primitives on re-entrant locks.These operators may lead to run-time errors and unwanted behavior; e.g., taking a lock without releasing it, which could lead to a deadlock, or trying to release a lock without owning it. This paper develops a static type and effect system to prevent the mentioned lock errors for a formal, object-oriented calculus which supports non-lexical lock handling and exceptions.Based on an operational semantics, we prove soundness of the effect type analysis. Challenges in the design of the effect type system are dynamic creation of threads, objects, and especially of locks, aliasing of lock references, passing of lock references between threads, and reentrant locks as found in Java. Furthermore, the exception handling mechanism complicates the control-flow and thus the analysis.

Exception handling in pervasive service composition using normative agents

The full integration of pervasive computing services into daily life leads to smart spaces with a wide range of intelligent devices that must be dynamically composed to provide a transparent service to users. To achieve this, pervasive services have to coordinate among themselves in both an automated and autonomous manner, with the aim of satisfying complex user requirements that no single service can fulfill. However, existing pervasive environments are normally ad-hoc and isolated systems incapable of: 1) reacting to dynamic and unforeseen situations that may raise exceptions, and 2) collaborating with pervasive services beyond their physical limits. The contributions of this work are: 1) Proposing a normative agent-based service composition method capable of handling exceptions in open pervasive systems. 2) Using the Web as the underlying infrastructure where pervasive services provided by either smart devices or web services can coexist and interact with each other. 3) Providing a modular and hierarchical agent coordination method based on virtual organizations to sustain coordination among agents belonging to multiple organizations (smart spaces). 4) Integrating exception handling mechanisms based on social norms and formalized by event calculus predicates into virtual organizations to support and guide exception handling in both a dynamic and autonomous manner.

Research on Exception Handling Mechanism Based on Directed Graph in Service Composition

To enforce consistency and reliability of web services composite at run-time, solving exception is to ensure the transaction atomicity anomalies，it is an effective method. This paper proposes a novel mechanism based on directed graph to addressing the problem of exception handling in web services composite. According to execution dependencies and compensation dependencies among tasks in business processes, adopt the approach of directed graph to set up functional model, when exceptions are handled with forward or backward-recovery methods during execution of business processes, the approach can guarantee compensation achieving, and also gives consideration to the problem that there are no compensation services or the cost to achieve compensation,it is too expensive. Simulations prove that when the approach can efficiently guarantee the consistency and reliability of composite services at run-time.