CN104321741A - Double rounded combined floating-point multiply and add - Google Patents

Abstract

Methods, apparatus, instructions and logic are disclosed providing double rounded combined floating-point multiply and add functionality as scalar or vector SIMD instructions or as fused micro-operations. Embodiments include detecting floating-point (FP) multiplication operations and subsequent FP operations specifying as source operands results of the FP multiplications. The FP multiplications and the subsequent FP operations are encoded as combined FP operations including rounding of the results of FP multiplication followed by the subsequent FP operations. The encoding of said combined FP operations may be stored and executed as part of an executable thread portion using fused-multiply-add hardware that includes overflow detection for the product of FP multipliers, first and second FP adders to add third operand addend mantissas and the products of the FP multipliers with different rounding inputs based on overflow, or no overflow, in the products of the FP multiplier. Final results are selected respectively using overflow detection.

Description

Double rounding combined floating-point multiplication and addition

technical field

The present disclosure relates to the field of processing logic, microprocessors, and associated instruction set architectures that perform logical, mathematical, or other functional operations when executed by a processor or other processing logic. In particular, the present disclosure relates to instructions and logic for providing double rounded combined floating point multiply and add functionality.

Background technique

Many of today's processors typically include instructions to provide computationally intensive operations yet provide a high degree of data parallelism, which can be exploited through efficient implementation using a variety of data storage devices such as: Single Instruction Multiple Data (SIMD) SIMD) vector registers. In some alternative processors, instructions may provide fused operations, such as multiply-add operations. In some alternative processors, the two types of instructions and/or a combination of the two types may be provided in a single instruction, such as, for example, a SIMD multiply-add operation.

Some processors in the past have implemented instructions for performing fused floating-point multiply-add operations. For example, in 1990, IBM implemented fused floating-point multiply-add operations on the RISC System 6000 (IBM RS/6000) processor. For example, some applications involving dot product calculations can take advantage of these new instructions to improve performance. However, because the floating-point hardware supporting such operations may be at least twice the width of standard floating-point multipliers and adders, one floating-point multiply-adder would take two floating-point multipliers and two floating-point as many areas as dot adders. Thus, a fused floating-point multiply-adder may completely replace separate floating-point multipliers and floating-point adders, and a fused floating-point multiply-adder may be used to emulate a single floating-point multiply and/or a single floating-point add, But some (possibly significant) performance is sacrificed. For legacy applications that have not been recompiled, or for applications that cannot take advantage of fused floating-point multiply-add operations, there is a (potentially significant) performance degradation.

Some other processors in the past have implemented instructions for nearly performing fused floating-point multiply-add operations. For example, in 2001, HAL SPARC64 implemented pseudo-code fused floating-point multiply-add operations by bypassing the results from the floating-point multiplier to the floating-point adder. While this approach does not suffer from the same performance degradation experienced by non-recompiled legacy applications or applications that cannot take advantage of fused floating-point multiply-add operations, the floating-point multipliers, bypasses, and floating-point adders are not wide enough Provides the same improved accuracy as true fused floating-point multiply-add operations.

In 2008, the Institute of Electrical and Electronics Engineers (IEEE) published a revised floating-point standard IEEE Std 754 ^TM -1985, IEEE Std 754-2008, which includes fused multiply-add (FMA) and fused multiply-subtract (FMS) operations . This IEEE standard specifies improved accuracy for true IEEE fused floating-point multiply-add operations without rounding between multiply and add. While standardization will undoubtedly lead to new processors offering IEEE FMA and FMS operations, the previously mentioned issues of performance degradation and increased die area remain.

To date, potential solutions to such performance-limiting problems, area trade-offs, and associated power issues and need for recompilation have not been fully explored.

Description of drawings

The invention is shown by way of example and not limitation in the various figures of the accompanying drawings.

Figure 1A is a block diagram of one embodiment of a system that executes instructions for providing double rounding combined floating point multiply and add functionality.

Figure IB is a block diagram of another embodiment of a system that executes instructions for providing double rounding combined floating point multiply and add functions.

Figure 1C is a block diagram of another embodiment of a system that executes instructions for providing double rounding combined floating point multiply and add functionality.

Figure 2 is a block diagram of one embodiment of a processor executing instructions for providing double rounded combined floating point multiply and add functionality.

Figure 3A illustrates a packed data type according to one embodiment.

Figure 3B illustrates a packed data type according to one embodiment.

Figure 3C illustrates a packed data type according to one embodiment.

Figure 3D illustrates instruction encoding for providing double rounded combined floating point multiply and add functionality, according to one embodiment.

Figure 3E illustrates instruction encoding for providing double rounding combined floating point multiply and add functionality, according to another embodiment.

Figure 3F illustrates instruction encoding for providing double rounding combined floating point multiply and add functionality, according to another embodiment.

FIG. 3G illustrates instruction encoding for providing double rounding combined floating point multiply and add functionality, according to another embodiment.

Figure 3H illustrates instruction encoding for providing double rounding combined floating point multiply and add functionality, according to another embodiment.

Figure 4A shows elements of one embodiment of a processor microarchitecture for executing instructions that provide double rounded combined floating point multiply and add functionality.

Figure 4B shows elements of another embodiment of a processor microarchitecture for executing instructions that provide double rounding combined floating point multiply and add functionality.

Figure 5 is a block diagram of one embodiment of a processor for executing instructions that provide double rounding combined floating point multiply and add functionality.

Figure 6 is a block diagram of one embodiment of a computer system for executing instructions that provide double rounding combined floating point multiply and add functionality.

7 is a block diagram of another embodiment of a computer system for executing instructions that provide double rounding combined floating point multiply and add functionality.

Figure 8 is a block diagram of another embodiment of a computer system for executing instructions that provide double rounding combined floating point multiply and add functionality.

Figure 9 is a block diagram of one embodiment of a system-on-a-chip for executing instructions that provide double rounding combined floating point multiply and add functions.

Figure 10 is a block diagram of one embodiment of a processor for executing instructions that provide double rounding combined floating point multiply and add functionality.

Figure 11 is a block diagram of one embodiment of an IP core development system that provides double rounding combined floating point multiply and add functionality.

Figure 12 illustrates one embodiment of an architectural emulation system that provides double rounding combined floating point multiply and add functionality.

Figure 13 illustrates one embodiment of a system for converting instructions that provide double rounding combined floating point multiply and add functionality.

Figure 14A illustrates one embodiment of an apparatus for executing an instruction that provides double rounding combined floating point multiply and add functionality.

Figure 14B illustrates another embodiment of means for executing an instruction that provides double rounding combined floating point multiply and add functionality.

Figure 15 shows a flow diagram of one embodiment of a process for providing double rounding combined floating point multiply and add (or subtract or convert) functionality.

Figure 16A shows a flowchart of an alternate embodiment of a process for providing double rounding combined floating point multiply and add functionality.

Figure 16B shows a flow diagram of an alternate embodiment of a process for providing double rounding combined floating point multiply and subtract functions.

Detailed ways

The following description discloses instructions and processing logic for providing double rounded combined floating point multiply and add functionality within or in association with a processor, computer system, or other processing apparatus. Algorithms written with a single floating-point (FP) multiply operation followed by an add operation can expect IEEE-compatible rounding of the result in each operation. Thus, for example, simply replacing pairwise multiply and add with fused FP multiply-add operations may not always be desirable, even if there is hardware available to compute fused FP multiply-add operations.

The novel methods, apparatus, instructions and logic disclosed in this application provide double rounding combined floating point multiply and add, multiply and subtract, or multiply and convert as scalar or vector SIMD instructions or fused micro-operations. Some method embodiments include detecting FP multiplication operations and subsequent FP operations (eg, such as addition, subtraction, or conversion) that specify the result of the FP multiplication as a source operand. The FP multiplication and the subsequent FP operation are fused and encoded as a combined FP operation, including rounding the result of the FP multiplication before applying the subsequent FP operation. Combined floating-point multiply and add (or subtract, or convert) operations can be used in place of separate multiply and add (or subtract, or convert) instructions, through recompilation or through dynamic fusion at runtime, thereby reducing latency And improve the efficiency of instruction execution.

An encoding of the combined FP operation may be stored and executed as part of the executable thread portion using fused multiply-add hardware including: overflow detection on the product of the FP multiplier , first and second FP adders for adding the third operand addend mantissa to the product of the FP multiplier with different rounding inputs based on overflow or no overflow in the product of the FP multiplier. The final result is then selected accordingly using the overflow signal from the overflow detection.

Therefore, latency can be reduced and instruction execution efficiency can be improved by recompilation or by dynamic fusion of runtime in software translation or hardware.

In the following description, various specific details such as processing logic, processor type, microarchitecture conditions, events, enabling mechanisms, etc. are set forth to provide a more thorough understanding of the embodiments of the present invention. However, it will be understood by those skilled in the art that the present invention may be practiced without these specific details. In addition, some well-known structures, circuits, etc. have not been shown in detail to avoid unnecessarily obscuring the embodiments of the invention.

Although the embodiments described below are described with reference to processors, other embodiments are applicable to other types of integrated circuits and logic devices. Similar techniques and teachings of embodiments of the present invention may be applied to other types of circuits or semiconductor devices that may also benefit from higher pipeline throughput and improved performance. The teachings of the embodiments of the invention are applicable to any processor or machine that performs data manipulation. However, the present invention is not limited to processors or machines that perform operations on 512-bit, 256-bit, 128-bit, 64-bit, 32-bit, or 16-bit data, and is applicable to any processor and machine that perform data manipulation or management. Furthermore, the following description provides examples, and the accompanying drawings show examples for illustrative purposes. However, these examples should not be construed in a limiting sense, as they are merely intended to provide illustrations of various embodiments of the invention, and are not exhaustive of all possible implementations of embodiments of the invention.

While the following examples describe instruction processing and dispatch in the context of execution units and logic circuits, other embodiments of the invention can also be implemented as data or instructions stored on a machine-readable tangible medium that When executed by a machine, causes the machine to perform functions consistent with at least one embodiment of the invention. In one embodiment, functions associated with embodiments of the present invention are embodied in machine-executable instructions. These instructions can be used to cause a general purpose processor or a special purpose processor programmed with these instructions to perform the steps of the present invention. Embodiments of the present invention may also be provided as a computer program product or software, which may include a machine or computer-readable medium having stored thereon instructions that can be used to instruct a computer (or other electronic device) to be programmed to perform one or more operations according to embodiments of the present invention. Alternatively, the steps of the various embodiments of the invention may be performed by dedicated hardware components containing fixed-function logic for performing the steps, or by any combination of programmed computer components and fixed-function hardware components.

Instructions used to program logic to perform embodiments of the invention may be stored in memory in the system, such as DRAM, cache, flash memory, or other memory. Further, instructions may be distributed via a network or other computer-readable media. Thus, a computer-readable medium may include any mechanism for storing or transmitting information in a format readable by a machine such as a computer, but is not limited to: floppy disk, optical disk, compact disk read-only memory (CD-ROM), magneto-optical disk , read-only memory (ROM), random-access memory (RAM), erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), magnetic or optical cards, flash memory, or in Tangible machine-readable memory used in sending information via the Internet by electrical, optical, acoustic, or other forms of transfer signals (such as carrier waves, infrared signals, digital signals, etc.). Thus, a computer-readable medium includes any type of tangible machine-readable medium for storing or transmitting electronic instructions or information in a form readable by a machine (eg, a computer).

Designs go through multiple stages, from innovation to simulation to manufacturing. Data representing a design may represent the design in a number of ways. First, hardware may be represented using a hardware description language or other functional description language, as would be useful in simulations. Additionally, circuit-level models with logic and/or transistor gates can be generated at other stages of the design flow. Furthermore, most designs at some stage reach the level of data representing the physical configuration of the various devices in the hardware model. Using conventional semiconductor fabrication techniques, the data representing the hardware model may be data indicating the presence or absence of different features on different mask layers for the masks used to create the integrated circuit. In any design representation, data may be stored on any form of machine-readable media. Memory or magnetic/optical storage, such as a disk, may be a machine-readable medium that stores information transmitted via optical or electrical waves that are modulated or otherwise generated to convey the information. Making a new copy when performing duplication, buffering or retransmission of electrical signals when sending instructions or electrical carriers carrying codes or designs. Accordingly, a communications provider or network provider would store, at least temporarily, on a tangible machine-readable medium an item embodying techniques of embodiments of the present invention (such as information encoded in a carrier wave).

