KR100563220B1 - Recycle register file - Google Patents

Abstract

The floating point unit having a register bank including a plurality of registers supports a vector operation for executing a specified operation multiple times in accordance with a series of data values from another register. The register bank at this time is divided into subsets and has a series of registers used in vector operation wrapping that wraps in the subset. This subset breaks the range of consecutive registers. Wrapping within that range allows for compact code, which is efficient for performing DSP operations such as FIR filtering and matrix transformation.

Data Processing Unit, Floating Point Unit, Vector Register, Scalar Register, Instruction Decoder

Description

Recycle register file {RECIRCULATING REGISTER FILE}             

The present invention relates to the field of data processing. In particular, the present invention relates to a data processing system having a register bank and supporting vector operations.

It is known to provide a data processing system having a register bank and supporting vector operations. Examples of such a system are a Cray 1 processor and a Digital Equipment Corporation MultiTitan processor.

The Cray 1 processor has separate vector and scalar register banks. If the opcode of the instruction to be executed represents a vector operation, a sequence of data values are returned from the vector register bank according to the length value stored in the length register and the mask stored in the mask register. The length specifies how long the data value is in the sequence, and the mask specifies which data value is returned from the plurality of data values associated with the vector register indicated in the instruction.

A multititanium processor is a single register bank of registers that can operate as scalars or vectors. The instruction itself includes a flag indicating whether the specified register is a scalar or a vector, and a length field indicating the number of data values in the sequence when the vector register is used.

The vector instructions themselves are desirable as such vector instructions increase code density because a single instruction can specify multiple data processing operations. Digital signal processing or graphics processing, such as audio, often requires the same operation on a series of related data values, for example, a requirement to perform a filter operation by multiplying the series of signal values by the tap coefficients of the digital filter. It is particularly well suited for utilizing vector operations.

It is also desirable to perform data processing operations as quickly and effectively as possible. One way to help increase speed and efficiency is to avoid reloading or repositioning data values already stored in register banks. The problem with solving this is that the instruction code, which can reuse data values, becomes longer and more complex. If many instructions are required to specify the required operation, this slows down the process and defeats the purpose of searching to reuse the data values in that register bank.

As an alternative to the use of general purpose processors such as Cray 1 and multititanium processors, special purpose digital signal processing circuits are often configured with specific roles to support a small number of digital signal processing operations. In these special purpose digital signal processing circuits, the general technique stores the required data values in a large memory to fetch the required data values for each operation as needed. This data value does not need to be reloaded or relocated in the large memory because it is controlled by the operation of the address used to access the memory with the sequential order of its use. The problem with this method is that the circuit must be specially designed to match the operation to be performed and is provided by the use of more typical general purpose processors due to the lack of flexibility and ease of integration with other functions.

It is an object of the present invention to provide efficient and fast data processing while maintaining the flexibility of a general purpose processor using an instruction decoder that supports register banks and vector operations.

Data processing apparatus according to an aspect of the present invention,

A register bank having a plurality of addressable registers,

An instruction decoder responsive to at least one data processing instruction specifying a vector operation that executes a data processing operation multiple times using data values from a series of registers in the register bank starting at an initial register specified in the data processing instruction; Including,

The register bank consists of at least one subset of registers, the series of registers being in the subset,

The command decoder provides an apparatus for controlling the series of registers to wrap within a subset of the registers.

Providing register wrapping within a subset (ie less than all) of registers in a register bank allows a compact code to be written that reuses data values in the register bank without requiring reloading or moving of the data values. The instruction code for each use can start at different points in the subset and follow the data values in hardware and other sequences in preparation for the required wrapping without providing extra instructions to split the vector sequence. Moreover, performing a vector operation on a subset of registers that wraps around themselves considers the possibility of performing data transfers of data values in registers that are not in the subset simultaneously. In addition, register wrapping provides hardware support for a ring (round) buffered configuration, for example, where data is loaded into a buffer at a point where each other turns around and tracks the buffer. Can be considered.

Although it may only have a single subset of wrapping registers, the vector operation executes the data processing operation using a plurality of respective data values from the registers of the corresponding plurality of sequences,

The register bank comprises a plurality of subsets of registers, the registers of the plurality of sequences being in each subset,

The command decoder has the advantage of providing a system for controlling the registers of the plurality of sequences to wrap within each subset of registers.

Within a digital signal processing operation, it is often necessary to reuse data values from two sequences (e.g., an FIR operation where the tap and signal values are multiplied and accumulated at different offset or matrix operations), thus enlarging a large subset of the registers This is preferred.

Although there is a possibility of overlapping subsets, the data values that actually require reuse in this situation are usually quite separate and the subset may be broken up. This is an advantage that makes the hardware implementation less complex.

It will be appreciated that a subset consists of registers from locations mixed with registers that are not in the subset. However, subsets facilitate programming and implementation when in the range of consecutively numbered registers.

The range at this time may be spaced within the register bank, but in a preferred embodiment the range is contiguous because it allows for more efficient use of register available space.

The ability of the present invention to more effectively use vector operations further comprises, in a preferred embodiment, a transfer controller for controlling the transfer of data values between the memory and a register in the memory and the register bank, wherein the transfer controller Responsive to multiple transfer instructions for transferring a series of data values between the memory and a series of registers in the register bank.

The ability to transfer data values to / from a block with a register in a register bank is in good agreement with the ability of the present invention to efficiently use vector operations because it is exchanged for a single instruction because the block with the register will be reused several times. do.

The use of a series of registers and the division of a register bank into a predetermined subset having registers in vector operations can be efficiently implemented in the preferred embodiment where each range is addressed through an incrementer that wraps between the end points of the range. .

A series of registers used in vector operations can take all of the alternate registers in many forms, for example a subset, but a very common useful situation is that the sequence is one of a series of consecutive registers.

The technique can be used in any processor that has a register bank and supports vector operations. However, the ability to allow compact code and reuse data values in registers is particularly useful, and it can be seen that register banks and instruction decoders do not interfere for other reasons in embodiments where they are in the floating point portion.

Data processing method according to another aspect of the present invention,

Storing data values in a plurality of addressable registers in a register bank;

Specifying a vector operation in accordance with at least one data processing instruction and executing the data processing operation multiple times using data values from a series of registers in the register bank starting at the initial register specified in the data processing instruction. But

The register bank consists of at least one subset of registers, the series of registers being in the subset,

During the execution, the series of registers provides a way to wrap within the subset of registers.

This technique is particularly useful when effectively providing a FIR filter operation that is reused several times at a relative offset between the tap coefficient value and the signal value changing with each vector operation.

Embodiments of the present invention will be described with reference to the accompanying drawings.             

1 is a schematic diagram of a data processing system,

2 illustrates a floating point unit (FPU) supporting scalar and vector registers,

3 is a flowchart illustrating a method of determining whether a given register is a vector or a scalar register in the case of a single precision operation;

4 is a flowchart illustrating a method of determining whether a given register is a vector or a scalar in case of double precision operation,

5 shows the register bank divided into subsets by wrapping within each subset during a single precision operation,

6 shows that register bank is divided into subsets by wrapping within each subset during double precision operations,

7A-7C illustrate a main processor diagram of coprocessor instructions, a single and double precision coprocessor diagram of coprocessor instructions, and a single precision coprocessor diagram of coprocessor instructions, respectively;

8 shows a main processor controlling single and double precision coprocessors,

9 shows a main processor controlling a single precision coprocessor,

10 is a circuit diagram within a single and double precision coprocessor that determines whether an accept signal should return to the main processor for a received coprocessor instruction;

11 is a circuit diagram within a single precision coprocessor for determining whether a received signal should return to the main processor for a received coprocessor instruction;             

12 illustrates undefined instructions other than handling within the main processor,

13 is a block diagram illustrating a device of a coprocessor according to a preferred embodiment of the present invention.

14 is a flowchart illustrating the operation of register control and instruction generation logic in accordance with a preferred embodiment of the present invention;

15 shows an example of the contents of a floating point register according to a preferred embodiment of the present invention,

16 shows a register bank in a Cray 1 processor,

17 shows a register bank in a multititanium processor.

1 shows a data processing system 22 having a main processor 24, a floating point coprocessor 26, a cache memory 28, a main memory 30, and an input / output system 32. Here, the main processor 24, the cache memory 28, the main memory 30, and the input / output system 32 are connected through the main bus 34. Coprocessor bus 36 connects main processor 24 to floating-point coprocessor 26.

In operation, the main processor 24 (also referred to as ARM core) performs a general form of data processing operation, including interaction with the cache memory 28, the main memory 30, and the input / output system 32. Run a stream of data processing instructions to control. The coprocessor instruction is inserted into the stream of the data processing instruction at this time. The main processor 24 recognizes these coprocessor instructions as being executed by the additional coprocessor. Thus, this main processor 24 issues these coprocessor instructions on the coprocessor bus 36 from where any additional coprocessor received the coprocessor instructions. In this case, floating point coprocessor 26 will receive and execute any received coprocessor instructions to be detected. This detection is made through the coprocessor number field in the coprocessor instruction.

2 schematically shows the floating point coprocessor 26 in more detail. This floating point coprocessor 26 includes a register bank 38 composed of 32 32-bit registers (less shown in FIG. 2). These registers can be computed individually as single precision registers storing 32-bit data values, or as pairs of 64-bit data values stored together. The floating point coprocessor 26 includes a pipelined multiplication accumulator 40 and a load storage controller 42. In a suitable situation, the multiplication accumulator 40 and the load storage control section 42 may cause the load storage control section 42 to float data values not used by the multiplication accumulator 40 through the main processor 24. During transfer to / from the decimal point coprocessor 26, the data values in register bank 38 can be operated concurrently with the multiplication accumulator 40 performing arithmetic operations (including multiplication operations as well as other operations). Can be.

