A common operation performed in graphics rendering is computing

the inverse square root of a number, $\frac{1}{\sqrt[\phantom{2}]{n}}$

This is used when normalizing vectors to calculate angles of incidence

and reflection$--$an operation so common modern $3$D graphics

programs typically perform millions of these calculations every second

to simulate lighting.

In the early $1990$ s$,$ when $3$D graphics rendering started to become

widespread in the video game industry, the floating point processing

power of most CPUs was too slow to perform the inverse square root

at the speed required, necessitating certain speedups. This question

investigates the tradeoffs between these speedups.

Suppose the application QUAKE spends $20\%$ of its execution time

computing the inverse square root of a flocting point number, and $15\%$

of its time computing the inverse square root of an integer. Consider

each of the following speedups:

$(1)$ Proposed additions to the $86$ ISA would add the rsqrtss instruction, which could be run in

parallel to speed up computation of the inverse square root for all numbers $($integer and

floating point$)$ by $20\%.$ Supposing this instruction is added, what would the overall speedup

for the QUAKE application be$,$ when considering this speedup alone?

You should input a float number here $($round your result to the nearest

thousandth$).$ The overall speed up is

$(2)$ On existing hardware $($without the speedup in $($a$)),$ computing the inverse square root of an

integer is $30\%$ faster than that of a floating point number. However, by utilizing a trick

involving a magic number, $0$x$5$F$3759$DF$,$ a floating point number can be converted to an

integer $($for the purposes of this computation$).$ This allows all inverse square root calculations

to be as fast as those for integers.

What is the overall speedup for the QUAKE application considering this optimization alone?

Show your work and round your result to the nearest thousandth.

You should input a float number here $($round your result to the nearest

thousandth$).$ The overall speed up is

$(3)$ You are not satisfied with either speedup, and go purchase a DSP which supports

calculating the inverse$-$square root for all numbers with a speedup equivalent to $20$CPU

cores. Supposing this DSP is added, the entire inverse$-$square root calculation is parallelizable,

and the DSP is only used to accelerate the inverse$-$square$-$root calculation, what is the overall

speedup for QUAKE considering this optimization alone?

You should input a float number here $($round your result to the nearest

thousandth$).$ The overall speed up is