In modern processors, a number of different execution units are used to process and execute various codes and instructions. Not all instructions are created equally, as some are completed faster and others take multiple clock cycles to complete. The faster the throughput of instructions, the better the overall performance of the processor. Therefore, it would be advantageous to have a large number of instructions execute as quickly as possible. However, certain instructions have greater complexity and require more execution time and processor resources. For example, there are floating point instructions, load/store operations, data movement, and so on.

As more computer systems are used for Internet, text, and multimedia applications, more processor support is gradually introduced. In one embodiment, an instruction set may be associated with one or more computer architectures, including data types, instructions, register architecture, addressing modes, memory architecture, interrupt and exception handling, and external input and output ( I/O).

In one embodiment, an instruction set architecture (ISA) may be implemented by one or more microarchitectures, which include processor logic and circuitry for implementing one or more instruction sets. Thus, processors with different microarchitectures may share at least a portion of a common instruction set. For example, Pentium 4 (Pentium 4) processor, The Core ^TM processor, as well as many processors from Advanced MicroDevices, Inc. of Sunnyvale, Calif., execute nearly identical versions of the x86 instruction set (in later versions Added some extensions), but with a different internal design. Similarly, processors designed by other processor development companies such as ARM Holdings, MIPS, or their licensors or compatibles may share at least a portion of a common instruction set, but may include different processor designs. For example, the same register architecture of an ISA may be implemented in different ways in different microarchitectures using new or known techniques, including dedicated physical registers, using register renaming mechanisms such as using register alias table RAT, reorder buffer One or more dynamically allocated physical registers of register ROB, and retirement register set). In one embodiment, registers may include: one or more registers, register architecture, register bank, or other collection of registers that may or may not be addressable by a software programmer.

In one embodiment, an instruction may include one or more instruction formats. In one embodiment, an instruction format may indicate a number of fields (number of bits, position of bits, etc.) to specify the operation to be performed and the operands of the operation to be performed. Some instruction formats can be further defined by instruction templates (or sub-formats). For example, instruction templates for a given instruction format may be defined to have different subsets of instruction format fields, and/or be defined to have different interpretations of a given field. In one embodiment, an instruction is represented using an instruction format (and, if defined, a given instruction template for that instruction format) and specifies or indicates the operation and the operands on which the operation will operate.

Scientific applications, financial applications, automatic vectorization general applications, RMS (recognition, mining and synthesis) applications, and vision and multimedia applications (such as, 2D/3D graphics, image processing, video compression/decompression, speech recognition algorithms and audio processing) It may be necessary to perform the same operation on a large number of data items. In one embodiment, Single Instruction Multiple Data (SIMD) refers to a type of instruction that causes a processor to perform an operation on multiple data elements. SIMD techniques can be used in processors that logically divide bits in a register into multiple fixed-size or variable-size data elements, each data element representing a separate value. For example, in one embodiment, the bits in a 64-bit register may be organized as a source operand containing four separate 16-bit data elements, each data element representing a separate 16-bit value. This data type may be referred to as a "packed" data type or a "vector" data type, and operands of this data type are referred to as packed data operands or vector operands. In one embodiment, a packed data item or vector may be a sequence of packed data elements stored in a single register, and a packed data operand or vector operand may be a SIMD instruction (or "packed data instruction" or "vector instruction" ) source or destination operand. In one embodiment, a SIMD instruction specifies a single vector operation to be performed on two source vector operands to produce data elements of the same or different size, with the same or different number of data elements, with the same or different order of data elements The destination vector operand (also known as the result vector operand).

such as by Core (Core ^™ ) processors (with instruction sets including x86, MMX ^™ , Streaming SIMD Extensions (SSE), SSE2, SSE3, SSE4.1, SSE4.2 instructions), ARM processors (such as ARM Processor family having an instruction set including vector floating point (VFP) and/or NEON instructions), MIPS processors (such as the Godson family of processors developed by the Institute of Computer Technology (ICT) of the Chinese Academy of Sciences) using SIMD technology (Core ^™ and MMX ^™ are registered trademarks or trademarks of Intel Corporation, Santa Clara, California).

In one embodiment, destination register/data and source register/data are generic terms denoting the source and destination of corresponding data or operations. In some embodiments, they may be implemented by registers, memory, or other storage areas having different names or functions than those shown. For example, in one embodiment, "DEST1" may be a temporary storage register or other storage area, while "SRC1" and "SRC2" are the first and second source storage registers or other storage areas, and so on. In other embodiments, two or more of the SRC and DEST memory regions may correspond to different data storage elements (eg, SIMD registers) in the same memory region. In one embodiment, one of the source registers may also serve as the destination register, for example by writing back the result of an operation performed on the first and second source data to the one of the two source registers that serves as the destination register.

Figure 1A is a block diagram of an exemplary computer system having a processor including an execution unit to execute instructions, according to one embodiment of the invention. According to the present invention, such as according to the embodiments described herein, the system 100 includes components, such as a processor 102, to employ execution units including logic to execute algorithms to process data. System 100 represents a system based on a III. 4. Xeon ^tm , Processing systems with XScale ^™ and/or StrongARM ^™ microprocessors, although other systems (including PCs with other microprocessors, engineering workstations, set-top boxes, etc.) may also be used. In one embodiment, sample system 100 may execute a version of the WINDOWS ^tm operating system available from Microsoft Corporation of Redmond, Washington, USA, although other operating systems (such as UNIX and Linux), embedded software, and/or graphical user interface. Thus, embodiments of the invention are not limited to any specific combination of hardware and software.

Embodiments are not limited to computer systems. Alternative embodiments of the present invention may be used in other devices, such as handheld devices and embedded applications. Some examples of handheld devices include: cellular phones, internet protocol devices, digital cameras, personal digital assistants (PDAs), handheld PCs. An embedded application may include a microcontroller, a digital signal processor (DSP), a system-on-a-chip, a network computer (NetPC), a set-top box, a network backbone, a wide area network (WAN) switch, or one or Any other system with multiple instructions.

1A is a block diagram of a computer system 100 formed with a processor 102 including one or more execution units 108 to execute algorithms to execute at least one instruction according to one embodiment of the invention. One embodiment is described with reference to a single-processor desktop or server system, but alternative embodiments may be included in multi-processor systems. System 100 is an example of a "hub" system architecture. Computer system 100 includes a processor 102 to process data signals. The processor 102 may be a Complex Instruction Set Computer (CISC) microprocessor, a Reduced Instruction Set Computing (RISC) microprocessor, a Very Long Instruction Word (VLIW) microprocessor, a processor implementing a combination of instruction sets, or any other processor devices (such as digital signal processors). Processor 102 is coupled to processor bus 110 , which may carry data signals between processor 102 and other components within system 100 . The various elements of system 100 perform conventional functions well known in the art.

In one embodiment, processor 102 includes a first level (L1) internal cache memory 104 . Depending on architecture, processor 102 may have a single internal cache or multiple levels of internal cache. Alternatively, in another embodiment, the cache memory may be located external to the processor 102 . Other embodiments may also include a combination of internal and external caches, depending on specific implementations and requirements. The register file 106 can store different types of data in multiple registers (including integer registers, floating point registers, status registers, instruction pointer registers).

Also located in processor 102 is an execution unit 108 , which includes logic to perform integer and floating point operations. Processor 102 also includes a microcode (ucode) ROM that stores microcode for specific macroinstructions. For one embodiment, execution unit 108 includes logic to process packed instruction set 109 . By including packed instruction set 109 within the instruction set of general purpose processor 102 and associated circuitry to execute these instructions, packed data in general purpose processor 102 can be used to perform operations used by many multimedia applications. As a result, many multimedia applications can be accelerated and execute more efficiently by using the full bandwidth of the processor's data bus to operate on packed data. This can reduce the need to transfer smaller data units on the processor data bus to perform one or more operations on one data element at a time.

Alternative embodiments of execution unit 108 may also be used in microcontrollers, embedded processors, graphics devices, DSPs, and other types of logic circuits. System 100 includes memory 120 . Memory device 120 may be a dynamic random access memory (DRAM) device, a static random access memory (SRAM) device, a flash memory device, or other memory device. Memory 120 may store instructions and/or data executable by processor 102, data being represented by data signals.

System logic chip 116 is coupled to processor bus 110 and memory 120 . The system logic chip 116 in the illustrated embodiment is a memory controller hub (MCH). Processor 102 may communicate with MCH 116 via processor bus 110. MCH 116 provides a high bandwidth memory path 118 to memory 120 for instruction and data storage, and for storing graphics commands, data, and textures. MCH 116 is used to direct data signals between processor 102, memory 120, and other components within system 100, and to bridge data signals between processor bus 110, memory 120, and system I/O 122. In some embodiments, system logic chip 116 may provide a graphics port coupled to graphics controller 112 . MCH 116 is coupled to memory 120 via memory interface 118. Graphics card 112 is coupled to MCH 116 through accelerated graphics port (AGP) interconnect 114.

System 100 uses peripheral hub interface bus 122 to couple MCH 116 to I/O controller hub (ICH) 130. The ICH 130 provides direct connections to some I/O devices via the local I/O bus. The local I/O bus is a high-speed I/O bus used to connect peripheral devices to memory 120 , chipset, and processor 102 . Some examples are audio controller, firmware hub (flash BIOS) 128, wireless transceiver 126, data storage 124, legacy I/O controller including user input and keyboard interface, serial expansion port (such as Universal Serial Bus USB) and network controller 134 . Data storage devices 124 may include hard drives, floppy drives, CD-ROM devices, flash memory devices, or other mass storage devices.

For another embodiment of the system, instructions according to one embodiment may be used in a system on a chip. One embodiment of a system on a chip includes a processor and memory. The memory used in such a system is flash memory. Flash memory can be on the same die as the processor and other system components. Additionally, other logic blocks such as memory controllers or graphics controllers may also be located on the system-on-chip.

Figure IB illustrates data processing system 140 implementing the principles of one embodiment of the present invention. Those skilled in the art will readily appreciate that the various embodiments described herein may be used in alternative processing systems without departing from the scope of the embodiments of the present invention.

Computer system 140 includes processing core 159 capable of executing at least one instruction according to one embodiment. For one embodiment, processing core 159 represents a processing unit of any type of architecture, including but not limited to: CISC, RISC, or VLIW type architectures. Processing core 159 may also be adapted to be fabricated in one or more processing technologies, and may be facilitated by being represented in sufficient detail on a machine-readable medium.

The processing core 159 includes an execution unit 142 , a set of registers 145 and a decoder 144 . Processing core 159 also includes additional circuitry (not shown) that is not necessary to understand embodiments of the present invention. The execution unit 142 is configured to execute instructions received by the processing core 159 . In addition to executing typical processor instructions, execution unit 142 is also capable of executing instructions in packed instruction set 143 for performing operations on packed data formats. Packed instruction set 143 includes instructions for performing embodiments of the present invention, as well as other packed instructions. Execution unit 142 is coupled to register bank 145 via an internal bus. Register set 145 represents a memory area on processing core 159 for storing information, including data. As mentioned above, it can be understood that it is not critical that the storage area is used to store packed data. Execution unit 142 is coupled to decoder 144 . The decoder 144 is used to decode instructions received by the processing core 159 into control signals and/or microcode entry points. In response to these control signals and/or microcode entry points, execution unit 142 performs the appropriate operations. In one embodiment, a decoder is used to interpret an instruction's opcode, which indicates what operation should be performed on corresponding data indicated within the instruction.