The received coprocessor instructions are latched in instruction register 44 in floating point coprocessor 26. In this simple way, a coprocessor instruction can be thought of as being composed of an opcode section following three register designation fields R1, R2, and R3 (in fact, these fields may be split or otherwise scattered within the entire instruction). These register designation fields R1, R2, and R3 correspond to registers in register bank 38 that serve as destinations, first and second sources for the data processing operations to be performed. The vector control register 46 (which may be part of a larger register that includes additional functionality) stores the length and stride values for vector operations that may be performed by the floating point coprocessor 26. It is also possible to initialize this vector control register 46 and update it with the length and stride values according to the vector control register load instruction. Applying this vector length and stride values globally in the floating point coprocessor 26 causes these values to change dynamically based on the whole without relying on self modifying code.

In consideration of the register control and the instruction generator 48, the load storage controller 42, and the vector controller 50, the main part of the instruction decoder may be performed. This register control and instruction generation unit 48 responds to the opcode and three register designation fields R1, R2, and R3, and does not perform any decoding on the opcode or use the vector control unit 50. First outputs the initial register access (address) signals to register bank 38. In this way, direct access to initial register values helps to achieve faster execution. If a vector register is specified, the vector control section 50 generates a sequence of necessary register access signals using a 3-bit incrementer (adder) 52. The vector control section 50 responds to the length value and the stride value stored in the vector control register 46 when addressing the register bank 38. The register score board 54 is configured to perform register locking so that the load storage control section 42 operating simultaneously with the pipelined multiplication accumulator 40 does not cause any data consistency problems (this register score board). (54) may be considered as part of the register control and instruction generation unit 48).

The opcodes in the instruction register 44 specify the nature of the data processing operation to be performed (e.g., whether the instruction is add, subtract, multiply, divide, load, store ...). This is independent of the vector or scalar nature of the register being specified. This also simplifies instruction decoding and set-up of the multiply accumulator 40. The first register designation value R1 and the second register designation value R2 together encode the vector / scalar nature of the operation specified by the opcode. In general, the three cases supported by the encoding are S = S * S (e.g., basic arbitrary mathematical calculations as generated by the C compiler from a C code block), V = V op S (e.g. For example, the magnitude of the vector component) and V = V op V (e.g., matrix operations such as FIR filters and graphical transformations) (in this case, "op" denotes a general operation and syntax is the destination). = Second operand op 1 form of operand). Also, some instructions (eg, compare, zero, or compare with absolute values) may be missing a destination register (eg, the output is a condition flag) or fewer input operands (comparison with zero is one input). Only operands). In this case, there is more opcode bit space available to specify options such as the vector / scalar property, so that the entire range of registers can be fully scalar for each operand (e.g., always a register of whatever register). Available).             

The register control and instruction generation unit 48 and the vector control unit 50, which together perform the role of the main part of the instruction decoder, may include the first register designation field R1 and Respond to the second register designation field R2. It should be noted that if the length value stored in vector control register 46 represents a length of 1 (corresponding to a stored value of zero), it can be used as an initial indication of scalar operations only.

3 is a flow diagram illustrating the processing logic used to decode the vector / scalar property from the register designation value in single precision mode. In step 56, a check is made as to whether the vector length is set to 1 (which equals the length value zero) as a whole. If the vector length is 1, all registers are treated as scalars in step 58. In step 60, a check is made as to whether the destination register R1 is in the range of SO to S7. If it is within that range, the operation is all scalar and in the form S = S op S, as shown in step 62. If it is not within the range in step 60, the destination is determined as a vector as shown in step 64. If this destination is a vector, the encoding also treats the second operand as a vector. Thus, there are two possibilities that exist at this stage: V = V op S and V = V op V. The option is determined by inspection of step 66, which determines whether the first operand is one of S0 to S7. If the first operand is one of SO to S7, the operation is V = V op S, otherwise the operation is V = V op V. This state is recognized in steps 68 and 70, respectively.

When the vector length is set to 1, all 32 registers in the register bank 38 are recognized in step 58 without relying on the check in step 60 which limits the range of registers whose scalar nature of the operation may be used for the destination. It should be noted that it is useful to use as a scalar because it will be. The check in step 60 is useful for recognizing all scalar operations when mixed vector and scalar instructions are being used. Also, when operating in mixed vector and scalar modes, if the first operand is a scalar, it may be any of SO to S7, while if the first operand is a vector, it is any of S8 to S31. It may be. If the number of registers available in the register bank is three times when the first operand is a vector, then a larger register number is generally employed, which is necessary to have a sequence of data values when using vector operations.

It will be appreciated that the common operation you want to perform is a graphic transformation. In the general case, the transformation to be performed may be represented by a 4 * 4 matrix. This operand is preferably such that the matrix value is stored in a register that can be reused in such calculation means and manipulated as a vector. In this way, input pixel values are usually stored in four registers so that they can be manipulated as vectors to help reuse. The output of the matrix operation is usually a scalar (accumulating separate vector row products) stored in four registers. If you want to output double input and output values, you will meet the requirements for 24 (16 + 4 + 4) vector registers and 8 (4 + 4) scalar registers.

FIG. 4 is a flowchart corresponding to FIG. 3, but in this case, the double precision mode is shown. As mentioned above, in double precision mode, register slots in register bank 38 operate in pairs to store the sixteen 64-bit data values in logical registers D0 through D15. In such a case, the encoding of the vector / scalar nature of the registers is determined by the checks in steps 60 and 66, where the destinations are ones of D0 to D3 and the first operand in D0 to D3, respectively. Is one? "

As mentioned above, encoding the vector / scalar nature of a register in a register designation field provides a significant reduction in instruction bit space, but with some difficulties for non-commutative operations such as subtraction and division. When the register configuration is V = V op S, the lack of symmetry between the first and second operands for non-commutative operations is determined by the SUB, RSUB and DIV, RDIV, which represent two different operand options for non-commutative operations. By extending the instruction set to include the same pair of opcodes, we can solve it without the need for additional instructions to swap register values.

5 illustrates vector wrapping in a subset of register banks 38. In particular, in the single precision mode, the register bank is broken into four register ranges, which are addresses SO to S7, S8 to S15, S16 to S23, and S24 to S31. This range is made of chips and is adjacent. Referring to FIG. 2, the wrapping function for these subsets, including eight registers, may be provided using a 3-bit incrementer (adder) 52 in the vector control unit 50. In this way, if the subset boundaries intersect, the incrementer will wrap again. This simple implementation is facilitated by the sorting of a subset of the eight word boundaries in the register address space.

With reference to FIG. 5, many vector operations are described that help to understand the wrapping of registers. The first vector operation is a start register S2, a vector length 4 (representing the length value in the vector control register 46 as 3) and stride 1 (representing the stride value in the vector control register 46 as 0). Specify. Thus, if an instruction is executed to be decoded with reference to register S2 as a vector with these full vector control parameter sets, the instruction will be executed four times each using data values in registers S2, S3, S4 and S5. Since this vector does not intersect the subset boundary, there is no vector wrapping.

In the second example, the start register is S14, the length is 6 and the stride is 1. Thus, the instruction will be executed six times, starting with register S14. The next register uses S15. This register is again incremented by stride, so if you use S16 instead of that register, it will wrap to register S8. So this instruction is executed three more times to complete the entire sequence S14, S15, S8, S9, S10 and S11.

The last example of FIG. 5 shows start register S25, length 8 and stride 2. The first register at this time uses S25, which is accompanied by S27, S29 and S31 according to stride value 2. In accordance with the use of the register S31, the next register value wraps back to the beginning of the subset, goes to register S24 in consideration of stride 2, and performs the operation using the register S25. The incrementer 52 may be in the form of a 3-bit adder that adds a stride to the current value when moving between vector registers. Thus, the stride can be adjusted by feeding other stride values to the adder.

6 illustrates the wrapping of register bank 38 in double precision mode. In this mode, the subset of registers includes D0 through D3, D4 through D7, D8 through D11, and D12 through D15. In the double-precision mode, the minimum value input to the adder that serves as an incrementer is 2, which corresponds to double-precision stride 1. Double-precision stride 2 requires an input of 4 to the adder. The first example shown in FIG. 6 is start register D0, length 4 and stride 1. The vector register sequence thus becomes DO, D1, D2 and D3. Since the subset boundaries do not intersect, there is no wrapping in this example. In the second example, the start register is D15, the length is 2, and the stride is 2. Accordingly, the vector register sequence is D15 and D13.

Referring to FIG. 2, it will be appreciated that the load storage control section 42 has a 5-bit incrementer at its output, and that load / store multiple operations are not affected by register wrapping applied to vector operations. This allows access to the same number of consecutive registers as required by a single load / store multiple instruction.

An example of an operation that makes good use of this wrapping configuration is an FIR filter divided into four signal values and four tap units. If the syntax R8-R11 op R16-R19 represents a vector operation R8 op R16, R9 op R17, R10 op R18 and R11 op R19, the FIR filter operation is performed as follows.

Load 8 taps into R8-R15 and 8 signal values into R16-R23

R8-R11 op R16-R19 and put the result in R24-R27

R9-R12 op R16-R19 and accumulate results in R24-R27

R10-R13 op R16-R19 and accumulate results in R24-R27

R11-R14 op R16-R19 and accumulate results in R24-R27

Reload new tab on R8-R11

R12-R15 op R16-R19 and accumulate the results in R24-R27

R13-R8 op R16-R19 and the result is accumulated in R24-R27 (from R15 to R8)

R14-R9 op R16-R19 and the result is accumulated in R24-R27 (from R15 to R8)

