Chapter 4 NUMB3RS

1. Chapter 4NUMB3RS

2. Checklist The following tools will be used in this lesson: • MPLAB X, Integrated Development Environment (v1.8 or later, free) • MPLAB XC16, C compiler (v1.11 or later, free) The following pieces of documentation will be used during this lesson: • PIC24FJ128GA010 Datasheet –DS39747 (latest rev.) • PIC24 Family Reference Manual - Section 14. Timers Make sure they are available and/or installed and ready to use on your computer. You can download them from Microchip web site at: http://www.microchip.com/mplabx And http://www.microchip.com/xc16

3. Integer Data Types

4. Under the Hood • Type the following few lines of code in a new main.c file: unsigned int i,j,k; main () { i = 0x1234; // assign an initial value to i j = 0x5678; // assign an initial value to j k = i * j; // perform product and store the result in k } • Build the project and open the Window>Embedded Memory>Program window to inspect the code produced: i = 0x1234; 212340 MOV #0x1234, W0 // move literal to W0 884280 MOV W0, 0x400 // move from W0 to i j = 0x5678; 256780 MOV #0x5678, W0 // move literal to W0 884290 MOV W0, 0x401 // move from W0 to j k = i * j; 804281 MOV 0x400, W1 // move from i to W1 804290 MOV 0x401, W0 // move from j to W0 B98800 MUL.SS W1, W0, W0 8842A0 MOV W0, 0x402 // move result to k

5. Going “long” • Try now with long (32-bit) integer values unsigned long i,j,k; main () { i = 0x01234567L; // assign an initial value to i j = 0x89ABCDEFL; // assign an initial value to j k = i * j; // perform product and store the result in k } • And inspect the new code produced for the multiplication: k = i * j; 804038 MOV 0x403, W8 804049 MOV 0x404, W9 804056 MOV 0x405, W6 804067 MOV 0x406, W7 780088 MOV W8, W1 780006 MOV W6, W0 B80A00 MUL.UU W1, W0, W4 B9C007 MUL.SS W8, W7, W0 780105 MOV W5, W2 410100 ADD W2, W0, W2 B9B009 MUL.SS W6, W9, W0 410100 ADD W2, W0, W2 780282 MOV W2, W5 884074 MOV W4, 0x407 884085 MOV W5, 0x408

6. “long long”Multiplications • Finally let’s try long long (64-bit) integer values unsigned long long i,j,k; main () { i = 0x0123456789ABCDEFLL; // assign an initial value to i j = 0xFEDCBA9876543210LL; // assign an initial value to j k = i * j; // perform product and store the result in k } • And inspect the new code produced for the multiplication: k = i * j; 07FDFC RCALL 0x290

7. Floating Point Types • Notice how the MPLAB XC16 compiler, by default, allocates for both the float and the double types the same number of bits (32), using the single precision floating-point format defined in the IEEE754 standard. • Only the long double data type is treated as a true double precision IEEE754 floating-point type (64-bit).

8. Notes for C Experts • If porting existing C code from a PC or workstation project, you might want to force the XC16 compiler to use the more standard (true) definition of a double as a 64-bit integer. • You can do so by accessing the Project Configuration Dialog and selecting the “Use 64-bit double”option!

9. Measuring Integer Performance /* * Numb3rs.c */ #include <config.h> int i1, i2, i3; long x1, x2, x3; long long xx1, xx2, xx3; main() { T1CON = 0x8000; // enable Timer1 1:1 with main clock i1 = 0x1234; // testing integers (16-bit) i2 = 0x5678; TMR1 = 0; // clear the timer i3 = i1 * i2; x1 = 0x01234567L; // testing long integers (32-bit) x2 = 0x89ABCDEFL; TMR1 = 0; // clear the timer x3 = x1 * x2; xx1 = 0x0123456789ABCDEFLL; // testing 64-bit integers xx2 = 0xFEDCBA9876543210LL; TMR1 = 0; // clear the timer xx3 = xx1 * xx2; } // main Single Step, then read TMR1 Single Step, then read TMR1 Single Step, then read TMR1

10. Measuring FP Performance /* * Numb3rs.c */ #include <config.h> float f1,f2, f3; long double d1, d2, d3; main() { T1CON = 0x8000; // enable Timer1 1:1 with main clock f1 = 12.34; // testing single precision floating point f2 = 56.78; TMR1 = 0; // clear the timer f3 = f1 * f2; d1 = 12.34L; // testing double precision floating point d2 = 56.78L; TMR1 = 0; // clear the timer d3 = d1 * d2; } // main Single Step, then read TMR1 Single Step, then read TMR1

11. Measuring Performance Summary

12. Lessons Learned • Use integers every time you can (i.e. when fractions are not required, or the algorithm can be re-written for integer arithmetic). • Use the smallest integer type that will not produce an overflow or underflow. • If you have to use a floating-point type (fractions are required), expect an order-of-magnitude reduction in the performance of the compiled program. • Double precision floating point (long double) seems to only reduce the performance by a further factor of two.

13. Notes for the Assembly Experts • Converting an integer type into a smaller/larger one: int x; // 16-bit long y; // 32-bit y = x; // implicit conversion Explicity Conversion using a “type cast”: int x; // 16-bit long y; // 32-bit x = (int) y; // type cast • Extracting or manipulating one bit out of an integer variable, use “bitfields”Example from the PIC24 peripheral libraries: extern unsigned int T1CON; extern union { struct { unsigned :1; unsigned TCS:1; ... unsigned TSIDL:1; unsigned :1; unsigned TON:1; }; struct { unsigned :4; unsigned TCKPS:2; }; } T1CONbits;

14. Notes for the PIC MCU Experts • 8-bit users will notice a considerable improvement in the performance both with integer arithmetic and floating point arithmetic. • The 16-bit ALU available in the PIC24 architecture manipulates twice the number of bits per cycle • Further improvement is due to the use of 8 working registers which make the coding of critical arithmetic routines and makes numerical algorithms more efficient

15. Tips and Tricks • The MPLAB C compiler supports several standard ANSI C libraries including: • limits.h - contains many useful macros defining implementation dependent limits, such as, for example, the number of bits composing a char type (CHAR_BIT) or the largest integer value (INT_MAX). • float.h - contains similar implementation dependent limits for floating point data types, such as, for example the largest exponent for a single precision floating point variable (FLT_MAX_EXP). • math.h- contains trigonometric functions, rounding functions, logarithms and exponentials.

16. Tips and Tricks Complex Data Types • The XC16 compiler supports complex data types as an extension of both integer and floating point types. Here is an example declaration for a single precision floating point type: __complex__ float z; • Notice the use of a double underscore before and after the keyword complex. • The variable z defined so has now a real and an imaginary part that can be individually addressed using the syntax: __real__ z and __imag__ z respectively. • Similarly, the next declaration produces a complex variable of 16-bit integer type: __complex__ int x; • Complex constants are easily created adding the suffix i or j as in the following examples: x = 2 + 3j; z = 2.0f + 3.0fj; • All standard arithmetic operations (+,-,*,/) are performed correctly on complex data types. Additionally the “~” operator produces the complex conjugate.

17. Suggested Excercises • Write a program that uses Timer2 and Timer3 joined in the new 32-bit timer mode. • Test the relative performance of the division for the various data types. • Test the performance of the trigonometric functions relative to standard arithmetic operations. • Test the relative performance of the multiplication for complex data types.

18. Recommended Readings • Gahlinger, P. M. (2000), The cockpit, a flight of escape and discovery, Sagebrush Press, Salt Lake City, UT • It’s an interesting journey around the world. Follow the author in search of ... his soul.Every instrument in the cockpit triggers a memory and starts a new chapter.

19. Online Resources • http://en.wikipedia.org/wiki/Taylor_series • If you are curious as to how the C compiler can approximate some of the functions in the math library.