Processing core 159 is coupled to bus 141 for communicating with a number of other system devices including, but not limited to, for example, synchronous dynamic random access memory (SDRAM) controller 146, static random access memory (SRAM) Controller 147, Burst Flash Interface 148, Personal Computer Memory Card International Association (PCMCIA)/Compact Flash (CF) Card Controller 149, Liquid Crystal Display (LCD) Controller 150, Direct Memory Access (DMA) Controller 151, and Alternate bus master interface 152 . In one embodiment, data processing system 140 also includes I/O bridge 154 for communicating with a plurality of I/O devices via I/O bus 153 . Such I/O devices may include, but are not limited to, universal asynchronous receiver/transmitter (UART) 155, universal serial bus (USB) 156, Bluetooth wireless UART 157, and I/O expansion interface 158, for example.

One embodiment of the data processing system 140 provides mobile communications, network communications, and/or wireless communications, and provides a processing core 159 capable of performing SIMD operations, including vector mixing and permutation functions. The processing core 159 is programmable with a variety of audio, video, image, and communication algorithms, including discrete transforms (such as Walsh-Hadamard transforms, fast Fourier transforms (FFTs), discrete cosine transforms (DCTs), and their corresponding inverse transforms), compression /decompression techniques (such as color space transformation), video encoding motion estimation or video decoding motion compensation, and modulation/demodulation (MODEM) functions (such as pulse code modulation PCM).

Figure 1C illustrates a further alternative embodiment of a data processing system capable of executing instructions for providing double rounded combined floating point multiply and add functions. According to an alternative embodiment, data processing system 160 may include main processor 166 , SIMD coprocessor 161 , cache processor 167 , and input/output system 168 . Input/output system 168 is optionally coupled to wireless interface 169 . SIMD coprocessor 161 is capable of performing operations including instructions according to one embodiment. Processing core 170 may be adapted for fabrication in one or more processing technologies, and may be facilitated in fabrication of all or a portion of data processing system 160 including processing core 170 by being represented in sufficient detail on a machine-readable medium.

For one embodiment, the SIMD coprocessor 161 includes an execution unit 162 and a set of register files 164 . One embodiment of the main processor 166 includes a decoder 165 for identifying instructions of an instruction set 163 comprising instructions for execution by the execution unit 162 according to one embodiment. For an alternate embodiment, SIMD coprocessor 161 also includes at least a portion of decoder 165B to decode instructions of instruction set 163 . Processing core 170 also includes additional circuitry (not shown) that is not necessary to understand embodiments of the present invention.

In operation, main processor 166 executes data processing instruction streams that control general types of data processing operations, including interaction with cache memory 167 and input/input system 168 . SIMD coprocessor instructions are embedded in the stream of data processing instructions. The decoder 165 of the main processor 166 recognizes these SIMD coprocessor instructions as the type that should be executed by the attached SIMD coprocessor 161 . Accordingly, main processor 166 issues these SIMD coprocessor instructions (or control signals representing SIMD coprocessor instructions) on coprocessor bus 171 from which any attached SIMD coprocessors receive them. instruction. In this case, the SIMD coprocessor 161 will accept and execute any received SIMD coprocessor instructions for that SIMD coprocessor.

Data may be received via wireless interface 169 for processing by SIMD coprocessor instructions. For one example, a voice communication may be received in the form of a digital signal that will be processed by SIMD coprocessor instructions to regenerate digital audio samples representative of the voice communication. For another example, compressed audio and/or video may be received in the form of a digital bit stream to be processed by SIMD coprocessor instructions to regenerate digital audio samples and/or motion video frames. For one embodiment of processing core 170, main processor 166 and SIMD coprocessor 161 are integrated into a single processing core 170 that includes an execution unit 162, a set of register files 164, and a decoder 165 to identify Instructions of an instruction set 163 comprising instructions according to one embodiment.

FIG. 2 is a block diagram of the microarchitecture of a processor 200 including logic circuits to execute instructions according to one embodiment of the invention. In some embodiments, instructions according to one embodiment may be implemented as instructions having byte size, word size, double word size, quad word size, etc. and data types such as single and double precision integers and floating point data type) to perform operations on data elements. In one embodiment, in-order front end 201 is the portion of processor 200 that fetches instructions to be executed and prepares them for later use by the processor pipeline. Front end 201 may include various units. In one embodiment, instruction prefetcher 226 fetches instructions from memory and feeds the instructions to instruction decoder 228 , which then decodes or interprets the instructions. For example, in one embodiment, a decoder decodes received instructions into machine-executable one or more operations called "microinstructions" or "micro-operations" (also called micro-operands or uops) . In other embodiments, the decoder parses the instructions into opcodes and corresponding data and control fields, which are used by the micro-architecture to perform operations according to one embodiment. In one embodiment, trace cache 230 accepts decoded uops and assembles them into a program ordered sequence or trace in uop queue 234 for execution. When trace cache 230 encounters a complex instruction, microcode ROM 232 provides the micro-operations needed to complete the operation.

Some instructions are translated into a single micro-op, while others require several micro-ops to complete the entire operation. In one embodiment, if more than four micro-ops are required to complete the instruction, decoder 228 accesses microcode ROM 232 for the instruction. For one embodiment, an instruction may be decoded into a small number of micro-ops for processing at instruction decoder 228 . In another embodiment, instructions may be stored in microcode ROM 232 if several micro-ops are required to complete the operation. Trace cache 230 references the entry point programmable logic array (PLA) to determine the correct microinstruction pointer to read the microcode sequence from microcode ROM 232 to complete one or more instructions according to one embodiment. After the microcode ROM 232 finishes serializing micro-ops for instructions, the front end 201 of the machine resumes fetching micro-ops from the trace cache 230.

The out-of-order execution engine 203 is the unit that prepares instructions for execution. The out-of-order execution logic has several buffers for smoothing and reordering the instruction stream to optimize the performance after the instruction stream enters the pipeline, and to schedule the instruction stream for execution. The allocator logic allocates the machine buffers and resources required by each uop for execution. Register renaming logic renames logical registers as entries in the register bank. Before the instruction scheduler (memory scheduler, fast scheduler 202, slow/general purpose floating point scheduler 204, simple floating point scheduler 206), the allocator also allocates each micro-op's entry into two micro-op queues One of the queues, one for memory operations and the other for non-memory operations. The uop schedulers 202, 204, 206 determine when uops are ready for execution based on the readiness of their dependent input register operand sources and the availability of execution resources needed by the uops to complete their operations. The fast scheduler 202 of one embodiment may schedule on every half of the main clock cycle, while other schedulers may only schedule once per main processor clock cycle. The scheduler arbitrates the allocation ports to schedule uops for execution.

Register banks 208 , 210 are located between schedulers 202 , 204 , 206 and execution units 212 , 214 , 216 , 218 , 220 , 222 , 224 in execution block 211 . There are also separate register banks 208, 210 for integer and floating point operations respectively. Each register file 208, 210 of one embodiment also includes a bypass network that bypasses or forwards just completed results that have not yet been written to the register file to new dependent micro-operations. Integer register file 208 and floating point register file 210 are also capable of communicating data with each other. For one embodiment, the integer register bank 208 is divided into two separate register banks, one register bank for low-order 32-bit data and a second register bank for high-order 32-bit data. The floating point register file 210 of one embodiment has entries that are 128 bits wide because floating point instructions typically have operands from 64 to 128 bits wide.

Execution block 211 includes execution units 212 , 214 , 216 , 218 , 220 , 222 , 224 in which instructions are actually executed. This block includes register banks 208, 210 that store integer and floating point data operand values that the microinstructions need to execute. Processor 200 of one embodiment is comprised of multiple execution units: Address Generation Unit (AGU) 212, AGU 214, Fast ALU (Arithmetic Logic Unit) 216, Fast ALU 218, Slow ALU 220, Floating Point ALU 222, Floating Point Mobile unit 224. For one embodiment, floating point execution blocks 222, 224 perform floating point, MMX, SIMD, SSE, and other operations. The floating-point ALU 222 of one embodiment includes a 64-bit/64-bit floating-point divider for performing divide, square root, and remainder micro-operations. For embodiments of the invention, instructions involving floating point values may be processed using floating point hardware. In one embodiment, ALU operations enter high-speed ALU execution units 216,218. The high-speed ALUs 216, 218 of one embodiment can perform high-speed operations with an effective latency of half a clock cycle. For one embodiment, most complex integer operations go into the slow ALU 220 because the slow ALU 220 includes integer execution hardware for long-latency type operations, such as multipliers, shifters, flag logic, and branch processing. Memory load/store operations are performed by the AGUs 212, 214. For one embodiment, the integer ALUs 216, 218, 220 are described as performing integer operations on 64-bit data operands. In alternative embodiments, the ALUs 216, 218, 220 may be implemented to support a wide range of data bits, including 16, 32, 128, 256, etc. Similarly, floating point units 222, 224 may be implemented to support operand ranges having various widths of bits. For one embodiment, the floating point units 222, 224 may operate on 128-bit wide packed data operands in conjunction with SIMD and multimedia instructions.

In one embodiment, the uop scheduler 202, 204, 206 dispatches dependent operations before the parent load finishes executing. Because uops are speculatively scheduled and executed in processor 200, processor 200 also includes logic to handle memory misses. If a data load misses in the data cache, there may be dependent operations that leave the scheduler with temporarily bad data and run in the pipeline. The replay mechanism tracks instructions that use erroneous data and re-executes them. Only dependent operations need to be replayed, while independent operations are allowed to complete. The scheduler and replay mechanism of one embodiment of the processor is also designed to catch instructions that provide transitions between mask registers and general registers.