R15-R10 op R16-R19 and the result is accumulated in R24-R27 (from R15 to R8)

Reload new tab on R12 to R15

If there is no tap, reload new data into the R16-R19

R12-R15 op R20-R23 and put the result in R28-R31

R13-R8 op R20-R23 and accumulate results in R28-R31 (from R15 to R8)

R14-R9 op R20-R23 and accumulate results in R28-R31 (from R15 to R8)

R14-R10 op R20-R23 and accumulate results in R28-R31 (from R15 to R8)

The rest is the same as above.

It should be noted from the above that the load is a register different from multiple accumulation and can occur in parallel (i.e. achieve double buffering).             

7A schematically illustrates how the main processor 24 illustrates coprocessor instructions. This main processor uses the bit combination of field 76 (which may be divided) within the instruction to identify the instruction as a coprocessor instruction. Coprocessor instructions within the standard ARM processor instruction set include a coprocessor number field 78 for use in identifying whether the coprocessor (s) added to the main processor are targeting a particular coprocessor instruction. Other types of coprocessors, such as DSP coprocessors (eg, the Piccolo coprocessor manufactured by ARM) or floating point coprocessors, may use different coprocessor numbers to assign the same coprocessor bus 36. It can be addressed separately in a single system. The coprocessor instruction also includes an opcode used by the coprocessor and three 5-bit fields that respectively specify a destination in the coprocessor register, a first operand and a second operand. In some instructions, such as loading or storing a coprocessor, the main processor may at least partially decode the coprocessor instructions to simultaneously complete the data processing operations desired by the coprocessor and the main processor. The main processor may also respond to the encoded data type in the coprocessor number as part of the instruction decode to perform in this situation.

7B illustrates a method of interpreting coprocessor instructions received by a coprocessor that supports multiple and single precision operations. This coprocessor is assigned two adjacent coprocessor numbers and uses the most significant 3 bits of the coprocessor number to identify whether it is a target coprocessor. In this way, the least significant bit of the coprocessor number is redundant to identify the target coprocessor and may instead be used to specify the data type used when executing the coprocessor instruction. In this example, the data type corresponds to a data size that is single or double precision.

It can be seen that in double-precision mode, the number of registers is effectively reduced from 32 to 16. Thus, although it is possible to reduce the register field size, the decoding of the register to be used in this case is not directly available from a self-contained field at a known location in the coprocessor instruction, but depends on the decoding of other parts of the coprocessor instruction. . This is complicated and bad and can slow coprocessor operations. Using the least significant bit of the coprocessor number to encode the data type means that the opcode simplifies its decoding and is completely independent of the rapidly moving data type.

FIG. 7C illustrates how a coprocessor that supports only a single data type, which is a subset of the data types supported by the coprocessor of FIG. 7B, interprets the coprocessor instructions. In this case, the entire coprocessor number is used to determine whether to receive the instruction. In this way, if a coprocessor instruction is of an unsupported data type, it corresponds to a different coprocessor number and will not be received. Thus, main processor 24 may rely on undefined instruction exceptions that handle and emulate operations of unsupported data types.

8 shows a data processing system including an ARM core 80 that acts as the main processor and communicates with the coprocessor 84 supporting coherent and single-precision data types over the coprocessor bus 82. Coprocessor instructions, including the coprocessor number, originate from the ARM core 80 on the coprocessor bus 82 if they collide within the scope of the instruction stream. Thus, the coprocessor 84 generates an accept signal back to the ARM core 80 when a match occurs, compared to its own coprocessor number. If it does not receive the received signal, the ARM core recognizes an Undefined Instruction Exception and consults an exception handling code stored in its memory system 86.

9 illustrates the system of FIG. 8 modified by replacing coprocessor 84 with coprocessor 88 that supports only single precision operations. In this case, coprocessor 88 knows only a single coprocessor number. Thus, double-precision coprocessor instructions in the raw instruction stream executed by coprocessor 84 of FIG. 8 are not received by single precision coprocessor 88. Thus, if it is desired to execute the same code, the undefined exception handling code in memory system 86 may include a double precision emulation routine.

The need to emulate double-precision instructions makes these instructions run slowly, but single-precision coprocessor 88 can be smaller and cheaper than its double-precision coprocessor 84, and in rare cases where double-position instructions are very rare. It will be appreciated that there may be a net benefit obtained.

10 shows an instruction latch circuit in coprocessor 84 that supports single and double precision instructions and has two adjacent coprocessor numbers. In this case, the most significant three bits CP # [3: 1] of the coprocessor number in the coprocessor instruction are compared with those assigned to that coprocessor 84. In this example, if coprocessor 84 has coprocessor numbers 10 and 11, a comparison can be made by matching the most significant bit of coprocessor number CP # [3: 1] for binary 101. If there is a match, the received signal is returned to the ARM core 80 and the coprocessor instruction is latched for execution.

FIG. 11 shows an equivalent circuit in the single precision coprocessor 88 of FIG. 9. In this case, only a single coprocessor number is known to make a single precision operation used by Default. The comparison of determining whether to receive and latch a coprocessor instruction is performed between the full 4-bit CP # [3: 0] of the coprocessor number and the binary 1010, which is a single embedded coprocessor number.

12 is a flow diagram illustrating how an undefined exception handling routine of the embodiment of FIG. 9 is triggered to perform double precision emulation code. Check whether the instruction that caused the undefined instruction exception is a coprocessor instruction with binary 1011, the coprocessor number (step 90). As a result of this check, if Y (Y), this is a double precision instruction and can be emulated in step 92 before returning to the main program flow. Other exception forms may be checked and handled by further steps, if not yes by step 90.

13 illustrates the use of a format register FPREG 200, or a data slot of register bank 220, to store information identifying the type of data stored for each 32-bit register. As mentioned above, each data slot can operate individually as a single precision register for storing 32-bit data values (data words), or double precision for storing 64-bit data values (two data words). It can be paired with another data slot provided in a register. In accordance with a preferred embodiment of the present invention, the FPREG register 200 is configured to identify whether any particular data slot has a single precision or double precision data stored therein.

As shown in FIG. 13, 32 data slots in the register bank 220 are configured to provide 16 pairs of data slots. If the first data slot has a single precision data value stored therein, in the preferred embodiment the other data slots in the pair are configured to store only a single precision data value, and any other to store the double precision data value. It will not link with the data slot. It is certain that any particular pair of data slots is configured to store two single precision data values, or one double precision data value. This information can be identified by a single bit of information associated with each pair of data slots in register bank 220, so that in a preferred embodiment the FPREG register 200 is configured to be in register bank 220. And stores 16-bit information for identifying the type of data stored in each pair of data slots. Accordingly, the FPREG register 200 may, for example, be a 16-bit register for consistency with other registers in the FPU coprocessor 26 or as a 32-bit register with 16 free bit information. .

15 shows six pairs of data slots in register bank 220, which may be used to store six double precision data values or twelve single precision data values, according to a preferred embodiment. Examples of data that can be stored in these data slots include DH representing the 32 most significant bits of the double precision data value, DL representing the 32 least significant bits of the double precision data value, and S representing the single precision data value. Shown.

Also shown in FIG. 15 is a corresponding entry in the FPREG register 200 in accordance with a preferred embodiment of the present invention. According to this preferred embodiment, a value of "1" is stored in the FPREG register 200 to indicate that associated pairs of that data slot contain double precision data values, and a value of "0" is a corresponding data slot pair. At least one of which contains a single precision data value or that both data slots are not initialized. Thus, if both data slots are not initialized, one of the data slots is not initialized and another data slot in the pair contains a single precision data value, or both data slots in the pair are single precision If it contains a data value, a logical "0" value is stored in the corresponding bit of its FPREG register 200.

As noted above, the preferred embodiment FPU coprocessor 26 may be used to process single precision or double precision data values, and coprocessor instructions generated by the main processor 24 may be used to ensure that any particular instruction is a single precision or assignment. Identify if it is a density instruction (see FIG. 7B and related description). When one instruction is received by the coprocessor, it is passed to the register control and instruction generator 48 for decoding and execution. If this instruction is a load instruction, the register control and instruction generation logic 48 instructs the load storage control section 42 to retrieve its identification data from the memory and transfer the data to the designated data slot of the register bank 220. Save it. At this time, the coprocessor knows whether a single precision or double precision data value is being retrieved, and the load storage control section 42 operates accordingly. Thus, the load store control logic 42 sends the register bank input logic 230 for storing the 32-bit single precision data value or the 64-bit double precision data value via the path 225 into the register bank 220. To pass.

In addition to the data loaded into the register bank 220 by the load storage control section 42, the data contains information of bits needed to identify whether single-precision or double-precision data is stored for each pair of data slots receiving the data. Is provided to the format register FPREG 200 so that it can be added. In a preferred embodiment, this data is stored in its format register FPREG 200 and then loaded into the register bank so that this information is available to register bank input logic 230.

In a preferred embodiment, as the internal format of the data in register bank 220 is the same as the external format, the single precision data value is stored as a 32-bit data value, and the double precision data value is 64 in register bank 220. It is stored as a bit data value. Since register bank input logic 230 accesses FPREG format register 200, knowing whether the data being received is single or double precision, and in this embodiment, register bank input logic 230 is on path 225. Is only configured to store the data received in the appropriate data slot (s) of the register bank 220. However, in other embodiments, register bank input logic 230 is configured to perform the necessary conversion if the internal representation in the register bank is different from the external format. For example, numbers are typically represented as 1.abc ... multiplied by an exponentially squared base value. For efficiency, typical single and double precision representations do not use data bits to represent 1 to the left of the decimal point, but rather treat the meaning of 1 as implied. If the internal representation used in register bank 220 required by 1 is clearly indicated, register bank input logic 230 performs the necessary data conversion. In this embodiment, the data slot is typically slightly larger than 32-bit to accommodate the additional data generated by the register bank input logic 230.

