C tools, such as source browsers, bug finders, and automated refactorings, need to process two languages: C itself and the preprocessor. The latter improves expressivity through file includes, macros, and static conditionals. But it operates only on tokens, making it hard to even parse both languages.

This talk presents a complete, performant solution to this problem. First, a configuration-preserving preprocessor resolves includes and macros yet leaves static conditionals intact, thus preserving a program's variability. To ensure completeness, we analyze all interactions between preprocessor features and identify techniques for correctly handling them. Second, a configuration-preserving parser generates a well-formed AST with static choice nodes for conditionals. It forks new subparsers when encountering static conditionals and merges them again after the conditionals. To ensure performance, we present a simple algorithm for table-driven Fork-Merge LR parsing and four novel optimizations. We demonstrate the effectiveness of our approach on the x86 Linux kernel.

This is joint work with Paul Gazzillo. The corresponding paper is online at http://cs.nyu.edu/rgrimm/papers/pldi12.pdf.

Bio:

Robert Grimm is an Associate Professor in the Department of Computer Science at New York University. He graduated with a Ph.D. in Computer Science from the University of Washington at Seattle in 2002. Professor Grimm's research explores how to leverage programming language technologies for making complex systems easier to build, maintain, and extend. His recent work focuses on multilingual and on streaming systems. Professor Grimm's honors include an NSF Career Award, a Junior Fellowship at NYU's Center for Teaching Excellence, and the Best Paper Award at the 6th ACM International Conference on Distributed Event-Based Systems.

Online video is the killer application of the Internet. It is predicted that more than 85% of the consumer traffic on the Internet will be video-related by 2016. Yet, the future economic viability of online video rests squarely on our ability to understand how viewers interact with video content. For instance:

• If a video fails to start up quickly, would the viewer abandon?
• If a video freezes in the middle, would the viewer watch fewer minutes?
• If videos fail to load, is the viewer less likely to return to the same site?


In this talk, we outline scientific answers to these and other such questions, establishing for the first time a causal link between video performance and viewer behavior. One of the largest such studies, our work analyzes the video viewing habits of over 6.7 million viewers who in aggregate watched almost 26 million videos. To go beyond mere correlation and to establish causality, we develop a novel technique based on Quasi-Experimental Designs (QEDs). While QEDs are well known in the medical and computational social science, our work represents its first use in network performance research and is of independent interest.
This talk is of general interest and is accessible to a broad audience.

Bio:

Ramesh K. Sitaraman received his B. Tech. in electrical engineering from the Indian Institute of Technology, Madras. He obtained his Ph.D. in computer science from Princeton University. Prof. Sitaraman is currently a faculty member in the Computer Science Department at the University of Massachusetts at Amherst, where he is part of the Theoretical Computer Science group.

On a leave from academia, as a principal architect, Prof. Sitaraman helped build Akamai Technologies and helped pioneer the Internet-scale distributed networks that currently deliver much of the world’s web content, streaming videos, and online applications. He was named an Akamai Fellow.

Prof. Sitaraman's research focuses on foundational issues in the design of large Internet-scale distributed systems, communication networks, cloud computing, and global Internet services. Prof. Sitaraman is a recipient of an NSF CAREER Award and a Lilly Fellowship. He has served on numerous program committees and editorial boards of major conferences and journals.

Parallel hardware is today's reality and language extensions that ease exploiting its promised performance flourish. For most mainstream languages, one or more tailored solutions exist that address the specific needs of the language to access parallel hardware. Yet, one widely used language is still stuck in the sequential past: JavaScript, the lingua franca of the web.

Solutions used in other languages do not transfer well to the world of JavaScript due to differences in programming models, the additional requirements of the web like safety and security, and developer expectations. To address this we created River Trail, a new parallel programming API designed specifically for JavaScript. This talk will describe River Trail and its vision of how to leverage current and future parallel hardware from within the browser and JavaScript.

