Changes

[[Category:SPO600 Labs]]{{Admon/lab|Purpose of this Lab|In this lab, you will investigate the impact of different algorithms which produce the same effect. You will test and select one of two three algorithms for adjusting the volume of PCM audio samples based on benchmarking of two possible approaches.}}{{Chris Tyler Draft}}

== Lab 5 4 ==

* Digital sound is typically represented, uncompressed, as signed 16-bit integer signal samples. There is one stream are two streams of samples , one each for the left and right stereo channels, at typical sample rates of 44.1 or 48 thousand samples per secondper channel, for a total of 88.2 or 96 thousand samples per second(kHz). Since there are 16 bits (2 bytes) per sample, the data rate is 88.2 * 1000 * 2 = 176,400 bytes/second (~172 KiB/sec) or 96 * 1000 * 2 = 192,000 bytes/second (~187.5 KiB/sec).

Perform Get the files for this lab on one of the ARMv8 AArch64 [[SPO600 Servers]]-- but you can perform the lab wherever you want.

# Unpack the archive <code>/public/spo600-20181-algorithm-selection-lab.tgz</code>

## Creates 5005,000,000 random "sound samples" in an input a data array (the number of samples is set in the <code>vol.h</code> file).## Scales those samples by the volume factor 0.75 and stores them in an output back to the data array.

# Test the performance of this program. Adjust the number of samples as necessary.#* How long does it take to runthe scaling?#* How much time is spent scaling the sound samples?Be sure to eliminate the time taken for the non-scaling part of the program (e.g., random sample generation).#* Do multiple runs take the same time? How much variation do you observe? What is the likely cause of this variation?#* Is there any difference in the results produced by the various algorithms? How much does numeric accuracy matter in this application?

Try these alternate approaches to scaling The sample program uses the sound samples by modifying copies of <code>vol1most basic, obvious algorithm for the problem.c</code>Let's call this "Algorithm 0", or the "Naive Algorithm". Edit the <code>Makefile</code> to build your modified programs Note that it uses casting between integer and floating-point formats as well as the originalmultiplication -- both of which can be [[Expensive|expensive]] operations. Test each approach to see the performance impact:

# Pre-calculate a lookup table (array) of all possible sample values multiplied by Try these alternate algorithms for scaling the volume factor, and look up each sample in that table to get the scaled values.# Convert the volume factor 0.75 to a fix-point integer sound samples by multiplying by a binary number representing a fixed-point value "1"modifying copies of <code>vol1. For example, you could use 0b100000000 (= 256 in decimal) to represent 1c</code>.00. Shift the result to the right the required number of bits after Edit the multiplication (<code>Makefile</code>8 if you're using 256 to build your modified programs as well as the multiplier)original.Test each approach to see the performance impact:

# Pre-calculate a lookup table (array) of all possible sample values multiplied by the volume factor, and look up each sample in that table to get the scaled values. (You'll have to handle the fact that the input values range from -32768 to +32767, while C arrays accept only a positive index).# Convert the volume factor 0.75 to a fix-point integer by multiplying by a binary number representing a fixed-point value "1". For example, you could use 0b100000000 (= 256 in decimal) to represent 1.00, and therefore use 0.75 * 256 = 192 for your volume factor. Multiply this fixed-point integer volume factor by each sample, then shift the result to the right the required number of bits after the multiplication (>>8 if you're using 256 as the multiplier). === Conclusions Deliverables === Blog about your experiments with an a detailed analysis of your results, including memory usage, time performance, accuracy, and trade-offs.

* You may need to run a very large amount of sample data through the function to be able to detect its performance. Feel free to edit the sample count in <filecode>vol.h</filecode> as necessary.

* Be aware of what other tasks the system is handling during your test run, including software running on behalf of other users.

* What is the impact of various optimization levels on the software performance?(For example, compiling with -O0 / -O1 / -O2 / -O3)* Does the distribution of data matter?(e.g., is there any difference if there are no absolute large numbers, or no negative numbers?)

* Aarchie and Betty Various machines within an architecture have very different performance profiles, energy consumption, and hardware costs -- so it's not reasonable to compare performance between the machines, but it is reasonable to compare the relative performance of the two algorithms in each context. Do you get similar resultsDoes the ratio of performance of the various approaches remain constant across the machines? Why or why not?