1 / 51

Chapter 9 Floating Point Arithmetic

Chapter 9 Floating Point Arithmetic.  9.1 Floating Point Formats. Common Format Components. Each codes a normalized number whose “binary scientific notation” would be ±1. dd…d x 2 exp Sign bit 0 for positive and 1 for negative Exponent field Actual exponent exp plus a bias

cheng
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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

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

More Related