KR20080018692A - Method, programming structure and recordable medium for performing fast floating point operation for various precisions - Google Patents

Abstract

A method, a programming structure and a recordable medium for performing fast floating point operation about various precisions are provided to create an operator object of each combination automatically by making a single precision operator object of the IEEE standard into a template based on the size of an exponent part and a mantissa part. A first precision is determined based on an exponent part and a mantissa part of a floating point. An execution program is created, which includes a first floating point operator object converted into a template. A second precision of a second floating point operator object is determined. And a floating point operation is performed by the first floating point operator object within the execution program which includes at least one operation of association between the first and the second floating point operator objects. Thus, the floating point operation of various precisions is able to be performed rapidly by the first floating point operator object by simply coding an object oriented software program.

Description

Method, Programming Structure and Recordable Medium for Performing Fast Floating Point Operation for Various Precisions}

1 is a view for explaining a conventional hardware floating-point operator.

2 is an object diagram for a floating point operator in accordance with one embodiment of the present invention.

3 is a diagram for explaining an IEEE floating point format.

4 is a flowchart illustrating an object diagram of FIG. 2.

5 is a diagram for describing a declaration of an object constant applicable to various precisions.

<Explanation of symbols for the main parts of the drawings>

PITFloatIEEE: IEEE Standard Single Precision Operator Template Object

PITFloat: Simple Operator Template Object

PITSingle: the inheriting IEEE standard 32-bit floating point operator object

PITFloat32: A simple 32-bit floating point operator object that inherits

TECHNICAL FIELD The present invention relates to a method for fast floating point operation, and more particularly, to a method, a programming structure, and a recording medium for performing a fast floating point operation for various precisions.

In order to guarantee the accuracy of operations in the scientific and technical fields, the use of floating point operators is unavoidable. Most processors currently processing multimedia digital data such as video or audio perform floating point operations using IEEE compatible floating point operators. IEEE compliant floating point operators support 32-bit single precision floating point operations or 64-bit double precision floating point operations. However, there are cases where application processors for processing digital data in certain fields do not require all the precision of IEEE compatible floating point operations. Alternatively, a particular application processor may require several floating-point operators that can support various precision operations.

1 is a view for explaining a conventional hardware floating-point operator 10. Referring to FIG. 1, two of the data (A, B) input to the registers 11, 12, 13, and 14 pass through an Arithmetic Logic Unit (ALU) through the multiplexers 15 and 16. 17). For example, the data input into the registers 11, 12, 13, 14 may be two data of different precision, such as a single-precision floating point representation and a double precision floating point representation. The ALU 17 selectively outputs a single-precision floating point representation or a double-precision floating point representation by performing a single precision operation or a double precision operation according to the precision information. The output data of the ALU 17 can be fed back to the registers 13, 14, whereby two of the data A, B input to the registers 11, 12, 13, 14 are again returned. It is selected to enable the ALU 17 to perform the operation according to the precision information.

In the case where two precision floating point data are mixed, the ALU 17 may be processed in the same manner as in FIG. 1, but whenever a floating point operator having a specific precision is required, The module must be used. Therefore, when the above-described conversion module is required in various parts in a specific application processor, it is necessary to implement the hardware resource as much as there is a disadvantage that the circuit is complicated, the circuit size is large, and the power consumption is increased.

Therefore, the floating point operator structure of various precision using a single operator as shown in FIG. 1 is not suitable for an application processor, and it is practically impossible to implement in hardware.

Accordingly, many attempts have been made to use software operators for floating point operations of arbitrary precision. However, even when using software operators, many operators must be created exponentially according to the precision of each floating point, and the code, for example, C ++ code, can be modified and compiled to meet the required precision in terms of usage. It is inconvenient to do a lot of tricky and precise work to complete the executable file.

In addition, when the precision of the floating point to be used for floating point calculation by the software is extracted during run-time and subsequent processing is performed accordingly, there is a problem that the operation speed decreases. Therefore, in order to achieve high-speed computational performance, the respective operators according to the combination of the two must be coded for floating-point operations with different precisions. However, in the case of coding each combination of operators as described above, there is a problem in that maintenance becomes very difficult because modification of functions applied to all the created operators is inevitable when the algorithm and the like are changed.