In addition, by loading the data value into register bank 220, load storage control 42 loads data into one or more system registers of coprocessor 26, such as the user status and control register FPSCR 210. can do. In a preferred embodiment, this FPSCR register 210 includes user accessible configuration bits and exception status bits and is described in more detail in the structure description of the floating point portion provided at the end of the description of the preferred embodiment.

When register control and instruction generator 48 receives a store instruction that identifies particular data slots in register bank 220 having contents stored in memory, load storage controller 42 receives the command and The necessary data words are read from the register bank 220 to the load storage control section 42 via the register bank output logic 240. The register bank output logic 240 accesses the contents of the FPREG register 200 to determine whether the data being read is single or double precision data. Thus, a suitable data conversion is applied to convert to any data conversion applied by the register bank input logic 230 and the data is provided to the load storage control logic 42 via the path 235.

According to a preferred embodiment of the present invention, when this stored instruction is a double precision instruction, the coprocessor 26 may assume that the instruction operates in a second mode of operation applied to the double precision data value. Since double-precision data values contain even data words, any storage instruction issued in the second mode of operation typically identifies an even number of data slots having content stored in memory. However, in accordance with a preferred embodiment of the present invention, if an odd data slot is specified, the load storage control section 42 reads the contents of the FPREG register 200 to store the identified even data slots from the register bank 220. It is configured to store the contents first in memory. In general, a transmitted data slot is a base address that identifies a particular data slot in a register bank, accompanied by a number that represents the number of data slots counted from that identified data slot to be stored (ie, the number of data words). Is identified by.

Thus, for example, if the store instruction gives the first data slot in register bank 220 as a base address and specifies 33 data slots, this causes the contents of all 32 data slots to be stored in memory, but Since the specified number of data slots is an odd number, the contents of the FPREG register 200 are stored in the memory.

In this way, a single instruction can be used to store the contents of the register bank in memory and the contents of the FPREG register 200 which identifies the type of data stored in the various data slots of the register bank 220. This avoids the need for a separate instruction to be issued to ensure the contents of the FPREG register 200, and thus does not adversely affect the processing speed during loading from storage to or from memory processing.

In another embodiment of the present invention, the technique may be one or more steps to enable additional system registers, such as the FPSCR register 210, to be stored in memory, using a single instruction if necessary. Thus, as discussed above, taking into account the example of a register bank 220 with 32 data slots, if 33 data slots are identified in a storage instruction, the FPREG register 200 may be divided into 32 in the register bank 220. In addition to the contents of the two data slots will be stored in the memory. However, if a different odd number exceeding the number of data slots in the register bank is identified as, for example, 35, this is in addition to the contents of the FPREG register 200 and the data slots in the register bank 220 to the FPSCR in memory. The matter necessary to store the contents of the register 210 can be interpreted by the load storage control section 42. The coprocessor may also include more system registers, such as an exception register that identifies an exception that occurred while processing instructions by the coprocessor. If a different odd number is identified as a storage instruction, for example 37, this is necessary to further store the contents of one or more exception registers in addition to the contents of the FPSCR register 210, FPFEG register 200 and register bank 200. It can be interpreted by the load storage control unit 42 as a matter.             

This technique is particularly useful when the code for initializing a store or load instruction is not known whether the register bank contents are present, where the register bank contents are only temporarily stored in memory for the next search into the register bank. If it is known whether the code is the contents of a register bank, it is also unnecessary to store the contents of the FPREG register 200 in memory. Common examples of code that do not know if they are the contents of a register bank are context switch code and procedure call entries and exit routines.

In such a case, the contents of the FPREG register 200 may be effectively stored in memory in addition to the contents of the register bank, and may be stored as required by certain other system registers, as actually described above.

Similar processing is used for the reception of consecutive load instructions. Accordingly, upon receiving a double precision load instruction specifying an odd data slot, the load storage control section 42 causes the contents of the FPREG register 200 to be loaded into the FPREG register 200, and then the contents of any system register are loaded. The number of slots identified in the load instruction is then shown, and the even data words are then stored in the designated data slots of the register bank 220. Thus, in view of the embodiment described above, when the number of data slots specified in the load instruction is 33, the FPREG register contents are loaded into the FPREG register 200 with the contents of 32 data slots. Similarly, when the number of data slots specified in the load instruction is 35, the contents of the FPSCR register 210 are also loaded into the FPSCR register in addition to those described above. Finally, if the specified number of data slots is 37, any exception register contents are also loaded into the exception register in addition to the above. It will be apparent to those skilled in the art that the specific operation associated with a particular odd number is entirely arbitrary and can be changed as desired.

14 is a flowchart illustrating the operation of register control and instruction generation logic 48 when executing store and load instructions in accordance with a preferred embodiment of the present invention. First, in step 300, the number of data words (which is the same as the number of data slots in the preferred embodiment) is read from the instruction together with the identified first register number in the instruction, namely the base register. Thus, in step 310, since it identifies whether the instruction is a double or single precision instruction, it is determined whether the instruction is a double precision instruction, as described above with the information available to the coprocessor.

If the instruction is a double precision instruction, the process proceeds to step 320 to determine whether the number of words specified in the instruction is odd. For this embodiment, assuming that no additional number of system registers are used to selectively transfer in addition to the FPREG register 200, if the number of words is odd, this indicates that the contents of the FPREG register 200 are to be transferred accordingly. In step 325, the contents of the FPREG register are transmitted by the load storage control section 42. Thus, in step 327, the word count is reduced by one, and the process proceeds to step 330. If it is determined in step 320 that the number of words is even, the process proceeds directly to step 330.

In step 330, it is determined whether the number of words is greater than zero. If it is not large, the instruction is considered complete and the process exits at step 340 (EXIT). However, if the word number is greater than zero, the process proceeds to step 332, where the double-precision data value (i.e., the contents of the two data slots) is transferred to or from this first specified register number. Thereafter, in step 334, the number of words is reduced by two, and in step 336, the number of registers is increased by one. As mentioned above, in practice, a register is actually made up of two data slots for a double precision instruction, so that increasing the register count by one is equivalent to increasing the number of data slots by two.

Thus, the procedure returns to step 330 to continue determining whether the number of words is greater than zero and repeat this process. If the word count reaches zero, the process exits at step 340.

If it is determined in step 310 that the instruction is not a double precision instruction, the process proceeds to step 350 to determine whether the word count is greater than zero again. Thus, if the processing proceeds to step 352, a single precision data value is sent to or from the identified first register number in the instruction. Then, in step 354, the word count is reduced by one, and in step 356, the register number count is incremented by one to designate the next data slot. The process then returns to step 350 to continue determining if the number of words is greater than zero. Thus, this process is repeated until the time of the word count is zero, and the process exits when the processing time is reached in step 360.

This approach provides a great deal of flexibility when executing code that does not know the register bank contents, eg, context switch code or procedure call entry and exit sequences. In such a case, it is preferable that the operating system does not know the contents of the register and treats the registers depending on the contents differently. The above method causes these code routines to be written into a single store or load instruction that specifies an odd number of data words. If the coprocessor requires the use of register content information, the odd number of data words in the instruction are interpreted as necessary, storing or loading the format information necessary to specify the content of the data in the register bank into or out of memory. do. This flexibility eliminates the need for unique operating system software to support coprocessors that require register content information.

This technique also eliminates the need to load and store register content information in separate operations in code. There is an option in the instruction to load and store register contents information, so no additional memory access is required. This reduces the code length and potentially saves time.

The structural description of the floating point portion including the above described technique is described below.

One. Introduction

VFPv1 is a floating point system (FPS) architecture designed to be implemented as a coprocessor for use as an ARM processor module. Implementations of this structure may incorporate hardware or software features, or the implementation may use software to supplement functionality or provide IEEE 754 compatibility. This specification seeks to achieve full IEEE 754 compatibility using a combination of hardware and software support.

Two coprocessor numbers are used by VFPv1, where 10 is used to operate on a single precision operand and 11 is used to operate on a double precision operand. The conversion between single and double-precision data is performed with two-transform instructions that operate in source operand coprocessor space.

The VFPv1 structure includes the following features:

· Support code fully compatible with IEEE 754 in hardware.

32 single precision registers or destination registers, each addressable as a source operand.

16 double-precision or destination registers, each addressable as a source operand (double-precision registers overlap with physical single-precision registers).

Vector mode provides a significant increase in floating-point code density and concurrency of load and store operations.

Four banks with eight circular single precision registers or four banks with four circular double precision registers to improve DSP and graphics operation.

Anomalous handling options select between IEEE 754 compatibility (supported from the floating point emulation package) or select fast flush-to-zero capability.             

Full-pipelined product-cumulative implementation with IEEE 754 compliant results.

Fast floating-point for converting integers to FFTOSIZ instructions for C, C ++, and Java.

The implementation can be chosen to fully implement VFPv1 in hardware or to utilize a combination of hardware and supporting code. At this time, VFPv1 can be completely implemented in software.

2. Terms

This specification uses the following terms:

Automatic exception -An exception condition that always bounces the support code regardless of the value of each exception enable bit. If the exception is automatic, choose one of the implementation options. See exception processing in sections 0 and 6.

Bounce -An exception reported to an operating system that is entirely controlled by support code without invoking a user trap controller or interrupting other flows of user code.

CDP -'Coprocessor Data Processing' for FPS, CDP operations are arithmetic rather than load or store operations.

ConvertToUnsignedInteger (Fm) -converts the contents of Fm to an unsigned 32-bit integer value. This result depends on the rounding mode for final rounding and handling of floating point values outside the range of 32-bit unsigned integers. An INVALID exception is possible if the floating point input value is negative or too large than a 32-bit unsigned integer.

