[Paper Review] SL: a "quick and dirty" but working intermediate language for SVP systems

Raphaël Poss|arXiv (Cornell University)|Aug 22, 2012

Parallel Computing and Optimization Techniques1 references15 citations

TL;DR

This paper introduces SL, a lightweight C extension designed as a target language for compiling parallel programs targeting SVP (System Virtualization Platform) systems. SL enables bulk thread creation, dataflow-based communication via word-sized channels, and synchronization on thread family termination, providing a portable, low-level interface for many-core and hardware multithreaded processors with minimal implementation complexity.

ABSTRACT

The CSA group at the University of Amsterdam has developed SVP, a framework to manage and program many-core and hardware multithreaded processors. In this article, we introduce the intermediate language SL, a common vehicle to program SVP platforms. SL is designed as an extension to the standard C language (ISO C99/C11). It includes primitive constructs to bulk create threads, bulk synchronize on termination of threads, and communicate using word-sized dataflow channels between threads. It is intended for use as target language for higher-level parallelizing compilers. SL is a research vehicle; as of this writing, it is the only interface language to program a main SVP platform, the new Microgrid chip architecture. This article provides an overview of the language, to complement a detailed specification available separately.

Motivation & Objective

• . The paper aims to address the lack of a portable, efficient intermediate language for programming SVP platforms.
• It seeks to overcome the limitations of the earlier µTC language, which proved uncompileable to target SVP platforms.
• The objective is to design a practical, implementable language that supports concurrency primitives at the lowest software level, below the OS.
• It aims to serve as a common interface across diverse SVP platforms, including the Microgrid chip architecture.
• The research also aims to support future compiler development and hardware portability for many-core systems.

Proposed method

• . SL is designed as a syntactic extension to ISO C99/C11, preserving standard C compatibility.
• It introduces new keywords: sl_def and sl_enddef to define thread functions with input/output dataflow channels.
• The sl_create and sl_sync constructs enable bulk creation and synchronization of thread families with configurable size and windowing.
• Dataflow communication is managed via sl_shparm (for thread function parameters) and sl_sharg (for thread family endpoints), with sl_getp/sl_setp and sl_geta/sl_seta for read/write operations.
• The language uses manifest typing and separate keywords for integer and floating-point types to simplify implementation and avoid complex type analysis.
• The SL toolchain compiles SL code into SVP machine code, targeting both software emulations and hardware platforms like the Microgrid.

Experimental results

Research questions

• RQ1 . How can a lightweight, portable intermediate language be designed to target diverse SVP platforms, including hardware multithreaded many-core systems?
• RQ2 . Why was the prior µTC language unsuitable for compilation, and what design principles enabled SL to overcome these limitations?
• RQ3 . To what extent can SL support efficient bulk thread creation, synchronization, and dataflow communication in a low-level, OS-bypassing execution model?
• RQ4 . How can a type system be simplified in a language targeting low-level systems without sacrificing expressiveness for concurrency?
• RQ5 . What extensions are necessary to support future hardware trends such as distributed memory and general-purpose synchronization patterns?

Key findings

• . SL successfully serves as the sole interface language for programming the Microgrid chip architecture, a main SVP platform.
• . The language enables non-deterministic, concurrent execution of thread families, as demonstrated by a program printing digits 0–9 and 10 in arbitrary order.
• . SL's design avoids complex static analysis by using manifest typing and explicit keywords for scalar types, significantly simplifying implementation.
• . The SL toolchain has been released under an open-source license, enabling community use and integration with compilers like SAC2C and parallelizing C compilers.
• . SL has already been used in multiple research projects, replacing µTC in publications due to its practicality and compatibility.
• . Ongoing work includes extending SL to support distributed memory models, POSIX threading API subsets, and higher-level abstractions for common patterns like reductions and load balancing.