Bugs in complex software systems, especially distributed systems, are often difficult to reproduce and diagnose manually. We have developed a programming language, called Cinquecento, for writing programs that help programmers debug complex programs.

The key features of Cinquecento are a first-class abstraction that represents a live program in execution, a C-based syntactic interface to this abstraction, and language mechanisms for tailoring new instances of this abstraction to unanticipated, heterogeneous programming environments. These novel features are embedded in an otherwise simple functional language with conventional semantics based closely on Scheme.

In this talk, we introduce and illustrate the main ideas of Cinquecento.

This is a practice talk for ASPLOS2010.

Multicore technology is making concurrent programs increasingly pervasive. Unfortunately, it is difficult to eliver reliable concurrent programs, because of the huge and non-deterministic interleaving space. In reality, without the resources to thoroughly check the interleaving space, critical concurrency bugs can slip into production runs and cause failures in the field. Approaches to making the best use of the limited resources and exposing severe concurrency bugs before software release would be desirable.

Unlike previous work that focuses on bugs caused by specific interleavings (e.g., races and atomicity-violations), this paper targets concurrency bugs that result in one type of severe effects: program crashes. Our study of the error-propagation process of realworld concurrency bugs reveals a common pattern (50% in our non-deadlock concurrency bug set) that is highly correlated with program crashes. We call this pattern concurrency-memory bugs: buggy interleavings directly cause memory bugs (NULL-pointerdereference, dangling-pointer, buffer-overflow, uninitialized-read) on shared memory objects.

Guided by this study, we built ConMem to monitor program execution, analyze memory accesses and synchronizations, and predicatively detect these common and severe concurrency-memory bugs. We also built a validator ConMem-v to automatically prune false positives by enforcing potential bug-triggering interleavings.

This is a practice talk for ASPLOS2010.

Paper: http://pages.cs.wisc.edu/~shanlu/paper/asplos184-zhang.pdf

Modern scientific applications, such as computer models for analyzing infor mation from particle colliders or space observatories, process data that is exponentially growing in size. High-performance computing (HPC) centers that support such applications are facing a data deluge, which can no longer be managed using ad hoc approaches in use today. Consequently, a reevaluation of the data management tools and techniques is required. In this talk, I will describe a fresh approach to HPC storage space management, especially for the center scratch space --- a high-speed storage used for servicing currently running and soon to run applications, which effectively treats the storage as a tiered cache and provide comprehensive integrated storage management. I will discuss how the caching model is achieved, and how its mechanisms are supported through just-in-time staging and timely offloading of data. Finally, I will show how this approach can also mitigate the effects of center storage failures. The overall goal is to improve HPC center serviceability and resource utilization.

Bio: Ali R. Butt is an Assistant Professor of Computer Science at Virginia Tech. Ali received his Ph.D. in Electrical and Computer Engineering from Purdue University in 2006. His research interests are in experimental computer systems, especially in data-intensive high-performance computing. His current work focuses on I/O and storage issues of modern HPC systems. Ali is a recipient of the NSF CAREER Award (2008), an IBM Faculty Award (2008), and a Virginia Tech College of Engineering "Outstanding New Assistant Professor" Award (2009).