Abstract: A comprehensive, though relatively simple, non-linear method for the seismic damage analysis of reinforced concrete buildings (the N2 method) has been elaborated. The basic features of the method are: the use of two separate mathematical models, application of the response spectrum approach and of the non-linear static analysis, and the choice of a damage model which includes cumulative damage. The method yields results of reasonable accuracy provided that the structure oscillates predominantly in the first mode. Three variants of a seven-storey building have been used as illustrative examples for the application of the method. Four different types of the analysis, with different degrees of sophistication, have been performed in order to estimate the influence of several assumptions and approximations used in the N2 method.

Abstract: As technology scales into the deep submicron regime, noise immunity is becoming a metric of comparable importance to area, timing, and power for the analysis and design of VLSI systems. This paper defines noise as it pertains to digital systems and addresses the technology trends which are bringing noise issues to the forefront. The noise sources which are plaguing digital systems are explained. A metric referred to as noise stability is defined, and a static noise analysis methodology based on this metric is introduced to demonstrate how noise can be analyzed systematically. Analysis issues associated with on-chip interconnect are also considered. This paper concludes with a discussion of the device, circuit, layout, and logic design issues associated with noise.

Abstract: Behavior analysis of complex distributed systems has led to the search for enhanced reachability analysis techniques which support modularity and which control the state explosion problem. While modularity has been achieved, state explosion in still a problem. Indeed, this problem may even be exacerbated, as a locally minimized subsystem may contain many states and transitions forbidden by its environment or context. Context constraints, specified as interface processes, are restrictions imposed by the environment on subsystem behavior. Recent research has suggested that the state explosion problem can be effectively controlled if context constraints are incorporated in compositional reachability analysis (CRA). Although theoretically very promising, the approach has rarely been used in practice because it generally requires a more complex computational model and does not contain a mechanism to derive context constraints automatically. This article presents a technique to automate the approach while using a similar computational model to that of CRA. Context constraints are derived automatically, based on a set of sufficient conditions for these constraints to be transparently included when building reachability graphs. As a result, the global reachability graph generated using the derived constraints is shown to be observationally equivalent to that generated by CRA without the inclusion of context constraints. Constraints can also be specified explicitly by users, based on their application knowledge. Erroneous constraints which contravene transparency can be identified together with an indication of the error sources. User-specified constraints can be combined with those generated automatically. The technique is illustrated using a clients/server system and other examples.

Abstract: Virtual functions make code easier for programmers to reuse but also make it harder for compilers to analyze. We investigate the ability of three static analysis algorithms to improve C++ programs by resolving virtual function calls, thereby reducing compiled code size and reducing program complexity so as to improve both human and automated program understanding and analysis. In measurements of seven programs of significant size (5000 to 20000 lines of code each) we found that on average the most precise of the three algorithms resolved 71% of the virtual function calls and reduced compiled code size by 25%. This algorithm is very fast: it analyzes 3300 source lines per second on an 80 MHz PowerPC 601. Because of its accuracy and speed, this algorithm is an excellent candidate for inclusion in production C++ compilers.

Abstract: Developers of concurrent software need cost-effective analysis techniques to acquire confidence in the reliability of that software. Analysis of concurrent programs is difficult because, in many cases, the patterns of communication among the various parts of the program are complicated and the number of possible communications is large. One class of techniques that can be used for analysis of concurrent programs is static analysis, which uses compile-time information to prove properties about a program. Given the variety of concurrency analysis tools available, analysts need assistance when selecting tools to use to check a specific program and property. Despite exponential worst-case bounds for most of the techniques, average case analysis times may help differentiate between the techniques in practice. The techniques provide a range of analysis accuracies, but these accuracies have not been formally or empirically quantified. Empirical tool comparisons can therefore provide useful insight into which tool would be most suitable for a given program and property. The main contribution of the work presented here is the development of a sound methodology for comparing concurrency analysis tools, with a thorough description of the experimental design and constraints, discussion of the issues and tradeoffs involved in developing such a methodology, and valid application of statistical analysis. We apply this methodology to conduct an experiment to compare a number of concurrency analysis tools. Comparisons are accomplished for analysis time, analysis failures, and analysis accuracy of the tools. Secondary contributions of the work presented here include development of predictive models and preliminary examination of several "real" programs. We develop, with varying degrees of success, predictive models that may help an analyst estimate the analysis time, analysis failure, and analysis accuracy of each tool given a program and a property to be checked. We also provide a preliminary examination of several "real" programs, including a discussion of the program constructs used in the programs and observations about program characteristics that are likely to affect the applicability of static concurrency analysis tools to these programs.

