PIC32MX: Benchmarking Mathematical Operations - Revision history

NickMarchuk at 20:20, 1 March 2010

2010-03-01T20:20:43Z

← Older revision		Revision as of 15:20, 1 March 2010
Line 1:		Line 1:
	== Original Assignment ==

	'''Do not erase this section!'''

	Your assignment is to empirically test how long it takes to perform add, subtract, multiply, divide, sqrt, sin, and cos operations with the 80 MHz PIC32460F512L and our standard code optimization setting. You will do these tests with chars (8-bit integers), shorts (16-bit), integers (32-bit), long long integers (64-bit), floats (32-bit single precision floating point), and double (64-bit double-precision floating point). The integers can be unsigned or signed. Your end result will be a table with the operation on one axis (likely the horizontal axis) and the kind of variable on the other axis, and each cell of the table will have a normalized duration for the operation. The time will be normalized by the fastest operation, so the smallest number in the table will be 1.00. All other numbers will indicate how many times longer that operation takes. All numbers will have two decimal places, e.g., 2.57 or 24.72. You will also give the time that 1.00 corresponds to in nanoseconds.

	Since bit-shifting left and right correspond to a version of multiplying and dividing, you should also include the operations >>1 and >>4 and <<1 and <<4. (If the results are identical, you can eliminate shift left from your table.)

	To generate this table, you can set an output bit low before the operation, then high immediately after the operation, and measure the time on an oscilloscope. Two things to consider: (1) Time a single operation, over and over, with a short delay between the operation. This should create a pulse train on your oscilloscope. Can you get an accurate estimate of the time this way? You could also try doing five or ten operations between changing the digital output. See if this gives the same estimate. (This estimate might be more accurate as you are essentially averaging over a number of operations.) Avoid using arrays and for loops in your test, as indexing arrays and running the loop each take time. (2) Make sure the compiler doesn't compute the results in advance. You could try testing operations with numbers generated randomly (don't time this operation!) vs. numbers that you just type in manually to make sure that both are giving you the same result.

	== Overview ==		== Overview ==

ToddPoole: /* double Performance */

2010-02-23T00:20:18Z

double Performance

