To best manage the many resources of a complex computer system, the system must be able to provide accurate feedback about its behavior. This feedback is useful for the system user, the software, and the hardware itself. Aspects of behavior include performance, liveness, availability, and power consumption. Resource management is even more critical for multithreaded computers, including multiprocessors and SMT, because these increasingly prevalent systems often provide infrastructure for multiple applications and users. These systems have many resources to manage, including thread contexts (or processors) and power.
Our goal is to enable multithreaded computers to provide accurate feedback. While existing hardware performance counters do provide feedback about system behavior, such feedback is often inaccurate and even misleading in the presence of spinning synchronization. Spinning threads are executing loops of instructions that perform no useful work while waiting to synchronize with other threads (e.g., while waiting to acquire a lock). Spinning can lead to overestimates of performance (e.g., high IPC or a low cache miss rate per instruction) and even livelock, both of which hinder management of the system's resources.
To overcome the challenges that spinning poses for multithreaded systems, we propose efficient hardware for detecting thread spinning. While there are many potential benefits of accurately self-monitoring multithreaded systems, we focus on three in this talk. First, we develop hardware performance counters that accurately reflect system performance. Second, we show how to improve scheduling and power management by not allocating resources to spinning threads. Third, we use the spin detector at each thread context to help detect when a multithreaded program is livelocked. Intuitively, if all threads of a program are simultaneously spinning, then the program is livelocked. Using full-system simulation with commercial and scientific workloads, we demonstrate that our mechanisms could be used to improve the management of multithreaded systems.
Return to the SPIDER schedule