Telescoping Languages: A Strategy for Automatic Generation of Scientific Problem-Solving Systems from Annotated Libraries

Abstract

As machines and programs have become more complex, the process of programming applications that can exploit the power of high-performance systems has become more difficult and correspondingly more labor-intensive. This has substantially widened the software gap the discrepancy between the need for new software and the aggregate capacity of the workforce to produce it. This problem has been compounded by the slow growth of programming productivity, especially for high-performance programs, over the past two decades. One way to bridge this gap is to make it possible for end users to develop programs in high-level domain-specific programming systems. In the past, a major impediment to the acceptance of such systems has been the poor performance of the resulting applications. To address this problem, we are developing a new compiler-based infrastructure, called TeleGen, that will make it practical to construct efficient domain-specific high-level languages from annotated component libraries. We call these languages telescoping languages, because they can be nested within one another. For programs written in telescoping languages, high performance and reasonable compilation times can be achieved by exhaustively analyzing the component libraries in advance to produce a language processor that recognizes and optimizes library operations as primitives in the language. The key to making this strategy practical is to keep compile times low by generating a custom compiler with extensive built-in knowledge of the underlying libraries. The goal is to achieve compile times that are linearly proportional to the size of the program presented by the user, rather than to the aggregate size of that program plus the base libraries.2001 Elsevier Science

Multi-stage Programming with Functors and Monads: Eliminating Abstraction Overhead from Generic Code

“…This simple technique clearly shows how we can abstract over domain operations and yet still 5 =⇒ under an expression shows the result of its evaluation generate efficient domain-specific code, thus achieving a proper separation of concerns. Let us consider a more complex expression:…”

“…Eliminating this abstraction overhead involves either complex analyses or domain-specific knowledge (or both!) [5][6][7], and so we can not rely on a general purpose compiler to assuredly perform such optimizations. A more appealing approach is generative programming [8][9][10][11][12][13][14].…”

“…This approach gives a stronger equational theory [22], and avoids the danger of creating unsoundness [21]. Furthermore, intensional code analysis essentially requires one to insert both an optimizing compiler and an automated theorem proving system into the code generating system [23,5,24,6]. While this is potentially extremely powerful and an exciting area of research, it is also extremely complex, which means that it is currently more error-prone and difficult to ascertain the correctness of the resulting code.…”

Sequoia: Programming the Memory Hierarchy

“…Compiler technology that relies on exposing library semantics [Guyer and Lin 1999;Kennedy et al 2001] can be used to further enhance performance by optimizing across tuned library calls. Task parameterization via Sequoia tunables and task variants generalizes meta-compilation, as it implicitly defines a parameter space for every Sequoia application.…”

Towards Automatic Synthesis of High-Performance Codes for Electronic Structure Calculations: Data Locality Optimization

“…Several factors such as the lack of a need to perform space-time trade-offs renders the task faced by efforts such as SPIRAL and FFTW [5] less complex than what computational chemists face. Other efforts in automatically generating efficient implementations of programs include the telescoping languages project [10], the ATLAS [32] project for deriving efficient implementation of BLAS routines, and the PHIPAC [3] and TUNE [31] projects.…”