The term "register" refers to on-board processor storage locations used as part of an instruction to identify operands. In other words, registers are those processor storage locations that are available outside of the processor (from the programmer's perspective). However, the registers of an embodiment are not limited to representing a particular type of circuitry. In contrast, the registers of an embodiment are capable of storing and providing data and performing the functions described herein. The registers described herein may be implemented by circuitry in the processor using any number of different techniques, such as dedicated physical registers, dynamically allocated physical registers using register renaming, a combination of dedicated and dynamically allocated physical registers, and so on. In one embodiment, the integer registers store thirty-two bits of integer data. The register bank of one embodiment also contains eight multimedia SIMD registers for packing data. For the following discussion, registers should be understood as data registers designed to hold packed data, such as the 64-bit wide ^MMXtm registers (in some instances Also known as "mm registers) in . These MMX registers (available in both integer and floating-point formats) operate with packed data elements that accompany SIMD and SSE instructions. Similarly, 128-bit wide XMM registers involving SSE2, SSE3, SSE4, or newer technologies (collectively "SSEx") may also be used to hold such packed data operands. In one embodiment, when storing packed data and integer data, the register does not need to distinguish between these two types of data types. In one embodiment, integer and floating point data may be included in the same register bank, or in different register banks. Further, in one embodiment, floating point and integer data may be stored in different registers, or stored in the same register.

In the examples of the figures described below, a plurality of data operands are depicted. Figure 3A illustrates various packed data type representations in a multimedia register according to one embodiment of the invention. FIG. 3A shows packed byte 310 , packed word 320 , packed double word (dword) 330 data types for 128-bit wide operands. The packed bytes format 310 of this example is 128 bits long and contains sixteen packed bytes data elements. A byte is defined herein to be 8-bit data. The information for each byte data element is stored: for byte 0 in bit 7 to bit 0, for byte 1 in bit 15 to bit 8, for byte 2 in bit 23 to bit 16, and finally for byte 15 Stored in bits 120 to 127. Therefore, all available bits are used in this register. This storage configuration improves the storage efficiency of the processor. Also, because sixteen data elements are accessed, one operation can now be performed on sixteen data elements in parallel.

Typically, a data element is a separate piece of data stored with other data elements of the same length in a single register or memory location. In packed data sequences involving SSEx techniques, the number of data elements stored in an XMM register is 128 bits divided by the bit length of a single data element. Similarly, in packed data sequences involving MMX and SSE techniques, the number of data elements stored in an MMX register is 64 bits divided by the bit length of a single data element. Although the data type shown in FIG. 3A is 128 bits long, embodiments of the invention can operate on operands that are 64 bits wide, 256 bits wide, 512 bits wide, or other sizes. The packed word format 320 of this example is 128 bits long and contains eight packed word data elements. Each packed word contains sixteen bits of information. The packed doubleword format 330 of FIG. 3A is 128 bits long and contains four packed doubleword data elements. Each packed doubleword data element contains thirty-two bits of information. A packed quadword is 128 bits long and contains two packed quadword data elements.

Figure 3B shows an alternative in-register data storage format. Each packed data may include more than one individual data element. Three packed data formats are shown: packed half data elements 314 , packed single data elements 342 , and packed double data elements 343 . One embodiment of packed half data elements 341 , packed single data elements 342 , packed double data elements 343 includes fixed point data elements. For alternative embodiments, one or more of packed half data elements 341 , packed single data elements 342 , packed double data elements 343 may contain floating point data elements. An alternate embodiment of packed half-data elements 341 is one hundred and twenty-eight bits long, containing eight 16-bit data elements. An alternate embodiment of packed single data element 342 is one hundred and twenty-eight bits long and contains four 32-bit data elements. One embodiment of packed double data element 343 is one hundred and twenty-eight bits long and contains two 64-bit data elements. It can be appreciated that such a packed data format can be further extended to other register lengths, for example, 96 bits, 160 bits, 192 bits, 224 bits, 256 bits, 512 bits or longer.

Figure 3C illustrates various signed and unsigned packed data type representations in a multimedia register according to one embodiment of the invention. Unsigned packed byte representation 344 shows the storage of unsigned packed bytes in a SIMD register. The information for each byte data element is stored as bit 7 through bit 0 for byte 0, bit 15 through bit 8 for byte 1, bit 23 through bit 16 for byte 2, etc., and finally for Byte 15 is stored in bits 120 through 127. Therefore, all available bits are used in this register. This storage configuration improves the storage efficiency of the processor. Also, because sixteen data elements are accessed, one operation can be performed on sixteen data elements in parallel. Signed packed byte representation 345 shows the storage of signed packed bytes. Note that the eighth bit of each byte data element is the sign indicator. Unsigned packed word representation 346 shows how word 7 through word 0 are stored in a SIMD register. The signed packed word representation 347 is similar to the unsigned packed word in-register representation 346 . Note that the sixteenth bit of each word data element is a sign indicator. Unsigned packed doubleword representation 348 shows how doubleword data elements are stored. The signed packed dword representation 349 is similar to the unsigned packed dword in-register representation 348 . Note that the necessary sign bit is the thirty-second bit of each doubleword data element.

Figure 3D is compared with "Intel.com/products/processor/manuals/" 64 and IA-32 Intel Architecture Software Developer's Manual Combined Volumes 2A and 2B: Instruction Set Reference AZ (Intel Architecture Software Developer's Manual Combined Volumes 2A and 2B: Instruction SetReference AZ)" The opcode format type described in the corresponding has 32 or A description of one embodiment of a more bit operation code (opcode) format 360 and register/memory operand addressing modes. In one embodiment, instructions may be encoded by one or more fields 361 and 362. Can Identify up to two operand locations per instruction, including up to two source operand identifiers 364 and 365. For one embodiment, destination operand identifier 366 is the same as source operand identifier 364, while in other embodiments They are not the same. For alternative embodiments, destination operand identifier 366 is the same as source operand identifier 365, while in other embodiments they are not. In one embodiment, source operand identifier 364 and One of the source operands identified by 365 is overwritten by the result of the instruction, while in other embodiments, identifier 364 corresponds to a source register element and identifier 365 corresponds to a destination register element. For one embodiment, Operand identifiers 364 and 365 may be used to identify 32-bit or 64-bit source and destination operands.

FIG. 3E shows another alternative operation code (opcode) format 370 having forty or more bits. Opcode format 370 corresponds to opcode format 360 and includes optional prefix byte 378 . Instructions according to one embodiment may be encoded by one or more of fields 378 , 371 and 372 . Through source operand identifiers 374 and 375 and through prefix byte 378, up to two operand locations in each instruction may be identified. For one embodiment, prefix byte 378 may be used to identify 32-bit or 64-bit source and destination operands. For one embodiment, the destination operand identifier 376 is the same as the source operand identifier 374, while in other embodiments they are not. For alternative embodiments, destination operand identifier 376 is the same as source operand identifier 375, while in other embodiments they are not. In one embodiment, the instruction operates on one or more operands identified by operand identifiers 374 and 375, and the one or more operands identified by operand identifiers 374 and 375 are However, in other embodiments, the operands identified by identifiers 374 and 375 are written to another data element in another register. Opcode formats 360 and 370 allow register-to-register addressing, memory to Register addressing, memory-to-register addressing, register-to-register addressing, direct register addressing, register-to-memory addressing.

Turning next to FIG. 3F, in some alternative embodiments, 64-bit (or 128-bit, or 256-bit, or 512-bit or more) single-instruction multiple-data (SIMD) arithmetic operations may be performed via coprocessor data processing (CDP ) command to execute. Operation encoding (opcode) format 380 shows one such CDP instruction with CDP opcode fields 382 and 389 . This type of CDP instruction operation may be encoded by one or more of fields 383 , 384 , 387 and 388 for alternate embodiments. Up to three operand locations may be identified per instruction, including up to two source operand identifiers 385 and 390 and one destination operand identifier 386 . One embodiment of the coprocessor can operate on 8, 16, 32 and 64 bit values. For one embodiment, instructions are performed on integer data elements. In some embodiments, using condition field 381, instructions may be executed conditionally. For some embodiments, the source data size may be encoded by field 383 . In some embodiments, zero (Z), negative (N), carry (C) and overflow (V) detection may be performed on SIMD fields. For some instructions, the saturation type may be encoded by field 384 .

Turning next to FIG. 3G , which depicts a process in accordance with another embodiment with the " Advanced Vector Extensions Programming Reference ( Another alternative operation code (opcode) format 397 for providing double-rounded combined floating-point multiply and add functionality corresponding to the type of opcode format described in Advanced Vector Extensions Programming Reference).

The original x86 instruction set provided multiple address byte (syllable) formats to 1-byte opcodes and direct operands contained in additional bytes, where the address of the additional byte is known from the first "opcode" byte exist. Additionally, specific byte values are reserved for opcodes as modifiers (called prefixes because they are placed before instructions). When the original configuration of 256 opcode bytes (including these special prefix values) is exhausted, specify a single byte to escape to the new set of 256 opcodes. Because of the addition of vector instructions (such as SIMD), more opcodes need to be generated even after expansion by using prefixes, and the "two-byte" opcode mapping is no longer enough. To do this, new instructions are added to additional maps that use two bytes plus an optional prefix as identifiers.

In addition, to facilitate the implementation of additional registers in 64-bit mode, an extra prefix (called "REX") is used between the prefix and the opcode (and any escape bytes needed to determine the opcode) . In one embodiment, REX has 4 "payload" bits to indicate the use of additional registers in 64-bit mode. In other embodiments, there may be fewer or more bits than 4 bits. The general format (corresponding generally to format 360 and/or format 370) of at least one instruction set is shown generally as follows:

[prefixes][rex]escape[escape2]opcode modrm(etc)

Opcode format 397 corresponds to opcode format 370 and includes optional VEX prefix bytes 391 (in one embodiment, starting with C4 or C5 hexadecimal) to replace most other commonly used legacy instructions Prefix bytes and escape codes. For example, the following illustrates an embodiment using two fields to encode an instruction, which can be used when there is no second escape code in the original instruction. In the example shown below, legacy bounces are represented by new bounce values, legacy prefixes are fully compressed as part of the "payload" bytes, legacy prefixes are re-stated and available for future extensions, and Added new features (such as increased vector lengths and additional source register specifiers).

When there is a second jump code in the original instruction, or when extra bits in the REX field (such as the XB and W fields) need to be used. In an alternative embodiment shown below, the first legacy breakout and legacy prefix are compressed similarly as above, and the second breakout code is compressed in the "map" field, and if a future map or feature space is available, the new Add new features (such as increased vector lengths and additional source register specifiers).

Instructions according to one embodiment may be encoded by one or more of fields 391 and 392 . Combined with source opcode identifiers 374 and 375 and optional scale-index-base (SIB) identifier 393, optional displacement identifier 394, and optional direct bytes 395 via field 391 , up to four operand locations can be identified for each instruction. For one embodiment, VEX prefix byte 391 may be used to identify 32-bit or 64-bit source and destination operands and/or 128-bit or 256-bit SIMD register or memory operands. For one embodiment, the functionality provided by opcode format 397 may be redundant with opcode format 370, while in other embodiments they differ. Opcode formats 370 and 397 allow register-to-register addressing, memory-to-register addressing as specified by MOD field 373 and in part by optional SIB identifier 393, optional displacement identifier 394, and optional direct byte 395 addressing, addressing from memory to register, addressing from register to register, addressing directly to register, and addressing from register to memory.

Turning now to FIG. 3H , another alternative operation code (opcode) format 398 for providing double rounded combined floating point multiply and add functionality is depicted in accordance with another embodiment. Opcode format 398 corresponds to opcode formats 370 and 397, and includes optional EVEX prefix bytes 396 (starting with hex 62 in one embodiment) to replace most other commonly used legacy instructions Prefix bytes and escape codes and provide additional functionality. Instructions according to one embodiment may be encoded by one or more of fields 396 and 392 . Pass field 396 with source opcode identifiers 374 and 375 and optional scale-index-base (SIB) identifier 393, optional displacement identifier 394, and optional direct bytes 395 Combined, up to four operand locations and masks per instruction can be identified. For one embodiment, EVEX prefix byte 396 may be used to identify 32-bit or 64-bit source and destination operands and/or 128-bit, 256-bit or 512-bit SIMD register or memory operands. For one embodiment, the functionality provided by opcode format 398 may be redundant with opcode formats 370 or 397, while in other embodiments they differ. Opcode format 398 allows register-to-register addressing with a mask specified by MOD field 373 and in part by optional (SIB) identifier 393, optional displacement identifier 394, and optional direct byte 395, Memory to register addressing, memory to register addressing, register to register addressing, direct register addressing, register to memory addressing. The general format (corresponding generally to format 360 and/or format 370) of at least one instruction set is shown generally as follows:

evex l RXBmmmmm WvvvLpp evex4 opcode modrm[sib][disp][imm].

For one embodiment, instructions encoded according to EVEX format 398 may have additional "load" bits, which are used to provide conversion between mask registers and general purpose registers, and have additional new features such as, for example, the user can Configuration mask registers, additional operands, selection from 128-bit, 256-bit or 512-bit vector registers or more registers to be selected, etc.

For example, VEX format 397 or EVEX format 398 may be used to provide double rounded combined floating point multiply and add functions. Additionally, for 128-bit, 256-bit, 512-bit or larger (or smaller) vector registers, VEX format 397 or EVEX format 398 can be used to provide double-rounded combined floating-point multiply and add functions.

An example instruction for providing double rounded combined floating point multiply and add functionality is shown by the following example:

It will be appreciated that in the above example instructions for scalar operations, Freg2, Freg3, Freg4 and Freg1 could be replaced by implicit stack references in a stack-based FP implementation. It will also be appreciated that in an implementation where conventional Not-a-Number (NaN) passing uses the first operand, the example reverse (R) instruction has difference. Through recompilation or through dynamic fusion at runtime, combined floating-point multiply and add (or subtract) operations can be used in place of separate multiply and add (or subtract) instructions, thereby reducing latency and improving instruction execution efficiency.

Figure 4A is a block diagram illustrating an in-order pipeline along with a register renaming stage, out-of-order issue/execution pipeline in accordance with at least one embodiment of the present invention. Figure 4B is a block diagram illustrating an in-order architecture core and register renaming logic, out-of-order issue/execution logic to be included in a processor in accordance with at least one embodiment of the present invention. The solid line boxes in FIG. 4A show the in-order pipeline, and the dashed line boxes show the register renaming, out-of-order issue/execution pipeline. Similarly, the solid-lined boxes in Figure 4B show in-order architectural logic, while the dashed-lined boxes show register renaming logic and out-of-order issue/execution logic.