ConvertToSignedInteger (Fm) -converts the contents of Fm to a signed 32-bit integer value. This result depends on the rounding mode for the final rounding and handling of floating point values outside the range of 32-bit signed integers. Invalid exceptions are possible if the floating point input value is greater than the 32-bit signed integer.

ConvertUnsignedIntToSingle / Double (Rd)-Converts the contents of an ARM register (Rd) interpreted as a 32-bit unsigned integer into a single or double precision floating point value. If the destination precision is single, inexact (INEXACT) exceptions to the conversion operation are possible.

ConvertSignedIntToSingle / Double (Rd)-Converts the contents of an ARM register (Rd) interpreted as a 32-bit signed integer into a single or double-precision floating point value. If the destination precision is single, inaccurate exceptions to the conversion operation are possible.

Denormalized value - Represents a value in the range (-2 ^Emin <x <2 ^Emin ). In the IEEE 754 format for single and double precision operands or anomalies, the unnormalized value has a zero exponent and the leading digit bit is zero rather than one. This IEEE 754-1985 specification requires that the generation and manipulation of aborted operands be performed with the same precision as normal operands.

Disabled exception-An exception with the associated exception enable bit in the FPSCR set to 0 is referred to as 'disabled'. The IEEE 754 specification for these exceptions defines the return of correct results. An operation that generates an exception condition may bounce with support code to yield a defined result of IEEE 754. Also, this exception will not be reported to the user exception handler.

Enabled exception -An exception with each exception enable bit set to 1. If this example occurs, the user handler will trap. An operation that generates an exception condition may bounce with support code to yield a defined result of IEEE 754. So this exception will be reported to the user exception handler.

Exponent -A component of a floating point number that normally represents a two-squared integer when determining the value of a given number. This index is often called a signed or unbiased index.

Fraction -A field of digits placed to the right of the implied binary decimal point.

Flush-To-Zero Mode -In this mode, all values in the range (-2 ^Emin <x <2 ^Emin ) after rounding are treated as zero rather than being converted to ^unnormalized values.

High (Fn / Fm) -The upper 32 bits of the double-precision value [63:32] as shown in memory.

IEEE 754-1985- "The IEEE Standard for Binary Floating Point Operations", ANSI / IEEE Std 754- 1985, The Institute of Electrical and Electronics Engineers (IEEE), Inc. New York, New York, 10017. This standard, often referred to as the IEEE 754 standard, defines data types, correct operations, exception types and handling, and error boundaries for floating point methods. Most processors are designed according to a standard of hardware or a combination of hardware and software.

Infinity- A special format of IEEE 754 used to represent ∞. This index is the maximum for precision, and all zeros are in place.

Input exception -An exception condition where one or more operands for a given operation are not supported by the hardware. The operation at this time bounces the supporting code to complete the operation.

Intermediate result -The internal format used to store the result of the calculation before rounding. This format has an exponent field and a digit field larger than the destination format.

Low (Fn / Fm)-Lower 32 bits [31: 0] of double-precision value as shown in memory.

MCR- "Move from ARM register to coprocessor". In the case of FPS, this includes instructions to transfer data or control registers between the ARM and FPS registers. Only 32 bits of information are transmitted using a single MCR class command.

MRC- "Move from Coprocessor to ARM Register". In the case of FPS, this includes instructions to transfer data or control registers between the FPS and ARM registers. Only 32 bits of information are transmitted using a single MRC class command.

NaN -No number, symbolic entity encoded in floating point format. There are two types of NaNs, signaling and non-signaling or quiet. Signaling NaN, if used as an operand, throws an invalid operand exception. Stop NaNs are passed through almost all arithmetic operations without signaling exceptions. The format of NaN has an exponent field of all 1s with non-zero digits. The fractional most significant bit is O to indicate signaling NaN, while the stationary NaN has its bit set to one.

Reserved -A field in a control register or instruction format is 'reserved' if the field is defined by the implementation or yields an UNPREDICTABLE result if the content of the field is nonzero. These fields are reserved or special implementations for future expansion of the structure. All pending bits not used by the implementation must be written to zero and will be read as zero.

Rounding Mode -The IEEE 754 specification requires that all calculations be performed as if infinite precision, that is, the product of two single-precision values, must correctly calculate a place for a double-digit number of places. . It is often necessary to indicate a value in the object precision rounding in place. The IEEE 754 standard provides four rounding modes: Round to Nearest (RZ), Round to Zero (RZ), Round to Plus infinity (RP) ) And round to minus infinity (RM). The first mode can be achieved by rounding at the midpoint with tie case rounding up if the least significant bit of the place making 'even' is zero. This second mode always performs rounding down, effectively truncating any bit to the right of its place, and is used for integer conversion by the C, C ++ and Java languages. The other two modes are used for interval arithmetic.

Significand -A component of a binary floating-point number consisting of an explicit or implied leading bit to the left of an implied binary point and a decimal field to the right.

Support Code -Software used to compensate for hardware to provide compatibility with the IEEE 754 standard. This support code is not only a library of routines that perform operations beyond hardware, such as transcendental calculations, but also supported functions such as splitting into unsupported inputs or inputs that can cause exceptions, and IEEE 754 is configured to have two components, a set of exception handlers that handle exception conditions to provide compliance. The support code is then required to perform the implemented functions to emulate the proper handling of any unsupported data type or data representation (e.g., an abnormal value or decimal data type). The FPS may be used for its interim calculations when the routine is recorded to carefully restore the user's state at the exit of the routine.

Trap- An exception condition with each exception enable bit set in the FPSCR. Your trap handler will run.

UNDEFINED -Indicates an instruction that generates an undefined instruction trap. See the ARM Architecture Reference Manual for more information on ARM exceptions.

UNPREDICTABLE -The result of an unreliable instruction or control register field value. This unpredictable instruction or result should not represent a security hole or should halt or hang any part of the processor or its system.

Unsupported Data -A specific data value that is not processed by the hardware and bounced into the support code for termination. These data include infinity, NaN, abnormal values, and zero. The implementation is free to choose among these values the ones that are fully or partially supported by the hardware or need assistance from the supporting code to terminate the operation. Any exception resulting from unsupported data processing will be trapped in the user code if the corresponding exception enable bit for that exception is set.

3. Register file

3.1 preface

This structure provides 32 single precision and 16 double precision registers that are all individually addressable within a fully defined 5-bit register index as a source or destination operand.

32 single-precision registers overlap with 16 double-precision registers, that is, the double-precision data recording to D5 overwrites the contents of S10 and S11. It is to ensure that a compiler or assembly language programmer knows of a conflict in register usage between the use of a register as a single precision data store in a redundant implementation and the use of a register as half of a double precision data store. Since there is no hardware configured to guarantee the use of registers limited to one precision, violations of this result are unpredictable.

VFPv1 provides access to these registers in scalar mode, and one, two, or three operand registers are used to yield the result written to the destination register, or the operand specified in vector mode refers to a register group. VFPv1 provides vector operations for up to eight components in a single instruction for a single precision operand and up to four components for a double precision operand.

TABLE 1 LEN bit encoding

LEN Vector length encoding 000 scalar 001 Vector length 2 010 Vector length 3 011 Vector length 4 100 Vector length 5 101 Vector length 6 110 Vector length 7 111 Vector length 8

Vector mode is made possible by writing a non-zero value in the LEN field. In this case, if the LEN field contains 0, the FPS operates in scalar mode, and the register field is interpreted by addressing 32 individual single precision registers or 16 double precision registers in the flat register model. If the LEN field is non-zero, the FPS operates in vector mode and the register field is interpreted by addressing a vector of registers. See Table 1 for the encoding of the LEN field.

Means of mixing scalar and vector operations without changing the LEN field are possible through specification of the destination register. Scalar operations may be specified while in vector mode if the destination register is in the first bank of registers S0-S7 or D0-D3. See section 0 for more information.

3.2 Single precision register usage

If the LEN field is 0 in the FPSCR, 32 single precision registers are available with numbers S0 through S31. Any register may be used as the source or destination register.

Example 1. Single precision register map

This single precision (coprocessor 10) register map may be represented as shown in Example 1. FIG.             

If the LEN field in the FPSCR is greater than zero, the register file operates as four banks of eight circular registers, as shown in Example 2. The first bank of vector registers V0 through V7 overlaps with the scalar registers S0 through S7 and is addressed as a scalar or vector depending on the register selected for each operand. See Sections 0 and 3.4 for register usage for more information.

Example 2. Circular Single Precision Register

For example, when LEN is set to 3 in the FPSCR, the reference vector V10 causes the registers S10, S11, S12 and S13 to be included in the vector operation. Similarly, V22 causes S22, S23, S16 and S17 to be included in the calculation. When accessing the register file in vector mode, the register after V7 in the order is V0, and similarly, V8 is after V15, V16 is after V23, and V24 is after V31.

3.3 Double-precision register file

If the LEN field is 0 in the FPSCR, 16 double-precision scalar registers are available.

Example 3. Double-Precision Register Map

Any register can be used as the source or destination register. This register map may be represented as shown in Example 3.

If the LEN field in the FPSCR is greater than zero, four scalar registers and sixteen vector registers in four banks of four circular registers are available, as shown in Example 4. The first bank of the vector registers V0 through V3 overlaps with the scalar registers D0 through D3. This register is addressed either as a scalar or according to the register selected for each operand. See Sections 0 and 3.4 for register usage for more information.

Example 4. Cyclic Double-Precision Register             

Because of the single precision embodiment in section 0, the double precision registers are circulating in four banks.

3.4 Register usage