Bio:

Richard L. Hudson is best known for his work in memory management including the invention of the Train Algorithm, the Sapphire Algorithm, the Mississippi Delta Algorithm, and leveraging transactional memory to enable concurrent garbage collection. He pioneered the use of stack maps which enables accurate garbage collection in statically typed languages like Java. He worked on transactional memory and was a driving force that led to the articulation of the x86 memory model. For the past 2+ years, Richard has worked on the River Trail team researching the concurrent programming models needed to implement a more visual and immersive web experience.

Richard joined Intel in 1998 where he has worked on programming language runtimes, memory management, concurrency, synchronization, memory models, and programming model issues. He went to Shortridge, holds a B.A. degree from Hampshire College, and an M.S. degree from the University of Massachusetts.

We have little reason to trust computer systems. We do not know what software lurks on the other side of a network connection, or even what software runs on our own machines. We have few means to specify or reason about why we might trust a piece of software. And we do not have adequate authorization mechanisms in place to limit the damage that rogue software can inflict.

In this talk, I will revisit the familiar problem of authorization, focusing on how formal authorization logic might be leveraged to build more trustworthy systems. Lessons will be drawn from our experience using such logic to implement a file-system and some applications for Nexus, an experimental operating system that relies on a trusted platform module (TPM) hardware co-processor as a secure root of trust.

Bio:

Kevin Walsh is an Assistant Professor in the Department of Mathematics and Computer Science at the College of the Holy Cross. He received his Ph.D. in 2012 from Cornell University; prior to his graduate studies he held a position as a visiting researcher at Duke University. His research spans authorization logics, trustworthy applications and operating systems, device driver isolation, peer-to-peer and wireless sensor networks, and network simulation and emulation.

Effective medical care depends on well-designed user interfaces that enable users to benefit from the increasing abundance of information that supports decision making. Novel strategies in information visualization allow clinicians and medical researchers to explore in systematic yet flexible ways, so as to derive insights and make discoveries.

This talk begins with commercial success stories such as www.spotfire.com, www.smartmoney.com/marketmap and www.hivegroup.com and explores their application to medical informatics. Then we look at research tools for electronic health records to find specified event sequences (www.cs.umd.edu/hcil/lifelines2) and to view compact summaries of millions of patient histories (www.cs.umd.edu/hcil/lifeflow). Demonstrations also cover visual interfaces to support clinicians in understanding patient status, doing medication reconciliation, and tracking medical lab tests (www.cs.umd.edu/hcil/sharp).

Bio:

Ben Shneiderman is a Professor in the Department of Computer Science and Founding Director (1983-2000) of the Human-Computer Interaction Laboratory (http://www.cs.umd.edu/hcil/) at the University of Maryland. He is a Fellow of the AAAS, ACM, and IEEE, and a Member of the National Academy of Engineering.

Prof. Shneiderman is the co-author with Catherine Plaisant of Designing the User Interface: Strategies for Effective Human-Computer Interaction (5th ed., 2010). With Stu Card and Jock Mackinlay, he co-authored Readings in Information Visualization: Using Vision to Think (1999). His book Leonardo’s Laptop appeared in October 2002 (MIT Press) and won the IEEE book award for Distinguished Literary Contribution. His latest book, with Derek Hansen and Marc Smith, is Analyzing Social Media Networks with NodeXL (2010).

This talk will provide a general and accessible overview of my recent work on Reverse Data Management. The vision of my research is to make data and its history (provenance) fully explorable, verifiable, and reversible. Today, increasingly more data is derived from other data, emphasizing the need to reverse engineer these derivations. For example, while today scientists who use previously cleaned data are forced to trust the cleaning process, I envision automatically reverse-engineering how data cleaning affects the results. Making such information part of the analysis process, and automating its extraction, can revolutionize not only data cleaning applications, but also financial data mining, data analysis debugging, and performance anomaly cause detection.

I will discuss applications of causality in data analysis and business intelligence tasks, and demonstrate the Tiresias system, which extends database functionality to handle strategy planning queries over large datasets. My talk will highlight future directions and potential synthesis projects.

Bio:

Alexandra Meliou is an Assistant Professor and the Department of Computer Science, at the University of Massachusetts, Amherst. She has held this position since September 2012. Prior to that, she was a Post-Doctoral Research Associate at the University of Washington, working with Dan Suciu. Alexandra received her Ph.D and M.S. degrees from the Electrical Engineering and Computer Sciences Department at the University of California, Berkeley, in 2009 and 2005 respectively. She is a 2008 Siebel Scholar, and her research interests are in the area of data and information management, with a current emphasis on provenance, causality, and reverse data management.

Multithreaded programs are notoriously prone to unintended interference between concurrent threads. To address this problem, we argue that yield annotations in the source code should document all thread interference, and we present a type system for verifying the absence of undocumented interference. Well-typed programs behave as if context switches occur only at yield annotations. Thus, they can be understood using intuitive sequential reasoning, except where yield annotations remind the programmer to account for thread interference.

Experimental results show that our type system for yield annotations is more precise than prior techniques based on method-level atomicity, reducing the number of interference points by an order of magnitude. The type system is also more precise than prior methods targeting race freedom. In addition, yield annotations highlight all known concurrency defects in our benchmark suite.

This is joint work with Cormac Flanagan, Jaeheon Yi, Caitlin Sadowski at UC Santa Cruz.

Bio:

Stephen Freund is an Associate Professor and Chair of the Computer Science Department at Williams College. His current research focuses on light-weight analyses to identify defects in concurrent software, such as race conditions, atomicity errors, and specification violations. Prior to joining Williams in 2002, Steve worked at the Compaq Systems Research Center on various programmer productivity tools. He received his PhD from Stanford University in 2000.

Over the last several years, JavaScript malware has emerged as one of the most popular ways to deliver drive-by attacks to unsuspecting users through the browser. This talk covers recent Microsoft Research experiences with finding malware on the web. It highlights two tools: Nozzle and Zozzle. Nozzle is a runtime malware detector that focuses on finding heap spraying attacks. Zozzle is a mostly static detector that finds heap sprays and other types of JavaScript malware. Both are extremely precise: Nozzle false positive rate is close to one in a billion; Zozzle's is about one in a million.

Both are deployed by Bing and are used daily to find thousands of malicious web sites. This talk will focus on interesting interplay between static and runtime analysis and cover what it takes to migrate research ideas into real-world products.

Nozzle is deployed at Bing and has been finding thousands of malware sites daily for months now. Initial estimates show that with Zozzle, the team can go even further in detecting malicious sites. The focus of Zozzle is on providing a very fast and accurate scanner for detecting malware in JavaScript code. Zozzle is able to process a megabyte of code in a second and finds malware with a false positive rate of one in a million JavaScript documents.

Bio:

Ben Livshits is a researcher at Microsoft Research in Redmond, WA and an affiliate professor at the University of Washington. Originally from St. Petersburg, Russia, he received a bachelor's degree in Computer Science and Math from Cornell University in 1999, and his M.S. and Ph.D. in Computer Science from Stanford University in 2002 and 2006, respectively. Dr. Livshits' research interests include application of sophisticated static and dynamic analysis techniques to finding errors in programs.

Ben has published papers at PLDI, Oakland Security, Usenix Security, CCS, SOSP, ICSE, FSE, and many other venues. He is known for his work in software reliability and especially tools to improve software security, with a primary focus on approaches to finding buffer overruns in C programs and a variety of security vulnerabilities (cross-site scripting, SQL injections, etc.) in Web-based applications. He is the author of several dozen academic papers and patents. Lately he has been focusing on how Web 2.0 application and browser reliability, performance, and security can be improved through a combination of static and runtime techniques. Ben generally does not speak of himself in the third person.

Debugging run-time errors remains one of the most time-consuming, and sometimes frustrating, efforts in developing and maintaining programs. A run-time error is uncovered, and the programmer then begins multiple iterations within a debugger in order to build up a hypothesis about the original program fault that caused the error. Examples of run-time errors include segmentation fault, assertion failure, infinite loop, deadlock, livelock, and missing synchronization locks.

This talk describes a debugging approach based on a reversible debugger, sometimes known as a time-traveling debugger. This is a more natural approach, since it allows a programmer during a single program run to work backwards from run-time error to earlier fault, and still earlier to the original causal fault. A new tool, reverse expression watchpoints, allows one to begin with a program error and an expression that has an incorrect value, and automatically bring the programmer backwards in time to a point at which the expression first took on an incorrect value. This tool is part of a long-range project in which a series of such tools is planned --- each tool customized for a different class of run-time errors.

The long-term goals described here are motivated by an analogy between syntax errors and run-time errors:

1. Currently, syntax errors are easily diagnosed by compilers that bring the programmer directly to the line number, within a textual program, that led to the bad syntax.
2. In the future, run-time errors will be easily diagnosed by a new class of reversible debugger tools that bring the programmer directly to the point in time, within a familiar debugging environment, that led to the later run-time error.

The reversible debugger is itself based on a fast, transparent checkpointing package for Linux: DMTCP (Distributed MultiThreaded CheckPointing). DMTCP can checkpoint such varied programs as Matlab, OpenMPI, MySQL, Python, Perl, GNU screen, Vim, Emacs, and most user-developed programs, regardless of the implementation language. No kernel modification or other root privilege is needed. Of particular interest for this talk is the ability of a customized version of DMTCP to checkpoint an entire gdb session. The reversible debugger also supports weak determinism for purposes of debugging multi-threaded programs. The current implementation has been demonstrated robust enough to run such large, real-world programs as MySQL and Firefox.

Bio:

Gene Cooperman received his Ph.D. from Brown University in 1978. He spent two years as a post-doc, followed by six years at GTE Laboratories. He has been a professor at Northeastern University since 1986, and a full professor since 1992. His interests lie in high performance computation and symbolic algebra. The first interest is currently focussed on DMTCP, a robust transparent checkpointing package that does not require any modifications to the application or kernel/run-time library. A combination of the two interests has led to his joint work on the Roomy language extension to translate traditional RAM-intensive computations into scalable computations based on parallel disks. A variation for remote RAM and supercomputing is being developed for the Madness software at Oak Ridge National Laboratory. He also has a decade-long relationship with CERN, where he supports semi-automatic thread parallelization of task-oriented software, such as Geant4 at CERN. He leads the High Performance Computing Laboratory at Northeastern University, where he currently advises four PhD students. He has over 80 refereed publications.

Over the past few years parallel dataflow graph frameworks (such as MapReduce, Hadoop, Dryad) have enabled data intensive computing on clusters built from commodity hardware. A key component in a parallel dataflow graph computation is the intermediate data that flows between various computation stages. This data is generated during the computation and, in general, has to be moved across machines in the cluster involving network I/O as well as disk I/O. At large volumes (viz., 10's to 100's of terabytes of data), unless careful attention is paid to disk overheads involved in dealing with intermediate data, cluster throughput will degrade.

In this talk, we describe a new approach to handling intermediate data at scale. We find that managing large volumes of intermediate data requires novel batching mechanisms to reduce disk subsystem overheads. Our approach is to build filesystem support specifically for storing intermediate data. We design an atomic record append primitive that enables concurrent writers to append to a file in a lock-free manner: multiple writers append to a block and multiple blocks of a file can be appended to concurrently. We denote files constructed via atomic append I-files. I-file blocks are written to sequentially and are read back mostly sequentially. We have developed an implementation of I-files and used it as the foundation for Sailfish, a MapReduce framework we built by modifying Hadoop. We have also used Sailfish to run unmodified Hadoop MapReduce jobs that process production datasets. Our results show that for transporting intermediate data at scale, Sailfish can outperform Hadoop by at least a factor of 2.

Bio:

Sriram is a member of the Cloud Sciences group at Yahoo! Labs. His interests are in building distributed storage systems that enable high performance compute services for processing massive datasets. At Yahoo!, Sriram leads the Sailfish project whose goal is to enable large-scale analytics on big data. Prior to Yahoo!, Sriram led the design and implementation of KFS (Kosmos Filesystem), an open-source filesystem project. KFS is deployed in production settings where it is used to manage multiple-PB's of storage.

As hardware and software continues to evolve into increasingly complex systems, our ability to understand their behavior and measure their performance is increasingly difficult.

Nevertheless, many areas of computer science use experiments to identify performance bottlenecks and to evaluate innovations. In the last few years, researchers have identified some disturbing flaws in the way that experiments are performed in computer science.

This talk presents two of these flaws.

First, changing a seemingly innocuous aspect of an experimental setup can result in a systems researcher drawing wrong conclusions from an experiment. What appears to be an innocuous aspect in the experimental setup may in fact introduce a significant bias in an evaluation of native (C and C++) applications.

Second, performance analysts profile their programs to find methods that are worth optimizing: the “hot” methods; however, four commonly used Java profilers (xprof , hprof , jprofile, and yourkit) often disagree on the identity of the hot methods. This talk demonstrates that these profilers all violate a fundamental requirement for sampling based profilers: to be correct, a sampling-based profiler must collect samples randomly.

Unfortunately, the flaws discussed above are not the full extent of the problem. If computer science is to be taken seriously as a scientific discipline, we as a community need to do a better job designing experiments and evaluating their results.

I will discuss some current efforts being made by the community to improve experimental evaluation in computer science.

Bio:

Peter F. Sweeney is a Research Staff Member in the Program Technology Department at the IBM T.J. Watson Research Center in Hawthorne, New York. His current research interests are performance analysis and tuning of computer systems with a focus on automation. In the past, he has focused on object-oriented optimization. Peter received a Master's degree in Computer Science from Columbia University SEAS and he joined IBM Research in 1985. Peter is a senior member of ACM and a co-author of the paper "Adaptive optimization in the Jalapeno JVM", which received the 2010 ACM SIGPLAN most influential OOPSLA 2000 paper award.

Challenges in digital services delivery: the cloud vs. the crowd (Diot)

The universal answer to home service delivery these days seems to be "the cloud", even though nobody really agrees on what "cloud services" means. In order to bring some transparency to the Cloud, we identify what are the challenges in digital home services delivery, discuss the strengths and limitations of a pure cloud approach, and finally propose an hybrid solution relying both on data centers and home devices to better serve home users. We discuss the research and technology challenges that have to be solved to deploy this digital service delivery architecture.

Performance of Networked Applications: The Challenges in Capturing the User’s Perception (Teixeira)

There is much interest recently in doing automated performance diagnosis on user laptops or desktops. One interesting aspect of performance diagnosis that has received little attention is the user perspective on performance. To conduct research on both end-host performance diagnosis and user perception of network and application performance, we designed an end-host data collection tool, called HostView. HostView not only collects network, application and machine level data, but also gathers feedback directly from users. User feedback is obtained via two mechanisms, a system-triggered questionnaire and a user-triggered feedback form, that for example asks users to rate the performance of their network and applications. This talk will describe our experience with the first deployment of HostView. Using data from 40 users, we illustrate the diversity of our users, articulate the challenges in this line of research, and report on initial findings in correlating user data to system-level data. This is joint work with Diana Joumblatt, Jaideep Chandrashekar, and Nina Taft.

 

A multi-domain cloud combines virtual infrastructure from multiple providers to create a powerful platform for networked services, computation, and experimental systems research. NSF's GENI initiative (Global Environment for Network Innovation) is a key example of a multi-domain infrastructure-as-a-service (IaaS) system: it generalizes IaaS cloud computing to incorporate diverse virtual infrastructures, noncommercial providers, configurable network connectivity, and software-defined networking.

One lesson we can draw from the GENI experience is that many of the technical challenges for the GENI control framework ultimately reduce to issues of trust and authorization. In this talk, I will outline an emerging architecture based on declarative policy for federation trust structure and authorization for access to cloud resources. The approach uses libabac from ISI, an open-source implementation of an authorization logic called Attribute-Based Access Control (ABAC). I also address the question of how to incorporate software identities as subjects in the authorization framework. How do we know if we can trust applications and services running in the cloud? I discuss preliminary research on Trusted Platform Cloud, which uses attestations by cloud providers to infer trust for autonomous software instances.

Bio:

Jeff Chase is a Professor of Computer Science at Duke University and a Visiting Scientist at the Renaissance Computing Institute (RENCI). He has spent much of the last four years working on the GENI control framework as a Control Framework Working Group chair and as leader of the Open Resource Control Architecture (ORCA) project. He is co-chair of the 2011 ACM Symposium on Cloud Computing (SOCC).

This presentation will describe four ongoing projects that are advised by my computer-architecture colleague Luis Ceze and that I am co-advising or contributing to. For each, I will point out what aprogramming-languages perspective has to offer and why it is useful to have students who can nimbly cross or blur the hardware/software divide. The projects — deterministic execution of multithreaded programs, code-centric specification of shared memory, language support for approximate low-power computing, and run-time errors for data races — address the key technology trends of ubiquitous parallelism and energy as a first-order concern.

Bio:

Dan Grossman is an Associate Professor in the Department of Computer Science & Engineering at the University of Washington where he has been a faculty member since 2003. Grossman completed his Ph.D. at Cornell University and his undergraduate studies at Rice University. His research interests lie in the area of programming languages, ranging from theory to design to implementation, with a focus on improving software quality. In recent years he has focused on better techniques for expressing multithreaded programs, particularly using languages with well-defined support for transactional memory. In prior work, he focused on type-safe systems programming using the Cyclone language, which he developed with colleagues.

Grossman has served on over fifteen conference and workshop program committees in addition to co-chairing the 2007 ACM SIGPLAN-SIGSOFT PASTE workshop and the 2009 ACM SIGPLAN TRANSACT workshop. He currently serves on the ACM SIGPLAN Executive Committee and the ACM Education Council. He is the recipient of an NSF Career Award and two "Teacher of the Year" Awards voted on by his department's undergraduates.

In his spare time, Dan can be found playing ice hockey (poorly), bicycling, hiking, or enjoying good food, beer, and theatre. Dan has never had a cavity.

Many multithreaded concurrency platforms that use a work-stealing runtime system incorporate a "cactus stack," wherein the stack variables that can be accessed by functions properly respect the functions' calling ancestry, even when many of the functions operate in parallel. Unfortunately, such existing concurrency platforms fail to satisfy at least one of the following three desiderata:

• full interoperability with legacy or third-party serial binaries that have been compiled to use an ordinary linear stack,
• a scheduler that provides near-perfect linear speedup on applications with sufficient parallelism, and
• bounded and efficient use of memory for the cactus stack.

We have addressed this cactus-stack problem by modifying the Linux operating system kernel to provide support for thread-local memory mapping (TLMM). We have used TLMM to reimplement the cactus stack in the open-source Cilk-5 runtime system. Our prototype Cilk-M runtime system removes the linguistic distinction imposed by Cilk-5 between serial code and parallel code, erases Cilk-5's limitation that serial code cannot call parallel code, and provides full compatibility with existing serial calling conventions. The Cilk-M runtime system provides strong guarantees on scheduler performance and stack space. Benchmark results indicate that the performance of the prototype Cilk-M is comparable to the Cilk-5 system, and the consumption of stack space is modest.

Bio:

I-Ting Angelina Lee is a Ph.D. student in computer science at the Massachusetts Institute of Technology, working with Prof. Charles E. Leiserson. Her primary research interest is in the design and implementation of programming models, languages, and managed runtime environments to support multithreaded software, with an emphasis on efficient implementations with theoretical foundations. She designed and implemented JCilk, a Java-based Cilk that has exception-handling semantics which integrate synergistically with the multithreading provided by Cilk's fork-join primitives. She developed the "ownership-aware" transactional-memory methodology for handling nested transactions that, unlike previous proposals, admits more concurrency and provides provable safety guarantees. Her current focus is on memory abstractions for parallel computing, and she is actively developing Cilk-M, a concurrency platform that uses thread-local memory mapping to support cactus stacks and hyperobjects. She received her Bachelor of Science in Computer Science from UC San Diego in 2003, where she worked on the Simultaneous Multithreading Simulator for DEC Alpha under the supervision of Prof. Dean Tullsen.

Hardware is the root of trust in computer systems, because all software runs on it. Economic, technological, and social factors make it increasingly difficult to build trustworthy hardware. Use of third-party intellectual property components, the global scope of the chip design process, increased design complexity and integration, growing design teams with relatively small numbers of designers responsible for each sub-component all conspire to make hardware more susceptible to malicious design and less trustworthy than in the past. Untrustworthy hardware is already a concern for military and public safety equipment as evidenced by the recent discovery of hardware "kill switches" in mission critical systems. In this talk I will provide a complete taxonomy of digital hardware attacks and use this taxonomy to derive a range of possible solutions to make hardware trustworthy.

Bio:

Simha Sethumadhavan is an Assistant Professor of Computer Science at Columbia University. He directs the computer architecture and security technologies lab (CASTL) at Columbia University. Prof. Sethumadhavan’s research interests are in hardware security, hardware support for security and privacy, energy-efficient computing and systems research tools. He has been recognized with teaching and research awards. He obtained his PhD from UT Austin in 2007.

Modern microprocessors achieve high performance through aggressive speculation. However, large amounts of energy and potential performance are lost by speculating fruitlessly. The two most important speculation techniques are caches and speculative execution.

Caches hold a subset of the blocks from the high-latency main memory, speculating that quick access to these blocks will benefit the program. Unfortunately, most blocks in the last-level cache will not be referenced again before they are removed from the cache. These dead blocks waste time and energy as they reduce the effective capacity of the cache.

Speculative execution mitigates pipeline control hazards by predicting the outcome of branches, allowing subsequent instructions to be fetched and executed down the predicted path. Many instructions will be wrongly executed before an incorrect prediction is discovered, again wasting time and energy.

This talk discusses novel techniques for reclaiming lost performance and energy through reducing speculation wasted by caches and speculative execution. The talk will also discuss ongoing projects and future research directions.

Bio: Daniel A. Jimenez is an Associate Professor in the Department of Computer Science at The University of Texas at San Antonio. He is currently on leave at the Barcelona Supercomputing Center. His research focuses on microarchitecture and low-level compiler optimizations. From 2002 through 2007, Daniel was an Assistant Professor in the Department of Computer Science at Rutgers. In 2005 Daniel took sabbatical leave at the Technical University of Catalonia (UPC) in Barcelona, Catalonia, Spain. In 2008 he was promoted to Associate Professor with tenure at Rutgers. Daniel earned his B.S. (1992) and M.S. (1994) in Computer Science at The University of Texas at San Antonio and his Ph.D. (2002) in Computer Sciences at The University of Texas at Austin. He is an NSF CAREER award recipient, an ACM Senior Member, and General Chair of the 2011 HPCA conference.