In FIG. 4A, processor pipeline 400 includes fetch stage 402, length decode stage 404, decode stage 406, allocate stage 408, rename stage 410, dispatch (also called dispatch or issue) stage 412, register read/memory read stage 414 , execute stage 416 , writeback/memory write stage 418 , exception handling stage 422 and commit stage 424 .

In FIG. 4B, arrows indicate coupling between two or more units, and the direction of the arrows indicates the direction of data flow between those units. FIG. 4B shows processor core 490 including front end unit 430 coupled to execution engine unit 450 , and both execution engine unit and front end unit are coupled to memory unit 470 .

Core 490 may be a Reduced Instruction Set Computing (RISC) core, a Complex Instruction Set Computing (CISC) core, a Very Long Instruction Word (VLIW) core, or a hybrid or alternative core type. As another option, core 490 may be a special purpose core, such as a network or communication core, compression engine, graphics core, or the like.

Front end unit 430 includes a branch prediction unit 432 coupled to an instruction cache unit 434 which is coupled to an instruction translation lookaside buffer (TLB) 436 which is coupled to an instruction fetch unit 438 , the instruction fetch unit 438 is coupled to the decode unit 440 . A decode unit or decoder that decodes an instruction and generates as output one or more micro-ops, microcode entry points, uops, other instructions, or other control signals that are decoded from the original instruction, or otherwise Reflects the original instruction, or is derived from the original instruction. Decoders can be implemented using a variety of different mechanisms. Examples of suitable mechanisms include, but are not limited to: look-up tables, hardware implementations, programmable logic arrays (PLAs), microcode read-only memories (ROMs), and the like. Instruction cache unit 434 is further coupled to a level two (L2) cache unit 476 in memory unit 470 . Decode unit 440 is coupled to rename/allocator unit 452 in execution engine unit 450 .

Execution engine unit 450 includes a rename/allocator unit 452 coupled to a retirement unit 454 and a set of one or more scheduler units 456 . Scheduler unit 456 represents any number of different schedulers, including reservation stations, central instruction windows, and the like. Scheduler unit 456 is coupled to physical register file unit 458 . Each of physical register file units 458 represents one or more physical register files, where different physical register files store one or more different data types (such as scalar integer, scalar floating point, packed integer, packed floating point, vector integer, vector floating point, etc.), state (such as the instruction pointer being the address of the next instruction to be executed), and the like. The physical register file unit 458 is overlaid by the retirement unit 454 to illustrate the various ways in which register renaming and out-of-order execution can be implemented (such as using reorder buffers and retiring register files, using future files, history buffers, retiring register sets, using register maps and register pools, etc.). Typically, architectural registers are visible from outside the processor or from a programmer's perspective. These registers are not limited to any known particular circuit type. Many different types of registers are applicable so long as they are capable of storing and providing the data described herein. Examples of suitable registers include, but are not limited to, dedicated physical registers, dynamically allocated physical registers using register renaming, a combination of dedicated physical registers and dynamically allocated physical registers, and the like. Retirement unit 454 and physical register file unit 458 are coupled to execution cluster 460 . Execution cluster 460 includes a set of one or more execution units 462 and a set of one or more memory access units 464 . Execution unit 462 may perform various operations (e.g., shift, add, subtract, multiply) and on various types of data (e.g., scalar floating point, packed integer, packed floating point, vector integer, vector floating point) implement. While some embodiments may include multiple execution units dedicated to a particular function or set of functions, other embodiments may include only one execution unit or multiple execution units that all perform all functions. Scheduler unit 456, physical register file unit 458, execution cluster 460 are shown as potentially plural, as some embodiments create separate pipelines for certain data/operation types (e.g., each with their own scheduler unit , physical register bank unit and/or execution cluster's scalar integer pipeline, scalar floating point/packed integer/packed floating point/vector integer/vector floating point pipeline, and/or memory access pipeline, and in the case of separate memory access pipelines The next particular embodiment is implemented with only the execution cluster of the pipeline having a memory access unit 464). It should also be understood that where separate pipelines are used, one or more of these pipelines may be out-of-order issue/execution and the remaining pipelines may be in-order issue/execution.

Set of memory access units 464 is coupled to memory unit 470 including data TLB unit 472 coupled to data cache unit 474 coupled to level two (L2) cache unit 476 . In one exemplary embodiment, the memory access unit 464 may include a load unit, a store address unit, and a store data unit, each of which is coupled to a data TLB unit 472 in the memory unit 470 . The L2 cache unit 476 is coupled to one or more other levels of cache, and ultimately to main memory.

As an example, an exemplary register-renaming, out-of-order issue/execution core architecture may implement pipeline 400 as follows: 1) instruction fetch 438 executes fetch and length decode stages 402 and 404; 2) decode unit 440 executes decode stage 406; 3) Rename/allocator unit 452 performs allocation stage 408 and rename stage 410; 4) scheduler unit 456 performs dispatch stage 412; 5) physical register file unit 458 and memory unit 470 performs register read/memory read stage 414; Execution cluster 460 executes execution stage 416; 6) memory unit 470 and physical register file unit 458 execute writeback/memory write stage 418; 7) units may involve exception handling stage 422; and 8) retirement unit 454 and physical register Group unit 458 executes commit stage 424 .

Core 490 may support one or more instruction sets such as the x86 instruction set (with some extensions added with newer versions), the MIPS instruction set of MIPS Technologies, Inc. of Sunnyvale, Calif., the ARM instruction set of Sunnyvale, Calif. Holding company's ARM instruction set (with optional additional extensions such as NEON)).

It should be understood that a core can support multithreading (a collection of two or more operations or threads executing in parallel), and that this multithreading can be accomplished in a variety of ways, including time-division multithreading, synchronous Multithreading (where a single physical core provides a logical core for each of the threads that the physical core is synchronously multithreading), or a combination thereof (e.g., time-division fetching and decoding and thereafter such as with Hyper-threading technology to synchronize multi-threading).

Although register renaming is described in the context of out-of-order execution, it should be understood that register renaming can be used in in-order architectures. While the illustrated embodiment of the processor also includes separate instruction and data cache units 434/474 and a shared L2 cache unit 476, alternative embodiments may also have a single internal cache for instructions and data , such as, for example, a first level (L1) internal cache, or multiple levels of internal cache. In some embodiments, the system may include a combination of internal caches and external caches external to the cores and/or processors. Alternatively, all cache memory may be external to the core and/or processor.

FIG. 5 is a block diagram of a single-core processor and a multi-core processor 500 with an integrated memory controller and graphics device according to an embodiment of the invention. 5 shows a processor 500 with a single core 502A, a system agent 510, a set of one or more bus controller units 516, while the optional additional dashed boxes show alternative processing A processor 500 having multiple cores 502A-N, a set of one or more integrated memory controller units 514 located in a system agent unit 510 , and integrated graphics logic 508 .

The memory hierarchy includes one or more levels of cache within each core, a set of one or more shared cache units 506 , and external memory (not shown) coupled to a set of integrated memory controller units 514 . The set of shared cache units 506 may include one or more intermediate level caches, such as level two (L2), level three (L3), level four (L4) or other levels of cache, last level cache (LLC) ), and/or combinations thereof. Although in one embodiment a ring-based interconnection unit 512 interconnects the integrated graphics logic 508, the set of shared cache units 506, and the system agent unit 510, alternative embodiments use any number of known techniques for interconnecting these units.

In some embodiments, one or more of cores 502A-N are capable of multithreading. System agent 510 includes those components that coordinate and operate cores 502A-N. The system agent unit 510 may include, for example, a power control unit (PCU) and a display unit. The PCU may be or include the logic and components needed to adjust the power states of cores 502A-N and integrated graphics logic 508 . The display unit is used to drive one or more externally connected displays.

Cores 502A-N may be homogeneous or heterogeneous in architecture and/or instruction set. For example, some of cores 502A-N may be in order while others are out of order. As another example, two or more of cores 502A-N can execute the same set of instructions, while other cores can execute a subset of the set of instructions or a different set of instructions.

The processor may be a general purpose processor such as a Core ^™ i3, i5, i7, 2 Duo and Quad, Xeon ^™ , Itanium ^™ , XScale ^™ or StrongARM ^™ processors, all of which Available from Intel Corporation, Santa Clara, CA. Alternatively, the processor may be from another company, such as from ARM Holdings, MIPS, or the like. A processor may be a special purpose processor such as, for example, a network or communications processor, compression engine, graphics processor, coprocessor, embedded processor, or the like. The processor may be implemented on one or more chips. Processor 500 may be part of and/or may be implemented on one or more substrates using any of a number of processing technologies such as, for example, BiCMOS, CMOS, or NMOS.

6-8 are example systems suitable for including a processor 500 , and FIG. 9 is an example system-on-chip (SoC) that may include one or more cores 502 . Known in the art for laptops, desktops, handheld PCs, personal digital assistants, engineering workstations, servers, network equipment, network hubs, switches, embedded processors, digital signal processors (DSPs), graphics devices, Other system designs and configurations for video game devices, set-top boxes, microcontrollers, cellular phones, portable media players, handheld devices, and various other electronic devices are also suitable. In general, a number of systems and electronic devices capable of incorporating the processors and/or other execution logic disclosed herein are generally suitable.

Referring now to FIG. 6 , shown is a block diagram of a system 600 in accordance with one embodiment of the present invention. System 600 may include one or more processors 610 , 615 coupled to graphics memory controller hub (GMCH) 620 . The optional nature of additional processors 615 is indicated in Figure 6 with dashed lines.

Each processor 610 , 615 may be some version of processor 500 . However, it should be understood that integrated graphics logic and integrated memory control units are unlikely to be present in processors 610,615. FIG. 6 shows that GMCH 620 may be coupled to memory 640, which may be, for example, dynamic random access memory (DRAM). For at least one embodiment, DRAM may be associated with non-volatile cache.

GMCH 620 may be a chipset or part of a chipset. The GMCH 620 may communicate with the processor(s) 610, 615 and control the interaction between the processor(s) 610, 615 and the memory 640. GMCH 620 may also act as an accelerated bus interface between processor(s) 610, 615 and other elements of system 600. For at least one embodiment, the GMCH 620 communicates with the processor(s) 610, 615 via a multi-drop bus, such as a front side bus (FSB) 695.

Additionally, the GMCH 620 is coupled to a display 645 (such as a flat panel display). GMCH 620 may include an integrated graphics accelerator. The GMCH 620 is also coupled to an input/output (I/O) controller hub (ICH) 650 that can be used to couple various peripheral devices to the system 600. An external graphics device 660, which may be a discrete graphics device coupled to the ICH 650, is shown as an example in the embodiment of FIG. 6, as well as another peripheral device 670.

Alternatively, additional or different processors may also be present in system 600 . For example, additional processor(s) 615 may include additional processor(s) identical to processor 610, additional processor(s) that are heterogeneous or asymmetrical to processor 610, accelerators such as graphics accelerators or digital signal processing (DSP) unit), field programmable gate array, or any other processor. There are various differences between physical resources 610, 615 in terms of a range of metrics including architectural, microarchitectural, thermal, power consumption characteristics, and the like. These differences would effectively manifest as asymmetry and heterogeneity between the processors 610,615. For at least one embodiment, the various processors 610, 615 may reside in the same die package.

Referring now to FIG. 7 , shown is a block diagram of a second system 700 in accordance with an embodiment of the present invention. As shown in FIG. 7 , multiprocessor system 700 is a point-to-point interconnect system and includes a first processor 770 and a second processor 780 coupled via a point-to-point interconnect 750 . Each of processors 770 and 780 may be some version of processor 500 , as may one or more of processors 610 , 615 .

While shown with only two processors 770, 780, it should be understood that the scope of the invention is not so limited. In other embodiments, there may be one or more additional processors within a given processor.

Processors 770 and 780 are shown including integrated memory controller units 772 and 782, respectively. Processor 770 also includes point-to-point (P-P) interfaces 776 and 778 as part of its bus controller unit; similarly, second processor 780 includes point-to-point interfaces 786 and 788 . Processors 770 , 780 may exchange information via P-P interface 750 using point-to-point (P-P) circuits 778 , 788 . As shown in FIG. 7, IMCs 772 and 782 couple each processor to respective memories, memory 732 and memory 734, which may be part of main memory locally attached to the respective processors.

