Efficient incremental evaluation of higher order attribute grammars

Vogt, Harald; Swierstra, S. Doaitse; Kuiper, M.F.

doi:10.1007/3-540-54444-5_102

Cited by 12 publications

(8 citation statements)

References 7 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…This can be regarded as similar to the lazy model presented in this work. In [26], visit functions are used instead of visit sequences in order to achieve efficient incrementality. More recently and for a specific kind of attribute grammars, in [27], the authors present an approach for incremental evaluation based, as in the present work, on cache invalidation.…”

Section: Outside Model-driven Software Engineeringmentioning

confidence: 99%

Reactive model transformation with ATL

Martnez

Tisi

Douence³

2017

Science of Computer Programming

View full text Add to dashboard Cite

Model-driven applications may maintain large networks of structured data models and transformations among them. The development of such applications is complicated by the need to reflect on the whole network any runtime update performed on models or transformation logic. If not carefully designed, the execution of such updates may be computationally expensive. In this paper we propose a reactive paradigm for programming model transformations, and we implement a reactive model-transformation engine. We argue that this paradigm facilitates the development of autonomous model-driven systems that react to update and request events from the host application by identifying and performing only the needed computation. We implement such approach by providing a reactive engine for the ATL transformation language. We evaluate the usage scenarios that this paradigm supports and we experimentally measure its ability to reduce computation time in transformation-based applications.

show abstract

Section: Outside Model-driven Software Engineeringmentioning

confidence: 99%

Reactive model transformation with ATL

Martnez

Tisi

Douence³

2017

Science of Computer Programming

View full text Add to dashboard Cite

show abstract

“…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

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

“…One approach, which is also used in the Synthesizer Generator, is to store the attribute values in the AST and update them using a tree-walk evaluator after a change in the AST (Demers et al 1981;Yeh and Kastens 1988). 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

Efficient incremental evaluation of higher order attribute grammars

Cited by 12 publications

References 7 publications

Reactive model transformation with ATL

Reactive model transformation with ATL

Incremental evaluation of higher-order attributes

Lazy stateless incremental evaluation machinery for attribute grammars

Contact Info

Product

Resources

About