Results 1 
6 of
6
Costa: Design and implementation of a cost and termination analyzer for java bytecode
 OF LECTURE NOTES IN COMPUTER SCIENCE
, 2007
"... ... interpretation based cost and termination analyzer for Java bytecode. The system receives as input a bytecode program, (a choice of) a resource of interest and tries to obtain an upper bound of the resource consumption of the program. costa provides several nontrivial notions of cost, as the co ..."
Abstract

Cited by 35 (15 self)
 Add to MetaCart
(Show Context)
... interpretation based cost and termination analyzer for Java bytecode. The system receives as input a bytecode program, (a choice of) a resource of interest and tries to obtain an upper bound of the resource consumption of the program. costa provides several nontrivial notions of cost, as the consumption of the heap, the number of bytecode instructions executed and the number of calls to a specific method. Additionally, costa tries to prove termination of the bytecode program which implies the boundedness of any resource consumption. Having cost and termination together is interesting, as both analyses share most of the machinery to, respectively, infer cost upper bounds and to prove that the execution length is always finite (i.e., the program terminates). We report on experimental results which show that costa can deal with programs of realistic size and complexity, including programs which use Java libraries. To the best of our knowledge, this system provides for the first time evidence that resource usage analysis can be applied to a realistic objectoriented, bytecode programming language.
SizeChange Termination, Monotonicity Constraints and Ranking Functions
"... Abstract. Sizechange termination involves deducing program termination based on the impossibility of infinite descent. To this end we may use a program abstraction in which transitions are described by monotonicity constraints over (abstract) variables. When only constraints of the form x> y ′ a ..."
Abstract

Cited by 22 (4 self)
 Add to MetaCart
(Show Context)
Abstract. Sizechange termination involves deducing program termination based on the impossibility of infinite descent. To this end we may use a program abstraction in which transitions are described by monotonicity constraints over (abstract) variables. When only constraints of the form x> y ′ and x ≥ y ′ are allowed, we have sizechange graphs, for which both theory and practice are now more evolved then for general monotonicity constraints. This work shows that it is possible to transfer some theory from the domain of sizechange graphs to the general case, complementing and extending previous work on monotonicity constraints. Significantly, we provide a procedure to construct explicit global ranking functions from monotonicity constraints in singlyexponential time, which is better than what has been published so far even for sizechange graphs. We also consider the integer domain, where general monotonicity constraints are essential because the domain is not wellfounded. 1
Dealing with numeric fields in termination analysis of javalike languages
 In FTfJP
, 2008
"... Abstract. Termination analysis tools strive to find proofs of termination for as wide a class of (terminating) programs as possible. Though several tools exist which are able to prove termination of nontrivial programs, when one tries to apply them to realistic programs, there are still a number of ..."
Abstract

Cited by 5 (3 self)
 Add to MetaCart
(Show Context)
Abstract. Termination analysis tools strive to find proofs of termination for as wide a class of (terminating) programs as possible. Though several tools exist which are able to prove termination of nontrivial programs, when one tries to apply them to realistic programs, there are still a number of open problems. In the case of Javalike languages, one of such problems is to find a practical solution to prove termination when the termination behaviour of loops is affected by numeric fields. We have performed statistics on the Java libraries to see how often this happens in practice and we found that in 12.95 % of cases, the number of iterations of loops (and therefore termination) explicitly depends on values stored in fields and, in the vast majority of cases, such fields are numeric. Inspired by the examples found in the libraries, this paper identifies a series of difficulties that need to be solved in order to deal with numeric fields in termination and propose some ideas towards a lightweight analysis which is able to prove termination of sequential Javalike programs
Analyzing the Implicit Computational Complexity of objectoriented programs
 in "Annual Conference on Foundations of Software Technology and Theoretical Computer Science  FSTTCS CARTE 15 2008, Inde
"... ABSTRACT. A supinterpretation is a tool which provides upper bounds on the size of the values computed by the function symbols of a program. Supinterpretations have shown their interest to deal with the complexity of first order functional programs. This paper is an attempt to adapt the framework ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
(Show Context)
ABSTRACT. A supinterpretation is a tool which provides upper bounds on the size of the values computed by the function symbols of a program. Supinterpretations have shown their interest to deal with the complexity of first order functional programs. This paper is an attempt to adapt the framework of supinterpretations to a fragment of objectoriented programs, including loop and while constructs and methods with side effects. We give a criterion, called brotherly criterion, which uses the notion of supinterpretation to ensure that each brotherly program computes objects whose size is polynomially bounded by the inputs sizes. Moreover we give some heuristics in order to compute the supinterpretation of a given method. 1
Using CLP Simplifications to Improve Java Bytecode Termination Analysis
"... In an earlier work, a termination analyzer for Java bytecode was developed that translates a Java bytecode program into a constraint logic program and then proves the termination of the latter. An efficiency bottleneck of the termination analyzer is the construction of a proof of termination for the ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
In an earlier work, a termination analyzer for Java bytecode was developed that translates a Java bytecode program into a constraint logic program and then proves the termination of the latter. An efficiency bottleneck of the termination analyzer is the construction of a proof of termination for the generated constraint logic program, which is often very large in size. In this paper, a set of program simplifications are presented that reduce the size of the constraint logic program without changing its termination behavior. These simplifications remove program clauses and/or predicate arguments that do not affect the termination behavior of the constraint logic program. Their effect is to reduce significantly the time needed to build the termination proof for the constraint logic program, as our experiments show. Keywords: Java, Java bytecode, static analysis, termination
Analyzing theImplicit Computational Complexityofobjectorientedprograms
"... ABSTRACT. A supinterpretation is a tool which provides upper bounds on the size of the values computed by the function symbols of a program. Supinterpretations have shown their interest to deal with the complexity of first order functional programs. This paper is an attempt to adapt the framework ..."
Abstract
 Add to MetaCart
(Show Context)
ABSTRACT. A supinterpretation is a tool which provides upper bounds on the size of the values computed by the function symbols of a program. Supinterpretations have shown their interest to deal with the complexity of first order functional programs. This paper is an attempt to adapt the framework of supinterpretations to a fragment of objectoriented programs, including loop and whileconstructsandmethodswithsideeffects. Wegiveacriterion,calledbrotherlycriterion,which usesthenotionofsupinterpretationtoensurethateachbrotherlyprogramcomputesobjectswhose size is polynomially bounded by the inputs sizes. Moreover we give some heuristics in order to compute thesupinterpretation ofagiven method. 1