Resource control methods for multithreaded cores
In a simultaneous multithreaded system, a core's hardware may be shared among multiple threads in a single clock cycle. This simultaneous occupancy of hardware is implemented to exploit thread-level parallelism in addition to instruction-level parallelism. However, since any combination of threads which simultaneously occupy a series of hardware resources may proceed at different paces, this technique inevitably leads to resource starvation and a biased distribution of shared resources. This in turn leads to degraded overall system performance. Two notable shared resources are the issue queue and the write buffer. The issue queue acts as a collection of buffers for a core's functional units. Before an instruction may execute, it must first be dispatched to the issue queue, which in turn dispatches the instruction to an appropriate functional unit. A write buffer acts as an intermediary between a core's final pipeline stage and its data cache. The write buffer holds the values of committed store instructions while the appropriate cache lines are located and brought into memory. This thesis presents techniques to increase system performance in multithreaded cores by dynamically controlling how these resources are allocated to different threads. The proposed techniques were implemented in a simulation environment and were shown to have significant overall system performance improvement in the simulated environment.