Russell W. Quong

ANTLR: a predicated- LL(k) parser generator

Despite the parsing power of LR/LALR algorithms, e.g. YACC, programmers often choose to write recursive‐descent parsers by hand to obtain increased flexibility, better error handling, and ease of debugging. We introduce ANTLR, a public‐domain parser generator that combines the flexibility of hand‐coded parsing with the convenience of a parser generator, which is a component of PCCTS. ANTLR has many features that make it easier to use than other language tools. Most important, ANTLR provides predicates which let the programmer systematically direct the parse via arbitrary expressions using semantic and syntactic context; in practice, the use of predicates eliminates the need to hand‐tweak the ANTLR output, even for difficult parsing problems. ANTLR also integrates the description of lexical and syntactic analysis, accepts LL(k) grammars for k > 1 with extended BNF notation, and can automatically generate abstract syntax trees.

Adding Semantic and Syntactic Predicates To LL(k): pred-LL(k)

Most language translation problems can be solved with existing LALR(1) or LL(k) language tools; e.g., YACC [Joh78] or ANTLR [PDC92]. However, there are language constructs that defy almost all parsing strategy commonly in use. Some of these constructs cannot be parsed without semantics, such as symbol table information, and some cannot be properly recognized without first examining the entire construct, that is we need “infinite lookahead.”

Expected I-cache miss rates via the gap model

To evaluate the performance of a memory system, computer architects must determine the miss rate m of a cache C when running program P. Typically, the measured miss rate depends on the specific address mapping M of P set arbitrarily by the compiler and linker. In this paper, we remove the effect of the address-mapping on the miss rate by analyzing a symbolic trace T of basic blocks. By assuming each basic block has an equal probability of ending up anywhere in the address map, we determine the expected miss rate averaged over all possible address mappings.Our resulting gap model gives the expected miss rate for instruction caches of varying cache size, line size, and set associativity. Our model is simple but robust, and turns out to be the familiar LRU stack model with a statistical viewpoint. Our model allows a trace of arbitrary length to be compactly summarized in a few thousand bytes of information. Our model also predicts how an intervening trace, such as an operating system call or a task switch, will affect the miss rate. Comparisons to measured miss rates from SPEC 92 instruction traces show that our model typically has relative differences of less than 20% for a variety of cache parameters.

The feasibility of using compression to increase memory system performance

We investigate the feasibility of using instruction compression at some level in a multi-level memory hierarchy to increase memory system performance. Compression effectively increases the memory size and the line size reducing the miss rate at the expense of increased access latency due to decompression delays. We analytically evaluate the impact of compression on the average memory access time for various memory systems and compression approaches. Our results show the benefit of using compression is sensitive to the miss rates and miss penalties at the point of compression and to a lesser extent the amount of compression possible. For high performance workstations of today, compression already shows promise; as miss penalties increase in future, compression will only become more feasible.<<ETX>>

LL and LR translators need k >1 lookahead

Language translation is a harder and more important problem than language recognition. In particular, programmers implement translators not recognizers. Yet too often, translation is equated with the simpler task of syntactic parsing. This misconception coupled with computing limitations of past computers has led to the almost exclusive use of LR(1) and LL(1) in parser generators. We claim that use of k &lt; 1 lookahead can and should be available in practice, as it simplifies the translator development. We give several examples justifying our arguments.

A tight lower bound for optimal bin packing

In this paper, we present an O(n log n) algorithm to compute a tight lower bound for the one-dimensional bin packing problem. We have simulated the algorithm on randomly generated bin packing problems with item sizes drawn uniformly from (a, b), where 0 = = B, the error is less than 0.003%.

A macroscopic profile of program compilation and linking

To profile the changes made to programs during development and maintenance, the authors have instrumented the make utility that is used to compile and link programs. With minor modifications, they have used make to find out how much time programmers spend waiting for compiling and linking, how many modules are compiled each time a program is linked, and the change in size of the compiled modules. Measurements show that most programs are relinked after only one or two modules are recompiled, and that over 90% of all recompilations yield object code that is less than 100 bytes larger in size. The authors are using these results to guide the design of an incremental programming environment, particularly with respect to an incremental linker. >

Fast average-case pattern matching by multiplexing sparse tables

Pattern matching consists of finding occurrences of a pattern in some data. One general approach is to sample the data collecting evidence about possible matches. By sampling appropriately, we force matches to be sparse and can encode a table of size m as a series of smaller tables with total size Θ((ln m)2ln ln m). This method yields practical algorithms with fast average-case running times for a wide variety of pattern matching and pattern recognition problems. n nWe apply our technique of multiplexing sparse tables to the k-mismatches string searching problem which asks for all occurrences of a pattern string P = p0, p1, …,pm-1, in a text string T = t0, t1, …,n-1, with ⩽k mismatches (substitutions) where P, T and k are given. Assuming a uniform character distribution over an alphabet of size A, for k⩽m/(2 logAm), our algorithm has an average-case running time of Θ(kn(log m)2(m log log m)) and uses Θ(m(log m)2(log log m))space.