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.}}

== Lab 5 6 ==

* 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).* To change the volume of sound, each sample can be scaled (multiplied) by a volume factor, in the range of 0.00 (silence) to 1.00 (full volume).

=== Basic Sound Scale Program Three Approaches ===

Perform Three approaches to this lab on one of the ARMv8 AArch64 [[SPO600 Servers]].problem are provided:

# Unpack the archive The basic or Naive algorithm (<code>/public/spo600-20181-algorithm-selection-labvol1.tgzc</code>). This approach multiplies each sound sample by 0.75, casting from signed 16-bit integer to floating point and back again. Casting between integer and floating point can be [[Expensive|expensive]] operations.# Examine the A lookup-based algorithm (<code>vol1vol2.c</code> source code). This program:approach uses a pre-calculated table of all 65536 possible results, and looks up each sample in that table instead of multiplying.## Creates 500,000 random "sound samples" in an input array A fixed-point algorithm (the number of samples is set in the <code>volvol3.hc</code> file).## Scales those samples by This approach uses fixed-point math and bit shifting to perform the volume factor 0.75 and stores them in an output arraymultiplication without using floating-point math.## Sums the output array and prints the sum.# Build and test this file.=== Don't Compare Across Machines ===#* Does it produce the same output each time?# Test In this lab, ''do not'' compare the relative performance across different machines, because the systems provided have a wide range of this programprocessor implementations, from server-class to mobile-class. Adjust However, ''do'' compare the number relative performance of samples as necessarythe various algorithms on the ''same'' machine.#* How long does it take to run?#* How much time is spent scaling === Benchmarking === Get the files for this lab from one of the sound samples?#* Do multiple runs take [[SPO600 Servers]] -- but you can perform the same time?lab wherever you want (feel free to use your laptop or home system). Test on both an x86_64 and an AArch64 system.

Try Perform these alternate approaches to scaling steps:# Unpack the sound samples by modifying copies of archive <code>vol1/public/spo600-algorithm-selection-lab.ctgz</code>. Edit # Study each of the <source code>Makefile</files and make sure that you understand what the code> is doing.# '''Make a prediction''' of the relative performance of each scaling algorithm.# Build and test each of the programs.#* Do all of the algorithms produce the same output?#** How can you verify this?#** If there is a difference, is it significant enough to build your modified programs as well as matter?#* Change the originalnumber of samples so that each program takes a reasonable amount of time to execute (suggested minimum 20 seconds, 1 minute or more is better). # Test the performance of each approach program.#* Find a way to see measure performance ''without'' the time taken to perform the test setup pre-processing (generating the samples) and post-processing (summing the results) so that you can measure ''only'' the time taken to scale the samples. '''This is the hard part!'''#* How much time is spent scaling the sound samples?#* Do multiple runs take the same time? How much variation do you observe? What is the performance impact:likely cause of this variation?#* Is there any difference in the results produced by the various algorithms?#* Does the difference between the algorithms vary depending on the architecture and implementation on which you test?#* What is the relative memory usage of each program?# Was your prediction accurate?

# 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.# 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. Shift the result to the right the required number of bits after the multiplication (>>8 if you're using 256 as the multiplier).== Deliverables ===

=== Conclusions ===Blog about your experiments with an a detailed analysis of your results, including memory usage, performance, accuracy, and trade-offs.

ImportantMake sure you convincingly prove your results to your reader! -- Also be sure to explain what you're doing so that a reader coming across your blog post understands the context (in other words, don't just jump into a discussion of optimization results -- give your post some context).

* Most solutions for a problem of this type involve generating a large amount of data in an array, processing that array using the function being evaluated, and then storing that data back into an array. The test setup can take more time than the actual test! Make sure that you measure the time taken in the code under test function only -- you need to be able to remove the rest of the processing time from your evaluation.* 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 <file>vol.h</file> as necessary.

* Be aware of what other tasks the system is handling during your test run, including software running on behalf of other users. === Tips ==={{Admon/tip|Analysis|Do a thorough analysis of the results. Be certain (and prove!) that your performance measurement ''does not'' include the generation or summarization of the test data. Do multiple runs and discard the outliers. Decide whether to use mean, minimum, or maximum time values from the multiple runs, and explain why you made that decision. Control your variables well. Show relative performance as percentage change, e.g., "this approach was NN% faster than that approach".}} {{Admon/tip|Non-Decimal Notation|In this lab, the number prefix 0x indicates a hexadecimal number, and 0b indicates a binary number, in harmony with the C language.}}

==== Analyzing Results ====* What is the impact {{Admon/tip|Time and Memory Usage of various optimization levels on a Program|You can get basic timing information for a program by running <code>time ''programName''</code> -- the software performance?* Does output will show the distribution of data matter?* If samples are fed at CD rate total time taken (44100 samples per second x 2 channels x 2 bytes per samplereal), can each of the algorithms keep up?* What is the memory footprint amount of each approach?* What is the performance of each approach?* What is CPU time used to run the energy consumption of each approach? application (What information do you need to calculate this?user)* Aarchie , and Betty have different performance profiles, so it's not reasonable to compare performance between the machines, but it is reasonable to compare amount of CPU time used by the relative performance operating system on behalf of the two algorithms in each contextapplication (system). Do you get similar results?* What other optimizations can be applied to this problem?

{{Admon/tip|Stack Limitstdint.h|Fixed-size, non-static arrays will be placed in the stack space. The size of the stack space is controlled by per-process limits, inherited from the shell, and adjustable with the <code>ulimitstdint.h</code> command. Allocating an array larger than the stack header provides definitions for many specialized integer size limit will cause a segmentation fault, usually on the first write. To see the current stack limit, use <code>ulimit -s</code> (displayed value is in KB; default is usually 8192 KB or 8 MB)types. To set the current stack limit, place a new size in KB or the keyword Use <code>unlimitedint16_t</code>after the <code>for 16-s</code> argument.<br /><br />Alternate (and preferred) approach, as used in the provided sample code: allocate the array space with <code>malloc()</code> or <code>calloc()</code>bit signed integers.}}

{{Admon/tip|stdint.hScripting|The <code>stdint.h</code> header provides definitions for many specialized integer size types. Use <code>int16_t</code> for 16-bit signed integers.bash scripting capabilities to reduce tedious manual steps!}}