Accordingly, there is a need for a high speed software floating point operator that supports various precisions independently of hardware constraints, ease of software implementation and maintenance, and precision.

Accordingly, an object of the present invention is to solve the above-described problem, and an object of the present invention is to provide a single precision arithmetic object of the IEEE standard and some of the computational characteristics of the IEEE standard for high-speed floating-point operation for various precisions. The present invention provides a method of performing a fast floating-point operation that allows templated objects to be selectively used together with object inheritance that allows for simple processing using a template and a simple operation object excluding the above.

Another object of the present invention is to provide a recording medium in which a programming structure and a program for executing the above fast floating point arithmetic method are recorded.

According to an aspect of the present invention, a floating point arithmetic method includes a first floating point operator templated according to a first precision determined based on sizes of an exponent part and a mantissa part of a floating point. Generating an executable file including the object; And performing a floating point operation using the executable file, wherein the first floating point operator object includes at least one operation that is in association with a second floating point operator object having a second precision. It features.

When compiling the source code for generating the executable file, an operation object is generated for the at least one operation according to a combination between the first floating point operator object and the second floating point operator object.

The first floating point arithmetic object is inherited by a third floating point arithmetic object that invokes the hardware operator of the first precision, and the second floating point arithmetic object is a fourth float calling the hardware operator of the second precision. Inherited by the decimal operator object.

In the template of the first floating point operator object, at least one object constant associated with the size of the exponent portion and the mantissa portion is declared.

In accordance with another aspect of the present invention for achieving the above object of the present invention, a floating point arithmetic method is a first floating point arithmetic template is a first precision is determined based on the size of the exponent portion and mantissa portion of the floating point Generating an executable file comprising an object and a second floating point arithmetic object having a second precision determined; And optionally performing floating point operations of the first precision by the first floating point operator object or performing floating point operations of the second precision by the second floating point operator object. Characterized in that it comprises a.

The first floating point operator object performs the floating point operation using at least one operation that is in association with the second floating point operator object.

The first floating point operator object performs a lower precision operation than the second floating point operator object.

The second floating point arithmetic object is a single precision arithmetic object of the IEEE standard, and the first floating point arithmetic object is an arithmetic object excluding some of the computational characteristics of the IEEE precision arithmetic arithmetic object.

When compiling the source code for generating the executable file, an operation object is generated for at least one operation according to a combination between the first floating point operator object and the second floating point operator object.

The first floating point arithmetic object is inherited by a third floating point arithmetic object that invokes the hardware operator of the first precision, and the second floating point arithmetic object is a fourth float calling the hardware operator of the second precision. Inherited by the decimal operator object.

In the template of the first floating point operator object, at least one object constant associated with the size of the exponent portion and the mantissa portion is declared.

In the object-oriented programming structure for floating-point operation according to another aspect of the present invention for achieving the object of the present invention as described above, the first precision is determined based on the size of the exponent part and the mantissa part of the floating point template Digitized first floating point operator object; And a second floating point operator object having a second precision, wherein the first floating point operator is optionally selected by a user in an executable file including the first floating point operator object and the second floating point operator object. And performing the first precision floating point operation by the object or the second precision floating point operation by the second floating point operator object.

Hereinafter, exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings and the contents described in the accompanying drawings, but the present invention is not limited or limited to the embodiments. Like reference numerals in the drawings denote like elements.

2 is an object diagram for a software floating point operator 20 in accordance with one embodiment of the present invention. The floating point operator 20 may be realized in a structure as shown in FIG. 2 by an object oriented programming language. That is, the floating point operator 20 may be implemented as source code by a high-level language that is easy to maintain, such as C ++ or JABA.

 The floating point operator 20 is a software operator for enabling floating point operations with varying precision in various applications. The floating-point operator 20 has been proposed to allow high-precision floating-point operations to be processed at high speed through software floating-point operations and to facilitate maintenance. The floating point operator 20 according to an embodiment of the present invention may be used to design or verify a hardware floating point operator of a specific application processor.