Three operations are supported between scalar and vector (OP ₂ can be any two operand operations supported by a floating point coprocessor and OP ₃ can be any three operand operations).

In the following description, the 'first bank' of the register file is defined as registers S0-S7 for single precision operation and registers D0-D3 for double precision calculation.

Scalar D = OP ₂ scalar A or scalar D = scalar A OP ₃ scalar B or scalar D = scalar A * scalar B + scalar D

Vector D = OP ₂ scalar A or vector D = scalar A OP ₃ vector B or vector D = scalar A * vector B + vector D

Vector D = OP ₂ Vector A or Vector D = Vector A OP ₃ Vector B or Vector D = Vector A * Vector B + Vector D

3.4.1 Scalar operation

Two conditions cause the FPS to operate in scalar mode.

One? The LEN field is 0 in FPSCR. The destination and source registers may be any of the scalar registers 0 to 31 for single precision operation and the scalar registers 0 to 15 for double precision calculation. This operation is performed only for the register explicitly specified in the instruction.

2? The destination register is in the first bank of the register file. The source scalar may be any other register. This mode allows intermediate mixing of scalar and vector operations without having to change the LEN field in the FPSCR.

3.4.2 Operations involving scalar and vector sources and vector destinations

To operate in this mode, the LEN field of the FPSCR is greater than zero and its destination register is not in the first bank of the register file. The scalar source register can be any register in the first bank of the register file and the remaining any register can be used for VectorB. Note that the behavior is that if the source scalar register is a member, or if the vector D overlaps with a vector B less than the LEN component, that is, the vector D and the vector B must be the same vector or are completely separate on all members. The case is unpredictable. See the summary table in section 0.

3.4.3 Operations involving only vector data

To operate in this mode, the LEN field of the FPSCR is greater than zero and the destination vector register is not in the first bank of the register file. The individual components of the vector A vector are recorded in the vector D in combination with the corresponding components in the vector B. Any register not in the first bank of that register file is available for vector A, and all vectors are available for vector B. As in the following case, the operation is unpredictable if both vectors of the source and destination overlap below the LEN component. They are the same or completely separate from all members. See the summary table in section 0.             

Note that for the FMAC family of operations, the destination register or vector is always an accumulate register or vector.

3.4.4 Operation summary table

The following table presents the register usage options for single and double precision two and three operand instructions. 'Any' indicates the availability of all registers in precision for the specified operand.

TABLE 2 Single precision three operand register usage

LEN field Destination register First source register Second source register Calculation form 0 Any Any Any S = SopS or S = S * S + S non-0 0-7 Any Any S = SopS or S = S * S + S LEN field Destination register First source register Second source register Calculation form non-0 8-31 0-7 Any V = SopV or V = S * V + V non-0 8-31 8-31 Any V = VopV or V = V * V + V

TABLE 3 Single precision two operand register usage

LEN field Destination register Source register Calculation form 0 Any Any S = op S non-0 0-7 Any S = op S non-0 8-31 0-7 V = op S non-0 8-31 8-31 V = op V

TABLE 4 Usage of double-precision three operand registers

LEN field Destination register First source register Second source register Calculation form 0 Any Any Any S = SopS or S = S * S + S non-0 0-3 Any Any S = SopS or S = S * S + S non-0 4-15 0-3 Any V = SopV or V = S * V + V non-0 4-15 4-15 Any V = VopV or V = V * V + V

TABLE 5 Usage of double-precision two operand registers

LEN field Destination register Source register Calculation form 0 Any Any S = op S non-0 0-3 Any S = op S non-0 4-15 0-7 V = op S non-0 4-15 8-31 V = op V

4. Instruction set

FPS instructions can be divided into three categories.

MCR and MRC-transfer operations between ARM and FPS

LDC and STC-load and store operations between FPS and memory

CDP-data processing operation

4.1 Instruction concurrency

The intent of the FPS architecture specification is two levels of concurrency.

Parallel load / store operations with pipelined features and CDP capabilities. Significant performance gains are available by supporting load and store operations that do not have register dependencies while processing the operations to execute in parallel with these operations.

4.2 Instruction serialization

The FPS specifies a single instruction that causes the FPS to Busy-Wait until all currently executing instructions complete and each exception status is known. If an exception is in progress, the serialization instruction is canceled and the ARM begins to handle the exception. In FPS, the serialization instruction is

FMOVX-reads or writes to floating point registers

There is this.             

Stops any read or write to the floating point register until the current instruction completes. FMOVX (FMOVX to the System ID Register) for the System ID Register raises an exception raised by the preceding floating point instruction. Performing User Status and Control Register Read / Change / Write (using FMOVX) can be used to clear the exception status bits FPSCR [4: 0]. .

4.3 Transforms that contain integer data

Conversion between floating point and integer data is a two-step process in the FPS consisting of a data transfer instruction containing integer data and a CDP instruction that performs the conversion. If any arithmetic operation is attempted on integer data in the FPS register, the result is unpredictable in integer format and this random operation should be avoided.

4.3.1 Convert integer data to floating point data in FPS register

Integer data may be loaded into a floating point single precision register from any ARM register using the MCR FMOVS instruction. Integer data from the FPS register is converted to a single or double-precision floating point value using integer-to-float family operations and written to the destination FPS register. This destination register becomes a source register when its integer value is no longer needed. The integer at this time is a signed or unsigned 32-bit amount.

4.3.2 Convert floating point data in FPS register to integer data

Converts the value of an FPS single or double-precision register into a signed or unsigned 32-bit integer format with float-to-integer family instructions. As a result, the integer is placed in the destination single precision register. At this time, the integer data is stored in ARM register by using MRC FMOVS instruction.

4.4 Register file addressing

An instruction operating in a single precision space (S = 0) uses the 5 bits available for that instruction field for operand access. At this time, the upper 4 bits are included in the operand field labeled Fn, Fm, or Fd, and the least significant bit of the address is in N, M, or D, respectively.

The instruction to operate in the double precision space (S = 1) uses only the upper 4 bits of the operand address. These four bits are included in the Fn, Fm, and Fd fields. The N, M, and D bits must contain zero if the corresponding operand field contains an operand address.

4.5 MCR (Move to Coprocessor from ARM register)

This MCR operation involves the transfer or use of data in ARM registers by the FPS. This moves data in a single-precision format from an ARM register or a double-precision format from a pair of ARM registers to an FPS register, loads a signed or unsigned integer value from an ARM register to a single-precision FPS register, This involves loading the contents of the ARM register into the control register.

The format for the MCR instruction is shown in Example 5.

Example 5. MCR Command Format

TABLE 6 MCR Bit Field Definition

Bit field Justice Opcode 3-bit opcode (see Table 7) Rd ARM source register encoding S Arithmetic operand size. 0-single precision operand 1-double precision operand N Single precision operation: destination register least significant bit double precision operation: Must be set to 0 or operation is undefined System register move pending Fn Single precision operation: Destination register address Higher four bits Double precision operation: Destination register address System register shift: 0000-FPID (coprocessor ID number) 0001-User Status and Control Register (FPSCR) 0100 -FPREG (register file contents register) Register encoding is pending and may vary in various implementations. R Pending bits

TABLE 7 MCR Opcode Field Definition

Opcode field name calculate 000 FMOVS Fn = Rd (32-bit, coprocessor 10) 000 FMOVLD Low (Fn) = Rd (32-bit double precision, coprocessor 11) 001 FMOVHD High (Fn) = Rd (double precision high 32-bit, coprocessor 11) 010-110 Hold 111 FMOVX System Register = Rd (Coprocessor 10 Space)

Note: Only 32-bit data operations are supported by the FMOV [S, HD, LD] instruction. Only data in the ARM register or single precision register is moved by the FMOVS operation. To transfer double-precision operands from two ARM registers, FMOVLD and FMOVHD instructions, move the lower half and upper half, respectively.

4.6 MRC (Move to ARM Register from Coprocessor / Compare Floating Registers)

This MRC operation involves the transfer of data from the FPS register to the ARM register. This means moving the result of converting a single precision value or floating point value to an integer into an ARM register, or moving a double-precision FPS register into two ARM registers, and changing the status bits of the CPSR to the result of the previous floating point comparison operation. Include.

The format of the MRC instruction is shown in Example 6.

Example 6. MRC Instruction Format

TABLE 8 MRC bit field definitions

Bitfield Justice Opcode 3-bit FPS opcode (see Table 9) Rd ARM destination * register encoding S Arithmetic operand size. 0-single precision operand 1-double precision operand

Bitfield Justice N Single precision operation: destination register least significant bit double precision operation: Must be set to O or operation is undefined System register move pending  M Hold Fn  Single precision operation: Destination register address Higher four bits Double precision operation: Destination register address System register shift: 0000-Coprocessor ID number (FPID) 0001-User Status and Control Register (FPSCR) 0100-Register File Content Register (FPREG) Register encodings are reserved and various implementations may vary. Fm  Hold R  Hold

For the FMOVX FPSCR instruction, if the Rd field contains R15 1111, the upper 4 bits of the CPSR will be updated with the resulting condition code.

TABLE 9 MRC Opcode Field Definition

Opcode field name calculate 000 FMOVS Rd = Fn (32-bit, coprocessor 10) 000 FMOVLD Lower 32 bits of Rd = Low (Fn) Dn are transmitted (double precision low 32 bits, coprocessor 11) 001 FMOVHD Rd = High (Fn) The upper 32 bits of Dn are transmitted (double precision high 32 bits, coprocessor 11). 010-110 Hold 111 FMOVX Rd = System Register

Comment: See MCR FMOV command comment.

4.7 LDC / STC (load / store FPS register)

