[Paper Review] PENCIL: Towards a Platform-Neutral Compute Intermediate Language for DSLs

Mohamed Riyadh Baghdadi, Albert Cohen+10 more|arXiv (Cornell University)|Feb 22, 2013

Parallel Computing and Optimization Techniques8 references10 citations

TL;DR

PENCIL is a platform-neutral intermediate language designed to enable productive, high-performance, and portable accelerator programming by serving as a common compilation target for domain-specific languages (DSLs). It supports high-level abstractions, explicit optimization directives (e.g., for parallelism and data layout), and integrates with polyhedral optimization frameworks to generate efficient low-level code for heterogeneous systems like GPUs and multi-threaded SIMD units.

ABSTRACT

We motivate the design and implementation of a platform-neutral compute intermediate language (PENCIL) for productive and performance-portable accelerator programming.

Motivation & Objective

• Address the lack of performance portability in accelerator programming by providing a unified intermediate language for DSLs.
• Reduce the development and maintenance cost of DSL compilers by abstracting platform-specific code generation.
• Enable high-level DSLs to express complex accelerator idioms—such as tiling, vectorization, and memory layout—through structured syntax and pragmas.
• Support both regular and irregular algorithms by modeling common computational motifs (e.g., stencil computations, sparse matrix operations).
• Facilitate cross-component optimization across multiple kernels by exposing dependence and memory access metadata for collective transformation.

Proposed method

• Design PENCIL as a high-level, platform-neutral intermediate language with C-like syntax and C99/GNU extensions for familiarity and ease of compilation.
• Integrate pragmas and directives (e.g., #pragma pencil reduction, #pragma independent) to expose dependence and memory access information that is hard to infer automatically.
• Leverage the polyhedral framework for static analysis and transformation, enabling automatic optimization of loop nests for parallelism and data locality.
• Support both DSL-generated code and hand-written PENCIL code in a unified compilation pipeline, enabling linking and joint optimization.
• Model irregular algorithms (e.g., sparse matrix-vector multiplication) using metadata and explicit annotations to preserve performance on diverse architectures.
• Enable numerical precision control via pragmas to allow trade-offs between performance and bit-wise reproducibility in floating-point computations.

Experimental results

Research questions

• RQ1 How can a platform-neutral intermediate language reduce the complexity and cost of developing and maintaining DSLs for accelerators?
• RQ2 What language constructs and metadata mechanisms are necessary to express common accelerator programming idioms—such as tiling, vectorization, and memory layout—while preserving performance portability?
• RQ3 To what extent can PENCIL represent both regular and irregular algorithms (e.g., dense linear algebra vs. sparse matrix operations) using a unified, extensible syntax?
• RQ4 How can dependence and memory access information be exposed via pragmas to enable effective cross-kernel optimization across multiple computational kernels?
• RQ5 Can PENCIL serve as a viable compilation target for both high-level DSLs and hand-optimized library code, enabling end-to-end optimization in a single pipeline?

Key findings

• PENCIL enables DSLs to express high-level abstractions with rich semantics, allowing the compiler to perform advanced optimizations such as automatic parallelization and loop transformations.
• The use of pragmas like #pragma pencil reduction and #pragma independent allows precise control over reduction and independence semantics, improving code generation for parallel execution.
• PENCIL successfully captures key features of existing DSLs such as OP2 (e.g., pointer-free access, access hints) and OptiML (e.g., sum, vector construction, untilconverged), demonstrating its expressiveness.
• The language supports both regular algorithms (e.g., stencil computations) and irregular ones (e.g., sparse matrix-vector product), with explicit metadata enabling efficient code generation.
• Cross-component optimization is feasible: dependence information from multiple kernels can be collectively analyzed and transformed to improve data locality and parallelism.
• PENCIL supports numerical precision trade-offs via pragmas, allowing developers to opt into performance-optimized, non-bit-exact floating-point execution when acceptable.