The floating point operator 20 is configured to generate single objects capable of handling all floating point operations within 32 bits that can be configured in the form of an IEEE floating point format. The floating point operator 20 is based on operating on a 32 bit processor having at least a 64 bit integer operator. That is, the floating point operator 20 is configured to perform all floating point operations that can be configured to any size within 32 bits. As shown in FIG. 3, the IEEE floating point format consists of a 1-bit sign S, an e-bit exponent E, and an m-bit unsigned significand M. In the Single Precision operation of the IEEE standard, a floating point is represented by a 1-bit sign S, an 8-bit exponent E, and a 23-bit mantissa M. In the double precision operation of the IEEE standard, a floating point is represented by a 1-bit sign S, a 16-bit exponent E, and a 46-bit mantissa M.

Here, although it is assumed that the floating point operator 20 targets a floating point operation within 32 bits, the present invention is not limited thereto and the concept of the floating point operator 20 according to an embodiment of the present invention is extended. It will be apparent to those skilled in the art that the present invention can be configured to perform operations with various precisions at expanded precisions such as 64 bits and 128 bits.

The floating point arithmetic operator 20 includes a single precision floating point arithmetic object PITFloatIEEE of the IEEE standard and a floating point arithmetic object PITFloat excluding some of the operational characteristics of the single precision arithmetic object of the IEEE standard. The object PITFloatIEEE is an object that supports all the operations and operator characteristics of single precision floating point defined by the IEEE standard. The object PITFloat is more than the object PITFloatIEEE by excluding some of the arithmetic characteristics of the IEEE standard single-precision arithmetic object, for example, infinity support, Not a Number (NaN) support, four rounding support, and irregular floating point support. An object that performs operations with low precision.

As such, when the objects PITFloatIEEE and PITFloat are templated into an executable file, a floating point operation by the object PITFloat is selectively performed or a floating point operation by the object PITFloatIEEE is selectively performed according to a user's selection. It can be done. The object PITFloatIEEE supports the precision of all computational characteristics specified in the IEEE standard, but the object PITFloat has a corresponding precision lower than the precision of the object PITFloatIEEE as the size of the exponent part and the mantissa part of the floating point is determined at the time of template formatting. Support.

For a detailed description of the structure of the floating point operator 20, reference is made to the flowchart of FIG.

First, when programming the floating point operator 20 in an object-oriented language such as C ++, JABA, etc., the size of the floating point exponent part (see uiExpsize in FIG. 5) and the mantissa part (see uiSigsize in FIG. 5) is referred to. The object PITFloat is then templated (S41). According to the size of the exponent part and the mantissa part, the object PITFloat may support floating point operations having arbitrary precision in a size within 32 bits. Since the object PITFloatIEEE is an object predefined to support the precision of all computational characteristics defined in the IEEE standard, it can be used by being copied from another application source and templated similarly to the template of the object PITFloat. As shown in FIG. 2, as an example of the object PITFloat, PITFloat <8,23> for a 32-bit floating point operation including a sign 1 bit, an exponent 8 bits, and a mantissa 23 bit may be generated. In addition, as an example of the object PITFloatIEEE, PITFloatIEEE <8,23> for 32-bit floating point operation may be generated.

Also, operations in association with the object PITFloatIEEE and the object PITFloat, for example, Add () () for addition, subtraction, to support operations between floating-points with different precisions An association relationship for Sub () (), Mul () () for multiplication, Div () () for division, Conv () () for expression conversion, etc. is defined (S42). That is, an operation that conforms to the precision of the object PITFloat lower than that of the object PITFloatIEEE is performed according to an operation defined by the object PITFloat with a high precision result value and the result value generated by the object PITFloat as an association in the object PITFloat. To be possible.