Abstract: The paper shows that some of the guidelines for job design that emerge from a static analysis of the multitask agency problem can be overturned in a dynamic model with limited commitment. Static analyses have shown that it is optimal to assign workers sole responsibility for tasks, and to allocate them tasks which are as homogeneous as possible with respect to the ease of measuring performance. Our dynamic analysis demonstrates that it can, instead, be optimal to make workers jointly responsible for tasks, and to make their task portfolios as similar to one another, but as internally diverse, as possible.

Abstract: A new manufacturing control software development methodology called IOPN (integrated object-oriented Petri net paradigm) is presented. The IOPN consists of four phases: (1) static analysis; (2) dynamic analysis; (3) integration; and (4) implementation. In the static analysis phase, all possible object classes required by the manufacturing control software, and the static relationships among these object classes are identified. In the dynamic phase, the objectoriented Petri net (OPN) control model is derived according to both the dynamic behaviour of shop floor operations and the desired control logic. After the control logic specified by the OPN model is analysed and there is proven to be no deadlock, the required control decision/knowledge (e.g. scheduling/ dispatching knowledge) must be included in the OPN model. Finally, the manufacturing control system is implemented directly from the specification of the OPN model by applying a number of transformation rules. Since the IOPN approach not only possesse...

Abstract: We are concerned with the static analysis of the communication topology for systems of mobile processes. For this purpose we construct an abstract interpretation of a large fragment of the π-calculus which can be used as a metalanguage to specify the behaviour of these systems. The abstract domain is expressive enough to give accurate descriptions of infinite and non-uniform distributions of processes and communication channels. We design appropriate widening operators for the automatic inference of such information.

Abstract: Data-flow testing relies on static analysis for computing the definition-use pairs that serve as the test case requirements for a program. When testing large programs, the individual procedures are first tested in isolation during unit testing. Integration testing is performed to specifically test the procedure interfaces. The procedures in a program are integrated and tested in several steps. Since each integration step requires data-flow analysis to determine the new test requirements, the accumulated cost of repeatedly analyzing a program can contribute considerably to the overhead of testing. Data-flow analysis is typically computed using an exhaustive approach or by using incremental data-flow updates. This paper presents a new and more efficient approach to data-flow integration testing that is based on demand-driven analysis. We developed and implemented a demand-driven analyzer and experimentally compared its performance during integration testing with the performance of (i) a traditional exhaustive analyzer, and (ii) an incremental analyzer. Our experiments show that demand-driven analysis is faster than exhaustive analysis by up to a factor of 25. The demand-driven analyzer also outperforms the incremental analyzer in 80% of the test programs by up to a factor of 5.

Abstract: For a program with sufficient parallelism, reducing synchronization costs is one of the most important objectives for achieving efficient execution on any parallel machine This paper presents a novel methodology for reducing synchronization costs of programs compiled for SPMD execution This methodology combines data flow analysis with communication analysis to determine the ordering between production and consumption of data on different processors, which helps in identifying redundant synchronization The resulting framework is more powerful than any that have been previously presented, as it provides the first algorithm that can eliminate synchronization messages even from computations that need communication We show that several commonly occurring computation patterns such as reductions and stencil computations with reciprocal producer-consumer relationship between processors lend themselves well to this optimization, an observation that is confirmed by an examination of some HPF benchmark programs Our framework also recognizes situations where the synchronization needs for multiple data transfers can be satisfied by a single synchronization message This analysis, while applicable to all shared memory machines as well, is especially useful for those with a flexible cache-coherence protocol, as it identifies efficient ways of moving data directly from producers to consumers, often without any extra synchronization

