Constant (computer programming)

Abstract: Explicit data graph execution (EDGE) architectures offer the possibility of high instruction-level parallelism with energy efficiency. In EDGE architectures, the compiler breaks a program into a sequence of structured blocks that the hardware executes atomically. The instructions within each block communicate directly, instead of communicating through shared registers. The TRIPS EDGE architecture imposes restrictions on its blocks to simplify the microarchitecture: each TRIPS block has at most 128 instructions, issues at most 32 loads and/or stores, and executes at most 32 register bank reads and 32 writes. To detect block completion, each TRIPS block must produce a constant number of outputs (stores and register writes) and a branch decision. The goal of the TRIPS compiler is to produce TRIPS blocks full of useful instructions while enforcing these constraints. This paper describes a set of compiler algorithms that meet these sometimes conflicting goals, including an algorithm that assigns load and store identifiers to maximize the number of loads and stores within a block. We demonstrate the correctness of these algorithms in simulation on SPEC2000, EEMBC, and microbenchmarks extracted from SPEC2000 and others. We measure speedup in cycles over an Alpha 21264 on microbenchmarks.

Abstract: A lambda calculus schema is an expression of the lambda calculus augmented by uninterpreted constant and function symbols and thus is an abstraction of programming languages such as LISP which permit functions to be passed to or returned from other functions. We then consider two natural implementation strategies: the retention strategy in which all variable bindings are retained until no longer needed (implying the use of some sort of garbage collected store) and the deletion strategy, modelled after the usual stack implementation of ALGOL-60, in which variable bindings are destroyed when control leaves the procedure (or block) in which they were created. Berry shows that the deletion strategy implementation is not “correct” for a wide class of languages in the sense that it is not equivalent to natural extensions of the copy rule of ALGOL to such languages, whereas the retention strategy is correct in that sense. We show, however, that no real power is lost in restricting oneself to a deletion strategy implementation, for any program can be translated into an equivalent one which will work correctly under such an implementation. The proof makes no use of the particular primitive functions and data of the language and hence is true of the corresponding schemata under all interpretations.