 In this section, we're going to be focusing on dynamic multiple-issue processors. They're a lot more interesting than the static issue processors that we looked at before, but these also go under a few different names. They're most commonly referred to as superscalar processors, and they generally implement some form of Tomasulo's algorithm. In this case, the CPU dynamically determines how many instructions to fetch every cycle, when to process those instructions, and when to commit their results. All of this will be determined dynamically based on the resources that each instruction needs. These algorithms can actually issue more than one instruction every cycle, but if they're going to do so, we'd like them to commit at least as many instructions back every cycle. You could consider a processor that, for example, issued four instructions every cycle, but could only commit three instructions at the end of the cycle. It would very quickly become obvious that the commit unit is going to be the bottleneck. I can issue more instructions into this pipeline than I can pull out of it. So the maximum throughput would ultimately be determined by the number of instructions we can push out the end. However, we could make our commit unit larger so that we can commit more instructions every cycle than we can actually issue. We'll look at these in more detail in the next section when we're looking at the algorithm that actually handles this.