7,069 research outputs found
Compile-Time Optimisation of Store Usage in Lazy Functional Programs
Functional languages offer a number of advantages over their imperative counterparts. However,
a substantial amount of the time spent on processing functional programs is due to
the large amount of storage management which must be performed. Two apparent reasons
for this are that the programmer is prevented from including explicit storage management
operations in programs which have a purely functional semantics, and that more readable
programs are often far from optimal in their use of storage. Correspondingly, two alternative
approaches to the optimisation of store usage at compile-time are presented in this thesis.
The first approach is called compile-time garbage collection. This approach involves determining
at compile-time which cells are no longer required for the evaluation of a program,
and making these cells available for further use. This overcomes the problem of a programmer
not being able to indicate explicitly that a store cell can be made available for further use.
Three different methods for performing compile-time garbage collection are presented in this
thesis; compile-time garbage marking, explicit deallocation and destructive allocation. Of
these three methods, it is found that destructive allocation is the only method which is of
practical use.
The second approach to the optimisation of store usage is called compile-time garbage
avoidance. This approach involves transforming programs into semantically equivalent programs
which produce less garbage at compile-time. This attempts to overcome the problem
of more readable programs being far from optimal in their use of storage. In this thesis, it is
shown how to guarantee that the process of compile-time garbage avoidance will terminate.
Both of the described approaches to the optimisation of store usage make use of the
information obtained by usage counting analysis. This involves counting the number of times
each value in a program is used. In this thesis, a reference semantics is defined against which
the correctness of usage counting analyses can be proved. A usage counting analysis is then
defined and proved to be correct with respect to this reference semantics. The information
obtained by this analysis is used to annotate programs for compile-time garbage collection,
and to guide the transformation when compile-time garbage avoidance is performed.
It is found that compile-time garbage avoidance produces greater increases in efficiency
than compile-time garbage collection, but much of the garbage which can be collected by
compile-time garbage collection cannot be avoided at compile-time. The two approaches are
therefore complementary, and the expressions resulting from compile-time garbage avoidance
transformations can be annotated for compile-time garbage collection to further optimise the
use of storage
The C Object System: Using C as a High-Level Object-Oriented Language
The C Object System (Cos) is a small C library which implements high-level
concepts available in Clos, Objc and other object-oriented programming
languages: uniform object model (class, meta-class and property-metaclass),
generic functions, multi-methods, delegation, properties, exceptions, contracts
and closures. Cos relies on the programmable capabilities of the C programming
language to extend its syntax and to implement the aforementioned concepts as
first-class objects. Cos aims at satisfying several general principles like
simplicity, extensibility, reusability, efficiency and portability which are
rarely met in a single programming language. Its design is tuned to provide
efficient and portable implementation of message multi-dispatch and message
multi-forwarding which are the heart of code extensibility and reusability.
With COS features in hand, software should become as flexible and extensible as
with scripting languages and as efficient and portable as expected with C
programming. Likewise, Cos concepts should significantly simplify adaptive and
aspect-oriented programming as well as distributed and service-oriented
computingComment: 18
Optimizing Abstract Abstract Machines
The technique of abstracting abstract machines (AAM) provides a systematic
approach for deriving computable approximations of evaluators that are easily
proved sound. This article contributes a complementary step-by-step process for
subsequently going from a naive analyzer derived under the AAM approach, to an
efficient and correct implementation. The end result of the process is a two to
three order-of-magnitude improvement over the systematically derived analyzer,
making it competitive with hand-optimized implementations that compute
fundamentally less precise results.Comment: Proceedings of the International Conference on Functional Programming
2013 (ICFP 2013). Boston, Massachusetts. September, 201
Modular, higher order cardinality analysis in theory and practice
Since the mid '80s, compiler writers for functional languages (especially lazy ones) have been writing papers about identifying and exploiting thunks and lambdas that are used only once. However, it has proved difficult to achieve both power and simplicity in practice. In this paper, we describe a new, modular analysis for a higher order language, which is both simple and effective. We prove the analysis sound with respect to a standard call-by-need semantics, and present measurements of its use in a full-scale, state-of-the-art optimising compiler. The analysis finds many single-entry thunks and one-shot lambdas and enables a number of program optimisations. This paper extends our preceding conference publication (Sergey et al. 2014 Proceedings of the 41st Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL 2014). ACM, pp. 335–348) with proofs, expanded report on evaluation and a detailed examination of the factors causing the loss of precision in the analysis
Type-based cost analysis for lazy functional languages
We present a static analysis for determining the execution costs of lazily evaluated functional languages, such as Haskell. Time- and space-behaviour of lazy functional languages can be hard to predict, creating a significant barrier to their broader acceptance. This paper applies a type-based analysis employing amortisation and cost effects to statically determine upper bounds on evaluation costs. While amortisation performs well with finite recursive data, we significantly improve the precision of our analysis for co-recursive programs (i.e. dealing with potentially infinite data structures) by tracking self-references. Combining these two approaches gives a fully automatic static analysis for both recursive and co-recursive definitions. The analysis is formally proven correct against an operational semantic that features an exchangeable parametric cost-model. An arbitrary measure can be assigned to all syntactic constructs, allowing to bound, for example, evaluation steps, applications, allocations, etc. Moreover, automatic inference only relies on first-order unification and standard linear programming solving. Our publicly available implementation demonstrates the practicability of our technique on editable non-trivial examples.PostprintPeer reviewe
Summary-based inference of quantitative bounds of live heap objects
This article presents a symbolic static analysis for computing parametric upper bounds of the number of simultaneously live objects of sequential Java-like programs. Inferring the peak amount of irreclaimable objects is the cornerstone for analyzing potential heap-memory consumption of stand-alone applications or libraries. The analysis builds method-level summaries quantifying the peak number of live objects and the number of escaping objects. Summaries are built by resorting to summaries of their callees. The usability, scalability and precision of the technique is validated by successfully predicting the object heap usage of a medium-size, real-life application which is significantly larger than other previously reported case-studies.Fil: Braberman, Victor Adrian. Universidad de Buenos Aires. Facultad de Ciencias Exactas y Naturales. Departamento de Computación; Argentina. Consejo Nacional de Investigaciones Científicas y Técnicas; ArgentinaFil: Garbervetsky, Diego David. Universidad de Buenos Aires. Facultad de Ciencias Exactas y Naturales. Departamento de Computación; Argentina. Consejo Nacional de Investigaciones Científicas y Técnicas; ArgentinaFil: Hym, Samuel. Universite Lille 3; FranciaFil: Yovine, Sergio Fabian. Universidad de Buenos Aires. Facultad de Ciencias Exactas y Naturales. Departamento de Computación; Argentina. Consejo Nacional de Investigaciones Científicas y Técnicas; Argentin
- …