Gregory John Michaelson

A parallel SML compiler based on algorithmic skeletons

Algorithmic skeletons are abstractions from common patterns of parallel activity which offer a high degree of reusability for developers of parallel algorithms. Their close association with higher order functions (HOFs) makes functional languages, with their strong transformational properties, excellent vehicles for skeleton-based parallel program development. However, using HOFs in this way raises substantial problems of identification of useful HOFs within a given application and of resource allocation on target architectures. We present the design and implementation of a parallelising compiler for Standard ML which exploits parallelism in the familiar

Predictable space behaviour in FSM-Hume

map

Resource analyses for parallel and distributed coordination

and

Real-Time People Tracking in a Camera Network

fold

Orthogonal parallel processing in vector Pascal

HOFs through skeletons for processor farms and processor trees, respectively. The compiler extracts parallelism automatically and is target architecture independant. HOF execution within a functional language can be nested in the sense that one HOF may be passed and evaluated during the execution of another HOF. We are able to exploit this by nesting our parallel skeletons in a processor topology which matches the structure of the Standard ML source. However, where HOF arguments result from partially applied functions, free variable bindings must be identified and communicated through the corresponding skeleton hierarchy to where those arguments are actually applied. We describe the analysis leading from input Standard ML through HOF instantiation and backend compilation to an executable parallel program. We also present an overview of the runtime system and the execution model. Finally, we give parallel performance figures for several example programs, of varying computational loads, on the Linux-based Beowulf, IBM SP/2, Fujitsu AP3000 and Sun StarCat 15000 MIMD parallel machines. These demonstrate good cross-platform consistency of parallel code behaviour.

Higher order function synthesis through proof planning

The purpose of the Hume language design is to explore the expressibility/decidability spectrum in resource-constrained systems, such as real-time embedded or control systems. It is unusual in being based on a combination of λ-calculus and finite state machine notions, rather than the more usual propositional logic, or flat finite-state-machine models. It provides a number of high level features including polymorphic types, arbitrary but sized user-defined data structures and automatic memory management, whilst seeking to guarantee strong space/time behaviour and maintaining overall determinacy. A key issue is predictable space behaviour. This paper describes a simple model for calculating stack and heap costs in FSM-Hume, a limited subset of full Hume. This cost model is evaluated against an example taken from the research literature: a simple mine drainage control system. Empirical results suggest that our model is a good predictor of stack and heap usage, and that this can lead to good bounded memory utilisation.

Profile Guided Dataflow Transformation for FPGAs and CPUs

Predicting the resources that are consumed by a program component is crucial for many parallel or distributed systems. In this context, the main resources of interest are execution time, space and communication/synchronisation costs. There has recently been significant progress in resource analysis technology, notably in type‐based analyses and abstract interpretation. At the same time, parallel and distributed computing are becoming increasingly important.

A Dataflow IR for Memory Efficient RIPL Compilation to FPGAs

We present an approach to track several subjects from video sequences acquired by multiple cameras in real time. We address the key concerns of real time performance and continuity of tracking in overlapping and nonoverlapping fields of view. Each human subject is represented by a parametric ellipsoid having a state vector that encodes its position, velocity and height. We also encode visibility and persistence to tackle problems of distraction and short-period occlusion. To improve likelihood computation from different viewpoints, including the relocation of subjects after network blind spots, the colored and textured surface of each ellipsoid is learned progressively as the subject moves through the scene. This is combined with the information about subject position and velocity to perform camera handoff. For real time performance, the boundary of the ellipsoid can be projected several hundred times per frame for comparison with the observation image. Further, our implementation employs a particle filter, developed for parallel implementation on a graphics processing unit. We have evaluated our algorithm on standard data sets using metrics for multiple object tracking accuracy (MOTA) and speed of processing, and can show significant improvements in comparison with published work.

Discovering applications of higher order functions through proof planning

Despite the widespread adoption of parallel operations in contemporary CPU designs, their use has been restricted by a lack of appropriate programming language abstractions and development environments. To fully exploit the SIMD model of computation such operations offer, programmers depend on CPU specific machine code or implementation-dependent libraries. Here we present vector Pascal (VP), a language designed to enable the elegant and efficient expression of SIMD algorithms. VP imports into Pascal abstraction mechanisms derived from functional languages, in turn having their origins in APL. In particular, it extends all operators to work on vectors of data. The type system is also extended to handle pixels and dimensional analysis. Code generation is via the ILCG system that allows retargeting to multiple different SIMD instruction sets based on formalised descriptions of the instruction set semantics.

ACCELERATED PEOPLE TRACKING USING TEXTURE IN A CAMERA NETWORK

The close association between higher order functions and algorithmic skeletons is a promising source of automatic parallelisation of programs. An approach to automatically synthesizing higher order functions from functional programs through proof planning is presented Our work has been conducted within the context of a parallelising compiler for SML, with the objective of exploiting parallelism latent in potential higher order function use in programs.