Abstract: In this paper we demonstrate the effectiveness of data flow analysis for verifying requirements of communication protocols. Data flow analysis is a static analysis method for increasing confidence in the correctness of software systems by automatically verifying that a given software artifact (e.g., design or code) must behave consistently with a specified requirement. In this case study, we apply the FLAVERS data flow analysis tool to pseudocode designs of the three way handshake connection establishment protocol and of the alternating bit protocol and prove that the behavior of the pseudocode is consistent with protocol behavioral requirement specifications. We show how FLAVERS is a particularly effective because it is computationally inexpensive, requires minimal human interaction, and is a general approach that can be applied incrementally until the desired accuracy is achieved. In addition, we show how assumptions about the environment in which a software system is executed can be incorporated into the analysis, using message losses as an example. We present experimental results and derive some guidelines about the classes of protocol requirement specifications that may be amenable to verification using FLAVERS.

Abstract: The incorrect use of pointers is one of the most common source of bugs. As a consequence, any kind of static code checking capable of detecting potential bugs at compile time is welcome. This paper presents a static analysis for the detection of incorrect accesses to memory (dereferences of invalid pointers). A pointer may be invalid because it has not been initialised or because it refers to a memory location which has been deallocated. The analyser is derived from an axiomatisation of alias and connectivity properties which is shown to be sound with respect to the natural semantics of the language. It deals with dynamically allocated data structures and it is accurate enough to handle circular structures.

Abstract: For large programs, static analysis can be one of the most time-consuming phases of the whole compilation process. We propose a new paradigm for the implementation of static analyses that is inspired by partial evaluation techniques. Our paradigm does not reduce the complexity of these analyses, but it allows an efficient implementation. We illustrate this paradigm by its application to the problem of control flow analysis of functional programs. We show that the analysis can be sped up by a factor of 2 over the usual abstract interpretation method.

Abstract: A well known problem with many Prolog interpreters and compilers is the lack of occur-check in the implementation of the unification algorithm This means that such systems are unsound with respect to first-order predicate logic Static analysis offers an appealing approach to the problem of occur-check reduction, that is, the safe omission of occur-checks in unification We compare, for the first time, three static methods that have been suggested for occur-check reduction, two based on assigning “modes∝ to programs and one which uses abstract interpretation In each case, the analysis or some essential part of it had not been implemented so far Of the mode-based methods, one is due to Chadha and Plaisted and the other is due to Apt and Pellegrini The method using abstract interpretation is based on earlier work by Plaisted, SOndergaard and others who have developed groundness and sharing analyses for logic programs The conclusion is that a truly global analysis based on abstract interpretation leads to markedly higher precision and hence fewer occur-checks at run-time Given the potential run-time speedups, a precise analysis would be well worth the extra time

Abstract: This chapter discusses the role that Generalized Stochastic Petri Nets (GSPN) can play in the static analysis of distributed software. The material is organized along two main lines: the need and the advantages of studying both qualitative and quantitative aspects of a program, and the need for doing it in an automatic manner. The role of performance evaluation in the analysis of distributed software is illustrated through a small example, classical in the qualitative approach (the dining philosophers). Although small this example allows to point out the need and the requirements of automatic translation and to discuss the main hypothesis behind program performance evaluation through GSPN models. A procedure for the automatic generation of GSPN models starting from a distributed program written in a CSP-like language, and for the definition of program performance indices in terms of GSPN ones is then given and illustrated by means of a realistic example.

Abstract: This paper presents an object-oriented Petri net cell control (OPNCC) model for scheduling and controlling the operations of a flexible manufacturing cell. The development of the OPNCC model includes three phases: 1. Static analysis. 2. Dynamic analysis. 3. Integration.

Abstract: We discuss the random generation of strings using the grammatical formalism AGFL. This formalism consists of context-free grammars extended with a parameter mechanism, where the parameters range over a finite domain. Our approach consists in static analysis of the combinations of parameter values with which derivations can be constructed. After this analysis, generation of sentences can be performed without backtracking.

