Live Heap Space Bounds for Real-Time Systems

Theoretical Computer Science

Puebla

et al. 2015

The aim of incremental analysis is, given a program, its analysis results, and a series of changes to the program, to obtain the new analysis results as efficiently as possible and, ideally, without having to (re-)analyze fragments of code which are not affected by the changes. Incremental analysis can significantly reduce both the time and the memory requirements of analysis. The first contribution of this article is a multi-domain incremental fixed-point algorithm for a sequential Java-like language. The algorithm is multi-domain in the sense that it interleaves the (re-)analysis for multiple domains by taking into account dependencies among them. Importantly, this allows the incremental analyzer to invalidate only those analysis results previously inferred by certain dependent domains. The second contribution is an incremental resource usage analysis which, in its first phase, uses the multi-domain incremental fixed-point algorithm to carry out all global pre-analyses required to infer cost in an interleaved way. Such resource analysis is parametric on the cost metrics one wants to measure (e.g., number of executed instructions, number of objects created, etc.). Besides, we present a novel form of cost summaries which allows us to incrementally reconstruct only those components of cost functions affected by the changes. Experimental results in the costa system show that the proposed incremental analysis provides significant performance gains, ranging from a speedup of 1.48 up to 5.13 times faster than non-incremental analysis.

Section: Organizationmentioning

confidence: 99%

Section: Global Analysis Of Oo Languagesmentioning

confidence: 99%

Section: The Rule-based Languagementioning

confidence: 99%

See 1 more Smart Citation

A multi-domain incremental analysis engine and its application to incremental resource analysis

Theoretical Computer Science

Puebla

et al. 2015

“…To formalize the analysis algorithms, we consider a rule-based intermediate representation of a today's programming language (e.g., Java, Java bytecode [3], X10 [4], Timber [15] can be compiled into this language. We then present a global analysis engine for such rule-based representation (RBR) which is parametric w.r.t.…”

Section: Global Analysis Of Oo Languagesmentioning

confidence: 99%

“…As customary a single static assignment transformation is applied on the rules variables. The process is identical as [3,4,15], hence, we will not go into the technical details of the transformation but just show the intuition by means of an example. EXAMPLE 2.1 (RBR).…”

Section: The Rule-based Languagementioning

confidence: 99%

Incremental resource usage analysis

Proceedings of the ACM SIGPLAN 2012 Workshop on Partial Evaluation and Program Manipulation

Puebla

et al. 2012

The aim of incremental global analysis is, given a program, its analysis results and a series of changes to the program, to obtain the new analysis results as efficiently as possible and, ideally, without having to (re-)analyze fragments of code which are not affected by the changes. Incremental analysis can significantly reduce both the time and the memory requirements of analysis. This paper presents an incremental resource usage analysis for a sequential Java-like language. Our main contributions are (1) a multi-domain incremental fixed-point algorithm which can be used by all global preanalyses required to infer the cost (including class, sharing, cyclicity, constancy, and size analyses), and which takes care of propagating dependencies among such domains, and (2) a novel form of cost summaries which allows us to incrementally reconstruct only those components of cost functions affected by the change. Experimental results in the COSTA system show that the proposed incremental analysis performs very efficiently in practice.

Object‐sensitive cost analysis for concurrent objects

Arenas

Software Testing Verif & Rel

et al. 2015

This article presents a novel cost analysis framework for concurrent objects. Concurrent objects form a wellestablished model for distributed concurrent systems. In this model, objects are the concurrency units that communicate among them via asynchronous method calls. Cost analysis aims at automatically approximating the resource consumption of executing a program in terms of its input parameters. While cost analysis for sequential programming languages has received considerable attention, concurrency and distribution have been notably less studied. The main challenges of cost analysis in a concurrent setting are as follows. First, inferring precise size abstractions for data in the program in the presence of shared memory. This information is essential for bounding the number of iterations of loops. Second, distribution suggests that analysis must infer the cost of the diverse distributed components separately. We handle this by means of a novel form of object-sensitive recurrence equations that use cost centres in order to keep the resource usage assigned to the different components separate. We have implemented our analysis and evaluated it on several small applications that are classical examples of concurrent and distributed programming. consider different types of resources of interest. For instance, we can measure traditional cost measures like number of executed instructions or memory consumption. In the former case, we will infer that 3 C elems .7 C hdRead inst C update inst / instructions will be executed. In the expression, elems corresponds to the maximum number of iterations of the loop; at each iteration, seven instructions are executed (the loop condition, the two increments, two method invocations, the get and the await), and the number of instructions of executing methods hdRead and update, denoted hdRead inst and update inst respectively, are added as well. For simplicity, we ignore here the values of the parameters. Besides, three instructions are executed outside the loop. The analysis will need to infer also the cost of the methods hdRead and update and plug them in the aforementioned expression. With regard to memory consumption, a new memory is not created in the loop; hence, we would output an expression of the form elems .hdRead heap C update heap / that relies on the memory created by the invoked methods (denoted hdRead heap and update heap ). Interestingly, we can also consider concurrency-related measures like the number of tasks spawned. In the aforementioned method, we spawn one task directly (but the method invocations might also spawn new tasks transitively). Therefore, we will compute an expression of the form elems .1ChdRead tasks Cupdate tasks / that relies on the number of tasks spawned by the calls to hdRead and update. Observe that the types of resources we have considered are platform independent (unlike WCET or energy consumption), that is, they can be inferred by inspecting the program, and the hardware on which the program will be executed can be ignored. Platform depend...