As usual, you have been provided with a file lab$10.$h with headers for the functions described, lab$10$c$.$c with analogous C implementations, tests.c with reasonably thorough tests of the functions as described.

Dot Product, again

The dot product $($pairwise product, and sum$)$ that we did in Lab $7$ makes more sense on floating point values.

In lab$10.$S$,$ write a function dot$\_$double that calculates the dot product of two arrays, as before but on double$-$precision floating point arrays.

An equivalent dot$\_$double$\_$c has been provided in lab$10$c$.$c$.$

Polynomial evaluation, again

We previously wrote a function that evaluated a cubic polynomial on a single x value, using the equivalent of this expression: x$*($x$*($a$*$x $+$ b$)+$ c$)+$ d$.$

This time, we want to apply this operation to an array of double x values, writing the result to another $($equally$-$sized$)$ array. That is$,$ for each array element, do the above calculation and put the result in the corresponding position in the "output" array.

In lab$10.$S$,$ write a function map$\_$poly$\_$double with this signature $($the coefficients will be constant$)$:

void map$\_$poly$\_$double$($double$*$ input, double$*$ output, uint$64\_$t length, double a$,$ double b$,$ double c$,$ double d$)$;

Equivalent map$\_$poly$\_$double$\_$c$1$ and map$\_$poly$\_$double$\_$c$2$ have been provided, with the two expressions we used in the previous exercise, for comparison.

That, but Single Precision

Maybe single$-$precision floating point operations are faster?

In lab$10.$S$,$ write functions dot$\_$single and map$\_$poly$\_$single that are equivalent to the above but work on single$-$precision floating point values $($float$).$ This should be as simple as swapping double$-$precision instructions for their single$-$precision equivalents, and changing the element size from $8$ to $4.$

Some single$-$precision instructions that I found useful: movd, addss, mulss.

As before, there are dot$\_$single$\_$c and map$\_$poly$\_$single$\_$c in lab$10$c$.$c for comparison.

Time It

The provided timing.c provides some timing tests on reasonably$-$sized arrays. Have a look. How does your code compare to what the compiler wrote? $($Use $-$O$3$ to give the compiler its best chance.$)$

Why not x$87?$

As mentioned in lecture, we aren't using the x$87$ instructions in this course. Why not? It seems like there are a lot of programmer$-$friendly instructions there $($loading constants, trigonometry, logarithms, they work on a stack and everybody loves stacks$).$

This function $($with C signature void sin$\_$x$87($double$*$ input, double$*$ output, uint$64\_$t length$))$ calculates the sine of each element of an array of double and fills another $($equally$-$sized$)$ array with the results. You don't need to worry about the details, except that it uses x$87$ floating point instructions to do the calculation. You can copy it into your lab$10.$S$.$

sin$\_$x$87$:

mov $$0,\%$rcx

s$87\_$loop:

cmp $\%$rdx$,\%$rcx

jae s$87\_$ret

fldl $(\%$rdi, $\%$rcx$,8)$

fsin

fstpl $(\%$rsi, $\%$rcx$,8)$

inc $\%$rcx

jmp s$87\_$loop

s$87\_$ret:

ret

Create a program sin$.$c and write a C implementation sin$\_$stdlib that does the same operation, but using the C standard library's sin function. You will have to include math.h and add $-$lm to your compiling$/$linking command.

The sin function you're calling isn't using any trig instructions, but is doing something different. Is it faster? $$

You have not been provided with testing or timing code for this part of the exercise. That is deliberate. Write a main function in your sin$.$c that produces output relevant to testing$/$timing the implementations $($i$.$e$.$ what you need to convince yourself your code is correct and answer the question below$).$ The command to compile it should be like this:

gcc $...$ lab$10$c$.$c lab$10.$S sin$.$c $-$lm

Questions

Answer these questions in a text file answers.txt$.$

What was the running time of the dot product implementations? Assembly vs the compiler, and single$-$ vs double$-$precision?

Same question, but for the polynomial evaluation? $($Prediction: the differences should be much more obvious here.$)$

What is the relative running time of the x$87-$based sine calculation vs the C implementation $($that uses its own implementation of the function$)?$