Processors 770, 780 may each exchange information with chipset 790 via separate P-P interfaces 752, 754 using point-to-point interface circuits 776, 794, 786, 798. Chipset 790 may also exchange information with high performance graphics circuitry 738 via high performance graphics interface 739 .

A shared cache (not shown) may be included in either processor or external to both processors, connected by a P-P interconnect to the processors so that if the processors are placed in a low power mode, the processors Locally cached information for either or both may be stored in a shared cache.

Chipset 790 may be coupled to first bus 716 via interface 796 . In one embodiment, the first bus 716 may be a Peripheral Component Interconnect (PCI) bus, or a bus such as a PCI Express bus or other third generation I/O interconnect bus, but the scope of the present invention is not limited by this limit.

As shown in FIG. 7 , various I/O devices 714 may be coupled to a first bus 716 along with a bus bridge 718 that couples the first bus 716 to a second bus 720 . In one embodiment, the second bus 720 may be a low pin count (LPC) bus. In one embodiment, a number of devices may be coupled to the second bus 720 including, for example, a keyboard and/or mouse 722, a communication device 727, and a storage unit 728, such as a disk drive or other mass storage unit, which may include instructions/code and data 730. equipment). Further, audio I/O 724 may be coupled to second bus 720. Note that other architectures are possible. For example, instead of the point-to-point architecture of Figure 7, the system could implement a multidrop bus or other such architecture.

Referring now to FIG. 8 , shown is a block diagram of a third system 800 in accordance with an embodiment of the present invention. Like elements in FIGS. 7 and 8 use like reference numerals, and certain aspects of FIG. 7 are omitted in FIG. 8 to avoid obscuring other aspects of FIG. 8 .

Figure 8 shows that processors 870, 880 may include integrated memory and I/O control logic ("CL") 872 and 882, respectively. For at least one embodiment, the CL 872, 882 may include an integrated memory controller unit such as described above in connection with FIGS. 5 and 7 . also. CL 872, 882 may also include I/O control logic. 8 shows that not only memory 832, 834 is coupled to CL 872, 882, but I/O device 814 is also coupled to control logic 872, 882. Legacy I/O devices 815 are coupled to chipset 890 .

Referring now to FIG. 9, shown is a block diagram of a SoC 900 in accordance with one embodiment of the present invention. In Fig. 5, similar parts have the same reference numerals. Also, dashed boxes are optional features for more advanced SoCs. In FIG. 9, interconnection unit 902 is coupled to: application processor 910, comprising a set of one or more cores 502A-N and shared cache unit 506; system agent unit 510; bus controller unit 516; integrated memory control processor unit 514; a collection of one or more media processors 920, which may include integrated graphics logic 508, an image processor 924 for providing still and/or video camera functionality, an audio processor 926 for providing hardware audio acceleration, and a video processor 928 for providing video encoding/decoding acceleration; a static random access memory (SRAM) unit 930; a direct memory access (DMA) unit 932; and a display unit 940 for coupling to one or more external monitor.

Figure 10 illustrates a processor, including a central processing unit (CPU) and a graphics processing unit (GPU), executable at least one instruction according to one embodiment. In one embodiment, instructions to perform operations in accordance with at least one embodiment are executable by a CPU. In another embodiment, the instructions may be executed by a GPU. In yet another embodiment, the instructions may be performed by a combination of operations performed by the GPU and the CPU. For example, in one embodiment, instructions according to one embodiment may be received and decoded for execution on a GPU. However, one or more operations in the decoded instruction may be performed by the CPU, and the results returned to the GPU for eventual retirement of the instruction. Instead, in some embodiments, the CPU may act as the main processor, while the GPU acts as a co-processor.

In some embodiments, instructions that benefit from highly parallel throughput may be executed by the GPU, while instructions that benefit from the performance of processors that benefit from a deeply pipelined architecture may be executed by the CPU. For example, graphics, scientific applications, financial applications, and other parallel workloads can benefit from the performance of GPUs and execute accordingly, while more serialized applications such as operating system kernels or application code are better suited to CPUs.

In Fig. 10, processor 1000 includes: CPU 1005, GPU 1010, image processor 1015, video processor 1020, USB controller 1025, UART controller 1030, SPI/SDIO controller 1035, display device 1040, high-definition Multimedia Interface (HDMI) Controller 1045, MIPI Controller 1050, Flash Memory Controller 1055, Double Data Rate (DDR) Controller 1060, Security Engine 1065, I ² S/I ² C (Integrated Cross-Chip Sound/Inter-IC ) interface 1070. Other logic and circuits may be included in the processor of Figure 10, including more CPUs or GPUs and other peripheral interface controllers.

One or more aspects of at least one embodiment can be implemented by representative data stored on a machine-readable medium, which represents various logic in a processor, which when read by a machine causes the machine to generate the execution The logic of the described technique. Such representations, so-called "IP cores," may be stored on tangible, machine-readable media ("tapes") and provided to various customers or manufacturers for loading into the fabricating machines that actually make the logic or processor. For example, IP cores such as the ^CortexTM processor family developed by ARM Holdings and the Loongson IP cores developed by the Institute of Computer Technology (ICT) of the Chinese Academy of Sciences may be licensed or sold to multiple customers or licensees, such as Texas Instruments, Qualcomm, Apple, or Samsung, and are implemented in processors manufactured by those customers or licensees.

Figure 11 shows a block diagram of IP core development according to one embodiment. Memory 1130 includes simulation software 1120 and/or hardware or software models 1110 . In one embodiment, data representing the IP core design may be provided to memory 1130 via memory 1140 (such as a hard disk), a wired connection (such as the Internet) 1150 , or a wireless connection 1160 . The IP core information generated by the simulation tools and models may then be sent to a manufacturing plant where it may be produced by a third party to execute at least one instruction according to at least one embodiment.

In some embodiments, one or more instructions may correspond to a first type or architecture (eg, x86) and be translated or emulated on a different type or architecture of processor (eg, ARM). According to one embodiment, the instructions may execute on any processor or type of processor, including ARM, x86, MIPS, GPU, or other processor type or architecture.

Figure 12 shows how instructions of a first type are emulated by different types of processors according to one embodiment. In FIG. 12, program 1205 includes instructions that perform the same or substantially the same functions as instructions according to one embodiment. However, the instructions of program 1205 may be of a different or incompatible type and/or format than processor 1215 , meaning instructions of the type in program 1205 cannot be natively executed by processor 1215 . However, by means of emulation logic 1210 , the instructions of program 1205 may be converted into instructions that can be natively executed by processor 1215 . In one embodiment, the emulation logic is embodied in hardware. In another embodiment, the emulation logic is embodied in a tangible machine-readable medium containing software that translates such instructions in program 1205 into a type that is natively executable by processor 1215 . In other embodiments, the emulation logic is a combination of fixed-function or programmable hardware and a program stored on a tangible, machine-readable medium. In one embodiment, the processor contains emulation logic, but in other embodiments, the emulation logic is external to the processor and provided by a third party. In one embodiment, the processor is capable of loading emulation logic embodied in a tangible, machine-readable medium containing software by executing microcode or firmware contained in or associated with the processor.