Abstract: Spurious results are an inherent problem of most static analysis methods. These methods, in an effort to produce conservative results, overestimate the executable behavior of a program. Infeasible paths and imprecise alias resolution are the two causes of such inaccuracies. In this paper we present an approach for improving the accuracy of Petri net-based analysis of concurrent programs by including additional program state information in the Petri net. We present empirical results that demonstrate the improvements in accuracy and, in some cases, the reduction in the search space that result from applying this approach to concurrent Ada programs.

Abstract: A well known problem with many Prolog interpreters and compilers is the lack of occur-check in the implementation of the unification algorithm. This means that such systems are unsound with respect to first-order predicate logic. Static analysis offers an appealing approach to the problem of occur-check reduction, that is, the safe omission of occur-checks in unification. We compare, for the first time, three static methods that have been suggested for occur-check reduction, two based on assigning “modes∝ to programs and one which uses abstract interpretation. In each case, the analysis or some essential part of it had not been implemented so far. Of the mode-based methods, one is due to Chadha and Plaisted and the other is due to Apt and Pellegrini. The method using abstract interpretation is based on earlier work by Plaisted, SOndergaard and others who have developed groundness and sharing analyses for logic programs. The conclusion is that a truly global analysis based on abstract interpretation leads to markedly higher precision and hence fewer occur-checks at run-time. Given the potential run-time speedups, a precise analysis would be well worth the extra time.

Abstract: In this thesis, optimal and near-optimal algorithms are developed for various classes of single fault test-sequencing algorithms. We first present a novel multi-signal modeling methodology that alleviates some of the model validation problems of traditional dependency modeling, while achieving the same diagnostic resolution. We discuss the failure probability estimation and reachability analysis algorithms for dependency and multi-signal models. We also present efficient static analysis algorithms to rapidly evaluate topological testability deficiencies of a system based on the results of reachability analysis and directed graph processing, including the determination of ambiguity groups of faults, redundant tests, hidden and masking false failure sets. Next, we present an array of optimal and near-optimal test-sequencing algorithms that incorporate real-world testing features such as precedence constraints on tests, setup operations for tests, and traveling costs for tests. We develop efficient implementation techniques to speed up the test sequencing algorithms, including bit-compacted representation of the fault dictionary (D-matrix) and a fast, efficient, in-place transposition algorithm for the compacted D-matrix. The algorithms have been used for developing diagnostic strategies for systems having 50,000 failures and 50,000 test points. We extend these algorithms to the case of imperfect tests, where tests have false alarms and missed detections. Specifically, we develop a dynamic programming formulation for the problem of imperfect test sequencing and obtain closed form solutions for systems of special structure. We present practical test sequencing algorithms based on Information Gain and Certainty Equivalence, and compare them with the optimal DP method for small systems. We also present top-down graph search techniques which enabled us to construct static diagnostic strategies for large systems (up to 2000 faults and 2000 unreliable tests). Finally, we consider the various test sequencing problems that arise in the Design for Testability including Minimax test sequencing, test sequencing with a constraint on the expected testing time, test sequencing with a constraint on the number of tests used, and minimal storage test sequencing, for which we derive optimal and near-optimal top-down graph search solution algorithms.

Abstract: This paper demonstrates a simple but accurate analytical method usable for the preliminary design stages of doubly symmetric single and double frame-tubes with braces in high-rise structures. The present method is formulated by replacing the tube with an equivalent rod, in which the effects of bending, transverse shear deformation, shear-lag and torsion are considered. The static analysis and free vibration are presented by applying the ordinary finite difference method to the governing equation for a double symmetric tube proposed by Takabatake et al. (1993). The dynamic analysis is taken from modal analysis. Static and dynamic numerical computations are carried out for doubly symmetric single and double frame-tubes with braces. The results obtained from the theory proposed here are in good agreement with results obtained from three-dimensional frame analysis using the FEM codes NASTRAN and DEMOS.

