nothing to directly improve the performance of contemporary or future single-threaded applications. This paper examines the scalability potential for exploiting the parallelism in single-threaded applications on these CMP platforms. The paper explores the total available parallelism in unmodified

computation in parallel. These designs provide real benefits for server-class applications that are explicitly multi-threaded. However, for desktop and other systems where single-thread applications dominate, multicore systems have yet to offer much benefit. Chip multiprocessors are most efficient

To my parents. ii ACKNOWLEDGEMENTS First, I would like to thank my adviser Professor Scott Mahlke. Scott has been a great mentor who provided priceless guidance, shown incredible patience and support during the past years. I consider myself truly lucky to have worked with him. Without his help and support this dissertation would not exist. Next, I would like to thank the remaining members of my dissertation committee, Professor Todd Austin, Professor Dennis Sylvester, Professor Chandrasekhar Boyapati, and Dr. Mike Schlansker. They all provide invaluable comments and insights to improve my thesis and shape this research into what is has become today. The research done in this work utilizes a large software infrastructure maintained and supported by the CCCP research group. This work would not be possible without the technical support from everyone in the group. In particular, Steve Lieberman wrote the first version of the memory profiler in Chapter 5. Mojtaba Mehrara added significant contribution to this dissertation by spending a great deal of efforts with me developing and debugging the code generation framework in Chapter 5. The code partitioning algorithm was based on the Bottom Up Greedy algorithm implemented by Kevin Fan. Mike Chu, Nate Clark, Kevin Fan, Manjunath Kudlur and Rajiv Ravindrand helped me many times, answering questions about the Trimaran infrastructure and fixing very hard bugs. More importantly, all members of the CCCP research group makes my graduate career much more fun. I would like to thank Jason Blome, Mike Chu, Nate Clark, Ganesh Dasika,

One way to improve the performance of a singlethreaded application is to run regions of the code speculatively on a multi-core system. In a composable multicore system, resources such as the L1 cache, register file, and instruction window are distributed among the cores. In such a system

The scaling of technology and the diminishing return of complicated uniprocessors have driven the industry towards multicore processors. While multithreaded applications can naturally leverage the enhanced throughput of multi-core processors, a large number of important applications are single-threaded

with the usual "copy on write" applicative semantics but for which writes are implemented destructively. Syntactic restrictions insure consistency between the formal semantics and the implementation. The design of single-threaded objects has been influenced both by the need to make execution efficient

created an extension to gdb that can simulate threads on any single-process event-driven system. We prove that our algorithm will work for similar systems that run an arbitrary number of message handlers in parallel. 1 Introduction and Motivation 1.1

Speculative Precomputation (SP) is a technique to improve the latency of single-threaded applications by utilizing idle multithreading hardware resources to perform aggressive long-range data prefetches. Instead of trying to explicitly parallelize a single-threaded application, SP does

the original sequential order; and (4) mechanisms to checkpoint the architectural state and recovery to handle misspeculations. The proposed scheme outperforms previous hardware-only schemes to implement the idea of combining cores for executing single-thread applications in a multi-core design by more than 10

the application of the analysis to the compilation of functional languages, semantics-directed compiler generation and globalization-directed transformations (i.e. transforming non-single-threaded expressions into single-threaded ones). Our results can also be turned to account to get single-threading criteria