Skip to content. Skip to navigation
McGill Home SOCS Home
Personal tools
You are here: Home Announcements and Events Seminars Seminar History

Seminar Home
Fall 2013 Schedule
Winter 2014 Schedule
Summer 2014 Schedule
Archives

Date
( Summer 2009 )
Category Seminar Info
2008/06/26 Vision, Graphics, and Robotics Place: MC 437
Time: 15:00 - 16:00
Speaker: Jeff Orchard
Affiliation: Computer Science Dept., University of Waterloo
Title: New Methods in Medical Image Registration
Abstract: Image registration is the task of aligning two or more images so that their content corresponds on a pixel-to-pixel basis. In this two-part talk, I will discuss two of my recent projects in automatic image registration. Part 1: Most image registration methods assume that the images being registered are nearly aligned. When that's not the case, things fall apart. I have developed a method that efficiently combats this problem by exhaustively considering all possible shifts of an image. It's made possible by some FFT trickery. Part 2: When registering medical images of different types (eg. MRI and a CAT scan), the images cannot be registered using pixel intensities directly. For example, bones are bright in a CAT scan, but dark in an MRI. Instead, the problem is often formulated in information-theoretic terms, yielding the current state-of-the-art method of Mutual Information. However, I will demonstrate that there are advantages to posing the problem in terms of clustering. Biography of Speaker:

Jeff Orchard received his B.Math. degree in applied mathematics from the University of Waterloo, Canada, in 1994, and his M.Sc. degree in applied mathematics from the University of British Columbia, Canada, in 1996. He received his Ph.D. degree in computing science from Simon Fraser University, Canada, in 2003. Since 2003, Prof. Orchard has been an Assistant Professor in the David R. Cheriton School of Computer Science at the University of Waterloo, Canada. His research interests revolve around applying mathematics and computation to visual data. He has worked on projects in image registration, motion compensation for medical imaging, functional MRI, medical image reconstruction, and image mosaicking. At the University of Waterloo, he is affiliated with the Scientific Computing Research Group, the Waterloo Institute for Health Informatics Research, and the Centre for Computational Mathematics in Industry and Commerce. In 2005, Prof. Orchard organized a workshop called the "Grand Mathematical Challenges in Medical Image Processing".


2008/06/25 Software Engineering Place: MC103
Time: 13:30 - 14:30
Speaker: Greg Steffan
Affiliation: University of Toronto
Area: compilers, hardware
Title: VESPA: Portable, Scalable, and Flexible FPGA-Based Vector Processors
Abstract: While soft processors are increasingly common in FPGA-based embedded systems, it remains a challenge to scale their performance. We propose extending soft processor instruction sets to include support for vector processing. The resulting system of vectorized software and soft vector processor hardware is (i) portable to any FPGA architecture and vector processor configuration, (ii) scalable to larger yet higher-performance designs, and (iii) flexible, allowing the underlying vector processor to be customized to match the needs of each application. Using our robust and verified parameterized vector processor design and industry-standard EEMBC benchmarks, we evaluate the performance and area trade-offs for different soft vector processor configurations using an FPGA development platform with DDR SDRAM. We find that on average we can scale performance from 1.8x up to 6.3x for a vector processor design that saturates the capacity of our platform's Stratix 1S80 FPGA. We also automatically generate application-specific vector processors with reduced datapath width and instruction set support which combined reduce the area by up to 70% without affecting performance.
2008/06/11 Software Engineering Place: McConnell 103
Time: 13:30 - 14:30
Speaker: Eric Bodden
Affiliation: McGill University
Title: Racer: Effective Race Detection Using AspectJ
Abstract: Programming errors occur frequently in large software systems, and even more so if these systems are concurrent. In the past researchers have developed specialized programs to aid programmers detecting concurrent programming errors such as deadlocks, livelocks, starvation and data races. In this work we propose a language extension to the aspect-oriented programming language AspectJ, in the form of three new pointcuts, lock(), unlock() and maybeShared(). These pointcuts allow programmers to monitor program events where locks are granted or handed back, and where values are accessed that may be shared amongst multiple Java threads. We decide thread-locality using a static thread-local objects analysis developed by others. Using the three new primitive pointcuts, researchers can directly implement efficient monitoring algorithms to detect concurrent programming errors online. As an example, we expose a new algorithm which we call Racer, an adoption of the well-known Eraser algorithm to the memory model of Java. We implemented the new pointcuts as an extension to the AspectBench Compiler, implemented the Racer algorithm using this language extension and then applied the algorithm to the NASA K9 Rover Executive. Our experiments proved our implementation very effective. In the Rover Executive Racer finds 70 data races. Only one of these races was previously known. We further applied the algorithm to two other multi-threaded programs written by Computer Science researchers, in which we found races as well.
2008/06/04 Software Engineering Place: McConnell 103
Time: 13:30 - 14:30
Speaker: Clark Verbrugge
Affiliation: McGill University
Title: Memory Models and Compiler Optimization
Abstract: Memory models are used in concurrent systems to specify visibility properties of shared data. A practical memory model, however, must permit code optimization as well as provide a useful semantics for programmers. Here we extend recent observations that the current Java memory model imposes significant restrictions on the ability to optimize code. Beyond the known and potentially correctable proof concerns illustrated by others we show that major constraints on code generation and optimization can in fact be derived from fundamental properties and guarantees provided by the memory model. To address this and accommodate a better balance between programmability and optimization we present some prelimary ideas for a simple concurrency semantics for Java that avoids basic problems at a cost of backward compatibility.
2008/06/04 Software Engineering Place: McConnell 103
Time: 13:30 - 14:30
Speaker: Clark Verbrugge
Affiliation: McGill University
Title: Memory Models and Compiler Optimization
Abstract: Memory models are used in concurrent systems to specify visibility properties of shared data. A practical memory model, however, must permit code optimization as well as provide a useful semantics for programmers. Here we extend recent observations that the current Java memory model imposes significant restrictions on the ability to optimize code. Beyond the known and potentially correctable proof concerns illustrated by others we show that major constraints on code generation and optimization can in fact be derived from fundamental properties and guarantees provided by the memory model. To address this and accommodate a better balance between programmability and optimization we present some prelimary ideas for a simple concurrency semantics for Java that avoids basic problems at a cost of backward compatibility.
2008/05/02 Software Engineering Place: McConnell 103
Time: 13:30 - 14:30
Speaker: Barthelemy Dagenais
Affiliation: McGill University
Title: Recommending Adaptive Changes for Framework Evolution
Abstract: In the course of a framework's evolution, changes ranging from a simple refactoring to a complete rearchitecture can break client programs. Finding suitable replacements for framework elements that were accessed by a client program and deleted as part of the framework's evolution can be a challenging task. We present a recommendation system, SEMDIFF, that suggests adaptations to client programs by analyzing how a framework adapts to its own changes. In a study of the evolution of the Eclipse JDT framework and three client programs, our approach recommended relevant adaptive changes with a high level of precision, and detected non-trivial changes typically undiscovered by current refactoring detection techniques.