Translation Look aside Buffers (TLBs) are critical to system performance, particularly as applications demand larger working sets and with the adoption of virtualization. Architectural support for super pages has previously been proposed to improve TLB performance. By allocating contiguous physical pages to contiguous virtual pages, the operating system (OS) constructs super pages which need just one TLB entry rather than the hundreds required for the constituent base pages. While this greatly reduces TLB misses, these gains are often offset by the implementation difficulties of generating and managing ample contiguity for super pages. We show, however, that basic OS memory allocation mechanisms such as buddy allocators and memory compaction naturally assign contiguous physical pages to contiguous virtual pages. Our real-system experiments show that while usually insufficient for super pages, these intermediate levels of contiguity exist under various system conditions and even under high load. In response, we propose Coalesced Large-Reach TLBs (CoLT), which leverage this intermediate contiguity to coalesce multiple virtual-to-physical page translations into single TLB entries. We show that CoLT implementations eliminate 40\% to 58\% of TLB misses on average, improving performance by 14\%. Overall, we demonstrate that the OS naturally generates page allocation contiguity. CoLT exploits this contiguity to eliminate TLB misses for next-generation, big-data applications with low-overhead implementations.

An object-oriented formal specification workbench is proposed for defining the syntax and semantics of programming languages, using which the formal properties of different languages can be elaborated and analyzed. Our specification approach is an object-oriented representation, structured around a denotational semantics methodology which abstracts out various common details so that formal syntax and semantics can be defined elegantly. Specific details can be inherited and specialized in defining the semantics of various programming languages, and the reusability and modifiability of many programming language features can be manifested across language paradigms. Furthermore, prototype implementations for these languages may be automatically developed from the formal specifications, providing a mechanism for compiler/interpreter reuse at the specification level.