Tutorials Program -- Sunday, June 10
Please choose one of the two choices for each of the session (Morning and Afternoon) to attend below:
Using FindBugs for Research (T1)
David Hovemeyer (York College of Pennsylvania)
William Pugh (University of Maryland)
FindBugs is a open source static analysis tool that looks for defects in Java programs. It incorporates some fairly sophisticated checking for null pointer bugs, but also looks for hundreds of other bug patterns, many of which can be found using very simple techniques. It has been downloaded more than 300,000 times from all over the world, and is used by a number of large open source efforts and companies. FindBugs is typically able to find hundreds of real defects/mistakes per million lines of noncommenting source statements.
In addition to having many bug detectors, FindBugs also has a plug-in architecture, allowing third party detectors to be added, and FindBugs can run within a GUI, the command line, Eclipse or Netbeans. FindBugs also supports the ability to track the persistence of defects across multiple versions or instances of a piece of software, so you can see when defect warnings are introduced, how long they persist and when they are removed.
We believe this offers researchers an excellent opportunity to study how certain defects are created, persist and are removed. It also provides an opportunity for researchers looking to gain broader visibility for their own tools: by packaging your own analysis as a FindBugs plugin, you can gain a huge installed base of users.
In this tutorial, we will present:
- a quick tutorial on how to run FindBugs
- Demonstrations of FindBugs and similar commercial and open source tools.
- a discussion of the analysis/implementation techniques used
- an explanation of the two mechanisms FindBugs provides for tracking defect warnings across versions.
- A discussion of JSR-305: a proposal for standard Java annotations to assist software defect detection tools.
- Discussion of our experience with FindBugs: the issues that are important to getting industrial uptake of academic tools, and our experience of the kinds of bugs that exist and persist in production code.
- Discussion of how to write your own FindBugs detectors.
Bios
David Hovemeyer is an Assistant Professor of Computer Science at York College of Pennsylvania. FindBugs was a product of his Ph.D. research on static program analysis to find bugs at the University of Maryland. He continues to be actively involved in the FindBugs project, focusing on implementation of the underlying analyses.
William Pugh received a B.S. in Computer Science from Syracuse University and received a Ph.D. in Computer Science (with in minor in Acting) from Cornell University. He is currently a professor at the University of Maryland, College Park. He has also made research contributions in the fields of incremental computation, implementation of functional and object-oriented languages, the use of partial evaluation for hard real-time systems, in techniques for analyzing and transforming scientific codes for execution on supercomputers, and in a number of issues related to the Java programming language, including the development of JSR 133 - Java Memory Model and Thread Specification Revision. Prof Pugh's current research focus is on developing tools to improve software productivity, reliability and education. Current research projects include FindBugs, a static analysis tool for Java, and Marmoset, an innovative framework for improving the learning and feedback cycle for student programming projects.
Top
X10: Concurrent Programming for Modern Architectures (T2)
Vijay Saraswat, Vivek Sarkar, and Nathaniel Nystron (IBM TJ Watson Research Center)
Two major trends are converging to reshape the landscape of concurrent object-oriented programming languages. First, trends in modern architectures (e.g., multi-core and high-performance clusters) are making concurrency and distribution inescapable for large classes of OO programmers. Second, experience with first-generation concurrent OO languages (e.g., Java threads and synchronization) have revealed several drawbacks of unstructured threads with lock-based synchronization.
X10 is a second-generation OO language designed to address both programmer productivity and parallel performance for modern architectures. It extends sequential Java with a handful of control constructs for concurrency and distribution:
- a clustered address space (with global data-structures) to deal with distribution;
- lightweight asynchrony to deal with massive parallelism;
- recursive fork-join parallelism for structured concurrency;
- termination detection for sequencing, and
- atomic blocks for mutual exclusion
In addition, X10 extends the Java type system with support for (value-) dependent types.
The tutorial illustrates how common design patterns for concurrency and distribution can be naturally expressed in X10: wait-free algorithms, data-flow synchronization, streaming parallelism, co-processor parallelism, hierarchical task-parallelism, and phased computations. Using examples drawn from high-performance computing and middleware
(transactions, event-driven computing), it shows design patterns for establishing that programs are determinate and/or deadlock-free. The tutorial includes an overview of the X10 compiler, and shows how developers may add their own constraint system to the compiler for extended dependent typechecking of X10 programs. It also includes an overview of the X10 multi-threaded runtime system for multi-core SMPs.
The X10 system (a compiler based on the Polyglot compiler framework, and a runtime based on the Java Concurrency Utilities) has been released under the Eclipse Open Source license at http://x10.sf.net. It runs on any multi-processor capable of running Java.
Bios
Vijay Saraswat joined IBM Research in 2003, after a year as a Professor at Penn State, a couple of years at startups and 13 years at Xerox PARC and AT&T Research. His main interests are in programming languages, constraints, logic and concurrency. At IBM, he leads the work on the design and implementation of X10, a modern object-oriented programming language intended for scalable concurrent computing. His recent papers include work on weak memory models, linearity and persistence in the -calculus, dependent type-systems for Java/X10-like languages and type systems for determinacy. Over the last twenty years he has lectured at most major universities and research labs in USA and Europe. Vijay received a B. Tech. degree from the Indian Institute of Technology, Kanpur, and an M.S. and Ph.D. from Carnegie-Mellon University. His thesis on Concurrent constraint programming won the ACM Doctoral Dissertation Award in 1989, a related paper won a Best paper in 20 years; award in the area of concurrent constraint programming from the Association of Logic Programming.
Vivek Sarkar is Senior Manager of the Programming Technologies Department in the IBM Research Division, a member of the IBM Academy of Technology and an ACM Distinguished Scientist. Vivek's research interest is in advancing the state of the art of programming models, tools, and optimizing and parallelizing compilers to deliver improved productivity and performance benefits to users of high-performance systems. He leads the PERCS Programming Model and Tools project, which includes work on the X10 language and on Eclipse Parallel Tools. In the past, he has worked on several compiler-related projects at IBM including the PTRAN and Jikes RVM research projects at the T.J. Watson Research Center, and the ASTI project at the Santa Teresa Laboratory which provided the foundation for high-level locality optimizations and OpenMP and HPF parallelization in IBM's XL Fortran product compilers. Vivek holds a B.Tech. degree from the Indian Institute of Technology, Kanpur, an M.S. degree from University of Wisconsin-Madison, and a Ph.D. from Stanford University. In 1997, he was on sabbatical as a visiting associate professor at MIT, where he was a founding member of the MIT RAW project. Vivek has given several tutorials in past conferences including PLDI 1993, POPL 1996, ASPLOS 1996, PLDI 2000,OOPSLA 2003, ECOOP 2004, OOPSLA 2006, and has also taught many short courses and full-length courses.
Nathaniel Nystrom is a post-doctoral researcher at IBM T.J. Watson Research Center in Hawthorne, NY. His research interests include programming languages, compilers, tools, and methodologies for constructing safe, secure, and efficient systems. He has done work on software extensibility, language-based security, programming language run-time systems, and compiler optimizations. He received his Ph.D. in Computer Science from Cornell University in 2007. Nate holds B.S. and M.S. degrees in Computer Science from Purdue University and an M.S. in Computer Science from Cornell.
Top
Hands on Phoenix -- A Framework for Program Analysis and Transformation (T3)
Jim Hogg, Kang Su Gatlin, and Andy Ayers (Microsoft)
The Phoenix Framework is an infrastructure, provided by Microsoft, for performing program analysis and transformation. Phoenix consolidates program analysis, transformation, and code generation into a framework based upon a single intermediate representation, which captures the code, and type information of the software under investigation. This will allow users to leverage the framework and their tools across multiple types of projects.
In this four hour tutorial, members of the Phoenix team will use a “hands-on” approach to teach Phoenix. Each participant will be assigned a workstation with all of the necessary software, and through the tutorial we will write Phoenix-based code, and build various tools. By the end of the tutorial each participant will have knowledge of:
- A basic understanding of Phoenix.
- Intermediate representation, symbol tables, CFG, alias package, SSA, type system, etc…
- How to write a plug-in for the backend phases of Microsoft’s C/C++ compiler.
- Static analysis and instrumentation.
- How to write a tool that does binary reading and writing.
- Static analysis, instrumentation, and post-link optimization.
Attendees will build these tools during the tutorial, which they can then use as a starting point for future work or research using the Phoenix Framework. For more information about Phoenix see http://research.microsoft.com/phoenix.
Bios
Jim Hogg joined Microsoft 7 years ago as a Program Manager. First, in the .NET Runtime team, working on metadata, and now with the Phoenix team. His previous experience includes stints in computational physics, seismic processing, and operating systems.
Kang Su Gatlin is a Program Manager on the Phoenix team and was previously a Program Manager on Visual C++ compiler backend. Prior to his life at Microsoft he was at the start-up company Entropia, where he worked on grid computing. And prior to that, Kang Su received his PhD from University of California, San Diego, in 2000.
Andy Ayers is an Architect on the Microsoft Phoenix Project, where he focuses mainly on making Phoenix a robust and capable platform for all kinds of program analysis and transformation. He joined Microsoft in 2002. Prior to joining Microsoft, Andy created a variety of binary analysis and transformation tools at InCert Software and helped develop and enhance the High-Level Optimizer at Hewlett Packard. Andy graduated from MIT with a PhD in 1993.
Top
Using Pin for Compiler and Computer Architecture Research and Education (T4)
Kim Hazelwood (University of Virginia)
Dan Connors (University of Colorado)
David Kaeli (Northeastern University)
Vijay Janapa Reddi (Harvard University)
Pin is a dynamic instrumentation system provided by Intel (http://rogue.colorado.edu/Pin) that has become widely used throughout academia and industry. Pin allows code (C/C++) to be injected at arbitrary places in an executable while it is running. The injected code is used to observe the behavior of the program, and can be used to write a variety of tools, including application profilers, memory leak detectors, and trace generators. Pin provides a rich API that abstracts away the underlying instruction set idiosyncrasies and allows context information such as register contents to be passed to the injected code as parameters. Pin automatically saves and restores the registers that are overwritten by the injected code so the application continues operate normally. Pin makes it easy to do studies on complex real-life applications, which makes it a useful tool not only for research, but also for education. This tutorial provides a detailed look at Pin as a mechanism for enabling rapid prototyping for research, and rapid profiling for education. The tutorial targets researchers, students, and educators alike, from the novice Pin user to the expert Pinhead.
Bios
Kim Hazelwood is an Assistant Professor of Computer Science at the University of Virginia and a faculty consultant for Intel. Her research lies at the interface of compilers and computer architecture, where she focuses on virtual execution environments, their applications, and their implementation. Prior to joining UVa in 2005, Kim held a post-doc position with the Intel Pin team. She has also contributed to several similar projects, including Dynamo, CarbonFire, DELI, DynamoRIO, and Jikes RVM. Kim received her Ph.D. from Harvard University in 2004.
Dan Connors is an Assistant Professor at the University of Colorado at Boulder. His research includes run-time compilation for energy control, temperature management, fault tolerance, and optimization of multi-core systems. He directs the DRACO research group which integrates compiler techniques, hardware performance monitors, and binary instrumentation tools such as Pin into projects that evaluate run-time adaptation of code and system resource allocation. He received his Ph.D. in Computer Engineering from the University of Illinois at Urbana-Champaign in 2000.
David Kaeli received a BS and PhD in Electrical Engineering from Rutgers University, and an MS in Computer Engineering from Syracuse University. He is presently a Full Processor on the ECE faculty at Northeastern University, Boston, MA where he directs the Northeastern University Computer Architecture Research Laboratory (NUCAR). Prior to joining Northeastern in 1993, Kaeli spent 12 years at IBM, the last 7 at T.J. Watson Research Center, Yorktown Heights, NY.
Vijay Janapa Reddi is a Ph.D. student at Harvard University working under Professor Michael D. Smith and also a research member at VMware RD. His research interests are in understanding optimization opportunities using virtual machines and their performance bottlenecks for future multi- and many-core environments. He received his M.S. degree from the University of Colorado at Boulder, where he collaborated with Intel to develop Pin.
Top