← Older revision		Revision as of 19:20, 22 February 2010
Line 991:		Line 991:
	===double Performance===		===double Performance===
	----		----
	A double data type, in ANSI C, is a double-precision value represented by 8 bytes, consisting of a sign bit, an 8-bit excess-1023 binary exponent, and a 52-bit mantissa. This roughly corresponds to a range of approximately 2.22E–308 1.79E+308 for unsigned doubles. Signed doubles are more complex, but are covered in depth here: http://msdn.microsoft.com/en-us/library/hd7199ke%28VS.80%29.aspx. In ~~this~~ ~~series~~ of ~~tests~~, ~~tests~~ (a) are ~~with~~ a predefined ~~number,~~ and ~~tests~~ (b) are ~~with~~ a random ~~number~~. ~~This~~ is in ~~order~~ to ~~test~~ ~~times~~ ~~for~~ pre-compiled operations and operations on the PIC.		A double data type, in ANSI C, is a double-precision value represented by 8 bytes, consisting of a sign bit, an 8-bit excess-1023 binary exponent, and a 52-bit mantissa. This roughly corresponds to a range of approximately 2.22E–308 1.79E+308 for unsigned doubles. Signed doubles are more complex, but are covered in depth here: http://msdn.microsoft.com/en-us/library/hd7199ke%28VS.80%29.aspx. Given that there are many different ways to perform a given operation on a double, we've done our best to include several different methods that we feel are representative of normal coding practices. Depending on how the source code is compiled, these different methods may or may not produce different results. Furthermore, unless otherwise noted, all (a) benchmarks are operations on two predefined (and mot likely pre-computed) doubles and all (b) benchmarks are operations on two random (and most likely '''not''' pre-computed) doubles. These multiple benchmarks per test exist to illustrate the differences in execution time between pre-compiled operations that the compiler may have optimized ahead of time and operations the PIC must perform in real time.
	==== Subtraction (Test 37) ====		==== Subtraction (Test 37) ====
	{{multiple image		{{multiple image

ToddPoole: /* float Performance */

2010-02-23T00:19:43Z

float Performance

← Older revision		Revision as of 19:19, 22 February 2010
Line 840:		Line 840:
	===float Performance===		===float Performance===
	----		----
	A float data type, in ANSI C, is a single-precision value represented by 4 bytes, consisting of a sign bit, an 8-bit excess-127 binary exponent, and a 23-bit mantissa. This roughly corresponds to a range of approximately 3.4E–38 to 3.4E+38 for unsigned floats. Signed floats are more complex to understand, but are covered in depth here: http://msdn.microsoft.com/en-us/library/hd7199ke%28VS.80%29.aspx. In ~~this~~ ~~series~~ of ~~tests~~, ~~tests~~ (a) are ~~with~~ a predefined ~~number,~~ and ~~tests~~ (b) are ~~with~~ a random ~~number~~. ~~This~~ is in ~~order~~ to ~~test~~ ~~times~~ ~~for~~ pre-compiled operations and operations on the PIC.		A float data type, in ANSI C, is a single-precision value represented by 4 bytes, consisting of a sign bit, an 8-bit excess-127 binary exponent, and a 23-bit mantissa. This roughly corresponds to a range of approximately 3.4E–38 to 3.4E+38 for unsigned floats. Signed floats are more complex to understand, but are covered in depth here: http://msdn.microsoft.com/en-us/library/hd7199ke%28VS.80%29.aspx. Given that there are many different ways to perform a given operation on a float, we've done our best to include several different methods that we feel are representative of normal coding practices. Depending on how the source code is compiled, these different methods may or may not produce different results. Furthermore, unless otherwise noted, all (a) benchmarks are operations on two predefined (and mot likely pre-computed) floats and all (b) benchmarks are operations on two random (and most likely '''not''' pre-computed) floats. These multiple benchmarks per test exist to illustrate the differences in execution time between pre-compiled operations that the compiler may have optimized ahead of time and operations the PIC must perform in real time.
	==== Subtraction (Test 30) ====		==== Subtraction (Test 30) ====
	{{multiple image		{{multiple image

ToddPoole: /* long long Performance */

2010-02-23T00:18:58Z

long long Performance

← Older revision		Revision as of 19:18, 22 February 2010
Line 683:		Line 683:
	===long long Performance===		===long long Performance===
	----		----
	A long long data type, in ANSI C, is a value that holds 8 bytes, or 64 bits. This corresponds to a range of 0 to 1.84467441 × 10^19 (2^64 - 1). If the variable is signed (negative), then the range is from -9.22337204 × 10^18 to 9.22337204 × 10^18 (-2^63 + 1 to 2^63 -1). In ~~this~~ ~~series~~ of ~~tests~~, ~~tests~~ (a) are ~~with~~ a predefined ~~number,~~ and ~~tests~~ (b) are ~~with~~ a random ~~number~~. ~~This~~ is in ~~order~~ to ~~test~~ ~~times~~ ~~for~~ pre-compiled operations and operations on the PIC.		A long long data type, in ANSI C, is a value that holds 8 bytes, or 64 bits. This corresponds to a range of 0 to 1.84467441 × 10^19 (2^64 - 1). If the variable is signed (negative), then the range is from -9.22337204 × 10^18 to 9.22337204 × 10^18 (-2^63 + 1 to 2^63 -1). Given that there are many different ways to perform a given operation on a long long, we've done our best to include several different methods that we feel are representative of normal coding practices. Depending on how the source code is compiled, these different methods may or may not produce different results. Furthermore, unless otherwise noted, all (a) benchmarks are operations on two predefined (and mot likely pre-computed) long longs and all (b) benchmarks are operations on two random (and most likely '''not''' pre-computed) long longs. These multiple benchmarks per test exist to illustrate the differences in execution time between pre-compiled operations that the compiler may have optimized ahead of time and operations the PIC must perform in real time.

	==== Subtraction (Test 23) ====		==== Subtraction (Test 23) ====
	{{multiple image		{{multiple image

ToddPoole: /* int Performance */

2010-02-23T00:17:32Z

int Performance

← Older revision		Revision as of 19:17, 22 February 2010
Line 525:		Line 525:
	===int Performance===		===int Performance===
	----		----
	An int data type, in ANSI C, is a value that holds 4 bytes, or 32 bits. This corresponds to a range of 0 to 4294967295 (2^32 - 1). If the variable is signed (negative), then the range is from -2147483647 to 2147483647 (-2^31 + 1 to 2^31 -1). In ~~this~~ ~~series~~ of ~~tests~~, ~~tests~~ (a) are ~~with~~ a predefined ~~number,~~ and ~~tests~~ (b) are ~~with~~ a random ~~number~~. ~~This~~ is in ~~order~~ to ~~test~~ ~~times~~ ~~for~~ pre-compiled operations and operations on the PIC.		An int data type, in ANSI C, is a value that holds 4 bytes, or 32 bits. This corresponds to a range of 0 to 4294967295 (2^32 - 1). If the variable is signed (negative), then the range is from -2147483647 to 2147483647 (-2^31 + 1 to 2^31 -1). Given that there are many different ways to perform a given operation on an int, we've done our best to include several different methods that we feel are representative of normal coding practices. Depending on how the source code is compiled, these different methods may or may not produce different results. Furthermore, unless otherwise noted, all (a) benchmarks are operations on two predefined (and mot likely pre-computed) ints and all (b) benchmarks are operations on two random (and most likely '''not''' pre-computed) ints. These multiple benchmarks per test exist to illustrate the differences in execution time between pre-compiled operations that the compiler may have optimized ahead of time and operations the PIC must perform in real time.

	==== Subtraction (Test 16) ====		==== Subtraction (Test 16) ====
	{{multiple image		{{multiple image

ToddPoole: /* short Performance */

2010-02-23T00:16:29Z

short Performance

← Older revision		Revision as of 19:16, 22 February 2010
Line 366:		Line 366:
	=== short Performance ===		=== short Performance ===
	----		----
	A short data type, in ANSI C, is a value that holds 2 bytes, or 16 bits. This corresponds to a range of 0 to 65535 (2^16 - 1). If the variable is signed (negative), then the range is from -32767 to 32767 (-2^15 + 1 to 2^15 -1). In ~~this~~ ~~series~~ of ~~tests~~, ~~tests~~ (a) are ~~with~~ a predefined ~~number,~~ and ~~tests~~ (b) are ~~with~~ a random ~~number~~. ~~This~~ is in ~~order~~ to ~~test~~ ~~times~~ ~~for~~ pre-compiled operations and operations on the PIC.		A short data type, in ANSI C, is a value that holds 2 bytes, or 16 bits. This corresponds to a range of 0 to 65535 (2^16 - 1). If the variable is signed (negative), then the range is from -32767 to 32767 (-2^15 + 1 to 2^15 -1). Given that there are many different ways to perform a given operation on a short, we've done our best to include several different methods that we feel are representative of normal coding practices. Depending on how the source code is compiled, these different methods may or may not produce different results. Furthermore, unless otherwise noted, all (a) benchmarks are operations on two predefined (and mot likely pre-computed) shorts and all (b) benchmarks are operations on two random (and most likely '''not''' pre-computed) shorts. These multiple benchmarks per test exist to illustrate the differences in execution time between pre-compiled operations that the compiler may have optimized ahead of time and operations the PIC must perform in real time.

	==== Subtraction (Test 9) ====		==== Subtraction (Test 9) ====
	{{multiple image		{{multiple image

ToddPoole: /* double Performance */

2010-02-23T00:14:08Z

double Performance

← Older revision		Revision as of 19:14, 22 February 2010
Line 993:		Line 993:

	===double Performance===		===double Performance===
⚫	A double data type, in ANSI C, is a double-precision value represented by 8 bytes, consisting of a sign bit, an 8-bit excess-1023 binary exponent, and a 52-bit mantissa. This roughly corresponds to a range of approximately 2.22E–308 1.79E+308 for unsigned doubles. Signed doubles are more complex ~~to understand~~, but are covered in depth here: http://msdn.microsoft.com/en-us/library/hd7199ke%28VS.80%29.aspx. In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.
	----		----
		⚫	A double data type, in ANSI C, is a double-precision value represented by 8 bytes, consisting of a sign bit, an 8-bit excess-1023 binary exponent, and a 52-bit mantissa. This roughly corresponds to a range of approximately 2.22E–308 1.79E+308 for unsigned doubles. Signed doubles are more complex, but are covered in depth here: http://msdn.microsoft.com/en-us/library/hd7199ke%28VS.80%29.aspx. In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.
	==== Subtraction (Test 37) ====		==== Subtraction (Test 37) ====
	{{multiple image		{{multiple image

ToddPoole: /* Division (Test 26) */

2010-02-23T00:13:07Z

Division (Test 26)

← Older revision		Revision as of 19:13, 22 February 2010
Line 761:		Line 761:
	This test determines the length of time required by the PIC32 chip to divide one 64-bit number (a long long) by another 64-bit number (a long long).		This test determines the length of time required by the PIC32 chip to divide one 64-bit number (a long long) by another 64-bit number (a long long).
	*Test (a): Time required to divide two constant long longs (may be pre-computed)		*Test (a): Time required to divide two constant long longs (may be pre-computed)
	**Instruction:		**Instruction: <code>longlong1 = 17179800000LL/7179869184LL;</code>
	**Time: 74 ns		**Time: 74 ns
	*Test (b): Time required to divide two random long longs (guaranteed not to be pre-comp)		*Test (b): Time required to divide two random long longs (guaranteed not to be pre-comp)
	**Instruction:		**Instruction: <code>random_longlong = larger/smaller;</code>
	**Time: 1724 ns		**Time: 1724 ns

ToddPoole: /* Multiplication (Test 25) */

2010-02-23T00:12:31Z

Multiplication (Test 25)

← Older revision		Revision as of 19:12, 22 February 2010
Line 741:		Line 741:
	This test determines the length of time required by the PIC32 chip to multiply one 64-bit number (a long long) by another 64-bit number (a long long).		This test determines the length of time required by the PIC32 chip to multiply one 64-bit number (a long long) by another 64-bit number (a long long).
	*Test (a): Time required to multiply two constant long longs (may be pre-computed)		*Test (a): Time required to multiply two constant long longs (may be pre-computed)
	**Instruction:		*Instruction: <code>longlong1 = 171798000LL7186984LL;</code>
	**Time: 74 ns		**Time: 74 ns
	*Test (b): Time required to multiply two random long longs (guaranteed not to be pre-comp)		*Test (b): Time required to multiply two random long longs (guaranteed not to be pre-comp)
	**Instruction:		*Instruction: <code>random_longlong = largersmaller;</code>
	**Time: 398 ns		**Time: 398 ns

ToddPoole: /* Addition (Test 24) */

2010-02-23T00:11:52Z

Addition (Test 24)

← Older revision		Revision as of 19:11, 22 February 2010
Line 721:		Line 721:
	This test determines the length of time required by the PIC32 chip to add one 64-bit number (a long long) to another 64-bit number (a long long).		This test determines the length of time required by the PIC32 chip to add one 64-bit number (a long long) to another 64-bit number (a long long).
	*Test (a): Time required to add two constant long longs (may be pre-computed)		*Test (a): Time required to add two constant long longs (may be pre-computed)
	**Instruction:		**Instruction: <code>longlong1 = 17179800000LL+179869184LL;</code>
	**Time: 88 ns		**Time: 88 ns
	*Test (b): Time required to add two random long longs (guaranteed not to be pre-comp)		*Test (b): Time required to add two random long longs (guaranteed not to be pre-comp)
	**Instruction:		**Instruction: <code>random_longlong = larger+smaller;</code>
	**Time: 200 ns		**Time: 200 ns