 Download Presentation Chapter 9 Floating Point Arithmetic Chapter 9 Floating Point Arithmetic - PowerPoint PPT Presentation

Download Presentation Chapter 9 Floating Point Arithmetic
An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

1. Chapter 9 Floating Point Arithmetic

2.  9.1 Floating Point Formats

3. Common Format Components • Each codes a normalized number whose “binary scientific notation” would be ±1.dd…d x 2exp • Sign bit • 0 for positive and 1 for negative • Exponent field • Actual exponent exp plus a bias • Bias gives an alternative to 2’s complement • Fraction (“mantissa”) field

4. IEEE Single Precision Format • 32-bit format • Sign bit • 8-bit biased exponent (the actual exponent in the normalized binary “scientific” format plus 127) • 23-bit fraction (the fraction in the scientific format without the leading 1 bit) • Generated by REAL4 directive

5. IEEE Double Precision Format • 64-bit format • Sign bit • 11-bit biased exponent (the actual exponent in the normalized binary scientific format plus 1023) • 52-bit fraction (the fraction in the scientific format without the leading 1 bit) • Generated by REAL8 directive

6. Double Extended Precision Format • 80-bit format • Sign bit • 15-bit biased exponent (the actual exponent in a normalized binary scientific format plus 16,383) • 64-bit fraction (the fraction in the scientific format including the leading 1 bit) • Generated by REAL10 directive