In order to support various precisions and to perform mutual operations between floating points with different precisions, operators for each operation are required for each combination of precisions. When implemented in software, it is not impossible to write the code for the operators for each operation individually by each combination of precisions, but it is not easy to modify the code for all the operators in future algorithmic improvements. This can reduce the reliability of the software. Therefore, in the present invention, the object PITFloat is templated based on the size of the exponent part and the mantissa part as described above, and the association relationship with the object PITFloatIEEE is defined so that the objects for the operators according to the combination of precision are automatically compiled at compile time. By making it to be generated as a floating point operation of various precision to be processed at high speed and easy to maintain (S43).

When the executable file is generated after the source code for the floating point operator 20 having such a programming structure is compiled, the object PITFloat in the executable file is floating with various precisions according to the operation defined above. Decimal operation can be performed.

As described above, the floating point operator 20 can be designed to operate in a system having a 32 bit processor, most systems having a 32 bit processor have a 32 bit floating point operator in hardware. Accordingly, the PITFloat <8,23> or the PITFloatIEEE <8,23> according to an embodiment of the present invention may be used for a 32-bit floating point operation in a specific application. However, when operating the floating-point operator 20 in a system having a 32-bit floating-point operator as hardware, as shown in FIG. 2, the performance is improved by high-speed processing of hardware through object inheritance (S44). . That is, the PITFloatIEEE <8,23> is inherited by an object PITSingle that calls a 32-bit hardware floating-point operator with precision according to the IEEE standard, and the PITFloat <8,23> is a general 32 with lower precision than the hardware operator PITSingle. It can be inherited by the object PITFloat, which invokes a bit hardware floating-point operator.

In addition, another feature of the present invention is that all parts necessary at compile time can be generated to minimize other operating parts at run time for fast software floating-point operations. Typical examples are various constants used for floating point operations, in particular constants related to the magnitude of the exponent portion and the mantissa portion can be generated at compile time. That is, as shown in FIG. 5, when the object PITFloat is templated, object constants related to the size of the exponent part and the mantissa part, for example, an exponent bias, an exponent mask, and an exponent minimum value ( ExponentMin), ExponentMax, BiasedExponentMax, and SpecialExponent are declared so that the list of constants is automatically constructed at compile time. For example, in the case of a 32-bit floating point operation, the exponent size uiExpSize in FIG. 5 may be 8 bits, wherein the exponent bias is 127, the exponent mask is 255, and the exponent minimum is ExponentMin. ) Is -126, the exponent maximum (ExponentMax) 127, the biased exponent maximum (BiasedExponentMax) is 254, the special exponent (SpecialExponent) is 255. These object constants are constants necessary for the operation of floating point according to the IEEE standard.

In FIG. 5, some object constants related to the exponent part have been described as an example, but object constants related to the mantissa part may be declared in the same manner.

Such object constants must be separately stored in a predetermined database by performing calculation separately according to the precision between each floating point, but it is inefficient to store the corresponding values in consideration of all configurations. Accordingly, in the present invention, the various object constants are declared at the time of template of the object PITFloat as described above, so that even if the precision is changed, the user may specify the attribute value of the exponent size, for example, the attribute of uiExpSize and the mantissa size in FIG. 5. By changing only the value, for example, uiSigSize in FIG. 5, related constants are automatically generated.

In the system for operating the floating point operator 20, according to the operation of a corresponding executable file for the floating point operator 20, a user may template the object PITFloatIEEE and the object PITFloat which are templated for the purpose of designing and verifying an operator. Any one can be selected and used (S45). Such a selection can be easily implemented by writing code for that selection.

The functions used in the methods and apparatus disclosed herein can be embodied as computer readable code on a computer readable recording medium. The computer-readable recording medium includes all kinds of recording devices in which data that can be read by a computer system is stored. Examples of computer-readable recording media include ROM, RAM, CD-ROM, magnetic tape, floppy disk, optical data storage, and the like, and may also be implemented in the form of a carrier wave (for example, transmission over the Internet). do. The computer readable recording medium can also be distributed over network coupled computer systems so that the computer readable code is stored and executed in a distributed fashion.

