Meetings in Summer 2007

From The Programming Languages and Systems Research Group
Revision as of 22:17, 25 June 2007 by Muehlber (talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search
Thursday, 26 April : " "
12:15 -- 13:15, CS202J Abstract:

Thursday, 03 May Ben Mitchel: "Animating Simulated Annealing with Lego Mindstorms"
12:20 -- 12:40, CS202J Abstract: This project explores the physical animation of simulated annealing using Lego Mindstorms, and assesses the suitability of this approach to algorithm animation for use as an interactive teaching aid.

Thursday, 03 May Ian Boden: "Animation of Garbage Collection Algorithms using Lego Mindstorms"
12:40 -- 13:00, CS202J Abstract: My project investigates the use of Lego Mindstorms for educating students about Garbage Collection algorithms. It concentrates on producing a tool for demonstration and independent learning which is as capable of educating as standard methods with the advantage of making the topic more exciting for the students.

Thursday, 10 May : " "
12:15 -- 13:15, CS202J Abstract:

Thursday, 17 May : " "
12:15 -- 13:15, CS119N Abstract:

Thursday, 24 May Malcolm Wallace: "Functional Programming and Visualisation: A Lazy PolyTypic Grid"
12:15 -- 13:15, CS202J Abstract: This talk will give an overview of the Lazy Polytypic Grid project,and outline some of our early results. Our aim is to explore how to make existing well-known visualisation algorithms (e.g. volumetric surface extraction):
  • lazy, so that the whole dataset is not required all at once;
  • datatype-generic (polytypic), so that the algorithm is independent of the original dataset storage format, including questions of irregular and unstructured sampling;
  • grid-enabled, such that it is possible to distribute the processing tasks across a heterogeneous network of machines, harnessing any implicit parallelism in the algorithms to speed up the calculation for huge datasets.

Thursday, 31 May Neil Mitchell: "Fastest Lambda First"
12:15 -- 13:15, CS202J Abstract: Haskell programs are often very succinct, but what they gain in beauty they can sometimes loose in speed. Work on the GHC compiler has enabled Haskell programs to perform at C speeds, or faster in some cases, but at the cost of using a lower-level style of Haskell.

This talk introduces a new technique for optimisation, which attempts to eliminate any overhead from an algorithm. The idea relies on the first-order transformation presented last term, and attempts to remove all data and higher-order functions from a program. With the techniques presented Haskell can remain beautiful, and perform at the same speed as C.

Links: slides (PDF)

Thursday, 07 June Colin Runciman: "Programming with Sets -- Specification and Refinement"
12:15 -- 13:15, CS202J Abstract:

Thursday, 14 June Ian Toyn: "An Update on the ISO Z Standard and Tools"
12:15 -- 13:15, CS202J Abstract: The speaker holds the position of Project Editor for the ISO Z standard. The talk will present a paper that was written for a proposed forthcoming Z User Meeting (ZUM). The paper provides a commentary on the recently approved first Technical Corrigendum to the first edition of the Z standard. (A Technical Corrigendum corrects defects in a standard.) The paper also reviews the conformance (or otherwise) to the standard of some widely-used Z tools, as summarised by the tool builders who are listed as co-authors.

The ZUM audience can be assumed to know Z, so for this PLASMA talk to be good practice, I hope I don't have to weaken that assumption very much, but feel free to ask questions.

Joint work with Rob Arthan, Leo Freitas, Tim Miller and Mark Saaltink.

Thursday, 21 June Gerald Lüttgen: "Parallelising Symbolic State-Space Generators: Frustration and Hope"
12:15 -- 13:15, CS202J Abstract: Due to the irregular nature of the task, efficient algorithms for symbolic state-space generation are notoriously hard to parallelise. This talk explores two different strategies for parallelising and implementing one such algorithm, Saturation, on multi-core PCs: one strategy employs the parallel language Cilk, while the other uses a thread pool implemented in Pthreads.

I will analyse the underlying parallel overheads, present experimental results and argue their relevance. The conclusions will give room for both frustration and hope regarding the parallelisability of symbolic model checkers on shared-memory architectures.

The research on which this talk is based is funded by the EPSRC under grant no. GR/S86211/01: "New-Generation Symbolic Model Checkers for Verifying Asynchronous Systems".

Thursday, 28 June Jonathan Ezekiel: "Parallelising Symbolic State-Space Generators"
12:15 -- 13:15, CS202J Abstract: Symbolic state-space generators are notoriously hard to parallelise, largely due to the irregular nature of the task. Parallel languages such as Cilk, tailored to irregular problems, have been shown to offer efficient scheduling and load balancing. This paper explores whether Cilk can be used to efficiently parallelise a symbolic state-space generator on a shared-memory architecture. We parallelise the Saturation algorithm implemented in the SMART verification tool using Cilk, and compare it to a parallel implementation of the algorithm using a thread pool. Our experimental studies on a dual-processor, dual-core PC show that Cilk can improve the run-time efficiency of our parallel algorithm due to its load balancing and scheduling efficiency. We also demonstrate that this incurs a significant memory overhead due to Cilk's inability to support pipelining, and conclude by pointing to a possible future direction for parallel irregular languages to include pipelining.

A paper to be presented at CAV 2007.