Temporal multithreading

From Wikipedia, the free encyclopedia

Temporal multithreading is one of the two main forms of multithreading that can be implemented on computer processor hardware, the other form being simultaneous multithreading. The distinguishing difference between the two forms is the maximum number of concurrent threads that can execute in any given pipeline stage in a given cycle. In Temporal multithreading the number is one, while in simultaneous multithreading the number is larger than one.

Within Temporal multithreading, there are many possible variations, but most can be classified into two sub-forms: coarse-grain and fine-grain. In coarse-grain Temporal multithreading, the main processor pipeline contains only one thread at a time. The processor must effectively perform a (albeit fast) context-switch before executing a different thread. This fast context switch is sometimes referred to as a thread switch. There may or may not be additional penalty cycles when switching. There are many possible variations with coarse-grain Temporal multithreading, mainly having to do with the algorithm that determines when to switch threads. This algorithm may be based on cycle counts, events such as cache misses, fairness, and many other factors.

In fine-grain Temporal multithreading, the main processor pipeline many contain multiple threads, with context switches effectively occurring between pipe stages. This form of multithreading can be more expensive than the coarse-grain forms because execution resources that span multiple pipe stages may have to deal with multiple threads. It can also be more expensive because the design cannot be optimized around the concept of a "background" thread - any of the concurrent threads implemented by the hardware might require its architected state to be read or written on any cycle.

In any of its forms, Temporal multithreading has several things in common with simultaneous multithreading. First, the hardware must store a complete set of architected state per concurrent thread implemented. Second, the hardware must preserve the illusion that a given thread has the processor resources to itself. Third, fairness algorithms must be included to prevent one thread from dominating processor time and/or resources.

Disadvantages relative to Simultaneous multithreading: TBD.

Advantages relative to Simultaneous multithreading: TBD.