Consider amultiple$-$issue design. Suppose you have two execution pipelines, each

capable of beginning execution of one instruction per cycle, and enough fetch$/$

decode bandwidth in the front end so that it will not stall your execution. Assume

results can be immediately forwarded from one execution unit to another, or to

itself. Further assume that the only reason an execution pipeline would stall is to

observe a true data dependency. Now how many cycles does the loop require?

The answer is $22.$ The fld goes first, as before, and the fdiv.d must wait for

it through four extra latency cycles. After the fdiv.d comes the fmul.d$,$ which

can run in the second pipe along with the fdiv.d$,$ since there$$s no dependency

between them. $($Note that they both need the same input, F$2,$ and they must both

wait onF$2$sreadiness$,$butthereisnoconstraintbetweenthem.$)$Thefldfollowing

the fmul.d does not depend on the fdiv.d nor the fmul.d$,$ so had this been a

superscalar$-$order$-3$ machine, that fld could conceivably have been executed con

currently with the fdiv.d and the fmul.d$.$ Since this problem posited a two

execution$-$pipe machine, the fld executes in the cycle following the fdiv.d$/$

fmul.d$.$ The loop overhead instructions at the loop$$s bottom also exhibit some

potential for concurrency because they do not depend on any long$-$latency

instructions.