The relationship between classes of tree-to-tree-series and o-tree-to-tree-series transformations, which are computed by restricted deterministic bottom-up weighted tree transducers, is investigated. Essentially, these transducers are deterministic bottom-up tree series transducers, except that the former are defined over monoids whereas the latter are defined over semirings and only use the multiplicative monoid thereof. In particular, the common restrictions of nondeletion, linearity, totality, and homomorphism can equivalently be defined for deterministic bottom-up weighted tree transducers. Using well-known results of classical tree transducer theory and also new results on deterministic weighted tree transducers, classes of tree-to-tree-series and o-tree-to-tree-series transformations computed by restricted deterministic bottomup weighted tree transducers are ordered by set inclusion. More precisely, for every commutative monoid and all sensible combinations of the above mentioned restrictions, the inclusion relation of the classes of tree-to-tree-series and o-tree-to-treeseries transformations is completely conveyed by means of Hasse diagrams.

Tree series transformations computed by bottom-up tree series transducers are called bottom-up tree series transformations. (Functional) compositions of such transformations are investigated. It turns out that bottom-up tree series transformations over commutative and ...-complete semirings are closed under left-composition with linear bottom-up tree series transformations and right-composition with boolean deterministic bottom-up tree series transformations.

Abstract. Retargeting a compiler’s back end to a new architecture is a time-consuming process. This becomes an evident problem in the area of programmable graphics hardware (graphics processing units, GPUs) or embedded processors, where architectural changes are faster than elsewhere. We propose the object-oriented rewrite system OORS to overcome this problem. Using the OORS language, a compiler developer can express the code generation and optimization phase in terms of costannotated rewrite rules supporting complex non-linear matching and replacing patterns. Retargetability is achieved by organizing rules into profiles, one for each supported target architecture. Featuring a rule and profile inheritance mechanism, OORS makes the reuse of existing specification possible. This is an improvement regarding traditional approaches. Altogether OORS increases the maintainability of the compiler’s back end and thus both decreases the complexity and reduces the effort of the retargeting process. To show the potential of this approach, we have implemented a code generation and a code optimization pattern matcher supporting different target architectures using the OORS language and introduced them in a GPU compiler. 1

A system called BURS that is based on term rewrite systems and a search algorithm A* are combined to produce a code generator that generates optimal code. The theory underlying BURS is re-developed, formalised and explained in this work. The search algorithm uses a cost heuristic that is derived from the term rewrite system to direct the search. The advantage of using a search algorithm is that we need to compute only those costs that may be part of an optimal rewrite sequence.

Abstract. We propose a construction that augments the precomputation step of a regular tree pattern matching algorithm to include cost analysis. The matching device generated is a pushdown automaton in contrast with the conventionallygenerated tree pattern matching automaton. Our technique can handle a larger class of cost augmented regular tree grammars than can be preprocessed byconventional methods, and has been tested on some input problem instances representing instruction sets for processors. 1

This survey reports results on the ambiguity of finite tree automata, the valuedness of bottom-up finite state tree transducers and boundedness of cost automata.

We sketch the conceptual ideas that are intended to become the basis for the Tree Automata Workbench MARBLES, an extensible system that will facilitate the experimentation with virtually any kind of algorithms on tree automata. Moreover, the system will come with a library and an application programmer’s interface that can be used by anyone wanting to apply such algorithms in research and development.

In this paper we investigate the relationship between classes of tree-to-tree-series (for short: t-ts) and o-tree-to-tree-series (for short: o-t-ts) transformations computed by restricted deterministic bottom-up weighted tree transducers (for short: deterministic bu-w-tt). Essentially, deterministic bu-w-tt are deterministic bottom-up tree series transducers [EFV02, FV03, ful, FGV04], but the former are de ned over monoids whereas the latter are de ned over semirings and only use the multiplicative monoid thereof. In particular, the common restrictions of non-deletion, linearity, totality, and homomorphism [Eng75] can equivalently be de ned for deterministic bu-w-tt. Using well-known results of classical tree transducer theory (cf., e.g., [Eng75, Fül91]) and also new results on deterministic bu-w-tt, we order classes of t-ts and o-t-ts transformations computed by restricted deterministic bu-w-tt by set inclusion. More precisely, for every commutative monoid we completely specify the inclusion relation of the classes of t-ts and o-t-ts transformations for all sensible combinations of restrictions by means of inclusion diagrams.

We propose a new technique for constructing code-generator generators, which combines the advantages of the Graham-Glanville parsing technique and the bottom-up tree parsing approach. Machine descriptions are similar to Yacc specifications. The construction effectively generates a pushdown automaton as the matching device. This device is able to handle ambiguous grammars, and can be used to generate locally optimal code without the use of heuristics. Cost computations are performed at preprocessing time. The class of regular tree grammars augmented with costs that can be handled by our system properly includes those that can be handled by bottom-up systems based on finite-state tree parsing automata. Parsing time is linear in the size of the subject tree. We have tested the system on specifications for some systems and report table sizes.

Abstract not found