7. Floating Point Formats • These are for normalized numbers • Binary scientific notation mantissa written starting with 1 and binary point • Zero cannot be normalized • +0 represented by a pattern of all 0 bits • Also formats for ±  and NaN ("not a number”)

8. 9.2 80x86 Floating Point Architecture

9. Floating Point Unit • FPU is independent of integer unit • Eight 80-bit registers, organized as a stack • ST, the stack top, also called ST(0) • ST(1), the register just below the stack top • ST(2), the register just below ST(1) • ST(3), ST(4), ST(5), ST(6) • ST(7), the register at the bottom of the stack • Several 16-bit control registers, including status word

10. Load Instructions • fld realMemoryOperand • Loads stack top ST with floating point data value • Values already on the stack are pushed down • fld integerMemoryOperand • Converts integer value to corresponding fp value that is pushed onto the stack • fld st(nbr) • Pushes a copy of st(nbr) onto the fp stack

11. More Loads and finit • fld1 • Pushes 1.0 onto floating point stack • fld0 • Pushes 0.0 onto fp stack • fldpi • Pushes  onto fp stack …and others • finit initializes the floating point processor, clearing the stack

12. Store Instructions • fst realMemoryOperand • Copies stack top ST value to memory • fstp realMemoryOperand • Copies stack top ST value to memory and pops the floating point stack • fist integerMemoryOperand • Copies stack top ST value to memory, converting to integer • fistp integerMemoryOperand • Same as fist, but also pops the floating point stack

13. Exchange Instructions • fxch • Exchange values in ST and ST(1) • fxch st(nbr) • Exchange ST and ST(nbr)

14. Addition Instructions • fadd • adds ST(1) and ST; pushes sum on stack • fadd st, st(nbr) • adds ST(nbr) and ST; sum replaces ST • fadd st(nbr), st • adds ST(nbr) and ST; sum replaces ST(nbr) • faddp st(nbr), st • adds ST(nbr) and ST; sum replaces ST(nbr); old ST popped from stack

15. More Addition Instructions • fadd realMemoryOperand • Adds ST and real memory operand; sum replaces ST • fiadd integerMemoryOperand • Adds ST and integer memory operand; sum replaces ST

16. Subtraction Instructions • fsub • pops ST and ST(1); calculates ST(1) - ST; pushes difference onto the stack • fsub st(nbr), st • calculates ST(nbr) - ST; replaces ST(nbr) by the difference • fsub st, st(nbr) • calculates ST - ST(nbr); replaces ST by the difference

17. More Subtraction Instructions • fsub realMemoryOperand • calculates ST - real number from memory; replaces ST by the difference • fisub integerMemoryOperand • calculates ST - integer from memory; replaces ST by the difference • fsubp st(nbr), st • calculates ST(nbr) - ST; replaces ST(nbr) by the difference; pops ST from the stack

18. Reversed Subtraction Instructions • fsubr • pops ST and ST(1); calculates ST - ST(1); pushes difference onto the stack • fsubr st(nbr), st • calculates ST - ST(nbr); replaces ST(nbr) by the difference • fsubr st, st(nbr) • calculates ST(nbr) - ST; replaces ST by the difference

19. More Reversed Subtraction Instructions • fsubr realMemoryOperand • calculates real number from memory - ST; replaces ST by the difference • fisubr integerMemoryOperand • calculates integer from memory - ST; replaces ST by the difference • fsubpr st(nbr), st • calculates ST - ST(nbr); replaces ST(nbr) by the difference; pops ST from the stack

20. Multiplication Instructions • fmul • pops ST and ST(1); multiplies these values; pushes product onto the stack • fmul st(nbr), st • multiplies ST(nbr) and ST; replaces ST(nbr) by the product • fmul st, st(num) • multiplies ST and ST(nbr); replaces ST by the product

21. More Multiplication Instructions • fmul realMemoryOperand • multiplies ST and real number from memory; replaces ST by the product • fimul integerMemoryOperand • multiplies ST and integer from memory; replaces ST by the product • fmulp st(nbr), st • multiplies ST(nbr) and ST; replaces ST(nbr) by the product; pops ST from stack

22. Division Instructions • fdiv • pops ST and ST(1); calculates ST(1) / ST; pushes quotient onto the stack • fdiv st(nbr), st • calculates ST(nbr) / ST; replaces ST(nbr) by the quotient • fdiv st,st(nbr) • calculates ST / ST(nbr); replaces ST by the quotient

23. More Division Instructions • fdiv realMemoryOperand • calculates ST / real number from memory; replaces ST by the quotient • fidiv integerMemoryOperand • calculates ST / integer from memory; replaces ST by the quotient • fdivp st(nbr),st • calculates ST(nbr) / ST; replaces ST(nbr) by the quotient; pops ST from the stack

24. Reversed Division Instructions • Similar to reversed multiplication--each division instruction has a version that reverses operands used as dividend and divisor • fdivr • fdivr • fdivr • fdivr • fidivr • fdivpr

25. Miscellaneous Instructions • fabs • Absolute value: ST := | ST | • fchs • Change sign: ST := - ST • frndint • Rounds ST to an integer value • fsqrt • Replace ST by its square root • There are also trigonometric, exponential and logarithmic functions

26. Comparisons • Each instruction compares ST with some other operand • Sets “condition code” bits 14, 10 and 8 in the status word register • These bits are named C3, C2 and C0

27. Comparison Instructions • fcom • compares ST and ST(1) • fcom st(nbr) • compares ST and ST(nbr) • fcom realMemoryOperand • compares ST and real number in memory • ficom integerMemoryOperand • compares ST and integer in memory

28. More Comparison Instructions • ftst • compares ST and 0.0 • fcomp • compares ST and ST(1); then pops stack • fcompp • compares ST and ST(1); then pops stack twice

29. Yet More Comparison Instructions • fcomp st(nbr) • compares ST and ST(nbr); then pops stack • fcomp realMemoryOperand • compares ST and real number in memory; then pops stack • ficomp integerMemoryOperand • compares ST and integer in memory; then pops stack

30. Status Word Access • Conditional jump instructions look at bits in flags register, not in status word. The fstsw instructions provide access to the status word bits. • fstsw memoryWord • copies status register to memory word • fstsw AX • copies status register to AX • Similar instructions available for control word

31. Comparison in 32-bit Mode fcom ; ST > ST(1)? fstsw ax ; copy condition code bits to AX sahf ; shift condition bits to flags jna endGT ; skip if not • sahf copies AH into the low order eight bits of the EFLAGS register • Puts C3 in the ZF position (bit 6) and C0 in the CF position (bit 0) • Makes it possible to use conditional jump instructions (unsigned mnemonics)

32. Comparison in 64-bit Mode • sahf not available in 64-bit mode • Two instructions directly set flags in the flags register • fcomi st, st(nbr) • compares ST and ST(nbr) • fcomip st, st(nbr) • compares ST and ST(nbr); pops stack

33.  9.3 Converting Floating Point To and From ASCII

34. ASCII to Floating Point • Algorithm similar to ASCII to integer: value := 0.0; point at first character of source string; while (source character is a digit) loop convert ASCII digit to 2's complement digit; value := 10*value + float(digit); point at next character of source string; end while; • Main difference is that you must divide the final value by 10dig, where dig is the number of digits after a decimal point

35. Floating Point to ASCII (1) • Algorithm generates E-notation: • a leading minus sign or a blank • a digit • a decimal point • five digits • the letter E • a plus sign or a minus sign • two digits • These pieces generated one at a time

36. Floating Point to ASCII (2) Make leading character a minus sign or a blank point at first destination byte; if value  0 then put blank in destination string; else put minus in destination string; value := value; end if; point at next destination byte;

37. Floating Point to ASCII (3) “Normalize” fp value to have single digit before decimal point exponent := 0; if value ≥ 10 then repeat divide value by 10; add 1 to exponent; until value < 10 loop else while value < 1 loop multiply value by 10; subtract 1 from exponent; end while; end if;

38. Floating Point to ASCII (4) add 0.000005 to value; { for rounding } if value ≥ 10 then divide value by 10; add 1 to exponent; end if; digit := int(value); { truncate to integer } convert digit to ASCII and store in destination string; point at next destination byte; store "." in destination string; point at next destination byte; Continue to normalize floating point value; get first digit and decimal point

39. Floating Point to ASCII (5) for i := 1 to 5 loop value := 10 * (value  float(digit)); digit := int(value); convert digit to ASCII and store in destination string; point at next destination byte; end for; Generate five digits after the decimal point

40. Floating Point to ASCII (6) store E in destination string; point at next destination byte; if exponent  0 then put + in destination string; else put  in destination string; exponent := exponent; end if; point at next destination byte; convert exponent to two decimal digits; convert two decimal digits of exponent to ASCII; store characters of exponent in destination string; Generate exponent

41.  9.4 Single-Instruction Multiple-Data Instructions

42. SIMD Instructions • Single-instruction multiple-data (SIMD) instructions operate on several operands at once with a single instruction • The Intel family has had some form of SIMD instructions since the Pentium II • MMX technology in Pentium II • Several generations of streaming SIMD extensions (SSE) • All current 80x86 CPUs include these features

43. SSE • First appeared in the Pentium III processor • Eight new 128-bit registers, XMM0 through XMM7 • 64-bit architecture added eight more XMM registers, XMM8 through XMM15 • A single 128-bit register can hold four 32-bit floating point numbers

44. SSE Instructions • Packed SSE instructions operates on four pairs of floating point numbers simultaneously • Scalar SSE instructions operate only on the low-order operands, ignoring the other three

45. Selected Scalar SSE Instructions

46. Selected Packed SSE Instructions

47. Using Scalar SSE Instructions • Similar to programming integer operations with general registers in the 32-bit or 64-bit mode • comiss comparison instruction sets flags in exactly as fcomi does for the floating point unit • “Unsigned” conditional jump instructions are appropriate following comiss or fcomi

48.  9.5 Floating Point Assembly Language Procedures With C/C++

49. Why Use Assembly Language Procedures? • May be possible or easier or more efficient to code parts of a program in assembly language than in a high-level language • Parts that need critical optimization • Implementation of low-level algorithms • The bulk of programming is usually better done in a high level language

50. 32-bit Linkages • Decorate assembly language procedure name with an underscore • If C program calls roots, name the procedure _roots • To use cdecl protocol in a C++ program, use the “C” declaration, for example,extern "C" void roots(…); • Push parameters on stack • Return single float value in ST