As described above, although the present invention has been described with reference to limited embodiments and drawings, the present invention is not limited to the above embodiments, and those skilled in the art to which the present invention pertains various modifications and variations from such descriptions. This is possible. Therefore, the scope of the present invention should not be limited to the described embodiments, but should be determined not only by the claims below but also by the equivalents of the claims.

As described above, in the fast floating-point arithmetic method according to the present invention, a single precision arithmetic object object and a simple arithmetic object object of the IEEE standard are templated based on the size of the exponent part and the mantissa part. The software is implemented so that objects are created automatically, which enables fast processing of various precision floating point operations and ease of maintenance.

In addition, in the fast floating point arithmetic method according to the present invention, two objects of different precision, which are templated, are inherited to enable high-speed hardware processing, and thus the performance of floating point arithmetic can be expected.

In the fast floating-point arithmetic method according to the present invention, a constant list related to the size of the exponent part and the mantissa part of the floating point is not calculated and stored separately for each precision, but is declared at the time of compilation of the two objects. Corresponding object constants can be generated for each precision, allowing for fast coding of floating point operators with varying precision.

Claims (16)

Generating an executable file comprising a first floating point operator object templated according to a first precision determined based on the size of the exponent portion and the mantissa portion of the floating point; And Performing a floating point operation using the executable file Including, The first floating point operator object including at least one operation that is in association with a second floating point operator object having a second precision. Floating point operation method characterized in that. The method of claim 1, Generating the executable file, Creating an operation object that performs the at least one operation when compiling source code Floating point operation method characterized in that. The method of claim 1, The first floating point operator object being inherited by a third floating point operator object that invokes the first precision hardware operator. Floating point operation method characterized in that. The method of claim 1, The second floating point operator object is inherited by a fourth floating point operator object that invokes the second precision hardware operator. Floating point operation method characterized in that. The method of claim 1, And the first floating point arithmetic object includes a declaration for at least one object constant associated with the magnitude of the exponent portion and the mantissa portion. In a method for performing floating point operations, Generating an executable file including a first floating point operator object templated according to a first precision determined based on sizes of the exponent portion and the mantissa portion of the floating point, and a second floating point operator object having a second precision determined; And Selectively performing the first precision floating point operation by the first floating point operator object or the second precision floating point operation by the second floating point operator object according to a user's selection Floating point arithmetic method comprising a. The method of claim 6, The first floating point operator object comprises at least one operation that is in association with the second floating point operator object. Floating point operation method characterized in that. The method of claim 6, And said first precision is lower than said second precision. The method of claim 6, The second precision is a single precision of the IEEE standard, and the first precision is a precision excluding some of the single-precision arithmetic characteristics of the IEEE standard. Floating point operation method characterized in that. The method of claim 6, Generating the executable file, Generating a calculation object for at least one operation according to a combination between the first floating point operator object and the second floating point operator object at compile time of the source code. Floating point operation method characterized in that. The method of claim 6, The first floating point operator object being inherited by a third floating point operator object that invokes the first precision hardware operator. Floating point operation method characterized in that. The method of claim 6, The second floating point operator object is inherited by a fourth floating point operator object that invokes the second precision hardware operator. Floating point operation method characterized in that. The method of claim 6, The first floating point operator object including a declaration for at least one object constant associated with the magnitude of the exponent portion and the mantissa portion Floating point operation method characterized in that. A computer-readable recording medium in which a program for executing the method of any one of claims 1 to 13 is recorded. In the object-oriented programming structure for floating point operations, A first floating point arithmetic object templated with a first precision determined based on sizes of the exponent part and the mantissa part of the floating point; And Second floating-point arithmetic object with second precision Including, Selectively executing the first precision floating point operation by the first floating point operator object in the executable file including the first floating point operator object and the second floating point operator object, or Performing said second precision floating point operation by a floating point operator object An object-oriented programming architecture for floating point arithmetic. The method of claim 15, The second floating point operator object is a single precision operator object of the IEEE standard, The first floating point arithmetic object is an arithmetic object excluding some of the arithmetic characteristics of the IEEE precision single precision arithmetic object. An object-oriented programming architecture for floating point arithmetic.

Images