Abstract: The dynamic analysis of a guyed mast subjected to strong turbulent winds is complicated by the nonlinear structural properties of the system and by the random nature of the wind load. Because of the significant differences between static and dynamic response characteristics, conventional static analysis methods can lead to unsafe designs. The new British Standard BS 8100 Part 4 for guyed masts has adopted two static analysis methods for estimating dynamic response : a simplified gust response factor method for shorter masts, and a more general patch load method for masts of all sizes. The Code methods simplify dynamic response calculations while overcoming deficiencies present in earlier static analysis methods. Results from a comprehensive calibration study indicate that the Code methods give reliable results for masts designed in accordance with good engineering practice.

Abstract: Distributed simulation has proved to be a cost effective technique for studying and understanding complex real world systems. Many distributed simulations need to incorporate hundreds or even thousands of processors, across both local and wide area networks. As the size and complexity of distributed simulations increase so do the demands on the hardware and software resources that provide simulation services, causing performance bottlenecks that limit the effectiveness of distributed simulation. Different abstractions of performance are needed depending on who is analyzing the distributed simulation and for what reason. This paper proposes a framework for identifying the factors affecting performance and provides a technique for associating the performance factors with high-level system metrics that describe the behavior of the physical and logical resources and services used in the design and implementation of distributed simulations. Dynamic and static analysis of the performance information provides feedback on the execution of the simulation and can provide meaningful information as a guide in making decisions about the configuration and control of the available hardware and software resources for distributed simulation exercises.

Abstract: A distributed real-time program is usually executed on a limited set of hardware resources and is required to satisfy timing constraints, despite anticipated hardware failures. Static analysis of the timing properties of such programs is often infeasible. This paper shows how to formally reason about these programs when scheduling decisions are made on-line and take into account deadlines, load and hardware failures. We use Timed CCS as a process description language, define a language to describe anticipated faults and apply a version of 5-calculus to specify and verify timing properties. This allows the property of schedulability to be the outcome of an equation-solving problem. And unlike conventional reasoning, the logis is fault-monotonic: if correctness is proved for a number of faults, correctness for any subset of these faults is guaranteed.

Abstract: The functional validation of a complex digital design is a laborious, ad-hoc and open-ended task. Many circuits are too complex to be formally verified in their entirety. Instead, simulation of a register transfer level (RTL) model is used. This research explores techniques to make the validation task more systematic, automated and efficient. This can be accomplished by using information embedded in the RTL model to extract the set of "interesting behaviors" of the design, represented as interacting finite state machines (FSM). If all such interesting behaviors of the RTL could be tested in simulation, the degree of confidence that the design is correct would be substantially higher. This work provides two tools towards this goal. First, a test vector generator is described that uses this information to produce a series of test vectors that exercise all the implemented behaviors of the design in RTL simulation. Secondly, the information can be used as the basis for coverage analysis of a pre-existing test vector suite. Previous coverage metrics, such as toggles on a node in the circuit or code block execution counts, often give good first order indications of how thorough a circuit has been exercised but do not usually give an accurate picture of whether multiple or concurrent events have been exercised. In this thesis, a new method is proposed of analyzing test vector suite coverage based on projecting a minimized control state graph onto control signals that enter the datapath part of the design. The fundamental problem facing any technique that uses state exploration is state space explosion. Two techniques are proposed to minimize this problem; first, a dynamic state graph pruning algorithm based on static analysis of the model structure to provide an exact minimization and second, approximation of the state graph with an estimation of the state space in a more compact representation. These techniques help delay the onset of state explosion, allowing useful information to be obtained and utilized, even for complex designs. Results and practical experiences of applying these techniques to the design of the node controller (MAGIC) of the Stanford FLASH Multiprocessor project are given.

Abstract: In order to play a bigger role in software engineering tools, static analysis techniques must take into account the specific needs of this application area, in particular in terms of interaction with the user and scalability. This new perspective requires a reexamination of the field of static program analysis both internally and in connection with related areas like theorem proving and debugging.

Abstract: Design variables control the shape of boundaries, holes, and cutouts. Internal mesh points move as the boundaries move using the static displacements of an auxiliairy model. A parametric modeling approach is used to define the complete problem, which includes fully automatic mesh generation to create the finite element mesh. A commercial finite element program was used for analysis and sensitivities