US20020116431A1 - System and method for improving the accuracy of reciprocal operations performed by a floating-point unit - Google Patents
System and method for improving the accuracy of reciprocal operations performed by a floating-point unit Download PDFInfo
- Publication number
- US20020116431A1 US20020116431A1 US10/055,346 US5534602A US2002116431A1 US 20020116431 A1 US20020116431 A1 US 20020116431A1 US 5534602 A US5534602 A US 5534602A US 2002116431 A1 US2002116431 A1 US 2002116431A1
- Authority
- US
- United States
- Prior art keywords
- floating
- point
- produce
- memory
- instruction
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Abandoned
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F7/00—Methods or arrangements for processing data by operating upon the order or content of the data handled
- G06F7/38—Methods or arrangements for performing computations using exclusively denominational number representation, e.g. using binary, ternary, decimal representation
- G06F7/48—Methods or arrangements for performing computations using exclusively denominational number representation, e.g. using binary, ternary, decimal representation using non-contact-making devices, e.g. tube, solid state device; using unspecified devices
- G06F7/483—Computations with numbers represented by a non-linear combination of denominational numbers, e.g. rational numbers, logarithmic number system or floating-point numbers
- G06F7/487—Multiplying; Dividing
- G06F7/4876—Multiplying
Definitions
- the present invention relates to floating-point arithmetic, and more specifically to a floating-point unit that implements Newton-Raphson convergent algorithms for determining reciprocals and reciprocal square roots.
- the reciprocal of a number (N) is defined as 1 divided by N.
- the reciprocal square root of N is defined as 1 divided by the square root of N.
- a floating-point representation is preferred in many applications because of its ability to express a wide range of values and its ease of manipulation for some specified operations.
- a floating-point representation includes three components: a sign bit (sign), a mantissa (M) and an exponent (exp).
- the floating-point number represented is ( ⁇ 1) sign * M * 2 exp .
- a standard code for representing floating-point numbers is the “IEEE Standard for Binary Floating-Point Arithmetic,” which is referred to herein as the IEEE-754 standard (or simply the IEEE standard) and incorporated herein by reference.
- IEEE-754 or simply the IEEE standard
- the exponent consists of 8 bits for single precision floating-point numbers and 11 bits for double precision floating-point numbers
- the mantissa consists of 23 bits for single precision and 52 bits for double precision. Additionally, for both single precision and double precision floating-point numbers there is a single bit that represents the sign of the number.
- floating-point units Many operations can be performed on floating-point numbers, including arithmetic operations, such as addition, subtraction, multiplication, division, and square roots. Because arithmetic operations with floating-point numbers require a great deal of computing power, many microprocessors come with a specialized integrated circuit, called a floating-point unit (FPU), for performing floating-point arithmetic. Floating-point units are also called math coprocessors, numeric coprocessors, coprocessors, or simply processors.
- FPU floating-point unit
- digit-by-digit There are two major schemes utilized by an FPU in performing division and square root functions.
- the first scheme is “digit-by-digit”, and the second scheme is “convergent approximation”.
- digit-by-digit schemes offer a short delay per iteration, but they also require a large number of iterations or clock-cycles.
- digit-by-digit schemes produce a final remainder, which can be used to determine whether a result is exact or inexact.
- Convergent approximations offer a faster convergence rate (lower number of iterations) than the digit-by-digit scheme, but they do not produce a final remainder; thus, one can not determine whether a result produced by a convergent approximation is exact or inexact. Nevertheless, convergent approximations provide approximate results that are adequate for most applications.
- Convergent approximation algorithms for approximating reciprocals and reciprocal square roots include the Newton-Raphson algorithm.
- X i+1 (3 ⁇ N*X i *X i )*X i /2, where X i is an approximation of the reciprocal square root of N at the ith iteration, where ⁇ is greater than or equal to 1, and X i+1 is a more accurate approximation.
- the present invention provides a method, and a system for implementing that method, for improving the accuracy of approximating the reciprocal of a number and the reciprocal square root of a number.
- the methods of the present invention do not negatively impact the performance of the system.
- the invention provides a method for approximating the reciprocal square root of a number (N).
- This method provides one advantage because of the order in which the multiplication is performed makes it likely that all results will be in normalized form. Specifically, the Newton-Raphson algorithm requires one to determine the product of: N*X i *X i .
- the method according to the present invention first multiplies N by X i to produce an intermediate result. This intermediate result will likely be in normalized form, even when N is large. The method then multiplies the intermediate result by X i to produce: (N*X i )*X i . If the method first multiplied X i by X i to produce the intermediate result, the intermediate result would most likely be in denormalized form when N is large.
- step (c) is typically a very small number. This provides an advantage because when the result of step (c) is expressed in normalized floating-point form, the precision of the result is increased, thereby improving the approximation of the reciprocal.
- the invention provides four instructions for implementing the above method for approximating the reciprocal square root of a number (N). These four instructions are executed by a floating-point unit.
- the invention provides a single instruction for implementing the above method for approximating the reciprocal square root of a number (N).
- This instruction is also executed by a floating-point unit.
- X i X i +X i *IR2.
- the invention provides a computer program product having a computer useable medium having floating-point instructions stored therein.
- the floating-point instructions enable a floating-point unit to approximate the reciprocal square root of a number (N).
- the invention provides a method for approximating the reciprocal of a number (N).
- step (d) is typically a very small number. This provides an advantage because when the result of step (d) is expressed in normalized floating-point form, the precision of the result is increased, thereby improving the approximation of the reciprocal.
- the invention provides a computer program product comprising a computer useable medium having a floating-point instruction stored therein.
- FIG. 1 is a block diagram of a portion of a computer system according to one embodiment of the invention.
- FIG. 2 illustrates a method for performing an iteration of the Newton-Raphson algorithm for approximating the reciprocal of a number.
- FIG. 3 illustrates a method for performing an iteration of the Newton-Raphson algorithm for approximating the reciprocal square root of a number.
- FIGS. 4A and 4B illustrate the importance of the order in which a multiplication is performed with respect to the Newton-Raphson reciprocal square root algorithm.
- FIG. 1 is a block diagram of a portion of a computer system 100 according to one embodiment of the invention.
- Computer system 100 includes a floating-point unit (FPU) 110 that implements a floating-point instruction set.
- FPU 110 supports the IEEE-754 standard and enhances, among other things, geometric computations in 3D-graphics applications executed on computer system 100 .
- FPU 110 is implemented with a super-pipelined, multiply-add micro-architecture. At its peak, FPU 110 can execute one floating-point instruction and one floating-point load/store instruction per cycle.
- Computer system 100 further includes an instruction dispatch unit (IDU) 120 , a load store unit (LSU) 130 , and an integer execution unit (IXU) 140 .
- IDU 120 is interfaced with instruction memory 115 , which stores, among other things, floating-point instructions.
- IDU 120 dispatches the floating-point instructions to FPU 110 and keeps track of the state of each dispatched floating-point instruction, the register dependency, and the possibility of bypassing a resultant operand to the next FPU instruction.
- FPU 110 performs floating-point computations, as directed by the floating-point instructions dispatched by IDU 120 .
- LSU 130 interfaces with other elements that are internal or external to processor 100 , and provides data to, and receives data from FPU 110 . For example, operands are loaded from LSU 130 to FPU 110 and results are stored from FPU 110 to LSU 130 .
- IXU 140 performs integer computations, and is able to transfer data to, and receive data from, FPU 110 .
- FPU 110 includes a floating-point register file (FPR) 152 that interfaces with LSU 130 .
- FPR 152 includes a number of read ports and a number of write ports. More specifically, in one embodiment, FPR 152 is a 32-entry 64-bit register file with four read ports and two write ports.
- a floating-point pipe file (PIP) 154 couples to FPR 152 and further interfaces with LSU 130 and IXU 140 .
- PIP 154 selects and receives operands from, among other sources, FPR 152 .
- PIP 154 then unpacks the received operands from an IEEE compliant format (also referred to herein as “memory format”) into an internal data format recognized by the processing units within FPU 110 .
- the internal data format of PIP 154 is similar to the IEEE-754 standard format, except that, among other things, the internal data format utilizes a 12-bit exponent field.
- the 12-bit exponent field provides an advantage in that it makes it likely that all intermediate results can be represented in normalized form.
- PIP 154 also packs the results from FPU 110 into the memory format (i.e., IEEE compliant format) required by the external circuitry and provides the packed results to FPR 152 .
- a floating-point multiplier (MUL) 156 couples to PIP 154 and executes floating-point multiply instructions as well as the multiply portion of compound instructions such as a multiply-add (MADD) instruction.
- MUL 156 receives the mantissas of two operands from PIP 154 .
- MUL 156 is described in further detail in U.S. patent application Ser. No._______ (Attorney Docket No. 19427-89-1).
- a floating-point adder (ADDER) 158 couples to PIP 154 and MUL 156 .
- ADDER 158 executes floating-point add and subtract instructions as well as the add portion of compound instructions such as MADD.
- ADDER 158 receives two operands and performs floating-point magnitude addition/subtraction using, for example, a prescale adder (PSA) operated in parallel with a massive cancellation adder (MCA).
- PSA prescale adder
- MCA massive cancellation adder
- the final output is selected from one of the adders based on, among other things, the exponent difference of the two input operands.
- the final output is then provided to PIP 154 for storage. Selection criteria for PSA and MCA is further described in the above-referenced U.S.
- a floating-point exponent unit 160 functions to determine the exponent of a result of a given floating-point arithmetic operation.
- exponent unit 160 can determine approximately what the result exponent will be from the exponents of the operands, but it must interact with the mantissa calculation units (e.g., MUL 156 and ADDER 158 ) to determine how to adjust the result exponent value based on normalization shifts. Additionally, exponent section 160 performs overflow/underflow prediction, as well as detection.
- a floating-point control unit 164 is the control unit for FPU 110 . Floating-point instructions are sent to control unit 164 from IDU 120 . IDU 120 receives instructions stored in instruction memory 115 . Instruction memory 115 is a conventional computer useable medium, such as a random access memory or a read only memory, for storing program instructions. Control unit 164 interacts with each above described floating-point section and directs the data path through the proper sequence of operations to generate the proper output.
- Reciprocal and reciprocal square root operations can be performed by FPU 110 utilizing the Newton-Raphson convergent approximation algorithms.
- a method 200 for performing an iteration of the Newton-Raphson reciprocal algorithm is illustrated in FIG. 2, and a method 300 , according to the present invention, for performing an iteration of the Newton-Raphson reciprocal square root algorithm is illustrated in FIG. 3.
- step 202 the number, which is in the memory format, is retrieved from a floating-point memory, such as floating-point register file 152 or load/store unit 130 , for example.
- step 204 the number is unpacked from the memory format to the internal format.
- step 206 an estimate of the reciprocal of the number is determined. Any known or future developed method or means for estimating the reciprocal of a number may be used in step 206 . However, in one embodiment, the estimate is determined by using a lookup table as described in U.S. patent application Ser. No.________ (Attorney Docket No. MIPS-19427A-007520).
- step 208 the estimate is multiplied by the number. Then, in step 210 , the result of step 208 is subtracted from one (1). By subtracting the result of step 208 from a value of 1 as opposed to a value of 2, the result of step 210 is usually a very small number, which when represented in normalized form provides for a greater accuracy, thereby improving the approximation of the reciprocal of the number.
- step 212 the result produced in step 210 is multiplied by the estimate.
- step 214 the result of step 212 is added to the estimate.
- the result of step 214 is an approximation of the reciprocal of the number. A more accurate approximation can be achieved by setting the estimate equal to the result of step 214 and repeating steps 208 - 214 . Additional such iterations of method 200 further increases the accuracy of the approximation.
- step 216 the result of step 214 is packed from the internal format into the memory format, and in step 218 the packed result is written to the floating-point memory.
- step 302 the method 300 for performing an iteration of the Newton-Raphson algorithm for approximating the reciprocal square root of a number begins in step 302 .
- step 302 an estimate of the reciprocal of the square root of the number is determined. Any known or future developed method or means for estimating the reciprocal of a number may be used in step 302 . However, in one embodiment, the estimate is determined by using a lookup table as described in U.S. patent application Ser. No.________ (Attorney Docket No. MIPS-19427A-007520).
- step 304 the estimate is multiplied by the number.
- step 306 the result produced in step 304 is multiplied by the estimate.
- step 308 the result produced in step 306 is subtracted from one (1).
- the result of step 308 is usually a very small number, which when represented in normalized form provides for a greater accuracy, thereby improving the approximation of the reciprocal square root of the number.
- FIGS. 4A and 4B This concept is illustrated in FIGS. 4A and 4B.
- FIG. 4A illustrates that if one were to first multiply the estimate (represented as X i ) by itself to produce a first result (X i *X i ) and then multiply the first result by the number (N) to produce a second result N*(X i *X i ), the first result, (X i *X i ), will likely be a denorm result (i.e., fall within the range of denorm numbers) if the number (N) is a large number.
- step 310 the result produced in step 308 is divided by a value of 2. That is, the exponent of the result produced in step 308 is reduced by one (1).
- step 312 the result produced in step 310 is multiplied by the estimate determined in step 302 .
- step 314 the result of step 312 is added to the estimate determined in step 302 .
- the result of step 314 is an approximation of the reciprocal of the square root of the number. A more accurate approximation can be achieved by setting the estimate equal to the result of step 314 and repeating steps 304 - 314 . Additional such iterations of method 300 further increases the accuracy of the approximation.
- the floating-point instruction set architecture (ISA) for FPU 110 includes instructions for implementing the above methods. More specifically, in one embodiment, the ISA includes three instructions for implementing an iteration of the Newton-Raphson reciprocal algorithm. The three instruction are: RECIP1 (operand 1), RECIP2(operand 1, operand2) and MADD(operand 1, operand2, operand3).
- the RECIP1(operand1) instruction enables FPU 110 to produce a result that is an estimate of the reciprocal of operand1.
- a lookup table is used.
- Instruction RECIP2(operand1, operand2) enables FPU 110 to produce a result equal to: (1 ⁇ operand1*operand2).
- the MADD instruction is a multiply-add instruction and it enables FPU 110 to produce a result equal to: (operand1+operand2*operand3).
- the RECIP1 and RECIP2 instructions are further described in U.S.
- An advantage of the above instructions is that the value of IR produced by the RECIP2(N, X i ) instruction is usually a very small number, which when normalized provides a great deal of precision, thereby increasing the accuracy of the approximation.
- the reason the value of IR is usually a very small number is that the value of N*X i is nearly equal to one, being nearly equal to N*(1/N); that is why when one subtracts N*X i from 1, as opposed to two (2), the result is a small number.
- N*X i A consequence of subtracting N*X i from one (1), as opposed to two (2), is that it necessitates the MADD instruction.
- the MADD instruction would be replaced by a simple multiply instruction.
- a multiply instruction is preferred over a MADD instruction because a MADD instruction conventionally has a greater latency than a multiply instruction.
- FPU 110 is implemented with a multiply-add pipeline, the latency of the MADD instruction is the same as the latency of a multiply instruction. Therefore, not only does the above method and sequence of instructions improve the accuracy of a reciprocal operation, but it can do so adding little or no delay.
- the ISA also includes a RECIP(N) instruction.
- the floating-point ISA includes four instructions for performing an iteration of the Newton-Raphson algorithm for approximating reciprocal square roots.
- the four instruction are: RSQRT1(operand1), RSQRT2(operand1, operand2), MUL(operand1, operand2), and MADD(operand1, operand2, operand3).
- the RSQRT1(operand1) instruction enables FPU 110 to produce a result that is an estimate of the reciprocal square root of the operand.
- a lookup table is used.
- Instruction RSQRT2(operand1, operand2) enables FPU 110 to produce a result equal to: (1 ⁇ operand1*operand2)/2.
- the MADD(operand1, operand2, operand3) instruction is described above.
- the MUL(operand1, operand2) instruction is a multiply instruction that enables FPU 110 to produce a result equal to: operand1*operand2.
- the RSQRT1 and RSQRT2 instructions are further described in U.S. patent application Ser. No.________ (Attorney Docket No. MIPS-19427A-007520).
- An advantage of the above instructions is that the intermediate result, IR1, is likely to be within the range of values that can be represented in normalized form as opposed to denormalized form. Because of accuracy considerations, it is preferably to represent values in normalized form.
- IR2 produced by the RSQRT2(IR1, X i ) instruction is usually a very small number, which when normalized provides a great deal of precision, thereby increasing the accuracy of the approximation.
- the reason the value of IR2 is usually a very small number is that the value of IRI *X i is nearly equal to one, being nearly equal to N 1 ⁇ 2 *(1/N 1 ⁇ 2 ); that is why when one subtracts IR 1 *X i from 1, as opposed to three (3), the result is a small number.
- the MADD instruction would be replaced by a simple multiply instruction.
- a multiply instruction is preferred over a MADD instruction because a MADD instruction typically has a greater latency than a multiply instruction.
- FPU 110 is implemented with a multiply-add pipeline, the latency of the MADD instruction is the same as the latency of a multiply instruction. Therefore, not only does the above method and sequence of instructions improve the accuracy of a reciprocal square root operation, but it can do so adding little or no delay.
- the ISA also includes an RSQRT(N) instruction.
- the RSQRT(N) instruction causes FPU 110 to produce an approximation (X i+1 ) of the reciprocal square root of N according to the following equation: X i+1 ⁇ X i +X i *IR2.
- the approximation of the reciprocal square root of N is stored in FPR 152 in the IEEE standard format.
Abstract
The invention provides a system and method for improving the accuracy of approximating the reciprocal of a number and the reciprocal square root of a number. A method according to the present invention for approximating the reciprocal square root of a number (N) includes the steps of: (a) estimating the reciprocal square root of the number to produce an estimate (Xi); (b) multiplying Xi by N to produce a first intermediate result (IR1); (c) determining a second intermediate result (IR2) according to the equation: IR2=(1−Xi,*IR1)/2; (d) multiplying IR2 by Xi to produce a third intermediate result (IR3); and (e) adding IR3 to Xi to produce an approximation of the reciprocal square root of the number. This method provides one advantage because of the order in which the multiplication is performed makes it likely that all results will be in normalized form. Specifically, the Newton-Raphson algorithm requires one to determine the product of: N*Xi*Xi. The method according to the present invention first multiplies N by Xi to produce an intermediate result. This intermediate result will likely be in normalized form, even when N is large. The method then multiplies the intermediate result by Xi to produce: (N*Xi)*Xi. If the method first multiplied Xi by Xi to produce the intermediate result, the intermediate result would most likely be in denormalized form when N is large. It is disadvantageous to produce a denormal result because producing a denormal result causes a loss of accuracy. Therefore, although (N*Xi)*Xi is mathematically identical to (Xi*Xi)*N, the former is preferred because it avoids denormal intermediate results. This method provides another advantage because the result of step (c) is typically a very small number. This provides an advantage because when the result of step (c) is expressed in normalized floating-point form, the precision of the result is increased, thereby improving the approximation of the reciprocal.
Description
- 1. Field of the Invention
- The present invention relates to floating-point arithmetic, and more specifically to a floating-point unit that implements Newton-Raphson convergent algorithms for determining reciprocals and reciprocal square roots.
- 2. Related Art
- The reciprocal of a number (N) is defined as 1 divided by N. The reciprocal square root of N is defined as 1 divided by the square root of N.
- In digital processing systems, numerical data is typically expressed using an integer or a floating-point representation. A floating-point representation is preferred in many applications because of its ability to express a wide range of values and its ease of manipulation for some specified operations. A floating-point representation includes three components: a sign bit (sign), a mantissa (M) and an exponent (exp). The floating-point number represented is (−1)sign* M * 2exp.
- A standard code for representing floating-point numbers is the “IEEE Standard for Binary Floating-Point Arithmetic,” which is referred to herein as the IEEE-754 standard (or simply the IEEE standard) and incorporated herein by reference. In the IEEE standard the exponent consists of 8 bits for single precision floating-point numbers and 11 bits for double precision floating-point numbers, the mantissa consists of 23 bits for single precision and 52 bits for double precision. Additionally, for both single precision and double precision floating-point numbers there is a single bit that represents the sign of the number.
- Many operations can be performed on floating-point numbers, including arithmetic operations, such as addition, subtraction, multiplication, division, and square roots. Because arithmetic operations with floating-point numbers require a great deal of computing power, many microprocessors come with a specialized integrated circuit, called a floating-point unit (FPU), for performing floating-point arithmetic. Floating-point units are also called math coprocessors, numeric coprocessors, coprocessors, or simply processors.
- There are two major schemes utilized by an FPU in performing division and square root functions. The first scheme is “digit-by-digit”, and the second scheme is “convergent approximation”. In general, digit-by-digit schemes offer a short delay per iteration, but they also require a large number of iterations or clock-cycles. Additionally, digit-by-digit schemes produce a final remainder, which can be used to determine whether a result is exact or inexact.
- Convergent approximations offer a faster convergence rate (lower number of iterations) than the digit-by-digit scheme, but they do not produce a final remainder; thus, one can not determine whether a result produced by a convergent approximation is exact or inexact. Nevertheless, convergent approximations provide approximate results that are adequate for most applications.
- Convergent approximation algorithms for approximating reciprocals and reciprocal square roots include the Newton-Raphson algorithm. The Newton-Raphson algorithm for approximating the reciprocal of a number (N) is expressed as: Xi+1=Xi* (2−N*Xi), where Xi is an approximation of the reciprocal of N at the ith iteration, where í is greater than or equal to 1, and Xi+1, is a more accurate approximation. For example, if Xi provides 14 bits of accuracy, Xi+1 provides an accuracy of 28 bits.
- The Newton-Raphson algorithm for approximating the reciprocal square root of N is expressed as: Xi+1=(3−N*Xi*Xi)*Xi/2, where Xi is an approximation of the reciprocal square root of N at the ith iteration, where í is greater than or equal to 1, and Xi+1 is a more accurate approximation.
- What is desired is a method for implementing the Newton-Raphson approximations such that the accuracy of the approximations is increased, but that the performance of the system implementing the method is not negatively affected.
- The present invention provides a method, and a system for implementing that method, for improving the accuracy of approximating the reciprocal of a number and the reciprocal square root of a number. The methods of the present invention do not negatively impact the performance of the system.
- In one aspect, the invention provides a method for approximating the reciprocal square root of a number (N). This method includes the steps of: (a) estimating the reciprocal square root of N to produce an estimate (Xi); (b) multiplying the estimate by N to produce a first intermediate result (IR1); (c) determining a second intermediate result (IR2) according to the equation: IR2=(1−Xi*IR1)/2; (d) multiplying the second intermediate result by the estimate to produce a third intermediate result; and (e) adding the third intermediate result to the estimate to produce an approximation of the reciprocal square root of the number.
- This method provides one advantage because of the order in which the multiplication is performed makes it likely that all results will be in normalized form. Specifically, the Newton-Raphson algorithm requires one to determine the product of: N*Xi*Xi. The method according to the present invention first multiplies N by Xi to produce an intermediate result. This intermediate result will likely be in normalized form, even when N is large. The method then multiplies the intermediate result by Xi to produce: (N*Xi)*Xi. If the method first multiplied Xi by Xi to produce the intermediate result, the intermediate result would most likely be in denormalized form when N is large. It is disadvantageous to produce a denormal result because producing a denormal result causes a loss of accuracy. Therefore, although (N*Xi)*Xi is mathematically identical to (Xi*Xi)*N, the former is preferred because it avoids denormal intermediate results.
- The above method provides another advantage because the result of step (c) is typically a very small number. This provides an advantage because when the result of step (c) is expressed in normalized floating-point form, the precision of the result is increased, thereby improving the approximation of the reciprocal.
- In another aspect, the invention provides four instructions for implementing the above method for approximating the reciprocal square root of a number (N). These four instructions are executed by a floating-point unit. The four instruction include: a first instruction that enables the floating-point unit to produce an estimate (Xi) of the reciprocal square root of N; a second instruction that enables the floating-point unit to produce a first intermediate result (IR1) equal to Xi multiplied by N; a third instruction that enables the floating-point unit to produce a second intermediate result (IR2) according to the equation: IR2=(1−Xi*IR1)/2; and a fourth instruction that enables the floating-point unit to produce an approximation (Xi+1) of the reciprocal square root of the number according to the equation: Xi+1=Xi+Xi*IR2.
- In another aspect, the invention provides a single instruction for implementing the above method for approximating the reciprocal square root of a number (N). This instruction is also executed by a floating-point unit. The instruction enables the floating-point unit to produce an estimate (Xi) of the reciprocal square root of N; produce a first intermediate result (IR1) equal to Xi multiplied by N; produce a second intermediate result (IR2) according to the equation: IR2=(1−Xi*IR1)/2; and, lastly, produce an approximation (Xi+1) of the reciprocal square root of N according to the equation: Xi=Xi+Xi*IR2.
- In another aspect, the invention provides a computer program product having a computer useable medium having floating-point instructions stored therein. The floating-point instructions enable a floating-point unit to approximate the reciprocal square root of a number (N). The floating-point instructions include: a first instruction to enable the floating-point unit to produce an estimate (Xi) of the reciprocal square root of the number; a multiply instruction to enable the floating-point unit to produce a first intermediate result (IR1) equal to the estimate multiplied by the number; a second instruction to enable the floating-point unit to produce a second intermediate result (IR2) according to the equation: IR2=(1−Xi*IR1)/2; and a third instruction to enable the floating-point unit to produce an approximation (Xi+1) of the reciprocal square root of the number according to the equation: Xi+1=Xi+1Xi*IR2.
- In another aspect, the invention provides a method for approximating the reciprocal of a number (N). The method includes the steps of: (a) retrieving the number from a floating-point memory, wherein the number is stored in the memory in a memory format; (b) unpacking the number from the memory format to an internal format; (c) estimating the reciprocal of the number to produce an estimate (Xi); (d) determining a first intermediate result (IR1) according to the equation: IR1=1−N*Xi; (e) multiplying the first intermediate result by the estimate to produce a second intermediate result; (f) adding the estimate to the second intermediate result to produce an approximation of the reciprocal of the number, wherein the approximation is in the internal format; (g) packing the approximation from the internal format to the memory format; and (h) writing the approximation in the memory format to the floating-point memory.
- The result of step (d) is typically a very small number. This provides an advantage because when the result of step (d) is expressed in normalized floating-point form, the precision of the result is increased, thereby improving the approximation of the reciprocal.
- In another aspect, the invention provides a computer program product comprising a computer useable medium having a floating-point instruction stored therein. The floating-point instruction enables a floating-point unit to approximate the reciprocal of a number (N). More specifically, the floating-point instruction enables the floating-point unit to produce an estimate (Xi) of the reciprocal of the number, produce an intermediate result (IR) according to the equation: IR=1−N*Xi, and produce an approximation (Xi+1)of the reciprocal of the number according to the equation: Xi+1=Xi+Xi*IR.
- Further features and advantages of the present invention, as well as the structure and operation of various embodiments of the present invention, are described in detail below with reference to the accompanying drawings.
- The accompanying drawings, which are incorporated herein and form part of the specification, illustrate a preferred embodiment of the present invention and, together with the description, further serve to explain the principles of the invention and to enable a person skilled in the pertinent art to make and use the invention. In the drawings, like reference numbers indicate identical or functionally similar elements. Additionally, the left-most digit(s) of a reference number identifies the drawing in which the reference number first appears.
- FIG. 1 is a block diagram of a portion of a computer system according to one embodiment of the invention.
- FIG. 2 illustrates a method for performing an iteration of the Newton-Raphson algorithm for approximating the reciprocal of a number.
- FIG. 3 illustrates a method for performing an iteration of the Newton-Raphson algorithm for approximating the reciprocal square root of a number.
- FIGS. 4A and 4B illustrate the importance of the order in which a multiplication is performed with respect to the Newton-Raphson reciprocal square root algorithm.
- FIG. 1 is a block diagram of a portion of a
computer system 100 according to one embodiment of the invention.Computer system 100 includes a floating-point unit (FPU) 110 that implements a floating-point instruction set. FPU 110 supports the IEEE-754 standard and enhances, among other things, geometric computations in 3D-graphics applications executed oncomputer system 100. In a preferred embodiment, FPU 110 is implemented with a super-pipelined, multiply-add micro-architecture. At its peak, FPU 110 can execute one floating-point instruction and one floating-point load/store instruction per cycle. -
Computer system 100 further includes an instruction dispatch unit (IDU) 120, a load store unit (LSU) 130, and an integer execution unit (IXU) 140. IDU 120 is interfaced withinstruction memory 115, which stores, among other things, floating-point instructions. IDU 120 dispatches the floating-point instructions to FPU 110 and keeps track of the state of each dispatched floating-point instruction, the register dependency, and the possibility of bypassing a resultant operand to the next FPU instruction. FPU 110 performs floating-point computations, as directed by the floating-point instructions dispatched by IDU 120. LSU 130 interfaces with other elements that are internal or external toprocessor 100, and provides data to, and receives data from FPU 110. For example, operands are loaded from LSU 130 to FPU 110 and results are stored from FPU 110 to LSU 130.IXU 140 performs integer computations, and is able to transfer data to, and receive data from, FPU 110. - FPU110 includes a floating-point register file (FPR) 152 that interfaces with LSU 130.
FPR 152 includes a number of read ports and a number of write ports. More specifically, in one embodiment,FPR 152 is a 32-entry 64-bit register file with four read ports and two write ports. - A floating-point pipe file (PIP)154 couples to
FPR 152 and further interfaces with LSU 130 andIXU 140. For each instruction,PIP 154 selects and receives operands from, among other sources,FPR 152.PIP 154 then unpacks the received operands from an IEEE compliant format (also referred to herein as “memory format”) into an internal data format recognized by the processing units within FPU 110. The internal data format ofPIP 154 is similar to the IEEE-754 standard format, except that, among other things, the internal data format utilizes a 12-bit exponent field. The 12-bit exponent field provides an advantage in that it makes it likely that all intermediate results can be represented in normalized form.PIP 154 also packs the results from FPU 110 into the memory format (i.e., IEEE compliant format) required by the external circuitry and provides the packed results toFPR 152. - A floating-point multiplier (MUL)156 couples to
PIP 154 and executes floating-point multiply instructions as well as the multiply portion of compound instructions such as a multiply-add (MADD) instruction. MUL 156 receives the mantissas of two operands fromPIP 154. MUL 156 is described in further detail in U.S. patent application Ser. No.______ (Attorney Docket No. 19427-89-1). - A floating-point adder (ADDER)158 couples to
PIP 154 and MUL 156.ADDER 158 executes floating-point add and subtract instructions as well as the add portion of compound instructions such as MADD.ADDER 158 receives two operands and performs floating-point magnitude addition/subtraction using, for example, a prescale adder (PSA) operated in parallel with a massive cancellation adder (MCA). The final output is selected from one of the adders based on, among other things, the exponent difference of the two input operands. The final output is then provided toPIP 154 for storage. Selection criteria for PSA and MCA is further described in the above-referenced U.S. patent application Ser. No.______ (Attorney Docket No. 19427-97).ADDER 158 is also described in further detail in U.S. patent application Ser. No.______ (Attorney Docket No. 19427-89-1). - A floating-
point exponent unit 160 functions to determine the exponent of a result of a given floating-point arithmetic operation. In general,exponent unit 160 can determine approximately what the result exponent will be from the exponents of the operands, but it must interact with the mantissa calculation units (e.g., MUL 156 and ADDER 158) to determine how to adjust the result exponent value based on normalization shifts. Additionally,exponent section 160 performs overflow/underflow prediction, as well as detection. - A floating-
point control unit 164 is the control unit for FPU 110. Floating-point instructions are sent to controlunit 164 from IDU 120. IDU 120 receives instructions stored ininstruction memory 115.Instruction memory 115 is a conventional computer useable medium, such as a random access memory or a read only memory, for storing program instructions.Control unit 164 interacts with each above described floating-point section and directs the data path through the proper sequence of operations to generate the proper output. - Reciprocal and reciprocal square root operations can be performed by FPU110 utilizing the Newton-Raphson convergent approximation algorithms. The Newton-Raphson reciprocal algorithm for approximating the reciprocal of a number (N) is defined as: Xi+1=Xi* (2−N*Xi), where Xi is an estimated result at iteration í, where í is an integer (e.g., 1,2,3, . . . n), and Xi+1 is a more accurate approximation. The Newton-Raphson reciprocal square root algorithm for approximating the reciprocal square root of N is defined as: Xi+1=(3−N*Xi*Xi)*Xi/2, where Xi is an initial approximation of the reciprocal square root of the number, and Xi+1 is a more accurate approximation.
- A
method 200, according to the present invention, for performing an iteration of the Newton-Raphson reciprocal algorithm is illustrated in FIG. 2, and a method 300, according to the present invention, for performing an iteration of the Newton-Raphson reciprocal square root algorithm is illustrated in FIG. 3. - Referring now to FIG. 2, the
method 200 for performing an iteration of the Newton-Raphson algorithm for approximating the reciprocal of a number begins instep 202. Instep 202 the number, which is in the memory format, is retrieved from a floating-point memory, such as floating-point register file 152 or load/store unit 130, for example. Instep 204, the number is unpacked from the memory format to the internal format. Instep 206, an estimate of the reciprocal of the number is determined. Any known or future developed method or means for estimating the reciprocal of a number may be used instep 206. However, in one embodiment, the estimate is determined by using a lookup table as described in U.S. patent application Ser. No.______ (Attorney Docket No. MIPS-19427A-007520). - Next, in
step 208, the estimate is multiplied by the number. Then, instep 210, the result ofstep 208 is subtracted from one (1). By subtracting the result ofstep 208 from a value of 1 as opposed to a value of 2, the result ofstep 210 is usually a very small number, which when represented in normalized form provides for a greater accuracy, thereby improving the approximation of the reciprocal of the number. - In
step 212, the result produced instep 210 is multiplied by the estimate. Instep 214, the result ofstep 212 is added to the estimate. The result ofstep 214 is an approximation of the reciprocal of the number. A more accurate approximation can be achieved by setting the estimate equal to the result ofstep 214 and repeating steps 208-214. Additional such iterations ofmethod 200 further increases the accuracy of the approximation. Instep 216, the result ofstep 214 is packed from the internal format into the memory format, and instep 218 the packed result is written to the floating-point memory. - Referring now to FIG.3, the method 300 for performing an iteration of the Newton-Raphson algorithm for approximating the reciprocal square root of a number begins in
step 302. Instep 302, an estimate of the reciprocal of the square root of the number is determined. Any known or future developed method or means for estimating the reciprocal of a number may be used instep 302. However, in one embodiment, the estimate is determined by using a lookup table as described in U.S. patent application Ser. No.______ (Attorney Docket No. MIPS-19427A-007520). - Next, in
step 304, the estimate is multiplied by the number. Then, instep 306, the result produced instep 304 is multiplied by the estimate. In step 308, the result produced instep 306 is subtracted from one (1). By subtracting the result ofstep 306 from a value of 1 as opposed to a value of 3, the result of step 308 is usually a very small number, which when represented in normalized form provides for a greater accuracy, thereby improving the approximation of the reciprocal square root of the number. Additionally, by first multiplying the estimate by the number and then multiplying that result by the estimate, the method will likely avoid a denormalized result that might have occurred had the method first multiplied the estimate by itself to produce a result and then multiplied the result by the number. Consequently, the order in which the multiplication occurs in accordance with the present invention is advantageous. This concept is illustrated in FIGS. 4A and 4B. FIG. 4A illustrates that if one were to first multiply the estimate (represented as Xi) by itself to produce a first result (Xi*Xi) and then multiply the first result by the number (N) to produce a second result N*(Xi*Xi), the first result, (Xi*Xi), will likely be a denorm result (i.e., fall within the range of denorm numbers) if the number (N) is a large number. Whereas, FIG. 4B illustrates that if one were to first multiply the estimate (Xi) by the number (N) to produce a first result (N*Xi) and then multiply the first result by the estimate to produce a second result (N*Xi)*Xi, the first result, (N*Xi), will likely not be a denorm result, even when the number (N) is a large number. - In
step 310, the result produced in step 308 is divided by a value of 2. That is, the exponent of the result produced in step 308 is reduced by one (1). Instep 312, the result produced instep 310 is multiplied by the estimate determined instep 302. Lastly, instep 314, the result ofstep 312 is added to the estimate determined instep 302. The result ofstep 314 is an approximation of the reciprocal of the square root of the number. A more accurate approximation can be achieved by setting the estimate equal to the result ofstep 314 and repeating steps 304-314. Additional such iterations of method 300 further increases the accuracy of the approximation. - The floating-point instruction set architecture (ISA) for FPU110 includes instructions for implementing the above methods. More specifically, in one embodiment, the ISA includes three instructions for implementing an iteration of the Newton-Raphson reciprocal algorithm. The three instruction are: RECIP1 (operand 1), RECIP2(
operand 1, operand2) and MADD(operand 1, operand2, operand3). - The RECIP1(operand1) instruction enables FPU110 to produce a result that is an estimate of the reciprocal of operand1. There are a variety of ways for producing the estimate. In one embodiment, a lookup table is used. Instruction RECIP2(operand1, operand2) enables FPU 110 to produce a result equal to: (1−operand1*operand2). The MADD instruction is a multiply-add instruction and it enables FPU 110 to produce a result equal to: (operand1+operand2*operand3). The RECIP1 and RECIP2 instructions are further described in U.S. patent application Ser. No.______ (Attorney Docket No. MIPS-19427A-007520).
- The Newton-Raphson algorithm for approximating the reciprocal of a number (N) is implemented by using FPU110 to execute the above mentioned instructions in the following sequence:
- (1) Xi=RECIP1(N);
- (2) IR=RECIP2(N, Xi); and
- (3) Xi+1=MADD(Xi, Xi, IR).
- After FPU110 executes the above three instructions in the above given sequence, Xi+1=Xi+Xi*IR=Xi+Xi*(1−N*Xi)=2Xi−N*Xi*Xi=Xi*(2−N*Xi), which is the Newton-Raphson approximation for the reciprocal of N.
- An advantage of the above instructions is that the value of IR produced by the RECIP2(N, Xi) instruction is usually a very small number, which when normalized provides a great deal of precision, thereby increasing the accuracy of the approximation. The reason the value of IR is usually a very small number is that the value of N*Xi is nearly equal to one, being nearly equal to N*(1/N); that is why when one subtracts N*Xi from 1, as opposed to two (2), the result is a small number.
- A consequence of subtracting N*Xi from one (1), as opposed to two (2), is that it necessitates the MADD instruction. Had N*Xi been subtracted from two(2) instead of one (1), the MADD instruction would be replaced by a simple multiply instruction. Typically, a multiply instruction is preferred over a MADD instruction because a MADD instruction conventionally has a greater latency than a multiply instruction. However, because FPU 110 is implemented with a multiply-add pipeline, the latency of the MADD instruction is the same as the latency of a multiply instruction. Therefore, not only does the above method and sequence of instructions improve the accuracy of a reciprocal operation, but it can do so adding little or no delay.
- The ISA also includes a RECIP(N) instruction. This single instruction is equivalent to the sequence of three instructions described above. That is, the RECIP instruction first causes FPU110 to produce and estimate (Xi) of the reciprocal of N. Then it causes FPU 110 to produce an intermediate result (IR) according to the equation: 1−N*Xi. The intermediate result is stored in
PIP 154 in the internal format. By storing intermediate results in the internal format, denormalized numbers are typically avoided. Finally, the RECIP instruction causes FPU 110 to produce an approximation (Xi+1) of the reciprocal of the number (N) according to the following equation: Xi+1=Xi+Xi*IR. The approximation of the reciprocal of the number is stored inFPR 152 in the IEEE standard format. - In addition to providing instructions for approximating reciprocals, the floating-point ISA includes four instructions for performing an iteration of the Newton-Raphson algorithm for approximating reciprocal square roots. The four instruction are: RSQRT1(operand1), RSQRT2(operand1, operand2), MUL(operand1, operand2), and MADD(operand1, operand2, operand3).
- The RSQRT1(operand1) instruction enables FPU110 to produce a result that is an estimate of the reciprocal square root of the operand. There are a variety of ways for producing the estimate. In one embodiment, a lookup table is used.
- Instruction RSQRT2(operand1, operand2) enables FPU110 to produce a result equal to: (1−operand1*operand2)/2. The MADD(operand1, operand2, operand3) instruction is described above. The MUL(operand1, operand2) instruction is a multiply instruction that enables FPU 110 to produce a result equal to: operand1*operand2. The RSQRT1 and RSQRT2 instructions are further described in U.S. patent application Ser. No.______ (Attorney Docket No. MIPS-19427A-007520).
- The Newton-Raphson algorithm for approximating the reciprocal square root of a number (N) is implemented by using FPU110 to execute the above mentioned instructions in the following sequence:
- (1) Xi=RSQRT1(N);
- (2) IRI=MUL(N, Xi)
- (3) IR2=RSQRT2(IR1, Xi); and
- (4) Xi+1=MADD(Xi, Xi, IR2).
- After FPU110 executes the above four instructions in the above given sequence, Xi+1=(3−N*Xi*Xi)*Xi/2, which is the Newton-Raphson approximation for the reciprocal square root of N.
- An advantage of the above instructions is that the intermediate result, IR1, is likely to be within the range of values that can be represented in normalized form as opposed to denormalized form. Because of accuracy considerations, it is preferably to represent values in normalized form.
- Another advantage of the above instructions is that the value of IR2 produced by the RSQRT2(IR1, Xi) instruction is usually a very small number, which when normalized provides a great deal of precision, thereby increasing the accuracy of the approximation. The reason the value of IR2 is usually a very small number is that the value of IRI *Xi is nearly equal to one, being nearly equal to N½*(1/N½); that is why when one subtracts IR1 *Xi from 1, as opposed to three (3), the result is a small number.
- A consequence of subtracting IR1*Xi from one (1), as opposed to three (3), is that it necessitates the MADD instruction. Had IR1*Xi been subtracted from three (3) instead of one (1), the MADD instruction would be replaced by a simple multiply instruction. As discussed above, conventionally, a multiply instruction is preferred over a MADD instruction because a MADD instruction typically has a greater latency than a multiply instruction. However, because FPU 110 is implemented with a multiply-add pipeline, the latency of the MADD instruction is the same as the latency of a multiply instruction. Therefore, not only does the above method and sequence of instructions improve the accuracy of a reciprocal square root operation, but it can do so adding little or no delay.
- The ISA also includes an RSQRT(N) instruction. This single instruction is equivalent to the sequence of four instructions described above. That is, the RSQRT instruction first causes FPU110 to produce and estimate (Xi) of the reciprocal square root of N. Then it causes FPU 110 to produce a first intermediate result (IRI) according to the following equation: IR1=N*Xi. Next, it causes FPU 110 to produce a second intermediate result (IR2) according to the following equation: IR2=(1−IR1*Xi)/2. Both intermediate results, IR1 and IR2, are stored using the internal format in
PIP 154. By storing intermediate results in the internal format, denormalized numbers are typically avoided. Finally, the RSQRT(N) instruction causes FPU 110 to produce an approximation (Xi+1) of the reciprocal square root of N according to the following equation: Xi+1−Xi+Xi*IR2. The approximation of the reciprocal square root of N is stored inFPR 152 in the IEEE standard format. - While various embodiments of the present invention have been described above, it should be understood that they have been presented by way of example only, and not limitation. Thus, the breadth and scope of the present invention should not be limited by any of the above-described exemplary embodiments, but should be defined only in accordance with the following claims and their equivalents.
Claims (40)
1. A method for approximating the reciprocal of a number (N), comprising:
(a) retrieving the number from a floating-point memory, wherein the number is stored in said memory in a memory format;
(b) unpacking the number from said memory format to an internal format;
(c) estimating the reciprocal of the number to produce an estimate (Xi);
(d) determining a first intermediate result (IR1) according to the equation: IR1=1−N*Xi;
(e) multiplying said first intermediate result by said estimate to produce a second intermediate result;
(f) adding said estimate to said second intermediate result to produce an approximation of the reciprocal of the number, wherein said approximation is in said internal format;
(g) packing said approximation from said internal format to said memory format; and
(h) writing said approximation in said memory format to said floating-point memory.
2. The method of claim 1 , further comprising the steps of:
(i) setting said estimate equal to said approximation; and
(j) repeating steps (d)-(f) to produce a more accurate approximation.
3. The method of claim 1 , wherein said internal format has an exponent of at least 12-bits, and said memory format has an exponent of not more than 11-bits.
4. A computer system having a processor in communication with means for storing instructions that enable the processor to perform arithmetic operations, the instructions comprising an instruction that enables the processor to produce an estimate (Xi) of a reciprocal of a number (N), produce an intermediate result (IR) according to the equation: IR=1−N*Xi, and
produce an approximation (Xi+1) of the reciprocal of said number according to the equation: Xi+1=Xi+Xi*IR.
5. The computer system of claim 4 , wherein said instruction enables the processor to first retrieve said number from a floating-point memory, wherein said number is stored in said memory in a memory format, and then enables the processor to unpack said number from said memory format to an internal format prior to enabling the processor to produce said estimate.
6. The computer system of claim 5 , wherein said approximation is in said internal format, and wherein said instruction further enables the processor to pack said approximation from said internal format to said memory format, and to write said approximation in said memory format to said memory.
7. The computer system of claim 5 , wherein said internal format has an exponent of at least 12-bits, and said memory format has an exponent of not more than 11-bits.
8. A computer program product comprising a computer useable medium having a floating-point instruction stored therein, the floating-point instruction for enabling a floating-point unit to approximate the reciprocal of a number (N), wherein the floating-point instruction enables the floating-point unit to
produce an estimate (Xi) of the reciprocal of the number, produce an intermediate result (IR) according to the equation: IR=1−N*Xi, and
produce an approximation (Xi+1) of the reciprocal of the number according to the equation: Xi+1=Xi+Xi*IR.
9. The computer program product of claim 8 , wherein said floating-point instruction enables the floating-point unit to first retrieve said number from a floating-point memory, wherein said number is stored in said memory in a memory format, and then enables the floating-point unit to unpack said number from said memory format to an internal format prior to enabling the floating-point unit to produce said estimate.
10. The computer program product of claim 9 , wherein said approximation is in said internal format, and wherein said floating-point instruction further enables the floating-point unit to pack said approximation from said internal format to said memory format, and to write said approximation in said memory format to said floating-point memory.
11. The computer program product of claim 9 , wherein said internal format has an exponent of at least 12-bits, and said memory format has an exponent of not more than 11-bits.
12. A computer system, comprising:
a floating-point unit having a floating-point register file that stores a floating-point number (N) in a memory format, a floating-point pipe file coupled to said floating-point register file, wherein said floating-point pipe file selects said floating-point number from said floating-point register file and unpacks said floating-point number into an internal format, and a floating-point arithmetic unit, coupled to said pipe file, that receives said unpacked floating-point number from said pipe file and performs an arithmetic operation using said number to produce a result in said internal format;
a memory for storing a sequence of instructions that enable said floating-point unit to approximate the reciprocal of said number, said sequence of instructions comprising:
a first instruction to enable said floating-point unit to produce an estimate (Xi) of the reciprocal of said number;
a second instruction to enable said floating-point unit to produce an intermediate result (IR) according to the equation: IR=1−N*Xi; and
a third instruction to enable said floating-point unit to produce an approximation (Xi+1) of the reciprocal of said number according to the equation:
Xi+1Xi+Xi*IR; and
an instruction dispatch unit for dispatching said sequence of instructions from said memory to said floating-point unit.
13. The computer system of claim 12 , wherein said approximation is sent to said pipe file, said pipe file packs said approximation into said memory format, and said pipe file writes said approximation in said memory format to said floating-point register file.
14. The computer system of claim 12 , wherein said arithmetic unit comprises a floating-point mantissa multiplier coupled to said pipe file.
15. The computer system of claim 12 , wherein said arithmetic unit comprises a floating-point mantissa adder coupled to said mantissa multiplier.
16. The computer system of claim 12 , wherein said internal format has an exponent of at least 12-bits, and said memory format has an exponent of not more than 11-bits.
17. A method for approximating the reciprocal square root of a number, comprising:
(a) estimating the reciprocal square root of the number to produce an estimate (Xi);
(b) multiplying said estimate by the number to produce a first intermediate result (IR1);
(c) determining a second intermediate result (IR2) according to the equation: IR2=(1−Xi*IR1)/2;
(d) multiplying said second intermediate result by said estimate to produce a third intermediate result; and
(e) adding said third intermediate result to said estimate to produce an approximation of the reciprocal square root of the number.
18. The method of claim 17 , further comprising the steps of:
retrieving the number from a floating-point memory, wherein the number is stored in said memory in a memory format; and
unpacking the number from said memory format to an internal format prior to estimating the reciprocal square root of the number to produce said estimate (Xi).
19. The method of claim 18 , further comprising the steps of:
packing said approximation from said internal format to said memory format; and
writing said approximation in said memory format to said floating-point memory.
20. The method of claim 18 , wherein said internal format has an exponent of at least 12-bits, and said memory format has an exponent of not more than 11-bits.
21. The method of claim 17 , further comprising the steps of:
setting said estimate (Xi) equal to said approximation; and
repeating steps (b) through (e).
22. In a computer system having a floating-point unit, a method for determining the reciprocal square root of a number, comprising:
(a) providing an estimate instruction to the floating-point unit that enables the floating-point unit to produce an estimate (Xi) of the reciprocal square root of the number;
(b) providing a multiply instruction to the floating-point unit that enables the floating-point unit to produce a first intermediate result (IR1) equal to said estimate multiplied by said number;
(c) providing an instruction to said floating-point unit that enables the floating-point unit to produce a first intermediate result (IR1) according to the equation: IR2=(1−Xi*IR1)/2; and
(d) providing a multiply-add instruction to said floating-point unit that enables the floating-point unit to produce an approximation (Xi+1) of the reciprocal square root of the number according to the equation: Xi+1=Xi+Xi*IR2.
23. A computer system having a processor in communication with a storing means for storing instructions that enable the processor to perform arithmetic operations, the instructions comprising:
a first instruction to enable the processor to produce an estimate (Xi) of a reciprocal square root of a number;
a multiply instruction to enable the processor to calculate a first intermediate result (IR1) of said estimate multiplied by said number;
a second instruction to enable the processor to produce a second intermediate result (IR2) according to the equation: IR2=(1−Xi*IR1)/2; and
a third instruction to enable the processor to produce an approximation (Xi+1) of the reciprocal square root of said number according to the equation: Xi+1=Xi+Xi*IR2.
24. The computer system of claim 23 , wherein said storing means comprises a random access memory for storing the instructions.
25. The computer system of claim 23 , wherein said processor is a floating-point unit, wherein said floating-point unit executes said first instruction to produce said estimate of the reciprocal square root of said number, executes said multiply instruction to calculate said first intermediate result, executes said second instruction to produce said second intermediate result, and executes said third instruction to produce said approximation.
26. A computer system having a processor in communication with a storing means for storing instructions that enable the processor to perform arithmetic operations, the instructions comprising an instruction that enables the processor to produce an estimate (Xi) of the reciprocal square root of a number, calculate a first intermediate result (IR1) of said estimate multiplied by said number, produce a second intermediate result (IR2) according to the equation: IR2=(1−Xi*IR1)/2, and produce an approximation (Xi+1) of the reciprocal square root of said number according to the equation: Xi+1=Xi+Xi*IR2.
27. The computer system of claim 26 , wherein said instruction further enables the processor to first retrieve said number from a floating-point memory, wherein said number is stored in said memory in a memory format, and then enables the processor to unpack said number from said memory format to an internal format prior to enabling the processor to produce said estimate.
28. The computer system of claim 27 , wherein said approximation is in said internal format, and wherein said instruction further enables the processor to pack said approximation from said internal format to said memory format, and to write said approximation in said memory format to said floating-point memory.
29. The computer system of claim 27 , wherein said internal format has an exponent of at least 12-bits, and said memory format has an exponent of not more than 11-bits.
30. A computer program product comprising a computer useable medium having floating-point instructions stored therein, the floating-point instructions for enabling a floating-point unit to approximate the reciprocal square root of a number (N), wherein the floating-point instructions comprise:
a first instruction to enable the floating-point unit to produce an estimate (Xi) of the reciprocal square root of said number;
a multiply instruction to enable the floating-point unit to produce a first intermediate result (IR1) equal to said estimate multiplied by said number;
a second instruction to enable the floating-point unit to produce a second intermediate result (IR2) according to the equation: IR2=(1−Xi*IR1)/2; and
a third instruction to enable the floating-point unit to produce an approximation (Xi+1) of the reciprocal square root of said number according to the equation: Xi+1=Xi+Xi*IR2.
31. A computer program product comprising a computer useable medium having a floating-point instruction stored therein, the floating-point instruction for enabling a floating-point unit to approximate the reciprocal square root of a number (N), wherein the floating-point instruction enables the floating-point unit to produce an estimate (Xi) of the reciprocal square root of said number, produce a first intermediate result (IR1) equal to said estimate multiplied by said number, produce a second intermediate result (IR2) according to the equation: IR2=(1−Xi*IR1)/2, and produce an approximation (Xi+1) of the reciprocal square root of said number according to the equation: Xi+1=Xi+Xi*IR2.
32. The computer program product of claim 31 , wherein said floating-point instruction enables the floating-point unit to first retrieve said number from a floating-point memory, wherein said number is stored in said memory in a memory format, and then enables the floating-point unit to unpack said number from said memory format to an internal format prior to enabling the floating-point unit to produce said estimate.
33. The computer program product of claim 32 , wherein said approximation is in said internal format, and wherein said floating-point instruction further enables the floating-point unit to pack said approximation from said internal format to said memory format, and to write said approximation in said memory format to said floating-point memory.
34. The computer program product of claim 32 , wherein said internal format has an exponent of at least 12-bits, and said memory format has an exponent of not more than 11-bits.
35. A computer system, comprising:
a floating-point unit;
a memory for storing a sequence of instructions that enables said floating-point unit to approximate the reciprocal square root of a number (N), said sequence of instructions comprising:
a first instruction to enable said floating-point unit to produce an estimate (Xi) of the reciprocal square root of said number;
a multiply instruction to enable said floating-point unit to produce a first intermediate result (IR1) equal to said estimate multiplied by said number;
a second instruction to enable said floating-point unit to produce a second intermediate result (IR2) according to the equation: IR2=(1−Xi*IR1)/2; and
a third instruction to enable said floating-point unit to produce an approximation (Xi+1) of the reciprocal square root of said number according to the equation: Xi+1=Xi+Xi*IR2; and
an instruction dispatch unit for dispatching said sequence of instructions from said memory to said floating-point unit.
36. The computer system of claim 35 , wherein said floating-point unit comprises:
a floating-point register file that stores said number in a memory format;
a floating-point pipe file coupled to said floating-point register file, wherein said floating-point pipe file selects said number from said floating-point register file and unpacks said number into an internal format; and
a floating-point arithmetic unit, coupled to said pipe file, that receives said unpacked number from said pipe file and performs an arithmetic operation using said number to produce a result in said internal format.
37. The computer system of claim 36 , wherein said result is sent to said pipe file, said pipe file packs said result into said memory format, and said pipe file writes said result in said memory format to said floating-point register file.
38. The computer system of claim 36 , wherein said arithmetic unit comprises a floating-point mantissa multiplier coupled to said pipe file.
39. The computer system of claim 36 , wherein said arithmetic unit comprises a floating-point mantissa adder coupled to said mantissa multiplier.
40. The computer system of claim 39 , wherein said internal format has an exponent of at least 12-bits, and said memory format has an exponent of not more than 11-bits.
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US10/055,346 US20020116431A1 (en) | 1999-07-30 | 2002-01-25 | System and method for improving the accuracy of reciprocal operations performed by a floating-point unit |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US09/363,637 US6912559B1 (en) | 1999-07-30 | 1999-07-30 | System and method for improving the accuracy of reciprocal square root operations performed by a floating-point unit |
US10/055,346 US20020116431A1 (en) | 1999-07-30 | 2002-01-25 | System and method for improving the accuracy of reciprocal operations performed by a floating-point unit |
Related Parent Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/363,637 Division US6912559B1 (en) | 1999-07-30 | 1999-07-30 | System and method for improving the accuracy of reciprocal square root operations performed by a floating-point unit |
Publications (1)
Publication Number | Publication Date |
---|---|
US20020116431A1 true US20020116431A1 (en) | 2002-08-22 |
Family
ID=23431049
Family Applications (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/363,637 Expired - Lifetime US6912559B1 (en) | 1999-07-30 | 1999-07-30 | System and method for improving the accuracy of reciprocal square root operations performed by a floating-point unit |
US10/055,346 Abandoned US20020116431A1 (en) | 1999-07-30 | 2002-01-25 | System and method for improving the accuracy of reciprocal operations performed by a floating-point unit |
Family Applications Before (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/363,637 Expired - Lifetime US6912559B1 (en) | 1999-07-30 | 1999-07-30 | System and method for improving the accuracy of reciprocal square root operations performed by a floating-point unit |
Country Status (1)
Country | Link |
---|---|
US (2) | US6912559B1 (en) |
Cited By (10)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20020184282A1 (en) * | 2001-03-01 | 2002-12-05 | Yuval Gideon A. | System and method for using native floating point microprocessor instructions to manipulate 16-bit floating point data representations |
US20060184602A1 (en) * | 2005-02-16 | 2006-08-17 | Arm Limited | Data processing apparatus and method for performing a reciprocal operation on an input value to produce a result value |
US20060184594A1 (en) * | 2005-02-16 | 2006-08-17 | Arm Limited | Data processing apparatus and method for determining an initial estimate of a result value of a reciprocal operation |
US20070112902A1 (en) * | 2005-11-17 | 2007-05-17 | International Business Machines Corporation | Reciprocal estimate computation methods and apparatus |
US20080183791A1 (en) * | 1999-07-30 | 2008-07-31 | Mips Technologies, Inc. | Processor With Improved Accuracy For Multiply-Add Operations |
US20080243985A1 (en) * | 2007-03-30 | 2008-10-02 | Ping Tak Peter Tang | Method and apparatus for performing multiplicative functions |
CN100454237C (en) * | 2005-05-12 | 2009-01-21 | 国际商业机器公司 | Processor having efficient function estimate instructions |
US8156171B1 (en) * | 2007-11-20 | 2012-04-10 | Altera Corporation | Digital logic circuit |
US10133553B2 (en) * | 2015-02-22 | 2018-11-20 | The Regents Of The University Of Michigan | Reciprocal unit |
CN111814107A (en) * | 2020-07-10 | 2020-10-23 | 上海擎昆信息科技有限公司 | Computing system and computing method for realizing reciprocal of square root with high precision |
Families Citing this family (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US7242414B1 (en) * | 1999-07-30 | 2007-07-10 | Mips Technologies, Inc. | Processor having a compare extension of an instruction set architecture |
Citations (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5619198A (en) * | 1994-12-29 | 1997-04-08 | Tektronix, Inc. | Number format conversion apparatus for signal processing |
US6175907B1 (en) * | 1998-07-17 | 2001-01-16 | Ip First, L.L.C | Apparatus and method for fast square root calculation within a microprocessor |
Family Cites Families (73)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4156279A (en) | 1977-11-22 | 1979-05-22 | Honeywell Information Systems Inc. | Microprogrammed data processing unit including a multifunction secondary control store |
JPS5776634A (en) | 1980-10-31 | 1982-05-13 | Hitachi Ltd | Digital signal processor |
JPS61213927A (en) | 1985-03-18 | 1986-09-22 | Hitachi Ltd | Processor for floating point arithmetic |
US4866652A (en) | 1987-09-01 | 1989-09-12 | Weitek Corporation | Floating point unit using combined multiply and ALU functions |
US4879676A (en) | 1988-02-29 | 1989-11-07 | Mips Computer Systems, Inc. | Method and apparatus for precise floating point exceptions |
JP3076046B2 (en) | 1989-01-31 | 2000-08-14 | 日本電気株式会社 | Exception detection circuit |
US5025407A (en) | 1989-07-28 | 1991-06-18 | Texas Instruments Incorporated | Graphics floating point coprocessor having matrix capabilities |
US5159665A (en) | 1989-11-27 | 1992-10-27 | Sun Microsystems, Inc. | Graphics accelerator system |
JPH04127364A (en) | 1990-09-19 | 1992-04-28 | Nec Corp | Product sum calculating device |
US5206823A (en) * | 1990-12-13 | 1993-04-27 | Micron Technology, Inc. | Apparatus to perform Newton iterations for reciprocal and reciprocal square root |
US5220524A (en) * | 1990-12-13 | 1993-06-15 | Micron Technology, Inc. | Machine method to perform newton iterations for reciprocals |
US5278949A (en) | 1991-03-12 | 1994-01-11 | Hewlett-Packard Company | Polygon renderer which determines the coordinates of polygon edges to sub-pixel resolution in the X,Y and Z coordinates directions |
JP2875909B2 (en) | 1991-07-12 | 1999-03-31 | 三菱電機株式会社 | Parallel processing unit |
US5359548A (en) | 1992-04-15 | 1994-10-25 | Fujitsu Limited | Floating-point arithmetic system having multiple-input addition and subtraction means |
JP3466656B2 (en) | 1992-04-29 | 2003-11-17 | キヤノン株式会社 | Method and apparatus for filling object-based rasterized images |
US5257216A (en) | 1992-06-10 | 1993-10-26 | Intel Corporation | Floating point safe instruction recognition apparatus |
US5357599A (en) | 1992-07-30 | 1994-10-18 | International Business Machines Corporation | Method and apparatus for rendering polygons |
US5367650A (en) | 1992-07-31 | 1994-11-22 | Intel Corporation | Method and apparauts for parallel exchange operation in a pipelined processor |
US5457779A (en) | 1993-01-15 | 1995-10-10 | Silicon Graphics, Inc. | System for accessing graphic data in a SIMD processing environment |
US5671170A (en) | 1993-05-05 | 1997-09-23 | Hewlett-Packard Company | Method and apparatus for correctly rounding results of division and square root computations |
US5341321A (en) * | 1993-05-05 | 1994-08-23 | Hewlett-Packard Company | Floating point arithmetic unit using modified Newton-Raphson technique for division and square root |
AU5550194A (en) | 1993-09-27 | 1995-04-18 | Giga Operations Corporation | Implementation of a selected instruction set cpu in programmable hardware |
EP0645699A1 (en) | 1993-09-29 | 1995-03-29 | International Business Machines Corporation | Fast multiply-add instruction sequence in a pipeline floating-point processor |
US5815695A (en) | 1993-10-28 | 1998-09-29 | Apple Computer, Inc. | Method and apparatus for using condition codes to nullify instructions based on results of previously-executed instructions on a computer processor |
EP0651321B1 (en) | 1993-10-29 | 2001-11-14 | Advanced Micro Devices, Inc. | Superscalar microprocessors |
US5392228A (en) | 1993-12-06 | 1995-02-21 | Motorola, Inc. | Result normalizer and method of operation |
US5420971A (en) | 1994-01-07 | 1995-05-30 | Panasonic Technologies, Inc. | Image edge finder which operates over multiple picture element ranges |
US5553015A (en) | 1994-04-15 | 1996-09-03 | International Business Machines Corporation | Efficient floating point overflow and underflow detection system |
JP3599409B2 (en) | 1994-06-14 | 2004-12-08 | 株式会社ルネサステクノロジ | Branch prediction device |
US5550767A (en) | 1994-10-14 | 1996-08-27 | Ibm Corporation | Method and apparatus for detecting underflow and overflow |
US5631859A (en) | 1994-10-27 | 1997-05-20 | Hewlett-Packard Company | Floating point arithmetic unit having logic for quad precision arithmetic |
US5530663A (en) | 1994-11-14 | 1996-06-25 | International Business Machines Corporation | Floating point unit for calculating a compound instruction A+B×C in two cycles |
US5751621A (en) | 1994-11-17 | 1998-05-12 | Hitachi, Ltd. | Multiply-add unit and data processing apparatus using it |
US5511016A (en) | 1994-11-30 | 1996-04-23 | International Business Machines Corporation | Method for store rounding and circuit therefor |
US5550768A (en) | 1995-01-31 | 1996-08-27 | International Business Machines Corporation | Rounding normalizer for floating point arithmetic operations |
JPH09507941A (en) | 1995-04-18 | 1997-08-12 | インターナシヨナル・ビジネス・マシーンズ・コーポレーシヨン | Block normalization without wait cycles in a multi-add floating point sequence |
US5720019A (en) | 1995-06-08 | 1998-02-17 | Hewlett-Packard Company | Computer graphics system having high performance primitive clipping preprocessing |
US5602769A (en) | 1995-07-05 | 1997-02-11 | Sun Microsystems, Inc. | Method and apparatus for partially supporting subnormal operands in floating point multiplication |
WO1997005576A1 (en) | 1995-07-26 | 1997-02-13 | Silicon Engines, Inc. | Method and apparatus for span and subspan sorting rendering system |
US5953241A (en) | 1995-08-16 | 1999-09-14 | Microunity Engeering Systems, Inc. | Multiplier array processing system with enhanced utilization at lower precision for group multiply and sum instruction |
US6385634B1 (en) | 1995-08-31 | 2002-05-07 | Intel Corporation | Method for performing multiply-add operations on packed data |
US5726927A (en) | 1995-09-11 | 1998-03-10 | Digital Equipment Corporation | Multiply pipe round adder |
US5701442A (en) | 1995-09-19 | 1997-12-23 | Intel Corporation | Method of modifying an instruction set architecture of a computer processor to maintain backward compatibility |
US5805486A (en) | 1995-11-28 | 1998-09-08 | Intel Corporation | Moderately coupled floating point and integer units |
US5774709A (en) | 1995-12-06 | 1998-06-30 | Lsi Logic Corporation | Enhanced branch delay slot handling with single exception program counter |
US5852726A (en) | 1995-12-19 | 1998-12-22 | Intel Corporation | Method and apparatus for executing two types of instructions that specify registers of a shared logical register file in a stack and a non-stack referenced manner |
US5729724A (en) | 1995-12-20 | 1998-03-17 | Intel Corporation | Adaptive 128-bit floating point load and store operations for quadruple precision compatibility |
US5793661A (en) | 1995-12-26 | 1998-08-11 | Intel Corporation | Method and apparatus for performing multiply and accumulate operations on packed data |
US6175370B1 (en) | 1996-02-02 | 2001-01-16 | Kabushiki Kaisha Toshiba | Geometry translation processor |
US5880983A (en) | 1996-03-25 | 1999-03-09 | International Business Machines Corporation | Floating point split multiply/add system which has infinite precision |
US5892698A (en) | 1996-04-04 | 1999-04-06 | Hewlett-Packard Company | 2's complement floating-point multiply accumulate unit |
US5860017A (en) | 1996-06-28 | 1999-01-12 | Intel Corporation | Processor and method for speculatively executing instructions from multiple instruction streams indicated by a branch instruction |
US5768170A (en) | 1996-07-25 | 1998-06-16 | Motorola Inc. | Method and apparatus for performing microprocessor integer division operations using floating point hardware |
US6249798B1 (en) | 1996-10-10 | 2001-06-19 | Institute For The Development Of Emerging Architectures, L.L.C. | Method, apparatus and computer system for directly transferring and translating data between an integer processing unit and a floating point processing unit |
US5996066A (en) | 1996-10-10 | 1999-11-30 | Sun Microsystems, Inc. | Partitioned multiply and add/subtract instruction for CPU with integrated graphics functions |
US5923577A (en) | 1996-10-21 | 1999-07-13 | Samsung Electronics Company, Ltd. | Method and apparatus for generating an initial estimate for a floating point reciprocal |
US5847979A (en) * | 1996-10-31 | 1998-12-08 | Samsung Electronics Company, Ltd. | Method and apparatus for generating an initial estimate for a floating point reciprocal of a square root |
US5928316A (en) | 1996-11-18 | 1999-07-27 | Samsung Electronics Co., Ltd. | Fused floating-point multiply-and-accumulate unit with carry correction |
US5880984A (en) | 1997-01-13 | 1999-03-09 | International Business Machines Corporation | Method and apparatus for performing high-precision multiply-add calculations using independent multiply and add instruments |
US5901076A (en) | 1997-04-16 | 1999-05-04 | Advanced Micro Designs, Inc. | Ripple carry shifter in a floating point arithmetic unit of a microprocessor |
US5862066A (en) | 1997-05-01 | 1999-01-19 | Hewlett-Packard Company | Methods and apparatus for fast check of floating point zero or negative zero |
US5790827A (en) | 1997-06-20 | 1998-08-04 | Sun Microsystems, Inc. | Method for dependency checking using a scoreboard for a pair of register sets having different precisions |
US6169554B1 (en) | 1997-06-30 | 2001-01-02 | Sun Microsystems, Inc. | Clip testing unit for a three-dimensional graphics accelerator |
US6275838B1 (en) | 1997-12-03 | 2001-08-14 | Intrinsity, Inc. | Method and apparatus for an enhanced floating point unit with graphics and integer capabilities |
US6175851B1 (en) | 1998-02-06 | 2001-01-16 | S3 Incorporated | Fast adder/subtractor for signed floating point numbers |
US6426746B2 (en) | 1998-03-31 | 2002-07-30 | Intel Corporation | Optimization for 3-D graphic transformation using SIMD computations |
US5995122A (en) | 1998-04-30 | 1999-11-30 | Intel Corporation | Method and apparatus for parallel conversion of color values from a single precision floating point format to an integer format |
US6476807B1 (en) | 1998-08-20 | 2002-11-05 | Apple Computer, Inc. | Method and apparatus for performing conservative hidden surface removal in a graphics processor with deferred shading |
US6115729A (en) | 1998-08-20 | 2000-09-05 | Arm Limited | Floating point multiply-accumulate unit |
US6199089B1 (en) | 1998-09-18 | 2001-03-06 | Ati International Srl | Floating point arithmetic logic unit rounding using at least one least significant bit |
US6298365B1 (en) | 1999-02-24 | 2001-10-02 | International Business Machines Corporation | Method and system for bounds comparator |
US6401108B1 (en) | 1999-03-31 | 2002-06-04 | International Business Machines Corp. | Floating point compare apparatus and methods therefor |
US6285779B1 (en) | 1999-08-02 | 2001-09-04 | Trident Microsystems | Floating-point complementary depth buffer |
-
1999
- 1999-07-30 US US09/363,637 patent/US6912559B1/en not_active Expired - Lifetime
-
2002
- 2002-01-25 US US10/055,346 patent/US20020116431A1/en not_active Abandoned
Patent Citations (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5619198A (en) * | 1994-12-29 | 1997-04-08 | Tektronix, Inc. | Number format conversion apparatus for signal processing |
US6175907B1 (en) * | 1998-07-17 | 2001-01-16 | Ip First, L.L.C | Apparatus and method for fast square root calculation within a microprocessor |
Cited By (17)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20080183791A1 (en) * | 1999-07-30 | 2008-07-31 | Mips Technologies, Inc. | Processor With Improved Accuracy For Multiply-Add Operations |
US8024393B2 (en) | 1999-07-30 | 2011-09-20 | Mips Technologies, Inc. | Processor with improved accuracy for multiply-add operations |
US7330864B2 (en) * | 2001-03-01 | 2008-02-12 | Microsoft Corporation | System and method for using native floating point microprocessor instructions to manipulate 16-bit floating point data representations |
US20020184282A1 (en) * | 2001-03-01 | 2002-12-05 | Yuval Gideon A. | System and method for using native floating point microprocessor instructions to manipulate 16-bit floating point data representations |
US8015228B2 (en) | 2005-02-16 | 2011-09-06 | Arm Limited | Data processing apparatus and method for performing a reciprocal operation on an input value to produce a result value |
US20060184602A1 (en) * | 2005-02-16 | 2006-08-17 | Arm Limited | Data processing apparatus and method for performing a reciprocal operation on an input value to produce a result value |
US20060184594A1 (en) * | 2005-02-16 | 2006-08-17 | Arm Limited | Data processing apparatus and method for determining an initial estimate of a result value of a reciprocal operation |
US8965946B2 (en) | 2005-02-16 | 2015-02-24 | Arm Limited | Data processing apparatus and method for performing a reciprocal operation on an input value to produce a result value |
US7747667B2 (en) * | 2005-02-16 | 2010-06-29 | Arm Limited | Data processing apparatus and method for determining an initial estimate of a result value of a reciprocal operation |
CN100454237C (en) * | 2005-05-12 | 2009-01-21 | 国际商业机器公司 | Processor having efficient function estimate instructions |
US7634527B2 (en) * | 2005-11-17 | 2009-12-15 | International Business Machines Corporation | Reciprocal estimate computation methods and apparatus |
US20070112902A1 (en) * | 2005-11-17 | 2007-05-17 | International Business Machines Corporation | Reciprocal estimate computation methods and apparatus |
US20080243985A1 (en) * | 2007-03-30 | 2008-10-02 | Ping Tak Peter Tang | Method and apparatus for performing multiplicative functions |
US8838663B2 (en) * | 2007-03-30 | 2014-09-16 | Intel Corporation | Method and apparatus for performing multiplicative functions |
US8156171B1 (en) * | 2007-11-20 | 2012-04-10 | Altera Corporation | Digital logic circuit |
US10133553B2 (en) * | 2015-02-22 | 2018-11-20 | The Regents Of The University Of Michigan | Reciprocal unit |
CN111814107A (en) * | 2020-07-10 | 2020-10-23 | 上海擎昆信息科技有限公司 | Computing system and computing method for realizing reciprocal of square root with high precision |
Also Published As
Publication number | Publication date |
---|---|
US6912559B1 (en) | 2005-06-28 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US6697832B1 (en) | Floating-point processor with improved intermediate result handling | |
US6163791A (en) | High accuracy estimates of elementary functions | |
US7346643B1 (en) | Processor with improved accuracy for multiply-add operations | |
US5631859A (en) | Floating point arithmetic unit having logic for quad precision arithmetic | |
Zhang et al. | Efficient multiple-precision floating-point fused multiply-add with mixed-precision support | |
US5341321A (en) | Floating point arithmetic unit using modified Newton-Raphson technique for division and square root | |
KR101005718B1 (en) | Processor reduction unit for accumulation of multiple operands with or without saturation | |
US6631392B1 (en) | Method and apparatus for predicting floating-point exceptions | |
US20200371805A1 (en) | Floating-point scaling operation | |
US20060041610A1 (en) | Processor having parallel vector multiply and reduce operations with sequential semantics | |
JP2557190B2 (en) | Optimization system for argument reduction | |
US6996596B1 (en) | Floating-point processor with operating mode having improved accuracy and high performance | |
US5548545A (en) | Floating point exception prediction for compound operations and variable precision using an intermediate exponent bus | |
US6912559B1 (en) | System and method for improving the accuracy of reciprocal square root operations performed by a floating-point unit | |
US8965946B2 (en) | Data processing apparatus and method for performing a reciprocal operation on an input value to produce a result value | |
JP4476210B2 (en) | Data processing apparatus and method for obtaining initial estimated value of result value of reciprocal operation | |
US6941334B2 (en) | Higher precision divide and square root approximations | |
US20050228844A1 (en) | Fast operand formatting for a high performance multiply-add floating point-unit | |
US5790444A (en) | Fast alignment unit for multiply-add floating point unit | |
Gerwig et al. | High performance floating-point unit with 116 bit wide divider | |
Schulte et al. | A software interface and hardware design for variable-precision interval arithmetic | |
JPH04172526A (en) | Floating point divider | |
EP0837390A1 (en) | Improvements in or relating to microprocessor integrated circuits | |
Ercegovac et al. | On-line scheme for normalizing a 3-D vector | |
Shapran et al. | DIVISION USING THE BASE RADIX16 NUMBER SYSTEM TO FORM FRACTION DIGITS |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
STCB | Information on status: application discontinuation |
Free format text: ABANDONED -- FAILURE TO RESPOND TO AN OFFICE ACTION |