LDC and STC operations transfer data between the FPS and memory. Floating-point data can be transmitted at the precision of a single data transfer or multiple data transfers, leaving its ARM address registers updated or left unaffected. Support for full operand stacks and empty ascending stack structures, as well as multiple operand accesses to data structures in move multiple operations. See Table 11 for a description of the various options for LDC and STC.

Example 7 shows the format of the LDC and STC instructions.

Example 7. LDC / STC Instruction Format

TABLE 10. LDC / STC Bit Field Definition

Bit field Justice P Pre / post indexing (0 = post, 1 = pre) U Up / Down Bits (0 = down, 1 = up)

Bit field Justice D Single precision operation: source / destination register least significant bit double precision operation: must be set to 0 W Rewrite bit (0 = do not rewrite, 1 = rewrite) L Direction bit (0 = save, 1 = load) Rn ARM base register encoding Fd Single precision operation: source / destination register address High 4 bit double precision operation: source / destination register address S Arithmetic operand size. 0-single precision operand 1-double precision operand Offset / transmits Unsigned 8-bit offset or number of single-precision (double the double-precision register count) registers for transfer for FLDM (IA / DB) and FSTM (IA / DB). The maximum number of words in a transmission is 16 which allows for 16 single precision values or 8 double precision values.

4.7.1 General Features for Load and Store Operations

Multiple registers load and store linearly through a register file without wrapping across the four or eight register boundaries used by vector operations. Trying to load past register file ends is unpredictable.

If the offset for a double load or storage multiple includes an odd register count of 17 or less, the implementation may write another 32-bit data item or read another 32-bit data item, but not necessarily so. It is not necessary. These additional data items can be used to identify the contents of registers as they are loaded or stored. This is useful for implementations where the register file format differs from the IEEE 754 format for precision and each register has the type information required to identify it in memory. If the offset is odd and the number is greater than the number of single precision registers, it can be used to context switch that register and initialize all system registers.

TABLE 11 Load and Save Addressing Mode Options

4.8 CDP (Coprocessor Data Processing)

The CDP instruction includes an operand from a floating point register file and includes all data processing operations that yield a result to be rewritten to that register file. Of particular interest are FMAC (chained multiplication-cumulative) operations, and operations that perform multiplication on two operands and add third operands. This operation differs from a fused multiply-cumulative operation in that the IEEE rounding operation is performed on the product before addition of the third operand. This speeds up the multiply-cumulative operations by making the Java code useful for FMAC operations, resulting in separate multiplication and addition operations.

Two instructions in the CDP group are useful for converting floating point values in the FPS register to integer values. FFTOUI [S / D] uses the current rounding mode in the FPSCR to convert single or double precision contents into unsigned integers in the FPS register. FFTOSI [S / D] converts to a signed integer. FFTOUIZ [S / D] and FFTOSIZ [S / D] perform the same function but invalidate the FPSCR rounding mode for that conversion and truncate any fractional bits. The function of FFTOSIZ [S / D] requires C, C ++, and Java to convert floating numbers to integers. The FFTOSIZ [S / D] instruction provides the capability without requiring adjustment of the rounding mode bits from FPSCR to RZ for conversion, thereby yielding a cycle count for conversion to FFTOSIZ [S / D] operations. Which saves 4 to 6 cycles.

The comparison operation is performed using the CDP CMP instruction, followed by the MRC FMOVX FPSCR instruction to load the resulting FPS flag bits (FPSCR [31:28]) into the ARM CPSR flag bits. The comparison operation at this time is provided with the possibility of invalid exception and without the possibility if one of the comparison operands is NaN. FCMP and FCMP0 do not signal invalid when one of the comparison operands is NaN, and FCMPE and FCMPE0 also signal an exception. The FCMP0 and FCMPE0 compare 0 with the operand in the Fm field and set the FPS flag accordingly. After the FMOVX FPSCR operation, define the ARM flags N, Z, C and V as follows.

Less than N

Z equals

C is greater than or equal to or not commanded

Do not receive V command             

The format of the CDP instruction is shown in Example 8 below.

Example 8. CDP Command Format

TABLE 13 CDP Bit Field Definition

Bit field Justice Oppe Code 4-bit FPS opcode (see Table 14) D Single precision operation: destination register least significant bit double precision operation: must be set to 0

Bit field Justice Fn Single precision operation: Source A register high 4 bits OR extended opcode most significant 4 bits Double precision operation: source A register address OR extended opcode most significant 4 bits Fd Single precision operation: destination register high 4 bits double precision operation: destination register address S Arithmetic operand size: 0-single precision operand 1-double precision operand N Single precision operation: source A register least significant bit extended opcode least significant bit double precision operation: must be set to 0 extended opcode least significant bit M Single precision operation: source B register least significant bit double precision operation: must be set to 0 Fm Single-Precision Operation: Source B Register Address High 4-bit double precision operation: Source B Register Address

4.8.1 Oppe Code

Table 14 shows the major opcodes of CDP instructions. All mnemonics are of the form [OPERATION] [COND] [S / D].

TABLE 14 CDP Oppe Code Specification

Opcode Field Operation name calculate 0000 FMAC Fd = Fn * Fm + Fd 0001 FNMAC Fd =-(Fn * Fm + Fd) 0010 FMSC Fd = Fn * Fm-Fd 0011 FNMSC Fd =-(Fn * Fm-Fd) 0100 FMUL Fd = Fn * Fm 0101 FNMUL Fd =-(Fn * Fm) 0110 FSUB Fd = Fn-Fm 0111 FNSUB Fd =-(Fn-Fm) 1000 FADD Fd = Fn + Fm 1001- 1011 Hold 1100 FDIV Fd = Fn / Fm 1101 FRDIV Fd = Fm / Fn 1110 FRMD Fd = Fn% Fm (left after the Fd = Fn / Fm decimal) 1111 expansion Use the Fn register field to specify an operation for two operand operations (see Table 15)

4.8.2 Extended operations

Table 15 shows the extension operations available using the extension values in the Opcode field. All instructions are of the form [OPERATION] [COND] [S / D] with serialization and the exclusion of FLSCB instructions. The instruction encoding for the extended operation is formed in the same manner as the index in the register file for the Fn operand, i.e., {Fn [3: 0], N}.             

TABLE 15. CDP Extended Operation

* Non vectorizable operations. Ignore this LEN field and perform a scalar operation on a specific register.

5. System register

5.1 System ID Register (FPSID)

This FPSID contains the FPS structure and the implementation ID value defined.

Example 9. FPSID Register Encoding

This word may be used to determine the model, feature set and modification of the FPS, and mask set number. This FPSID is read-only and writing to that FPSID is ignored. See Example 9 for the FPSID register layout.

5.2 User Status and Control Register (FPSCR)

The FPSCR register contains user accessible configuration bits and exception status bits. Configuration options include exception enable bit, rounding control, vector stride and length, handling of abnormal operands and results, and the use of debug mode. This register is for user and operating system code to configure the FPS and query the status of completed operations.

Example 10. User Status and Control Register (FPSCR)

It must be saved and restored during the context switch. Bits 31 through 28 contain the flag value from the most recent comparison instruction and can be accessed using the read of the FPSCR. This FPSCR is shown in Example 10 above.             

5.2.1 Comparison Status and Processing Control Bytes

Bits 31 to 28 contain the most recent comparison operation result and some control bits that are useful for specifying the arithmetic response of the FPS in a particular situation. The comparison status and the format of the process control byte are shown in Example 11.

Example 11. FPSCR Comparison Status and Processing Control Byte

TABLE 16. FPSCR comparison status and processing control byte field definitions

Register bits name function 31 N Comparison was less than 30 Z The comparison was the same 29 C Comparison results are greater than or equal to or not ordered 28 V The comparison did not receive an order 27: 25 Hold 24 FZ Flush to zero 0: IEEE 754 underflow handling (default) 1: Flush Tiny becomes zero Any result less than the normal range for the destination precision will be zero written to the destination. You do not get this underflow exception trap.

5.2.2 System control bytes

This system control byte controls the rounding mode, vector stride and vector length fields. This bit is specified as shown in Example 12. The VFPv1 architecture incorporates register file striding mechanisms and vector operations for use. If you set the stride bit to 00, the next register selected for the vector operation becomes the register immediately after the previous register in that register file. The normal register file wrapping mechanism is not affected by the stride value. A stride of 11 increments all input registers and output registers by two.

For example,

FMULEQS F8, F16, F24

Is the following nonvector operation:

FMULEQS F8, F16, F24

FMULEQS F10, F18, F26

FMULEQS F12, F20, F28

FMULEQS F14, F22, F30

Rather than 'single register', it effectively 'straws' the operands to multiply the register file by 2 registers.

Example 12. FPSCR System Control Byte

TABLE 17. FPSCR system control byte field definitions

Register bits name function 23: 22 RMODE Rounding Mode Set 00: RN (Round to Nearest; Default) 01: RP (Round towards Plus Infinity) 10: RM (Round towards Minus Infinity) 11: RZ (Round towards Zero) 21: 20 STRIDE Vector register access set: 00: 1 (Default) 01: Hold 10: Hold 11: 2 19 Hold (R) 18: 16 LEN Vector length. Specify length for vector operations (not all encodings are available per run) 000: 1 (Default) 001: 2 010: 3 011: 4 100: 5 101: 6

Register bits name function 18:16 LEN    110: 7 111: 8

5.2.3 Exception enable byte

The exception enable byte occupies 15: 8 bits and includes an exception trap enable. This bit is specified as shown in Example 13. This exception enable bit follows the requirements of the IEEE 754 specification for handling floating point exception conditions. If this bit is set, the exception is enabled and the FPS signals a user visible trap to the operating system when an exception condition occurs for the current instruction. If the bit is cleared, the exception is not enabled and the FPS does not signal a user visible trap to the operating system in the event of that exception condition, producing a mathematically reasonable result. The default for the exception enable bit is disabled. See the IEEE 754 standard for more information about exception handling.             

