2000ACM SIGPLAN NoticesOpen access

Caching function calls using precise dependencies

Allan Heydon, Roy Levin, Yu Yuan

Open full text 12 citations

Abstract

This paper describes the implementation of a purely functional programming language for building software systems. In this language, external tools like compilers and linkers are invoked by function calls. Because some function calls are extremely expensive, it is obviously important to reuse the results of previous function calls whenever possible. Caching a function call requires the language interpreter to record all values on which the function call depends. For optimal caching, it is important to record precise dependencies that are both dynamic and fine-grained . The paper sketches how we compute such dependencies, describes the implementation of an efficient function cache, and evaluates our implementation's performance.

Open-access reader

About this research paper

What this paper is about

This paper describes the implementation of a purely functional programming language for building software systems. In this language, external tools like compilers and linkers are invoked by function calls. Because some function calls are extremely expensive, it is obviously important to reuse the results of previous function calls whenever possible. Caching a function call requires the language interpreter to record all values on which the function call depends. For optimal caching, it is important to record precise dependencies that are both dynamic and fine-grained . The paper sketches how we compute such dependencies, describes the implementation of an efficient function cache, and evaluates our implementation's performance.

Why it matters

OpenAlex reports 12 citations for this work. Citation counts describe recorded attention and do not establish research quality.

Key contribution

A contribution statement is not available in the OpenAlex record.

Method / approach

Method details are not available in the OpenAlex metadata.

Main findings

Findings are not separately available in the OpenAlex metadata.

Limitations

Limitations are not available in the OpenAlex metadata.

Applications

Application details are not available in the OpenAlex metadata.

Available abstract

This paper describes the implementation of a purely functional programming language for building software systems. In this language, external tools like compilers and linkers are invoked by function calls. Because some function calls are extremely expensive, it is obviously important to reuse the results of previous function calls whenever possible. Caching a function call requires the language interpreter to record all values on which the function call depends. For optimal caching, it is important to record precise dependencies that are both dynamic and fine-grained . The paper sketches how we compute such dependencies, describes the implementation of an efficient function cache, and evaluates our implementation's performance.

Key concepts: Computer science, Function (biology), Compiler, Cache, Programming language, Interpreter, Functional programming, Reuse

Related papers

Back to paper searchBrowse research topicsOriginal source
Caching function calls using precise dependencies — Research Paper | ScholarLens