Functional Incremental Attribute Evaluation

Saraiva, João; Swierstra, S. Doaitse; Kuiper, M.F.

doi:10.1007/3-540-46423-9_19

Cited by 23 publications

(18 citation statements)

References 7 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…However, with the implementation that we propose the inherited attributes of previous visits are not in scope and need to be explicitly passed to the visit in which the inherited attribute is used. For the standard non-incremental evaluation the visit-tree approach (Saraiva et al 2000) is used by the UUAGC. There it is statically computed which attributes from the first visit are used in subsequent visits, and these are passed as extra arguments to the second visit.…”

Section: Intra-visit Attributesmentioning

confidence: 99%

See 1 more Smart Citation

Incremental evaluation of higher-order attributes

Bransen

Dijkstra

Swierstra

2017

Science of Computer Programming

View full text Add to dashboard Cite

Compilers, amongst other programs, often work with data that (slowly) changes over time. When the changes between subsequent runs of the compiler are small, one would hope the compiler to incrementally update its results, resulting in much lower running times. However, the manual construction of an incremental compiler is very hard and error prone and therefore usually not an option.Attribute grammars provide an attractive way of constructing compilers, as they are compositional in nature and allow for aspect oriented programming. In this work we extend previous work on the automatic generation of incremental attribute grammar evaluators, with the purpose of (semi-)automatically generating an incremental compiler from the regular attribute grammar definition, by adding support for incremental evaluation of higher order attributes, a well known extension to the classical attribute grammars that is used in many ways in compiler construction, for example to model different compiler phases.

show abstract

Section: Intra-visit Attributesmentioning

confidence: 99%

“…Another technique for the incremental evaluation of higher order attribute grammars is to use function caching or memoization (Vogt et al 1991;Saraiva et al 2000). Because the subtree and inherited attributes together are used as key for the memoization table, this technique also works for higher order attributes.…”

Section: Function Cachingmentioning

confidence: 99%

Incremental evaluation of higher-order attributes

Bransen

Dijkstra

Swierstra

2017

Science of Computer Programming

View full text Add to dashboard Cite

show abstract

“…Another approach is taken by Vogt et al (1991) where the attribute values are not stored in the AST itself, but are computed in visit functions for which function caching is used to store previously computed results. This approach is improved upon in (Saraiva et al 2000).…”

Section: Attribute Grammarsmentioning

confidence: 99%

Lazy stateless incremental evaluation machinery for attribute grammars

Bransen

Dijkstra

Swierstra

2014

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

View full text Add to dashboard Cite

Many computer programs work with data that changes over time.Computations done over such data usually are repeated completely after a change in the data. For complex computations such repetitive recomputation can become too inefficient. When these recomputations take place on data which has only changed slightly, it often is possible to reformulate the computation to an incremental version which reuses the result of the computation on previous data. Such a situation typically occurs in compilers and editors for structured data (like a program) where program analyses and transformations (for example error checking) are done while editing.Although rewriting to incremental versions thus offers a solution to this problem, a manual rewrite of an already complex computation to its incremental counterpart is tedious, error prone, and inhibits further development of the original computation. We therefore intend to generate such incremental counterparts (semi)automatically by focusing on computations expressed using Attribute Grammars (AGs).In this paper we do groundwork for this goal and develop machinery for incremental attribute grammar evaluation based on change propagation and pure functions. We use pretty printing with free variable annotation to explain our techniques. Furthermore, our techniques also expose rules of conduct for a programmer desiring incrementality: the automatic translation of code to an incremental version does not always directly result in efficiency improvements because code often is written in a style unsuitable for automatic incrementalization. We show some common cases in which (small) code changes facilitating incrementality are required. We evaluate the effectiveness of the overall approach using a simple benchmark for the example, and a more extensive benchmark based on constraint-based type inference implemented with AGs.

show abstract

“…To prevent unbounded growth of the function cache Lac uses several function cache update algorithms [SKS96].…”

Section: T H E F U N C T I O N C a C H Ementioning

confidence: 99%