We view the process of constructing a program as the stepwise transformation of a relation into simpler relations. In this paper, we focus on a particular transformation: that which decomposes the specification of an ...
详细信息
We view the process of constructing a program as the stepwise transformation of a relation into simpler relations. In this paper, we focus on a particular transformation: that which decomposes the specification of an iterative program into the specification of the initialization segment and the specification of the while loop. We investigate in some detail the mathematics of this decomposition.
Results are presented of an analysis of several defect models using data collected from two large commercial projects. Traditional models typically use either program matrices (i.e. measurements from software products...
详细信息
Results are presented of an analysis of several defect models using data collected from two large commercial projects. Traditional models typically use either program matrices (i.e. measurements from software products) or testing time or combinations of these as independent variables. The limitations of such models have been well-documented. The models considered use the number of defects detected in the earlier phases of the development process as the independent variable. This number can be used to predict the number of defects to be detected later, even in modified software products. A strong correlation between the number of earlier defects and that of later ones was found. Using this relationship, a mathematical model was derived which may be used to estimate the number of defects remaining in software. This defect model may also be used to guide software developers in evaluating the effectiveness of the software development and testing processes.
In order to model and verify systems of concurrent processes (such as those involved in communication protocols), finite-state machines and Petri nets can be used as local and global models, respectively. The problem ...
详细信息
In order to model and verify systems of concurrent processes (such as those involved in communication protocols), finite-state machines and Petri nets can be used as local and global models, respectively. The problem of composing a set of communicating finite-state machines into a single global Petri net is considered in the letter with special attention to the case of more than two processes.
The difference of two posynomials (namely, polynomials with arbitrary real exponents, but positive coefficients and positive independent variables) is termed a signomial. Each signomial program (in which a signomiat i...
详细信息
The difference of two posynomials (namely, polynomials with arbitrary real exponents, but positive coefficients and positive independent variables) is termed a signomial. Each signomial program (in which a signomiat is to be either minimized or maximized subject to signomial constraints) is transformed into an equivalent posynomiat program in which a posynomial is to be minimized subject only to inequality posynomial constraints. The resulting class of posynomial programs is substantially larger than the class of (prototype) geometric programs (namely, posynomial programs in which a posynomial is to be minimized subject only to upper- bound inequality posynomial constraints). However, much of the (prototype) geometric programming theory is generalized by studying the equilibrium solutions to the reversed geometric programs in this larger class. Actually, some of this theory is new even when specialized to the class of prototype geometric programs. On the other hand, all of it can indirectly, but easily, be applied to the much larger class of well- posed algebraic programs (namely, programs involving real- valued functions that are generated solely" by addition, subtraction, multiplication, division, and the extraction of roots).
In shared-memory parallel programs that use explicit synchronization, race conditions result when accesses to shared memory are not properly synchronized. Race conditions are often considered to be manifestations of b...
详细信息
In shared-memory parallel programs that use explicit synchronization, race conditions result when accesses to shared memory are not properly synchronized. Race conditions are often considered to be manifestations of bugs, since their presence can cause the program to behave unexpectedly. Unfortunately, there has been little agreement in the literature as to precisely what constitutes a race condition. Two different notions have been implicitly considered: one pertaining to programs intended to be deterministic (which we call general races) and the other to nondeterministic programs containing critical sections (which we call data races). However, the differences between general races and data races have not yet been recognized. This paper examines these differences by characterizing races using a formal model and exploring their properties. We show that two variations of each type of race exist: feasible general races and data races capture the intuitive notions desired for debugging and apparent races capture less accurate notions implicitly assumed by most dynamic race detection methods. We also show that locating feasible races is an NP-hard problem, implying that only the apparent races, which are approximations to feasible races, can be detected in practice. The complexity of dynamically locating apparent races depends on the type of synchronization used by the program. Apparent races can be exhaustively located efficiently only for weak types of synchronization that are incapable of implementing mutual exclusion. This result has important implications since we argue that debugging general races requires exhaustive race detection and is inherently harder than debugging data races (which requires only partial race detection). Programs containing data races can therefore be efficiently debugged by locating certain easily identifiable races. In contrast, programs containing general races require more complex debugging techniques.
Basic principles of address programming, namely, addressness and program control are considered and analyzed. Their further development within the framework of composition and compositionnominative programming is demo...
详细信息
Basic principles of address programming, namely, addressness and program control are considered and analyzed. Their further development within the framework of composition and compositionnominative programming is demonstrated.
The introduction of a 'loop header' block facilitates the hoisting of loop-invariant code from a loop. In a λ-calculus intermediate representation, which has a notion of scope, this transformation is particul...
详细信息
The introduction of a 'loop header' block facilitates the hoisting of loop-invariant code from a loop. In a λ-calculus intermediate representation, which has a notion of scope, this transformation is particularly useful. Loop headers with scope also solve a problem with in-line expansion of recursive functions or loops: if done naively, only the first iteration is inlined. A loop header can encapsulate the loop or recursion for better in-line expansion. This optimization improves performance by about 5% in Standard ML of New Jersey.
We introduce a tensor sum which is useful for the design and analysis of digit-index permutations (DIPs) algorithms. Using this operation we obtain a new high-performance algorithm for the family of DIPs. We discuss a...
详细信息
We introduce a tensor sum which is useful for the design and analysis of digit-index permutations (DIPs) algorithms. Using this operation we obtain a new high-performance algorithm for the family of DIPs. We discuss an implementation in the applicative language Sisal and show how different choices of parameters yield different DIPs. The efficiency of the special case of digit reversal is illustrated with performance results on a Cray C-90.
We present a new approach to static program analysis that permits each expression in a program to be assigned an execution time estimate. Our approach uses a time system in conjunction with a conventional type system ...
详细信息
We present a new approach to static program analysis that permits each expression in a program to be assigned an execution time estimate. Our approach uses a time system in conjunction with a conventional type system to compute both the type and the time of an expression. The time of an expression is either an integer upper bound on the number of ticks the expression will execute, or the distinguished element long that indicates that the expression contains a loop, and thus may run for an arbitrary length of time. Every function type includes a latent time that is used to communicate its expected execution time from the point of its definition to the points of its use. Unlike previous approaches, a time system works in the presence of first-class functions and separate compilation. In addition, time polymorphism allows the time of a function to depend on the times of any functions that it takes as arguments. Time estimates are useful when compiling programs for multiprocessors in order to balance the overhead of initiating a concurrent computation against the expected execution time of the computation. The correctness of our time system is proven with respect to a dynamic semantics.
In the paper, an algorithm is presented for solving two-level programming problems. This algorithm combines direction finding problem with a regularization of the lower level problem. The upper level objective functio...
详细信息
In the paper, an algorithm is presented for solving two-level programming problems. This algorithm combines direction finding problem with a regularization of the lower level problem. The upper level objective function is included in the regularization to yield uniqueness of the follower's solution set. This is possible if the problem functions are convex and the upper level objective function has a positive definite Hessian. The computation of a direction of descent and of the step size is discussed in more detail. Afterwards the convergence proof is given. Last but not least some remarks and examples describing the difficulty of the inclusion of upper-level constraints also depending on the variables of the lower level are added.
暂无评论