Some implementations generate a bounce on support code to adjust for exception conditions other than hardware capabilities even when the exception is disabled. This is generally not what the user code can see.

Example 13. Enable FPSCR Exception

TABLE 18. FPSCR Exception Enable Bytes field

Register bits name function 15: 13 Hold 12 IXE Incorrect Enable Bit 0: Disable (default) 1: Enable 11 UFE Underflow enable bit 0: Disable (default) 1: Enable 10 OFE Overflow Enable Bit 0: Disable (default) 1: Enable 9 DZE Enable bit divided by 0 0: Disable (default) 1: Enable 8 IOE Invalid operand enable bit 0: disable (default) 1: enable

5.2.4 Exception status byte

The exception status byte occupies 7: 0 bits of the FPSCR and contains the exception status flag bits. There are five exception status flag bits, one for each floating point exception. These bits are 'sticky', that is, if set with a detected exception, they must be cleared by an FMOVX write to the FPSCR or an FSERIALCL instruction. These bits are designated as shown in Example 14. For enabled exceptions, the corresponding exception status bit is not set automatically. The task of supporting code is to set the appropriate exception status bits whenever necessary. Some exceptions will be automatic, ie, when the exception condition is detected, the FPS will bounce on consecutive floating point instructions regardless of how the exception enable bit is set. This allows some of the many relevant exception handling required by the IEEE 754 standard to be performed in software rather than in hardware. In our example, we have an underflow condition with the FZ bit set to zero. In this case, the correct result is a number that is aberrant according to the exponent and rounding mode of the result. The FPS allows the implementer to select a response containing the option to bounce and to use the support code to calculate the correct value and write this value to the destination register. If the underflow exception enable bit is set, the user's trap handler is called after the support code completes the operation. This code changes the state of the FPS and returns, or terminates the processing.

Example 14. FPSCR Exception Status Byte

TABLE 19. FPSCR exception status byte field definition

Register bits name function 7: 5  Hold 4 IXC Incorrect exception detection 3 UFC Underflow exception detected 2 OFC Overflow exception detected One DZC Exception detection divided by zero 0 IOC Invalid operation exception detected

5.3 Register File Content Register (FPREG)

This register file content register is a privileged register that contains information that can be used by a debugger to properly represent the contents of the register when interpreted by the currently running program. This FPREG contains 16 bits, which is 1 bit for each double precision register in the register file.

Example 15. Encoding the FPREG Register

When the bit is set, the physical register pair represented by the bit is represented as a double precision register. If this bit is cleared, the physical register does not initialize or contain one or two single precision data values.

TABLE 20. FPREG bit field definition

FPREG bit Bit set Bit clear C0 D0 valid S1 and S0 valid or deinitialized C1 D1 valid S3 and S2 valid or deinitialized C2 D2 valid S5 and S4 valid or deinitialized C3 D3 valid S7 and S6 valid or deinitialized C4 D4 valid Valid or deinitialized S9 and S8 C5 D5 valid Valid or deinitialized S11 and S10 C6 D6 valid Valid or deinitialized S13 and S12 C7 D7 valid Valid or deinitialized S15 and S14 C8 D8 valid Valid or deinitialized S17 and S16 C9 D9 valid Valid or deinitialized S19 and S18 C10 D10 valid Valid or uninitialized S21 and S20 C11 D11 valid Valid or deinitialized S23 and S22 C12 D12 valid Valid or deinitialized S25 and S24 C13 D13 valid Valid or uninitialized S27 and S26 C14 D14 valid Valid or deinitialized S29 and S28 C15 D15 valid Valid or uninitialized S31 and S30

6. exception handling

FPS operates in one of two modes: debug mode and normal mode. If the DM bit is set in the FPSCR, the FPS operates in debug mode. In this mode, the FPS waits for the ARM to be informed of the exception status and then executes one instruction at the same time. This ensures that register files and memory are accurate for the instruction flow, but at the cost of much execution time. This FPS receives new instructions from the ARM and signal exceptions regarding the detection of the exception condition when allowing resources. Exception reporting to ARM is always precise for floating point instruction stream exceptions in the case of load or store operations that follow a vector operation and execute in parallel with that vector operation. In this case, the contents of the register file for the load operation or the memory for the store operation are not precise.

6.1 Support code

The implementation of the FPS may select IEEE 754 according to a combination of hardware and software support. For unsupported data types and automatic exceptions, the supporting code performs hardware-specific functions and returns the appropriate results to the destination register, without calling the user's trap handler or otherwise modifying the user's code flow. Return to It is shown to the user that only hardware can be responsible for handling floating point code. Bouncing support code to control these features greatly increases the time to perform or process the feature, but the occurrence of these situations is generally minimal for user code, embedded applications, and well-written numerical applications.

This support code consists of a library consisting of two components: routines that perform support functions such as operations beyond the hardware's range, such as transcendental calculations, as well as input functions that generate unsupported inputs or exceptions that generate exceptions, and IEEE 754 has a set of exception handlers that handle exception traps to provide compliance. This support code is needed to perform implementation functions to emulate proper handling of any unsupported data type or data representation (eg, an abnormal value). This routine may be written to use the FPS in their intermediate calculations when carefully restoring the user's state at the exit of the routine.

6.2 Exception reporting and handling

Report the exception in normal mode to the ARM of the next floating-point instruction that was issued after the exception condition was detected. The state of the ARM processor, FPS register file, and memory is not precise for the violation instruction when an exception occurs. Sufficient information is available to the supporting code so that it accurately emulates the instruction and handles any exceptions arising from the instruction.

In some implementations, the support code can be used to process some or all of the operations with specific IEEE 754 data, including infinity, NaN, abnormal data, and zero. This implementation refers to these data as unsupported, bounces against the support code in a way that is not generally visible to the user code, and returns to the designated IEEE 754 ending with the destination register. Any exception resulting from that operation obeys the IEEE 754 rule for exceptions. This includes trapping into user code when the corresponding exception enable bit is set.

The IEEE 754 standard defines the response to exception conditions for enabled exceptions and for disabled exceptions in the FPSCR. The VFPv1 structure does not specify a boundary between hardware and software suitably used in accordance with the IEEE 754 specification.

6.2.1 Unsupported Operations and Formats

FPS does not support any operation with conversion to or from decimal data or decimal data. These operations require the IEEE 754 standard and must be provided by the support code. Attempts to utilize decimal data require a library routine for the desired function. This FPS cannot be used to trap instructions that use decimal data rather than decimal data types.

6.2.2 Use of FMOVX when FPS is disabled or exception

An FMOVX instruction executed in SUPERVISOR or UNDEFINED mode is used if the FPS is in an exception state or disabled (if its implementation supports the disable option) without sending an exception signal to ARM. Read and write or read FPSID or FPREG.

Although specific embodiments of the present invention have been described as described above, it is clear that the present invention is not limited thereto and many modifications and additions can be made within the scope of the present invention. For example, various combinations of the following dependent claim features can be made to the features of the independent claims without departing from the scope of the invention.

Claims (15)

A register bank having a plurality of addressable registers, An instruction decoder responsive to at least one data processing instruction specifying a vector operation starting at an initial register specified in said data processing instruction and performing a data processing operation multiple times using data values from a series of registers in said register bank; Including, The register bank consists of at least one subset of registers, the series of registers being in the subset, And the command decoder controls the series of registers to wrap within the subset of registers. The method of claim 1, The vector operation executes the data processing operation using a plurality of respective data values from a corresponding plurality of sequences of registers, The register bank comprises a plurality of subsets of registers, the registers of the plurality of sequences being in each subset, And the command decoder controls the registers of the plurality of sequences to wrap within each subset of registers. The method of claim 2, And said plurality of subsets are deconstructed. The method according to any one of claims 1, 2 and 3, And said subset comprises a range of number registers consecutively. The method of claim 2, Each of the plurality of subsets comprises a range of consecutively numbered registers. The method of claim 5, And said plurality of subsets comprises each contiguous range of consecutively numbered registers. The method of claim 6, A data processing device comprising four consecutive ranges. The method according to any one of claims 1, 2, 3, 5, 6, and 7, And a transfer controller for controlling transfer of data values between the memory and registers in the register bank, the transfer controller transferring a series of data values between the memory and a series of registers in the register bank. And a data transfer device responsive to a multiple transfer command. The method of claim 6, Wherein each range is addressed through an incrementer that wraps between the endpoints of the range. The method according to any one of claims 1, 2, 3, 5, 6, 7, and 9, And said sequence is a sequence consisting of consecutive registers. The method according to any one of claims 1, 2, 3, 5, 6, 7, and 9, And the register bank and the command decoder are part of a floating point unit. Storing data values in a plurality of addressable registers in a register bank; Specifying a vector operation in accordance with at least one data processing instruction and executing the data processing operation multiple times using data values from a series of registers in the register bank starting at the initial register specified in the data processing instruction. and, The register bank consists of at least one subset of registers, the series of registers being in the subset, During said execution, said series of registers wraps within said subset of registers. The method of claim 12, The vector operation executes the data processing operation using a plurality of respective data values from a corresponding plurality of sequences of registers, The register bank comprises a plurality of subsets of registers, the registers of the plurality of sequences being in each subset, And the instruction decoder controls the registers of the plurality of sequences to wrap within each subset of registers. The method of claim 13, The data value in one sequence is the tap coefficient of the filter, and the data value in the other sequence is the signal value for filtering by the filter. The method of claim 12, And a plurality of vector operations are executed according to data values in the plurality of sequences having the starting point of at least one sequence that changes with each vector operation.

Images