| Hardware-level multithreaded systems provide infrastructure capable of executing multiple software threads in parallel. Such systems range from conventional multiprocessors to the recent simultaneous multithreading (SMT) and chip-multiprocessor (CMP) systems. To ensure that application programs receive high "quality-of-service" (e.g., high throughput, low response time), it is important for multithreaded systems to manage their hardware resources efficiently.; Existing resource management solutions in operating systems and hardware are far from optimal. The major obstacle they face is the lack of accurate knowledge in the OS and hardware about application runtime behavior. For example, existing processors try their best to maximize metric values (e.g., instructions-per-cycle) meaningful to them, which, however, often do not correlate with metrics in which the applications are interested (e.g., transactions-per-second for a database application). Such lack of knowledge about application behavior often leads to inefficient resource usage in multithreaded systems.; In this thesis, we develop mechanisms that enable multithreaded systems to self-monitor application runtime behavior. To support efficient management of processor resources (e.g., functional units), we study monitoring of thread microexecutions and their correlations with application-level performance metrics. To support efficient management of system resources (e.g., entire processors), we study monitoring of thread interactions. We focus on monitoring thread synchronization behaviors, which reflect application performance, and thread deadlocks, which reveal errors in applications.; We make three contributions in this thesis. First, we develop a directed acyclic graph (DAG) model for quantifying the criticality of instructions on shared memory multithreaded systems. Second, we design a hardware mechanism that dynamically detects spinning synchronizations in multithreaded programs. Based on this design, we develop (1) hardware performance counters that more accurately reflect application performance than existing counters, (2) thread scheduling and power control policies that more efficiently manage resources than existing policies, and (3) OS and hardware support for detecting application livelocks. The third contribution of this thesis is an operating system mechanism, called Pulse, which can dynamically detect deadlocks in user applications. By using OS-level speculative execution, Pulse can detect deadlocks involving consumable resources, such as synchronization semaphores and pipes, which, to the best of our knowledge, no existing tools can detect. |
