Sol M. Shatz

Task allocation for maximizing reliability of distributed computer systems

For distributed systems, system reliability is defined as the probability that the system can run an entire task successfully. When the systems hardware configuration is fixed, the system reliability is mainly dependent on the software design. The task allocation problem is addressed with the goal of maximizing the system reliability. A quantitative problem model, algorithms for optimal and suboptimal solutions, and simulation results are provided and discussed. >

Detection of Ada static deadlocks using Petri net invariants

A method is presented for detecting deadlocks in Ada tasking programs using structural; and dynamic analysis of Petri nets. Algorithmic translation of the Ada programs into Petri nets which preserve control-flow and message-flow properties is described. Properties of these Petri nets are discussed, and algorithms are given to analyze the nets to obtain information about static deadlocks that can occur in the original programs. Petri net invariants are used by the algorithms to reduce the time and space complexities associated with dynamic Petri net analysis (i.e. reachability graph generation). >

A Petri net framework for automated analysis of Ada tasking behavior

Abstract In order to understand and analyze real-time distributed programs, one must account for interactions between proceses. Unfortunately, these interactions can be quite complex due to concurrency and nondeterminism. This paper describes a framework for automated static analysis of distributed programs written in Ada. The analysis is aimed at discovery of a programs potential tasking behavior, that is, behavior in terms of tasking-related issues. Central to the framework is the translation of a program into an abstract grammar system that represents a Petri net graph model.

Models and algorithms for reliability-oriented task-allocation in redundant distributed-computer systems

Reliability-oriented task-allocation for heterogeneous distributed-computer systems with hardware redundancy is discussed. Redundancy of both processors and communication links is considered. A quantitative allocation model is derived and used to present and discuss models and algorithms for systems with level-two or level-three redundancy. The results contribute to the body of knowledge on task allocation and provide an alternative to performance-oriented methods. >

An application of Petri net reduction for Ada tasking deadlock analysis

As part of our continuing research on using Petri nets to support automated analysis of Ada tasking behavior, we have investigated the application of Petri net reduction for deadlock analysis. Although reachability analysis is an important method to detect deadlocks, it is in general inefficient or even intractable. Net reduction can aid the analysis by reducing the size of the net while preserving relevant properties. We introduce a number of reduction rules and show how they can be applied to Ada nets, which are automatically generated Petri net models of Ada tasking. We define a reduction process and a method by which a useful description of a detected deadlock state can be obtained from the reduced nets information. A reduction tool and experimental results from applying the reduction process are discussed.

Application and experimental evaluation of state space reduction methods for deadlock analysis in Ada

An emerging challenge for software engineering is the development of the methods and tools to aid design and analysis of concurrent and distributed software. Over the past few years, a number of analysis methods that focus on Ada tasking have been developed. Many of these methods are based on some form of reachability analysis, which has the advantage of being conceptually simple, but the disadvantage of being computationally expensive. We explore the effectiveness of various Petri net-based techniques for the automated deadlock analysis of Ada programs. Our experiments consider a variety of state space reduction methods both individually and in various combinations. The experiments are applied to a number of classical concurrent programs as well as a set of “real-world” programs. The results indicate that Petri net reduction and reduced state space generation are mutually beneficial techniques, and that combined approaches based on Petri net models are quite effective, compared to alternative analysis approaches.

FORMALIZATION OF OBJECT BEHAVIOR AND INTERACTIONS FROM UML MODELS

UML, being the industry standard as a common OO modeling language, needs a well-defined semantic base for its notation. Formalization of the graphical notation enables automated processing and analysis tasks. This paper describes a methodology for synthesis of a Petri net model from UML diagrams. The approach is based on deriving Object Net Models from UML statechart diagrams and connecting these object models based on UML collaboration diagram information. The resulting system-level Petri net model can be used as a foundation for formal Petri net analysis and simulation techniques. The methodology is illustrated on some small examples and a larger case study. The case study reveals some unexpected invalid system-state situations.

Design and implementation of a Petri net based toolkit for Ada tasking analysis

The use of Petri nets for defining a general static analysis framework for Ada tasking is advocated. The framework has evolved into a collection of tools that have proven to be a very valuable platform for experimental research. The design and implementation of tools that make up the tasking-oriented toolkit for the Ada language (TOTAL) are defined and discussed. Modeling and query/analysis methods and tools are discussed. Example Ada tasking programs are used to demonstrate the utility of each tool individually as well as the way the tools integrate. TOTAL is divided into two major subsystems, the front-end translator subsystem (FETS) and the back-end information display subsystem (BIDS). Three component tools that make up FETS are defined. Examples demonstrate the way these tools integrate in order to perform the translation of Ada source to Petri-net format. The BIDS subsystem and, in particular, the use of tools and techniques to support user-directed, but transparent, searches of Ada-net reachability graphs are discussed. >

Survey: Combating online in-auction fraud: Clues, techniques and challenges

The number of Internet auction shoppers is rapidly growing. However, online auction customers may suffer from auction fraud, sometimes without even noticing it. In-auction fraud differs from pre- and post-auction fraud in that it happens in the bidding period of an active auction. Since the in-auction fraud strategies are subtle and complex, it makes the fraudulent behavior more difficult to discover. Researchers from disciplines such as computer science and economics have proposed a number of methods to deal with in-auction fraud. In this paper, we summarize commonly seen indicators of in-auction fraud, provide a review of significant contributions in the literature of Internet in-auction fraud, and identify future challenging research tasks.

A protocol modeling and verification approach based on a specification language and Petri nets

An approach for automated modeling and verification of communication protocols is presented. A language that specifies the input/output behavior of protocol entities is introduced as the starting point of the approach, and verification of the linguistic specifications is discussed. Rules for conversion of the specifications into a Petri net model (based on a timed Petri net) are presented and illustrated by examples. This leads to a second level of verification on the net model. The approach is illustrated by its application to a part of the LAPD protocol. >