Frank Penczek

Parallel signal processing with S-Net

We argue that programming high-end stream-processing applications requires a form of coordination language that enables the designer to represent interactions between stream-processing functions asynchronously. We further argue that the level of abstraction that current programming tools engender should be drastically increased and present a coordination language and component technology that is suitable for that purpose. We demonstrate our approach on a real radar-data processing application from which we reuse all existing components and present speed-ups that we were able to achieve on contemporary multi-core hardware.

Implementation architecture and multithreaded runtime system of S-NET

S-NET is a declarative coordination language and component technology aimed at modern multi-core/many-core architectures and systems-on-chip. It builds on the concept of stream processing to structure networks of communicating asynchronous components, which can be implemented using a conventional (sequential) language. In this paper we present the architecture of our S-NET implementation. After sketching out the interplay between compiler and runtime system, we characterise the deployment and operational behaviour of our multithreaded runtime system for contemporary multi-core processors. Preliminary runtime figures demonstrate the effectiveness of our approach.

Message Driven Programming with S-Net: Methodology and Performance

Development and implementation of the coordination language S-NET has been reported previously. In this paper we apply the S-NET design methodology to a computer graphics problem. We demonstrate (i) how a complete separation of concerns can be achieved between algorithm engineering and concurrency engineering and (ii) that the S-NET implementation is quite capable of achieving performance that matches what can be achieved using low-level tools such as MPI. We find this remarkable as under S-NET communication, concurrency and synchronization are completely separated from algorithmic code. We argue that our approach delivers a flexible component technology which liberates application developers from the logistics of task and data management while at the same time making it unnecessary for a distributed computing professional to acquire detailed knowledge of the application area.

Distributed S-Net: Cluster and Grid Computing without the Hassle

S-Net is a declarative coordination language and component technology primarily aimed at modern multi-core/many-core chip architectures. It builds on the concept of stream processing to structure dynamically evolving networks of communicating asynchronous components, which themselves are implemented using a conventional language suitable for the application domain. We present the design and implementation of Distributed S-Net, a conservative extension of S-Net aimed at distributed memory architectures ranging from many-core chip architectures with hierarchical memory organisations to more traditional clusters of workstations, supercomputers and grids. Three case studies illustrate how to use Distributed S-Net to implement different models of parallel execution. Runtimes obtained on a workstation cluster demonstrate how Distributed S-Net allows programmers with little or no background in parallel programming to make effective use of distributed memory architectures with minimal programming effort.

S-Net for multi-memory multicores

S-Net is a declarative coordination language and component technology aimed at modern multi-core/many-core architectures and systems-on-chip. It builds on the concept of stream processing to structure dynamically evolving networks of communicating asynchronous components. Components themselves are implemented using a conventional language suitable for the application domain. This two-level software architecture maintains a familiar sequential development environment for large parts of an application and offers a high-level declarative approach to component coordination. In this paper we present a conservative language extension for the placement of components and component networks in a multi-memory environment, i.e. architectures that associate individual compute cores or groups thereof with private memories. We describe a novel distributed runtime system layer that complements our existing multithreaded runtime system for shared memory multicores. Particular emphasis is put on efficient management of data communication. Last not least, we present preliminary experimental data.

A multi-level monitoring framework for stream-based coordination programs

Stream-based Coordination is a promising approach to execute programs on parallel hardware such as multi-core systems. It allows to reuse sequential code at component level and to extend such code with concurrency-handling at the coordination level. In this paper we identify the monitoring information required to enable the calculation of performance metrics, automatic load balancing, and bottleneck detection. The monitoring information is obtained by implicitly instrumenting multiple levels: the runtime system and the operating system. We evaluate the monitoring overhead caused by different use cases on S-Net as it is a challenging monitoring benchmark with a flexible and fully asynchronous execution model, including dynamic mapping and scheduling policies. The evaluation shows that in most cases the monitoring causes a negligible overhead of less than five percent.

An operational semantics for S-Net

We present the formal operational semantics of S-NET, a coordination language and component technology based on stream processing. S-NET turns conventional (sequential) functions/procedures into asynchronous components interacting with each other through a streaming network; it defines network topologies inductively by a small combinator language that captures essential forms of concurrency. Our formal semantics allows us to reason about program properties and defines the design space for alternative implementation strategies.

CAOS: a domain-specific language for the parallel simulation of cellular automata

We present the design and implementation of CAOS, a domain-specific high-level programming language for the parallel simulation of extended cellular automata. CAOS allows scientists to specify complex simulations with limited programming skills and effort. Yet the CAOS compiler generates efficiently executable code that automatically harnesses the potential of contemporary multi-core processors, shared memory multiprocessors, workstation clusters and supercomputers.

A Data-Flow Based Coordination Approach to Concurrent Software Engineering

In this paper we present S-Net, a coordination language based on dataflow principles, intended for design of concurrent software. The language is introduced and then used for programming a concurrent solver for a combinatorial optimisation problem. We present the analysis and tracing facilities of our S-Netruntime system and show how these aid programmers in optimising the performance of their applications.

Design and Implementation of CAOS: an implicitly parallel language for the high-performance simulation of cellular automata

Disclaimer/Complaints regulations If you believe that digital publication of certain material infringes any of your rights or (privacy) interests, please let the Library know, stating your reasons. In case of a legitimate complaint, the Library will make the material inaccessible and/or remove it from the website. Please Ask the Library: https://uba.uva.nl/en/contact, or a letter to: Library of the University of Amsterdam, Secretariat, Singel 425, 1012 WP Amsterdam, The Netherlands. You will be contacted as soon as possible.