William B. Gardner

The pilot approach to cluster programming in C

The Pilot library offers a new method for programming parallel clusters in C. Formal elements from Communicating Sequential Processes (CSP) were used to realize a process/channel model of parallel computation that reduces opportunities for deadlock and other communication errors. This simple model, plus an application programming interface (API) fashioned on Cs formatted I/O, are designed to make the library easy for novice scientific C programmers to learn. Optional runtime services including deadlock detection help the programmer to debug communication issues. Pilot forms a thin layer on top of standard Message Passing Interface (MPI), preserving the latters portability and efficiency, with little performance impact. MPIs powerful collective operations can still be accessed within the conceptual model.

Converging CSP specifications and C++ programming via selective formalism

CSP (communicating sequential processes) is a useful algebraic notation for creating a hierarchical behavioral specification for concurrent systems, due to its formal interprocess synchronization and communication semantics. CSP specifications are amenable to simulation and formal verification by model-checking tools. A translator has been created to synthesize C++ code from CSP for execution with an object-oriented framework called CSP++, thereby making CSP specifications directly executable. To overcome the drawback that CSP is neither a full-featured nor popular programming language, an approach called “selective formalism” allows the use of CSP to be limited to specifying the control portion of a system, while the rest of its functionality is supplied in the form of C++ modules. These are activated through association with abstract events in the CSP specification. This is a new means of bringing convergence between a formal method and a popular programming language. It is believed that this methodology can be extended to hardware/software codesign for embedded systems.

The pilot library for novice MPI programmers

The Pilot library is a new method for programming MPI-enabled clusters in C, targeted at novice parallel programmers. Formal elements from Communicating Sequential Processes (CSP) are used to realize a process/channel model of parallel computation that reduces opportunities for deadlock and other communication errors. This simple model, plus an application programming inter-face (API) styled after Cs formatted I/O, are designed to make the library easy to learn. The Pilot library exists as a thin layer on top of any standard Message Passing Interface (MPI) implementation, preserving MPIs portability and efficiency, with little per-formance overhead arising as result of Pilots additional features.

Rapid prototyping of embedded software using selective formalism

Our software synthesis tool, CSP++, generates C++ source code from verifiable CSPm specifications, and includes a framework for runtime execution. Our technique of selective formalism allows the synthesized formal control backbone code to be linked with non-formal user-coded C++ functions that carry out I/O and data processing. This tool already facilitates rapid prototyping of formally-specified software by bypassing the customary manual translation from a formal notation. In this work, we extend the rapid prototyping capability to SOPC (system on programmable chip) by targeting the CSP++ execution framework to an FPGA processor core. This is demonstrated with a new point-of-sale case study.

A new Canadian interdisciplinary Ph.D. in computational sciences

Abstract In response to growing demands of society for experts trained in computational skills applied to various domains, the School of Computer Science at the University of Guelph is creating a new approach to doctoral studies called an interdisciplinary Ph.D. in computational sciences. The program is designed to appeal to candidates with strong backgrounds in either computer science or an application discipline who are not necessarily seeking a traditional academic career. Thesis based, it features minimal course requirements and short duration, with the student’s research directed by co-advisors from computer science and the application discipline. The degree program’s rationale and special characteristics are described. Related programs in Ontario and reception of this innovative proposal at the institutional level are discussed.

CellPilot: Seamless communication within Cell BE and heterogeneous clusters

The Pilot library is targeted to novice scientific programmers within High Performance Computing. The CellPilot library extends the Pilot library to the Cell Broadband Engine processor and heterogeneous clusters. Using Pilots process and channel abstractions, the CellPilot library can create a process on any of the processor types, both PPEs and SPEs, across the cluster. Communication is achieved by creating a channel between any two processes, and using the write/read channel functions in the participating processes. The CellPilot library uses MPI for the inter-node communication and the Cell SDK within a Cell node. All the architecture specific details of Cell communications are hidden from the user.

CellPilot: A Seamless Communication Solution for Hybrid Cell Clusters

The Cell Pilot library provides a comprehensive inter process communication solution for parallel programming in Con clusters comprised of Cell BE and other computers. It extends the process/channel approach of the existing Pilot library to cover processes running on Cell PPEs and SPEs. The same simple API is used to read and write messages on channels defined between pairs of processes regardless of location, while hiding communication details from the user. Cell Pilot uses MPI for inter-node communication, and the Cell SDK within a Cell node.

Should We Be Teaching Parallel Programming

This paper reflects on seven years of experience teaching parallel programming at the undergraduate level in Ontario. A rationale is given for incorporating the topic into the CS curriculum, and essential content is identified. Two contrasting approaches are described: integration into core courses vs. standalone elective. Advantages of using the authors Pilot library to teach message-passing programming are presented.

BHive: Behavior-Driven Development Meets B-Method

Behavior-Driven Development (BDD) is an “outside-in” approach to software development built upon semi-formal mediums for specifying the behavior of a system as it would be observed externally. Through the representation of a system as a collection of user stories and scenarios using BDD’s notation, practitioners automate acceptance tests using examples of desired behavior for the envisioned system. A formal model created in concert with BDD tests would provide valuable insight into test validity and enhance the visibility of the problem domain. This work called BHive builds upon the formal underpinnings of BDD scenarios by mapping their “Given,” “When,” and “Then” statements to “Precondition,” “Command,” and “Postcondition” constructs as introduced by Floyd-Hoare logic. We posit that this mapping allows for a B-Method representation to be created and that such a model is useful for exploring system behavior and exposing gaps in requirements and test plans. In this extension of previous work, we outline recent additions to BDD tooling required for the described integration, present a new strategy for test case generation from our approach, and expand on the benefits of the BHive approach to integrating formalism within a BDD project.

AutoPilot: message passing parallel programming for a cache incoherent embedded manycore processor

The Renesas Electronics IMAPCAR2 embedded realtime image processor combines a single core with a 128-way SIMD array. At runtime, sections of the SIMD array can be reconfigured as additional CPU cores, interconnected via a message ring. Effective use is made difficult by the low-level message passing API and lack of cache coherency between processors. The AutoPilot library addresses this by providing a high-level message-oriented parallel programming model mirroring that of Pilot, itself a wrapper around the Message Passing Interface (MPI) for cluster computing. AutoPilot shows that Pilots processes-and-channels architecture is a viable choice for parallel programming on cache-incoherent multicore and manycore architectures. It provides a simpler API for programmers, with built-in safety checks that eliminate some common sources of errors. Since the IMAPCAR2 is targeted chiefly at automotive applications, open source AutoPilot has a large degree of MISRA-C compliance.