13 is a block diagram contrasting the use of a software instruction converter to convert binary instructions in a source instruction set to binary instructions in a target instruction set in accordance with various embodiments of the invention. In the illustrated embodiment, the instruction converter is a software instruction converter, but the instruction converter may alternatively be implemented in software, firmware, hardware, or various combinations thereof. 13 shows that a program utilizing a high-level language 1302 can be compiled using an x86 compiler 1304 to generate x86 binary code 1306 that can be natively executed by a processor 1316 having at least one x86 instruction set core. A processor having at least one x86 instruction set core 1316 means any processor capable of processing (1) a substantial portion of the instruction set of an Intel x86 instruction set core or (2) designed to have An object code version of an application or other software running on an Intel processor with at least one x86 instruction set core to perform substantially the same function as an Intel processor with at least one x86 instruction set core Basically the same results for Intel processors. The x86 compiler 1304 represents a compiler for generating x86 binary code 1306 (eg, object code) executable on a processor 1316 having at least one x86 instruction set core, with or without additional link processing. Similarly, FIG. 13 shows that a program in a high-level language 1302 can be compiled using an alternative instruction set compiler 1308 to generate a processor 1314 that does not have at least one x86 instruction set core (e.g., with a Sunnyvale, Calif. Alternative instruction set binary code 1310 natively executed by the MIPS instruction set of MIPS Technologies, Inc., of Sunnyvale, California, and/or by a processor of a core executing the ARM instruction set of ARM Holdings, Inc. of Sunnyvale, Calif. An instruction converter 1312 is used to convert x86 binary code 1306 into code that can be natively executed by a processor 1314 that does not have an x86 instruction set core. This translated code is unlikely to be identical to the alternate instruction set binary code 1310 because instruction converters capable of doing so are difficult to manufacture; however, the transformed code will perform common operations and be composed of instructions from the alternate instruction set. Thus, instruction converter 1312 represents, by emulation, emulation or any other process, software, firmware, hardware or a combination thereof that allows a processor or other electronic device that does not have an x86 instruction set processor or core to execute x86 binary code 1306 .

Figure 14A shows one embodiment of a means 1401 for executing an instruction that provides double rounding combined floating point multiply and add (or subtract, or convert) functionality. In one embodiment, means 1401 may be part of a SIMD FP multiply-adder, where means 1401 is replicated one or more times to perform SIMD double-round combined floating-point multiply and add operations in parallel. The means 1401 includes an FP multiplier stage 1430 for multiplying the mantissa of the first operand multiplicand 1410 with the mantissa of the second operand multiplier 1412 to produce a product. The mantissa of the first operand multiplicand 1410 and the mantissa of the second operand multiplier 1412 may be passed through a trailing zero detector stage 1420 to produce a sticky bit S 1422. In one embodiment, the product produced by the FP multiplier stage 1430 may be passed through an overflow detection stage 1436 to detect an overflow condition in the product of the FP multiplier stage 1430 and generate an overflow signal O 1438. The apparatus 1401 also includes an FP alignment stage 1432 to align the mantissa of the third operand addend (or minuend, or subtrahend) 1414 according to the product of the FP multiplier stage 1430 . In one embodiment, the aligned mantissa of the third operand addend (or minuend, or subtrahend) may also be inverted by inverter 1434 depending on the operation being performed. FP multiplier stage 1430 , overflow detection stage 1436 , FP alignment stage 1432 , and inverter 1434 together form processing block 1403 .

Apparatus 1401 also includes a first carry-save adder, CSA 11440, and a first combined multiply-add (CMA) adder stage 1450 for utilizing a The group round input adds together the aligned mantissa of the third operand addend (or minuend, or subtrahend) 1414 and the product of FP multiplier stage 1430 to produce a first sum or difference.

Apparatus 1401 includes a second carry-save adder, CSA21442, and a second CMA adder stage 1454 for multiplying the third The aligned mantissa of operand addend (or minuend, or subtrahend) 1414 and the product of FP multiplier stage 1430 are added together to produce a second sum or difference. For one embodiment, CMA adder stage 1454 may only be about half the width of CMA adder stage 1450 and may receive one or more carry inputs Cin from about the center of CMA adder stage 1450 . Apparatus 1401 also includes a multiplexer stage 1458 for combining the second sum or difference with the first sum based on overflow detection stage 1436 detecting an overflow condition in the product of FP multiplier stage 1430 or not detecting an overflow condition. Choose between Poor or Poor. A first carry-save adder CSA1 1440 and a second carry-save adder CSA2 1442 constitute a processing block 1404 . For some embodiments, a complement stage 1460 follows the multiplexer stage 1458 to complement the selected sum or difference depending on the operations performed. Some embodiments of apparatus 1401 include leading zero prediction (LZA) circuits 1456 and 1452 corresponding to CMA adder stages 1454 and 1450 for providing input to normalization stage 1462, based on or no overflow condition detected, this input provided by the leading zero prediction circuit to the normalization stage is selectable via multiplexer 1468 . The first CMA adder stage 1450, the LZA 1452, the second CMA adder stage 1454, the LZA 1456, and the multiplier stage 1458 make up the processing block 1405.

Following normalization stage 1462 , the sum or difference is rounded in rounding stage 1464 and the rounded result is stored in result 1470 . Complementation stage 1460 , normalization stage 1462 , rounding stage 1464 , and multiplexer 1468 may make up processing block 1406 . It will be appreciated that while device 1401 has been described as performing multiplication and addition (or subtraction), any operation that may be performed by an FP adder circuit, such as conversion, may also be combined in a similar manner with rounded FP multiplication. It will also be understood that some of the processes of processing blocks 1403 , 1404 , 1405 , and 1406 may have critical timing requirements that may be met by specific embodiments of apparatus 1401 .

Figure 14B shows an alternate embodiment of a means 1402 for executing an instruction that provides double rounding combined FP multiply and add (or subtract, or convert) functionality. In one embodiment, the means 1402 may be part of a SIMD FP multiply-adder, wherein the means 1402 may be replicated one or more times to perform SIMD double-round combined floating-point multiply and add operations in parallel. Device 1402 is shown with two fused FP multiplier-adders. In some embodiments, two fused FP multiply-adders have the same precision or width (e.g., both 64-bit or 32-bit) for performing SIMD double-round combined FP multiply and add (or subtract, or conversion) operation. In some embodiments, one of the fused FP multiply-adders has greater precision or width (e.g., one is 64 bits and one is 32 bits), wherein means 1402 may perform a double precision double rounding combined FP multiply and Add (or subtract, or convert) operations, or two single-precision double-round combined FP multiply and add (or subtract, or convert) operations can be performed in parallel. Other combinations are also possible. Apparatus 1402 includes FP multiplier stages 1430-1431 for multiplying a plurality of mantissas of first operand multiplicands 1410-1411 with a plurality of mantissas of second operand multipliers 1412-1413 to generate a plurality of corresponding product. The mantissas of the first operand multipliers 1410-1411 and the mantissas of the second operand multipliers 1412-1413 may be passed through trailing zero detector stages 1420-1421 to generate sticky bits S0-S1. In one embodiment, the corresponding products generated by FP multiplier stages 1430-1431 may be passed through overflow detection stages 1436-1437 to detect overflow conditions in the products of FP multiplier stages 1430-1431 and generate overflow signal O 1438-1439. Apparatus 1402 also includes FP alignment stages 1432-1433 to align a plurality of mantissas of third operand addends (or minuends, or subtrahends) 1414-1415 according to respective products of FP multiplier stages 1430-1431. In one embodiment, the aligned mantissa of the third operand addend (or minuend, or subtrahend) may also be inverted by inverters 1434-1435 depending on the operation being performed. FP multiplier stages 1430-1431, overflow detection stages 1436-1437, FP alignment stages 1432-1433, and inverters 1434-1435 together form processing block 1403.

The apparatus 1402 also includes a plurality of first carry-save adders CSA 11440-1441 and a first CMA adder stage 1450-1451 for, under the assumption that no overflow condition is detected in the corresponding products of the FP multipliers 1430-1431, The aligned mantissas of the third operand addends (or minuends, or subtrahends) 1414-1415 are added together with the corresponding products of FP multiplier stages 1430-1431 using a set of rounding inputs R1 to produce the first A set of sum or difference.

The apparatus 1402 includes a plurality of second carry-save adders CSA 21442-1443 and a second CMA adder stage 1454-1455 for utilizing the first Two sets of rounding inputs R2 add the aligned mantissas of the third operand addends (or minuends, or subtrahends) 1414-1415 with the corresponding products of FP multiplier stages 1430-1431 to produce the second Group sum or difference. Apparatus 1402 also includes multiplexer stages 1458-1459 for detecting overflow conditions or not detecting overflow conditions in the corresponding products of FP multiplier stages 1430-1431 based on overflow detection stages 1436-1437, respectively in the second Choose between Sum or Difference and First Sum or Difference. A plurality of first carry-save adders CSA1 1440-1441 and a plurality of second carry-save adders CSA2 1442-1443 constitute the processing block 1404. For some embodiments, complement stages 1460-1461 follow multiplexer stages 1458-1458 to complement selected sums or differences depending on the operations performed. Some embodiments of apparatus 1402 include leading zero prediction (LZA) circuits 1456-1457 and 1452-1453 corresponding to CMA adder stages 1454-1455 and 1450-1451 for providing input to normalization stages 1462-1463, according to The input to the normalization stage provided by the leading zero prediction circuit is selectable via multiplexers 1468-1469 with or without an overflow condition detected in the respective products of the FP multiplier stages 1430-1431. The first CMA adder stage 1450-1451, the LZA 1452-1453, the second CMA adder stage 1454-1455, the LZA 1456-1457 and the multiplier stage 1458-1459 make up the processing block 1405.

After normalization stages 1462-1463, the corresponding sums or differences are rounded in rounding stages 1464-1465 and the rounded results are stored in SIMD results 1470-1471. Supplementation stages 1460-1461, normalization stages 1462-1463, rounding stages 1464-1465, and multiplexers 1468-1469 may constitute processing block 1406. It will be appreciated that while means 1402 have been described as performing SIMD multiplication and addition (or subtraction) on vectors with two elements, each vector may include any number (e.g., 4, 6, 8, 10, 16, 32, etc. )Elements. It will also be appreciated that some embodiments of means 1401 and/or means 1402 may perform SIMD multiply and add (or subtract, or convert, etc.) operations on vectors with 64-bit FP elements, while other embodiments may perform Vectors of FP elements, or 80-bit FP elements, or 128-bit FP elements perform similar operations, and still other embodiments may perform double-rounded floating-point multiplication on 32-bit FP elements combined with 64-bit FP elements addition or similar operations.

Figure 15 shows a flow diagram of one embodiment of a process 1501 for providing double rounding combined floating point multiply and add functionality. Process 1501 and other processes disclosed herein are performed by processing blocks that may comprise dedicated hardware or software or firmware opcodes executable by a general purpose machine or a special purpose machine or some combination thereof.

In process block 1510 of process 1501, it is detected that the executable thread portion includes a first floating-point (FP) multiply operation, and in process block 1520, a second FP operation is detected that replaces the first FP multiply operation The result of is specified as the source operand. At processing block 1530, the first FP multiply operation and the second FP operation are encoded as a combined FP operation, including rounding of the result of the first FP multiply operation and subsequent second FP multiply operation using the rounded result as an operand input. FP operation. At processing block 1540, an encoding of the combined FP operation is stored, and at processing block 1550, the combined FP operation is executed as part of the executable thread portion instead of separate first floating point (FP) multiply operation and second floating point (FP) multiply operation. Two FP operations.

It will be appreciated that while the processing blocks of process 1501 are shown as being performed sequentially in a particular order, many operations may be performed in parallel or in a different order than shown, where possible. It will also be appreciated that in process 1501, while instructions for providing double rounded combined FP multiply and add functionality are shown as being executed in processing block 1550, other steps or stages may also be performed, such as stages 402-414 of pipeline 400 and/or one or more of stages 418-424 to facilitate or respond to the instruction entirely to provide double rounding combined FP multiply and add functions.

Figure 16A shows a flow diagram of another embodiment of a process 1601 for providing double rounding combined floating point multiply and add functionality. At processing block 1610 of process 1601 , in the executable thread portion, an FP multiply operation is converted to a double-rounded FP combined multiply-add (FCMADD) operation with an addend operand of zero. At processing block 1620, in the executable thread portion, the FP add operation is converted to a double rounded FCMADD operation with a multiplier operand of one and the adder operand of the FP add operation is used The multiplicand operand for this FCMADD operation. At processing block 1630, if the multiplicand of a double-round FCMADD operation with a multiplier operand of one matches the destination operand of a sequentially preceding double-round FCMADD operation with an addend operand of zero, then the The two instructions are combined to replace the double-round FCMADD operation with a multiplier operand of one. At processing block 1640, any remaining double-rounding FCMADD operations that have an addend operand of zero are removed if the remaining double-rounding FCMADD operations produce unused results.

FIG. 16B shows a flowchart of another embodiment of a process 1602 for providing double rounding combined floating point multiply and subtract functions. At processing block 1610 of process 1602, in the executable thread portion, the FP multiply operation is converted to a double-rounded FP combined multiply-add (FCMADD) operation with an addend operand of zero. At processing block 1615, in the executable thread portion, the FP subtract operation is converted to a double-rounded FP combined multiply-subtract (FCMSUB) operation with a multiplier operand of one and the subtracted The operand is used as the multiplicand operand for this FCMSUB operation. At processing block 1625, if the multiplicand of a double-round FCMSUB operation with a multiplier operand of one matches the destination operand of the sequentially preceding double-round FCMADD operation with an addend operand of zero, then the Two instructions combine into the FCMSUB operation and replace the multiplicand and multiplier operand of the FCMADD operation with the multiplicand and multiplier operand of the FCMSUB operation. At processing block 1635, if the subtrahend of a double-round FCMSUB operation with a multiplier operand of one matches the destination operand of a sequentially preceding double-round FCMADD operation with an addend operand of zero, then the two Instructions are combined into a FCMSUB.R operation to replace the double-round FCMSUB operation with a multiplier operand of one. At processing block 1640, any remaining double-rounding FCMADD operations that have an addend operand of zero are removed if the remaining double-rounding FCMADD operations produce unused results.

It will also be appreciated that while the processing blocks of process 1601 and process 1602 are shown as being performed sequentially in a particular order, where possible, many operations may be performed in parallel or in some order different from that shown. It will also be understood that combined floating-point multiplication and addition (or subtraction, or conversion, e.g. in a reservation station of an out-of-order processor, by recompilation or dynamic fusion of atomics at runtime or micro-ops in the processor pipeline etc.) operations can be used in place of individual multiply and add (or subtract, or convert, etc.) instructions, thereby reducing latency and improving instruction execution efficiency. Such recompilation or dynamic fusion of atoms at runtime or of micro-operations in a processor pipeline may be performed by processing blocks comprising dedicated hardware or software or firmware operational codes that may be executed by a general-purpose machine or by a special-purpose machine or by Some combination of them to perform.

Embodiments of the mechanisms disclosed herein may be implemented in hardware, software, firmware, or a combination of these implementations. Embodiments of the invention may be implemented as computer programs or program code executing on a programmable system comprising at least one processor, memory system (including volatile and non-volatile memory and/or storage elements) , at least one input device, and at least one output device.

Program code can be applied to input instructions to perform the functions described herein and generate output information. The output information may be applied to one or more output devices in known manner. For the purposes of this application, a processing system includes any system having a processor such as, for example, a digital signal processor (DSP), microcontroller, application specific integrated circuit (ASIC), or microprocessor.

The program code can be implemented in a high-level procedural language or an object-oriented programming language to communicate with the processing system. The program code can also be implemented in assembly or machine language, if desired. In fact, the mechanisms described in this paper are not limited in scope to any particular programming language. In either case, the language may be a compiled or interpreted language.

One or more aspects of at least one embodiment can be implemented by representative instructions stored on a machine-readable medium, which represent various logic in a processor, which when read by a machine cause the machine to generate the execution of the instructions herein. The logic of the described technique. Such representations, known as "IP cores," may be stored on a tangible, machine-readable medium and provided to various customers or production facilities for loading into the manufacturing machines that actually make the logic or processors.

Such machine-readable storage media may include, but are not limited to, tangible arrangements of particles manufactured or formed by a machine or apparatus, including storage media such as: hard disks; including floppy disks, optical disks, compact disk read-only memory (CD-ROM), Compact rewritable discs (CD-RW) and any other type of magneto-optical disc; semiconductor devices such as read-only memory (ROM); such as dynamic random access memory (DRAM), static random access memory (SRAM) random access memory (RAM); erasable programmable read-only memory (EPROM); flash memory; electrically erasable programmable read-only memory (EEPROM); magnetic or optical cards; Any other type of media.

Accordingly, embodiments of the invention also include non-transitory, tangible machine-readable media containing instructions or containing design data, such as a hardware description language (HDL), which defines the structures, circuits, devices, processes described herein device and/or system characteristics. These embodiments are also referred to as program products.

In some cases, an instruction converter may be used to convert instructions from a source instruction set to a target instruction set. For example, an instruction converter may transform (eg, using static binary translation, dynamic binary translation including dynamic compilation), warp, emulate, or otherwise convert an instruction into one or more other instructions to be processed by the core. The instruction converter can be implemented in software, hardware, firmware, or a combination thereof. The instruction converter can be on-processor, off-processor, or part-on-processor and part-off-processor.

Accordingly, techniques for executing one or more instructions in accordance with at least one embodiment are disclosed. While specific example embodiments have been described and illustrated in the drawings, it is to be understood that these embodiments are illustrative only and do not limit the translation of the invention, and that the invention is not limited to the specific embodiments shown and described. structure and configuration, since numerous other modifications will occur to those skilled in the art after a study of this disclosure. In this technical field, because the development is fast and the future progress is unknown, various embodiments of the present disclosure can easily obtain changes in configuration and details by benefiting from technological progress without departing from the principles and principles of the present disclosure. scope of the appended claims.

Claims (40)

1. a method for machine realization, comprising:

What detection comprised that (FP) multiply operation of the first floating-point and the 2nd FP operate can execution thread part, and the result of a described FP multiply operation is appointed as source operand by described 2nd FP operation;

Be the FP operation of combination by a described FP multiply operation and the 2nd FP operate coding, the FP operation of described combination comprises and uses result through rounding off as described source operand to the rounding off of the result of a described FP multiply operation, then described 2nd FP operation;

Store the coding of the FP operation of described combination; And

Perform the FP operation of described combination, using as described can the part of execution thread part.

2. the method for machine realization as claimed in claim 1, is characterized in that, described 2nd FP operation is FP add operation.

3. the method for machine realization as claimed in claim 1, is characterized in that, described 2nd FP operation is the operation of FP subtraction.

4. the method for machine realization as claimed in claim 1, is characterized in that, described 2nd FP operation is FP conversion operations.

5. the method for machine realization as claimed in claim 1, is characterized in that, the described coding of the FP operation of described combination is stored in microoperation storer as microoperation.

6. the method for machine realization as claimed in claim 5, is characterized in that, described detection performs optimization logic by processor and performs.

7. the method for machine realization as claimed in claim 1, is characterized in that, be stored as instruction set architecture (ISA) macro instruction the described coding that the FP of described combination operates.

8. the method for machine realization as claimed in claim 7, is characterized in that, be stored in instruction cache the described coding that the FP of described combination operates as ISA macro instruction.

9. the method for machine realization as claimed in claim 8, it is characterized in that, described detection is performed by processor ISA conversion logic.

10. the method for machine realization as claimed in claim 7, it is characterized in that, described detection is performed by Compiler Optimization logic.

The method that 11. 1 kinds of machines realize, comprising:

Floating-point (FP) add operation can checked, to determine that whether the first source operand of described FP add operation is the result of FP multiply operation in execution thread part; And

If described first source operand is determined to be described result and described FP addition and multiply operation have same precision, then replace described FP add operation with two combination FP multiply-add operation of rounding off, and described FP multiply operation is labeled as merges; And

In the described FP multiply operation that can check fusion in execution thread part, to determine consequently no will use by another operation; And

If the result of the FP multiply operation of described fusion is determined not used by other operation any, then remove the FP multiply operation of described fusion.

The method that 12. machines as claimed in claim 11 realize, is characterized in that, described two combination FP multiply-add operation of rounding off is stored in microoperation storer as microoperation.

The method that 13. machines as claimed in claim 12 realize, is characterized in that, described inspection performs optimization logic by processor and performs.

The method that 14. machines as claimed in claim 11 realize, is characterized in that, described two combination FP multiply-add operation of rounding off is stored as instruction set architecture (ISA) macro instruction.

The method that 15. machines as claimed in claim 14 realize, is characterized in that, described two combination FP multiply-add operation of rounding off is stored in instruction cache as ISA macro instruction.

The method that 16. machines as claimed in claim 15 realize, it is characterized in that, described inspection is performed by processor ISA conversion logic.

The method that 17. machines as claimed in claim 14 realize, it is characterized in that, described inspection is performed by Compiler Optimization logic.

The method that 18. 1 kinds of machines realize, comprising:

Floating-point (FP) multiply operation in execution thread part can convert two combination FP multiply-adds operations of rounding off that addend operand is zero to;

FP add operation in execution thread part can convert two combination FP multiply-adds operations of rounding off that multiplier operand is to by described, the addend operand of described FP add operation is used as the multiplicand operand of described two combination FP multiply-add operation of rounding off; And

Round off and combine the destination operand that FP multiply-add operate if multiplicand operand and addend operand that multiplier operand is one first pair combination FP multiply-add operation of rounding off are zero sequenced last second pair and match, then the multiplier operated with the described second pair combination FP multiply-add that rounds off and multiplicand operand replace described first pair to round off and combine the multiplier and multiplicand operand that FP multiply-add operates; And

If two combination FP multiply-add operations of rounding off that addend operand is any remainder of zero produce untapped result, then remove two combination FP multiply-add operations of rounding off of described remainder.

The method that 19. machines as claimed in claim 18 realize, is characterized in that, described two combination FP multiply-add operation of rounding off is stored in microoperation storer as microoperation.

The method that 20. machines as claimed in claim 19 realize, is characterized in that, described conversion performs optimization logic by processor and performs.

The method that 21. machines as claimed in claim 18 realize, is characterized in that, described two combination FP multiply-add operation of rounding off is stored as instruction set architecture (ISA) macro instruction.

The method that 22. machines as claimed in claim 21 realize, it is characterized in that, described conversion is performed by processor ISA conversion logic.

The method that 23. machines as claimed in claim 22 realize, is characterized in that, described two combination FP multiply-add operation of rounding off is stored in instruction cache as ISA macro instruction.

The method that 24. 1 kinds of machines realize, comprising:

Can floating-point (FP) multiply operation in execution thread part convert to addend operand be zero two FP that round off combine multiply-add (FCMADD) operation;

By described can the FP subtraction operation transformation in execution thread part become multiplier operand be one two FP that round off combine multiplication-subtraction (FCMSUB) operation, the minuend operand of described FP subtraction operation is used as the multiplicand operand that described FCMSUB operates;

The destination operand that FCMADD operates if the sequenced front a pair of that the multiplicand that described two FCMSUB that round off that multiplier operand is operate and addend operand are zero rounds off matches, the multiplicand then replacing described FCMSUB to operate by the multiplicand that operates with described FCMADD and multiplier operand and multiplier operand, by described two FCMADD operative combination that rounds off in described FCMSUB operation;

The destination operand that FCMADD operate if the sequenced front a pair of that subtrahend and addend operand that multiplier operand is described two FCMSUB operations of rounding off of are zero rounds off matches, then by described two FCMADD operative combination to the two FCMSUB of rounding off inverse operation that rounds off to replace the described couple of FCMSUB that rounds off to operate; And

If two FCMADD operations of rounding off that addend operand is any remainder of zero produce untapped result, then two FCMADD operations of rounding off of described remainder are removed.

The method that 25. machines as claimed in claim 24 realize, is characterized in that, described conversion performs optimization logic by processor and performs.

The method that 26. machines as claimed in claim 25 realize, is characterized in that, described two FCMSUB that rounds off operates or described two FCMSUB inverse operation that rounds off is stored in microoperation storer as microoperation.

The method that 27. machines as claimed in claim 24 realize, it is characterized in that, described conversion is performed by processor ISA conversion logic.

The method that 28. machines as claimed in claim 27 realize, is characterized in that, described two combination FP multiply-add operation of rounding off is stored as instruction set architecture (ISA) macro instruction.

The method that 29. machines as claimed in claim 27 realize, is characterized in that, described two combination FP multiply-add operation of rounding off is stored in instruction cache as ISA macro instruction.

30. 1 kinds of devices, comprising:

Floating-point (FP) multiplier circuit, bears results for first operand multiplicand mantissa being multiplied by mutually with second operand multiplier mantissa;

FP alignment circuit, for 3-operand mantissa of aliging according to the result of described FP multiplier circuit;

Overflow detection circuit, for detecting the spilling situation in the described result of described FP multiplier circuit;

One FP adder circuit, for based on hypothesis spilling situation not detected in the described result of described FP multiplier circuit, utilize first to round off input by added together for the described result of described 3-operand mantissa and described FP multiplier circuit through alignment, with produce first with or poor;

2nd FP adder circuit, for based on hypothesis spilling situation being detected in the described result of described FP multiplier circuit, utilize second to round off input by added together for the described result of described 3-operand mantissa and described FP multiplier circuit through alignment, with produce second with or poor; And

Multiplexer circuit, for spilling situation being detected based on described overflow detection circuit in the result of described FP multiplier circuit or spilling situation not detected, described second and or difference and first and or difference between select.

31. devices as claimed in claim 30, is characterized in that, described first operand multiplicand, described second operand multiplier and described 3-operand are single instruction multiple data (SIMD) vector registors.

32. devices as claimed in claim 31, is characterized in that, the data element of described first operand multiplicand, described second operand multiplier and described 3-operand is 64 FP data elements.

33. devices as claimed in claim 31, is characterized in that, the data element of described first operand multiplicand, described second operand multiplier and described 3-operand is 32 FP data elements or 16 FP data elements.

34. devices as claimed in claim 30, is characterized in that, described first operand multiplicand, described second operand multiplier and described 3-operand are scalar FP registers.

35. devices as claimed in claim 34, is characterized in that, described scalar FP register is on FP storehouse.

36. 1 kinds of processors, comprising:

One or more vector registor, comprises multiple data field of the value for storing vector element separately;

Decoder stage, for two combination floating-point (FP) multiply-add or the multiplication-subtraction instruction of rounding off of single instruction multiple data of decoding (SIMD), described single instruction multiple data (SIMD) two round off combination floating-point (FP) multiply-add or multiplication-subtraction instruction appointment: the destination operand of described one or more vector registor, the first operand multiplicand of described one or more vector registor, vector element size, the second operand multiplier of described one or more vector registor, and the 3-operand of described one or more vector registor,

SIMD FP multiply-add device, comprising:

Floating-point (FP) multiplier stages, for multiple mantissa of described first operand multiplicand being multiplied to the multiple corresponding mantissa of described second operand multiplier, to produce multiple corresponding result;

FP aligns level, for the multiple corresponding mantissa of the described 3-operand that aligns according to the accordingly result of described FP multiplier stages;

Overflow detection circuit, for detecting the spilling situation in the accordingly result of described FP multiplier stages;

One FP adder stage, for based on hypothesis spilling situation not detected in the accordingly result of described FP multiplier stages, utilize first round off input by described 3-operand corresponding through alignment multiple mantissa added together to the corresponding result of described FP multiplier stages, with produce accordingly multiple first with or poor;

2nd FP adder stage, for based on hypothesis spilling situation being detected in the accordingly result of described FP multiplier stages, utilize second round off input by described 3-operand corresponding through alignment multiple mantissa added together to the corresponding result of described FP multiplier stages, with produce accordingly multiple second with or poor; And

Multiplexer level, for spilling situation being detected based on described overflow checking level in the accordingly result of described FP multiplier stages or spilling situation not detected, corresponding multiple described second and or difference and first and or difference between select.

37. processors as claimed in claim 36, is characterized in that, the data element of described first operand multiplicand, described second operand multiplier and described 3-operand is 64 FP data elements.

38. processors as claimed in claim 36, is characterized in that, the data element of described first operand multiplicand, described second operand multiplier and described 3-operand is 32 FP data elements.

39. processors as claimed in claim 36, is characterized in that, described two combination floating-point (FP) multiply-add or multiplication-subtraction instruction of rounding off is produced by processor instruction set framework (ISA) conversion logic.

40. processors as claimed in claim 39, is characterized in that, described two combination FP multiply-add or multiplication-subtraction instruction of rounding off is stored in instruction cache as ISA macro instruction.