Programming Graphics Processors Functionally

Abstract:

Graphics cards for personal computers have recently undergone a radical
transformation from fixed-function graphics pipelines to multi-processor,
programmable architectures. Multi-processor architectures are clearly
advantageous for graphics for the simple reason that graphics computations are
naturally concurrent, mapping well to stateless stream processing. They
therefore parallelize easily and need no random access to memory with its
problematic latencies.

This paper presents Vertigo, a
purely functional, Haskell-embedded language for 3D graphics and an optimizing
compiler that generates graphics processor code. The language integrates
procedural surface modeling, shading, and texture generation, and the compiler
exploits the unusual processor architecture. The shading sub-language is based
on a simple and precise semantic model, in contrast to previous shading
languages. Geometry and textures are also defined via a very simple
denotational semantics. The formal semantics yields not only programs that are
easy to understand and reason about, but also very efficient implementation,
thanks to a compiler based on partial evaluation and symbolic optimization,
much in the style of Pan.

Haskell's overloading facility is extremely useful throughout Vertigo. For
instance, math operators are used not just for floating point numbers, but
also expressions (for differentiation and compilation), tuples, and functions.
Typically, these overloadings cascade, as in the case of surfaces, which may
be combined via math operators, though they are really functions over tuples
of expressions on floating point numbers. Shaders may be composed with the
same notational convenience. Functional dependencies are exploited for vector
spaces, cross products, and derivatives.