Instruction handling for accumulating register results within a microprocessor - Patents.com
The accumulator register file optimizes data handling in processors with high computational throughput by allowing multiple writes to the same entry, reducing power consumption and delays in dense matrix operations.
Patent Information
- Application Number
- JP2022513041
- Authority / Receiving Office
- JP · JP
- Patent Type
- Patents
- Current Assignee / Owner
- Priority Date
- 2019-08-29
- Filing Date
- 2020-07-21
- Publication Date
- 2024-11-15
- Estimated Expiration
- 2040-07-21
AI Technical Summary
In processors with high computational throughput, register renaming of in-flight instructions for dense matrix operations leads to excessive data movement, power consumption, and unnecessary delays due to execution bubbles.
Implementing an accumulator register file associated with dense mass execution units, allowing results to be written to the same entry multiple times without renaming, and minimizing data movement by local operations within the accumulator register file.
Reduces power consumption and minimizes delays by optimizing data handling during dense matrix operations, enhancing execution throughput and efficiency.
Smart Images

Figure 0007584501000001 
Figure 0007584501000002 
Figure 0007584501000003
Abstract
Description
[Technical field]
[0001] The present invention relates generally to data processing systems, processors, and more particularly to an accumulator register file within a processor that includes accumulator registers associated with one or more dense math execution units, such as one or more matrix-multiply-accumulator (MMA) units. [Background technology]
[0002] Current processors in data processing systems process more than one instruction at a time, and often process those instructions out of order. In modern computer architectures, several techniques are known for designing computers adapted to execute more than one instruction at a time, or at least within the same time frame. For example, one design to increase throughput includes multiple execution slices within a processor core to process multiple instruction threads simultaneously, where these threads share certain resources of the processor core. Execution slices can refer to multiple data processing hardware units within a processor that are connected in series, such as in a pipeline or pipeline-like structure, to process multiple instructions in a single processing cycle. Pipelining involves processing instructions in multiple stages so that some instructions are processed in parallel. Multiple execution slices can be used as part of simultaneous multithreading within a processor core.
[0003] These various pipelined stages may include an "instruction fetch" stage that fetches an instruction from memory. In the "decode" stage, the instruction is decoded into different control bits that typically indicate (i) the type of functional unit (e.g., execution unit) to perform the operation specified by the instruction, (ii) the source operands of the operation, and (iii) the destination of the result of the operation. In the "dispatch" stage, the decoded instruction is dispatched to an issue queue (ISQ) where the instruction waits for data and available execution units. In the "execute" stage, the instructions in the issue queue are typically issued to the execution units. The "execute" stage processes the operation as specified by the instruction. Executing the operation specified by the instruction typically involves accepting data, e.g., one or more operands, and producing one or more results. There is usually a register file associated with the execution unit and / or issue queue to hold data and / or information for the execution unit. A register file typically has information read from and / or written to entries or locations in the register file.
[0004] One design that increases computational throughput is to have specialized computational units, such as matrix multiply accumulator units (MMA units), to handle various data types and to perform highly parallel tasks. Wide single instruction, multiple data (SIMD) dataflow is one approach to achieving high computational throughput. Summary of the Invention [Problem to be solved by the invention]
[0005] It is not uncommon for processors to have register renaming of in-flight instructions to improve out-of-order execution of instructions. However, in situations where execution units with high computation and throughput are used, such as dense math situations, register renaming of in-flight instructions can result in a lot of data movement that can be power-intensive to handle and can introduce unnecessary delays and latencies due to one or more execution bubbles. [Means for solving the problem]
[0006] A computer system for processing information is disclosed that includes at least one processor, a primary register file associated with the at least one processor, the primary register file having a plurality of entries for storing data, one or more write ports for writing data to the primary register file entries, and one or more read ports for reading data from the primary register file entries, one or more execution units including a dense math execution unit, and at least one accumulator register file having a plurality of entries for storing data, the at least one accumulator register file being associated with the dense math execution unit. In one or more embodiments, the processor is configured to process data in the dense math execution unit, and results of the dense math execution unit are written to the accumulator register file. In one aspect, the processor is configured to write results back to the same accumulator register file entry multiple times. In one embodiment, the processor is further configured to write data from the accumulator register file to a main register file. Preferably, the processor is configured to write data from the accumulator register file to a plurality of main register file entries in response to an instruction accessing a main register file entry that is mapped to the accumulator register file.
[0007] In one aspect, a processor is configured to prime an accumulator register file to receive data, and in a preferred aspect, the processor is configured to prime an accumulator register file to store data in the accumulator register file in response to an instruction. In one embodiment, the processor marks one or more primary register file entries mapped to the primed accumulator register file as busy in response to primed an accumulator register file entry. The accumulator register file is preferably local to the dense math unit, and in one aspect, the dense math execution unit is a matrix multiplication accumulator (MMA) unit and the accumulator register file is located within the MMA. In one embodiment, each entry in the accumulator register file is mapped to multiple primary register file entries.
[0008] In one embodiment, a processor for processing information is disclosed that includes: a primary register file associated with the processor, the primary register file having a plurality of entries for storing data, one or more write ports for writing data to the primary register file entries, and one or more read ports for reading data from the primary register file entries; one or more execution units including a dense math execution unit; and at least one accumulator register file having a plurality of entries for storing data, the at least one accumulator register file associated with the dense math execution unit, a bit field width of the accumulator register file being wider than a bit field width of the primary register file. In one aspect, the processor is configured to process data in a dense math execution unit in a manner such that a result of the dense math execution unit is written multiple times to the same accumulator register file entry, and is configured to write data back to a primary register file entry from the accumulator register file entry that is written multiple times.
[0009] In another aspect, a computer system for processing information is disclosed that includes at least one processor; a main register file associated with the at least one processor, the main register file having a plurality of entries for storing data, one or more write ports for writing data to the main register file entries, and a plurality of read ports for reading data from the register file entries; one or more execution units including a dense math execution unit; at least one accumulator register file having a plurality of entries for storing data, the at least one accumulator register file having a plurality of entries for storing data, the at least one accumulator register file being associated with the dense math execution unit; one or more computer readable storage media; and program instructions stored on the one or more computer readable storage media for execution by the at least one processor. In one embodiment, the program instructions, when executed on the processor, cause the dense math execution unit to write a result to the same accumulator register file entry multiple times. In response to the processor processing the dense math execution unit instruction, the program instructions cause the processor to map a single accumulator register file entry to multiple main register file entries, write a result to the same accumulator register file entry multiple times, de-prime the accumulator register file entry that was written to multiple times, write the resulting data from the accumulator register file entry that was written to multiple times to the main register file, and deallocate the de-primed accumulator register file entry.
[0010] A method of processing instructions within a processor is also disclosed. In one or more embodiments, the method includes providing an accumulator register file associated with a dense math execution unit, performing a dense math operation with the dense math execution unit, and writing a result of the dense math operation with the dense math execution unit to the accumulator register file. In one aspect, the method further includes the dense math execution unit performing reads and writes to the accumulator register file without writing to the main register file. In one embodiment, the accumulator register file is both a source and a target during the dense math execution unit operation. The method preferably includes writing to the same accumulator register file entry multiple times during the dense math execution unit operation, and in one aspect, the method includes writing accumulator register file data to the main register file.
[0011] The above and other objects, features and advantages of the present invention will become apparent from the following more particular description of illustrative embodiments thereof which are illustrated in the accompanying drawings.
[0012] Various aspects, features and embodiments of computer systems, computer architecture structures, processors, register files including accumulator register files, or methods of operation thereof, or combinations thereof, are better understood when read in conjunction with the provided figures, in which embodiments are provided to illustrate aspects, features or various embodiments or combinations thereof of computer systems, computer architecture structures, processors, register files, accumulator register files, and methods of operation thereof, but the claims should not be limited to the exact systems, embodiments, methods, processes or devices or combinations thereof shown, and the illustrated features and / or processes may be used alone or in combination with other features and / or processes. [Brief description of the drawings]
[0013] [Figure 1] FIG. 1 illustrates an example of a data processing system in which aspects of the present disclosure may be implemented. [Diagram 2] FIG. 1 is a block diagram of a processor capable of implementing certain aspects of the present disclosure. [Diagram 3] FIG. 1 is a block diagram of a portion of a multi-slice processor in accordance with an aspect of the present disclosure. [Figure 4] FIG. 2 is a block diagram of a portion of a multi-slice processor having an accumulator register file according to one embodiment of the present disclosure. [Diagram 5] FIG. 2 is a simplified block diagram illustrating an arrangement of an MMA unit, an accumulator register file, and a physical VS register file, according to one embodiment of the present disclosure. [Figure 6] FIG. 1 is a simplified block diagram of two super slices of a processor with MMA units and accumulator register files. [Figure 7] 4 is a flow diagram of a method according to one embodiment for processing data in a processor. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
[0014] The following description is written to illustrate the general principles of the present invention and is not meant to limit the inventive ideas described herein. In the following detailed description, numerous details are set forth to provide an understanding of computer systems, computer architecture structures, processors, register files, accumulator register files, and their methods of operation. However, those skilled in the art will appreciate that many different embodiments of computer systems, computer architecture structures, processors, register files, accumulator register files, and their methods of operation can be practiced without those specific details, and that the claims and the present invention should not be limited to the systems, assemblies, subassemblies, embodiments, features, processes, methods, aspects or details, or combinations thereof, described and shown in detail herein. Also, specific features described herein can be used in combination with other features described in various possible respective combinations and permutations.
[0015] Unless otherwise defined herein, all terms are to be given their broadest possible interpretation, including the meaning implied from this specification and the meaning understood by a person skilled in the art or as defined in dictionaries, academic treatises, etc., or both. It should also be noted that, unless otherwise specified, when used in this specification and the appended claims, the singular forms "a", "an" and "the" include plural referents, and that the terms "comprises" and / or "comprising" specify the presence of stated features, integers, steps, operations, elements or components, or combinations thereof, but do not preclude the presence or addition of one or more features, integers, steps, operations, elements, components, or groups thereof, or combinations thereof.
[0016] The following discussion omits or briefly describes conventional features that will be apparent to those skilled in the art of information processing systems, including processors and microprocessor systems and architectures. Those skilled in the art are assumed to be familiar with processor architectures in general, and in particular with multi-slice processors and processors that operate with out-of-order execution, including the use of registers by multi-slice processors. Note that numbered elements are numbered according to the figure in which they are introduced and will often, but not always, be referred to by that number in subsequent figures.
[0017] FIG. 1 illustrates an example of a data processing system 100 in which aspects of the present disclosure can be implemented. The system includes a central processing unit (CPU) 110. The CPU 110 is coupled to various other components by a system bus 112. A read-only memory ("ROM") 116 is coupled to the system bus 112, and includes a basic input / output system ("BIOS") that controls certain basic functions of the data processing system 100. Further coupled to the system bus 112 are a random access memory ("RAM") 114, an I / O adapter 118, and a communications adapter 134. The I / O adapter 118 can be a small computer system interface ("SCSI") adapter that communicates with a disk storage device 120. The communications adapter 134 interconnects the bus 112 with an external network, allowing the data processing system to communicate with other similar systems. Further coupled to the system bus 112 are input / output devices via a user interface adapter 122 and a display adapter 136. Keyboard 124, trackball 132, mouse 126 and speakers 128 are all interconnected to bus 112 through user interface adapter 122. A display monitor 138 is connected to system bus 112 by display adapter 136. In this manner, a user can provide input to the system through keyboard 124, trackball 132 or mouse 126, and receive output from the system through speakers 128 and display 138. Additionally, an operating system, such as AIX, is used to coordinate the functions of the various components depicted in FIG. 1 ("AIX" is a trademark of IBM Corporation).
[0018] CPU (or "processor") 110 may include various registers, buffers, memory and other units formed by integrated circuits and may operate according to reduced instruction set computing ("RISC") techniques. CPU 110 performs operations according to processor cycles, and in some aspects, performs operations according to processor cycles synchronized with an internal clock (not shown).
[0019] 2 illustrates a simplified block diagram of a processor 110, according to one embodiment. The processor 110 includes a memory 202, an instruction cache 204, an instruction fetch unit 206, a branch predictor 208, a branch classification unit 218, a processing pipeline 210, and a destination resource 220. The processor 110 may be included in a computer processor or may otherwise be distributed within a computer system. The memory 202 may store instructions and data, and the instruction cache 204 may store instructions to access and fetch instructions in the memory 202. The memory 202 may include any type of volatile or non-volatile memory. The memory 202 and the instruction cache 204 may include multiple cache levels.
[0020] FIG. 2 illustrates a simplified example of an instruction fetch unit 206 and a processing pipeline 210. In various embodiments, the processor 110 may include multiple processing pipelines 210 and an instruction fetch unit 206. In one embodiment, the processing pipeline 210 includes a decode unit 20, an issue unit 22, an execution unit 24, a write-back logic 26, a logical register mapper 28, a history buffer, e.g., a Save & Restore Buffer (SRB) 30, and a physical register file 32. The instruction fetch unit 206 and / or a branch predictor 208 may also be part of the processing pipeline 210. The processing pipeline 210 may further include other functionality, such as error checking and error handling logic, one or more parallel paths through the processing pipeline 210, and other functionality now known in the art or hereafter known in the art. Although FIG. 2 illustrates a forward path through the processor 110, other feedback and signaling paths may be included between elements of the processor 110. The processor 110 may include other circuits, functional units and components.
[0021] The instruction fetch unit 206 fetches instructions from the instruction cache 204 according to the instruction address for further processing by the decode unit 20. The decode unit 20 decodes the instructions and passes the decoded instructions, parts of instructions, or other decoded data to the issue unit 22. The decode unit 20 may further detect branch instructions that were not predicted by the branch predictor 208. The issue unit 22 analyzes those instructions or other data and, based on this analysis, sends the decoded instructions, parts of instructions, or other data to one or more execution units 24 in the pipeline 210. The physical register file 32 holds data for the execution units 24. The execution units 24 implement and execute operations specified by instructions issued to the execution units 24. The execution units 24 may include multiple execution units, such as fixed-point execution units, floating-point execution units, load / store execution units (LSUs), vector-scalar execution units (VSUs), or other execution units or combinations thereof. The logical register mapper 28 contains entries that provide a mapping between logical register entries (LReg) and entries in the physical register file 32. When an instruction specifies a read of a logical register entry (LReg), the logical register mapper 28 notifies the issue unit 22, which in turn notifies the execution unit 24, so that the execution unit 24 can locate the data in the physical register file 32.
[0022] When a mispredicted branch instruction or other exception is detected, the instructions and data following the mispredicted branch instruction or exception are discarded, e.g., flushed from various units of the processor 110. A history buffer, e.g., the save and restore buffer (SRB) 30, contains both speculative and architected register states and backs up logical register file data when a new instruction is dispatched. In this regard, the history buffer stores information from the logical register mapper 28 when a new instruction evicts data in case the new instruction needs to be flushed and old data restored. The history buffer (SRB) 30 retains the stored information until the new instruction is completed. To restore the contents of a logical register entry from the history buffer (SRB) 30 to the logical register mapper 28, the history buffer (SRB) 30 interfaces with the logical register mapper 28 and updates pointers in the logical register mapper 28 so that the instruction knows where to get the correct data, e.g., the processor is returned to the state that existed before an interruptible instruction, e.g., a branch instruction, was mispredicted.
[0023] Write-back logic 26 writes the results of the executed instructions back to destination resources 220. Destination resources 220 can be any type of resource, including registers for executed instructions or data, cache memory, other memory, I / O circuitry for communicating with other devices, other processing circuitry, or any other type of destination.
[0024] Instructions may be processed in a pipelined series of logical stages within processor 110. However, it should be understood that the functions of these stages may be combined into one, and therefore this particular division of stages should not be taken as a limitation unless such a limitation is expressly recited in the claims. Indeed, in FIG. 2, some stages are shown as a single logical unit for simplicity of understanding, and further relevant details are provided below.
[0025] 3 illustrates a block diagram of a portion of a processor 110, in this example a multi-slice processor 110, in accordance with one embodiment of the present disclosure. For purposes of discussion, it should be noted that FIG. 3 only illustrates a schematic representation of a portion of the multi-slice processor 110. It is understood that the multi-slice processor may have other configurations. As shown in FIG. 3, the multi-slice processor includes two processing slices: slice 0 (slice S0 or 360) and slice 1 (slice S1 or 365). The processor includes an instruction fetch unit 310. Slices S0 and S1 each include an instruction dispatch unit (320a and 320b), a logical register mapper (350a and 350b), a history buffer (HB) (370a and 370b), an issue queue (ISQ) (330a and 330b), an instruction completion table (ICT) (325a and 325b), and an execution unit (340a and 340b), which includes a load store unit (LSU) (304a and 304b), a vector scalar unit (VSU) (306a and 306b), and a register file (RF) (380a and 380b). Execution unit 340 may include one or more queues that hold instructions for execution by execution unit 340.
[0026] It should be noted that two slices are shown merely for ease of illustration and discussion, and that the multislice processor 110 may include more than two processing or execution slices, each having all of the components discussed above for slices S0 and S1 (slices 360 and 365), respectively. These processing slices may further be grouped into super slices (SS 395), each of which includes a pair of processing slices. For example, the multislice processor may include two super slices SS0 and SS1, where SS0 includes slices S0 and S1, and SS1 (not shown) includes slices S2 and S3.
[0027] The instruction fetch unit 310 fetches instructions for execution by the processor 110 or processor slice. Instructions fetched by the instruction fetch unit 310 are sent to the instruction dispatch unit 320. The instruction dispatch unit 320 sends instructions to an issue queue (ISQ) 330, typically in program order. The issue queue (ISQ) 330 issues instructions to the execution units 340. The ISQ 330 typically holds instructions until data associated with the instruction has been retrieved and is ready for use. The physical register file 380 may serve to store data for use in operations specified in instructions dispatched to the execution units 340, and results of operations performed by the execution units 340 may be written to specified target register entries in the physical register file 380.
[0028] In one aspect, ISQ 330 holds a set of instructions and register file 380 accumulates data for instruction inputs. Register files can be used to stage data between memory and other functional (execution) units in the processor. There may be multiple register files and types. Once all the source data for the instruction has been accumulated, it is passed to one or more execution units designated to execute the instruction. Each execution unit, e.g., LSU 304 and VSU 306, can make result data available on a write-back bus for writing to register file (RF) entries.
[0029] Delays can occur because ISQ 330 does not issue instructions to execution units 340 when the data is not ready, e.g., the data is not in an appropriate data cache or register. For at least this reason, the issue queue (ISQ) typically issues instructions to execution units 340 out of order so that instructions for which the necessary data is available can be executed. In one or more embodiments, to identify instructions, dispatch unit 320 stamps each instruction dispatched to issue queue 330 with an identifier, e.g., an identification tag (iTag). Dispatch unit 320 can stamp instructions with other information and meta data. Instructions (iTags) are typically allocated (assigned) and stamped by dispatch unit 320 in ascending program order, per thread.
[0030] The logical register mapper 350 contains meta data (e.g., iTag, RFtag, etc.) that provides a mapping between logical register entries (e.g., GPR1) and physical register file 380 entries (e.g., physical register array entries). The RFtag is a pointer that correlates the logical register entry to the physical register file entry. For example, when an instruction wants to read a logical register, e.g., GPR1, the logical register mapper 350 tells the issue queue 330 where in the physical register file 380 it can find that data, e.g., a physical register array entry, which in turn tells the execution unit 340. The execution unit 340 executes instructions out of order, and when the execution unit 340 finishes an instruction, it sends the finished instruction, e.g., an iTag, to the ICT 325. The ICT 325 contains a queue of instructions dispatched by the dispatch unit 320 and tracks the progress of those instructions as they are processed.
[0031] The history buffer (SRB) 390 contains logical register entries that have been evicted from the logical register mapper 350 by younger instructions. Information stored in the history buffer (SRB) 390 may include the iTag (i.e., evictor iTag) of the instruction that evicted the logical register entry from the logical register. In one embodiment, the history buffer (SRB) 390 stores the iTag, the logical register entry number (a bit field that identifies the logical register entry (LReg)), and the register file tag (RFTag) information. The history buffer (SRB) 390 may also store and track other information. The history buffer (SRB) 390 interfaces with the logical register mapper 350 to recover the iTag and the register file tag (RFTag) (and other meta data) for each evicted logical register entry (LReg). This information is kept in a history buffer (SRB) entry in history buffer (SRB) 390 until the new instruction (the evictor instruction) completes, at which point the entry is removed from history buffer (SRB) 390 in one embodiment.
[0032] A CPU 110 with multiple processing slices may be capable of executing multiple instructions simultaneously. For example, each processing slice may be capable of executing one instruction simultaneously in one processing cycle. Such a CPU with multiple processing slices may be referred to as a multi-slice processor or a parallel slice processor. The simultaneous processing of multiple execution slices may significantly increase the processing speed of a multi-slice processor. In single-threaded (ST) mode, a single thread is processed, and in SMT mode, two threads (SMT2) or four threads (SMT4) are processed simultaneously.
[0033] In one embodiment, each execution / processing slice may have its own register file, as shown in FIG. 3. In another embodiment, one register file may be allocated per super slice, and the one register file may be shared by the processing slices of that super slice. In one embodiment, one register file may be allocated to two or more super slices, and the one register file may be shared by the processing slices of the super slices. For example, slices S0, S1, S2, and S3 may be allocated to share one register file. Register files are discussed in more detail below.
[0034] It is not uncommon for processors to have register renaming of in-flight instructions to improve out-of-order execution of instructions. However, in situations where execution units with high computation and throughput are used, such as dense math operations, register renaming of in-flight instructions can result in a lot of data movement that can be power consuming to handle and can introduce unnecessary delays and latency due to one or more execution bubbles. In one or more embodiments, an accumulator register file is used and a process is performed that uses accumulator register file renaming with dense math instructions. The accumulator register file and accumulator register file renaming process are used such that data movement during execution is minimized to reduce power and improve execution throughput. In one aspect, an accumulator register is provided to enter an accumulator register renaming mode. After the accumulator registers are prepared, in one or more embodiments, a dense math execution unit, such as a matrix multiply accumulator (MMA) unit or an inference engine, or both, can locally read and write the accumulator registers without having to write to the main register file. The dense math execution unit preferably accesses the same accumulator register file entry multiple times, reads from the same accumulator register file entry multiple times, or writes to the same accumulator register file entry multiple times, or a combination thereof, without having to rename a new accumulator register file, or write back to the main register file, or both.In one embodiment, when the dense math operation is completed or in response to a predetermined operation and instruction, or when the dense math operation is completed in response to a predetermined operation and instruction, the result in the accumulator register file may be written to a main register file or main memory, or both.
[0035] The accumulator registers are preferably local to the MMA unit, and in one or more embodiments, the accumulator registers may be within the MMA unit. In further embodiments, the accumulator registers may have entries with a bit field width wider than the bit field width of the main register file entries. In one aspect, the accumulator register file is de-readyed when a dense math execution unit operation is completed. In one aspect, results stored in the accumulator register file may be moved from the accumulator register file to the main register file when a dense math execution unit operation is completed to allow subsequent instructions, such as subsequent non-dense math instructions, to use the results. In one embodiment, accumulator register file entries written back to the main register file may be de-allocated. In one or more embodiments, processes, processor architectures, and systems are described that handle dense math instructions using one or more accumulator registers associated with one or more dense math execution units, e.g., one or more inference engines and / or MMA units, one or more accumulator registers local to one or more dense math execution units, e.g., one or more inference engines and / or MMA units, and / or one or more accumulator registers located within one or more dense math execution units, e.g., one or more inference engines and / or MMA units. In one embodiment, the inference engine can be a set of eight matrix multiplication accumulator (MMA) units and thirty-two 512-bit accumulator registers.
[0036] 4 illustrates a simplified block diagram of a processing pipeline utilizing an accumulator register file associated with an execution unit, e.g., an inference engine / MMA unit, and a vector / scalar (VS) main register file located in a vector / scalar (VS) execution unit (VSU). The processing pipeline or execution slice includes a dispatch unit 320, a logical mapper 350 having a number of entries 351(a)-351(n), an instruction completion table (ICT) 325, an issue queue (ISQ) 330, a matrix multiply accumulator (MMA) unit 460, an accumulator register file having a number of entries 471(a)-471(n), and a VS execution unit (VSU) 340 having a main (VS) register file 380 having a number of entries 381(a)-381(n). Although FIG. 4 illustrates accumulator register file 470 as associated with and local to inference engine / MMA unit 460, in one or more embodiments, accumulator register file 470 may be located within MMA unit 460. In one or more embodiments, accumulator register file 470 is utilized as a source and target (accumulator) during operation of the inference engine and / or MMA. That is, in one aspect, when the MMA operates, it uses operands from the accumulator register file and writes results back to the accumulator register file, and in one embodiment, the MMA writes the results back to the same accumulator register file entry 471(n). In one or more embodiments, the results of the inference engine / MMA unit may be written back to the same target accumulator register file entry 471(n) multiple times. In this way, processors containing VS or main register files do not experience renaming operations during operation of the inference engine or MMA.
[0037] In one or more embodiments, the bit field width of accumulator register file 470 is wider than the bit field width of main (VS) register file 380. In one embodiment, accumulator register file 470 is a pool of wider accumulator register file entries 471(a)-471(n). For example, in one embodiment, accumulator register file 470 is a pool of 64 512-bit physical register entries 471, and the main VS register file is 128 bits wide. In one embodiment, each accumulator register file entry 471 holds multiple main register file entries, and in one embodiment, each accumulator register file entry 471 holds a set of four contiguous main VS register file entries (381(n)-381(n+3)). The simplified block diagram of FIG. 5 shows a VS or main register file 380 having four entries 381(a)-381(d) that map to a single accumulator register entry 471 in an accumulator register file 470. In one example, four consecutive 128-bit main VS register file entries 381(a)-381(d) map to a single 512-bit accumulator register file entry 471. In one or more embodiments, there are eight logical accumulator registers (ACC0-ACC7) per thread. These eight logical accumulator registers are mapped to 32 physical registers in an accumulator array, e.g., in an accumulator register file.
[0038] The instructions are used to prepare and run dense math execution units, such as an inference engine and / or one or more MMA units. General Matrix Rank Operation ("ger") instructions are one example, and in one or more aspects, a General Matrix Rank Operation ("ger") instruction performs n on 2n data. 2The inference engine / MMA unit workload typically has three parts: the accumulator register file is primed with the initial data to perform the operation; the MMA unit performs a multiplication operation and accumulates the result in the accumulator register file; and in one aspect, when the dense math execution unit completes or in response to an instruction, or when the dense math execution unit completes in response to an instruction, the result in the accumulator register file is written back to memory, e.g., the main register file and / or main memory. Accumulator instructions ("ger" instructions) typically have two VSR operand sources, one accumulator VSR destination and one accumulator VSR source.
[0039] To initiate a dense math operation, e.g., an MMA unit operation, in one or more embodiments, the processor decodes or detects, or decodes and detects, a dense math instruction, e.g., an inference engine / MMA unit “ger” instruction. In one embodiment, each dense math instruction has an iTag and utilizes one full dispatch lane and one full issue queue (ISQ) entry. In one aspect, the primary register mapper 350 allocates four targets (primary register file entries) for each dense math instruction, e.g., an MMA unit instruction. In one embodiment, the primary register mapper 350 further evicts the mapper entry from the primary register mapper 350. For instructions that write to the same accumulator register file entry, e.g., 471(a) in FIG. 4, the primary register mapper 350 does not allocate new primary register file tags RFTags (entries), but requires a new iTag for the new instruction. In one or more aspects, when a dense math instruction (iTag) that utilizes accumulator register file 470 completes, the primary register file entries (RFTags) are not deallocated if accumulator register file 470 has not written the result to primary register file 380. The primary register file entries (RFTags) are deallocated when data in the corresponding accumulator register file entries is pushed for writing back to primary register file 380, e.g., in response to a younger non-dense math instruction, or in response to data in the corresponding accumulator register file entries being pushed for writing back to primary register file 380, e.g., in response to a younger non-dense math instruction, or both.
[0040] In one embodiment, the primary register mapper 350 marks the primary register file entry that is mapped to the accumulator register file entry. In one aspect, the primary register mapper 350 writes the same accumulator register file iTag to multiple consecutive primary register file entries 381, e.g., VSR(n) through VSR(n+3). That is, one iTag is aliased to a group of consecutive primary register file entries, e.g., four primary register file entries 381(n) through 381(n+3). A younger non-dense math instruction that reads or writes the primary register file entry assigned to the accumulator register file entry (the locked-out primary register file entry) notifies the issue queue (ISQ) 330 to initiate the write-back process. In one or more embodiments, a series of instructions moving from the accumulator are sent by dispatch unit 320 and issued by issue unit 330 to read the contents of the accumulator registers from accumulator register file 470. In one or more alternative embodiments, this write-back process includes stopping dispatch unit 320 and notifying issue queue 330 to drain the data in accumulator register file 470 before the issue queue can resume issuing instructions. In one aspect, instructions that write to the same group of main register file entries are marked for issuing in sequence.
[0041] In one or more embodiments, dense math instructions that utilize the accumulator register file 470 are issued from the issue queue 330 in order, preferably by register number and in one aspect by type of instruction. In one aspect, the issue rate of dense math instructions that utilize the accumulator register file is one per cycle (except for the first instruction that is issued to prime the accumulator register file, which may take more than one cycle). Instructions that utilize the accumulator register file are preferably issued in order and consecutively. If there is an older instruction that utilizes the accumulator register file, the issue queue can issue the older instruction. This is because the older instruction performs a read or write to the main register file, but the accumulator register file only updates the accumulator register file until the data in the accumulator register file can be pushed to be written back to the main register file.
[0042] In one or more embodiments, an accumulator register file should be prepared. In one or more embodiments, a respective accumulator register file is prepared as needed. If the accumulator register file is a data source, then the accumulator register file, and in particular the accumulator register file entry that utilizes the data, should be prepared to initiate a dense math operation, e.g., an MMA operation, that utilizes the accumulator register file. The accumulator register file is prepared when data is written to the accumulator register file from memory, e.g., a primary register file or primary memory, or both, or as a result of a priming instruction. For example, an instruction, e.g., xxmtacc, can move data from a primary (VS) register file to the accumulator register file to synchronize the accumulator register file and the primary (VS) register file. In another example, an instruction, e.g., lxacc, can load and move data from primary memory to the accumulator register file. In a further example, the accumulator register file is primed when data in one or more entries of the accumulator register file is set to zero. Other instructions for primed accumulator register files are also contemplated.
[0043] In one embodiment, a vector scalar (VS) execution unit (VSU) writes the primary (VS) register data and the iTag of the instruction that is priming to the appropriate accumulator register file entry. The priming of the accumulator register file further allocates accumulator register renames. In priming, the accumulator register targets are renamed and mapped to physical register file entries. Referring to FIG. 5, during an example of priming, the accumulator register renames are allocated and the VS register data in entries 381(a)-381(d) are written to the allocated accumulator register entry 471. In one or more embodiments, the VS execution unit writes the primary (VS) register file data and the iTag of the instruction that is priming to the mapped accumulator register file. In one or more embodiments, an accumulator free list 472 maintains a count of allocated free accumulator tags. These accumulator tags identify accumulator register file entries. In one aspect, an accumulator register file busy flag is used to indicate which accumulator register file entry is currently active. When all accumulator register file entries are occupied, dispatch stalls similar to a main register resource stall.
[0044] In one or more embodiments, the first time an instruction that utilizes the accumulator register file is issued, it takes two consecutive cycles to prime the accumulator register file. In one embodiment, if the accumulator busy flag is not set, it takes two cycles to issue the instruction. This is because the accumulator register file needs to be primed / reprimed and the main register file needs to read the accumulator register file as a source. The second time an instruction that utilizes the accumulator register file is issued, it preferably takes one cycle to issue. During priming and depriming of the accumulator registers, multiple main register file tags, e.g., four main register file tags, are issued in one shot for each accumulator register file entry.
[0045] In dense math operations, the accumulator register file is not written to or read from the primary (VS) register file every cycle. Instead, by using the accumulator register file, large data results remain local to the dense math engine, e.g., the MMA unit. That is, the MMA unit operations write back to the accumulator register file. In one aspect, the same accumulator register file is written to multiple times, e.g., multiple times. In one embodiment, the accumulator register file entry is not renamed with every instruction. In one or more embodiments, the accumulator register file is utilized as the source and target (accumulator) during the MMA operations. Loop 475 in FIG. 5 illustrates the operation of the MMA unit writing back to the same target entry 471 in the accumulator register 470.
[0046] Each MMA unit instruction writes to a single accumulator register file entry and sets the state of the target accumulator register entry to dirty, which indicates that the accumulator register file entry and the corresponding primary (VS) register file entry are not synchronized. For an MMA unit instruction, e.g., the "ger" instruction, the accumulator register file stores the result and the primary (VS) register file does not store the result. Data is not written back to the primary register file in the primary execution unit, e.g., the VSU, while the primary execution unit updates the accumulator register file iTag when it receives a new instruction from the issue queue. For an instruction that uses an accumulator register file entry, the iTag of the younger instruction that uses the accumulator register file replaces the older iTag, but the primary register file tag (RFTag) does not change.
[0047] In response to several scenarios, the accumulator register file is unreadyed and the data in the accumulator register file is written back. In one embodiment, the accumulator register file is written back and / or unreadyed in response to an instruction or when the primary (VS) register file is sourced after the accumulator register is dirty. For example, in response to an instruction that moves from an accumulator register to the primary (VS) register file, e.g., xxmfacc, the accumulator register file is unreadyed and the result in the accumulator register file is moved out of the accumulator register file and written back to the primary (VS) register file. In another example, in response to an instruction that moves from the accumulator register file and stores, e.g., stxacc, the accumulator register file is unreadyed and the result in the accumulator register file is written back to main memory. In one or more embodiments, the hardware unprepares an accumulator register when an accumulator register file entry is dirty and accessed by the main (VS) register file. In one embodiment, the hardware runs a sequence that writes all accumulator registers back to the main (VS) register file. In one aspect, each accumulator register file entry is unprepared, the data in the accumulator register file is written to the main VS register file, and the accumulator register file is deallocated from the rename pool. In one or more embodiments, when an accumulator register is prepared and the main (VS) register file is targeted, the accumulator register is unprepared even if the accumulator register was not dirty.
[0048] In response to a younger primary execution unit instruction, e.g., a VSU instruction, touching a primary register file that is mapped to an active accumulator register file, in one embodiment, the issue queue is signaled to begin writing back the affected accumulator register file entry. In a preferred embodiment, this can be accomplished by executing a series of internal operations inserted into the instruction stream. In one aspect, the issue queue stalls the dispatch unit until the accumulator register is drained. That is, the accumulator register file writes the data back to the corresponding primary register file entry. In one aspect, it takes many cycles to write the data back to the primary register file, e.g., four cycles if an accumulator register file entry is mapped to four primary register file entries. The primary execution unit, e.g., a VSU, finishes the write back when the last portion of the accumulator register file data is written back. When the write back is completed, the "ACC busy" flag is reset (cleared). A dense math instruction that utilizes the accumulator register file is a single instruction and takes up one entry in the instruction completion table (ICT) 325. An accumulator register instruction is completed when the last piece of data in the accumulator register file is written back to the main register file. The iTags of the completed instruction are broadcast to the history buffer (not shown in FIG. 4) to deallocate the main register file entry (RFTags). The processor then processes the younger non-dense math instructions. This processing includes reading data from the main register file. After the accumulator register file is further drained and the ACC busy flag is cleared, the issue queue can resume issuing instructions and the dispatch unit can resume dispatching instructions.
[0049] In one aspect, when a dense math instruction, such as a "ger" instruction, sources an accumulator register file that has not been prepared since the last unprepared (e.g., by xxmtacc or ldacc), the hardware prepares the accumulator register file entry. The hardware prepares the accumulator register file and runs a sequence to allocate (rename) the accumulator register file entry. The dense math instruction is then executed.
[0050] FIG. 6 illustrates another embodiment of a processor having one or more dense math execution units, e.g., matrix multiply accumulator (MMA) units, associated with a local accumulator register file, where the processor is configured such that the operation of one or more dense math units writes back results multiple times to the same accumulator register file entry. FIG. 6 illustrates two super slices of the processor for handling data. Each super slice includes at least one MMA unit 460, two vector scalar (VS) execution units 306, and two load store (LS) units 304. A single accumulator register file 470 is used that is connected to both MMA units 460. In an alternative embodiment, each execution slice can have its own MMA unit with a local accumulator register file, and in a further aspect, each MMA unit has an accumulator register file contained within the MMA unit of the respective execution slice. In the embodiment of Figure 6, issue queue (ISQ) 1 330b for super slice 0 and issue queue (ISQ) 2 330c for super slice 1 issue instructions, such as a "ger" instruction, to their respective MMA units (460a and 460b). Alternatively, as indicated by the dotted lines in Figure 6, issue queue (ISQ) 0 330a and issue queue (ISQ) 3 330d can issue instructions, such as a "ger" instruction, to their respective MMA units (460a and 460b) of their respective super slices.
[0051] 7 is an exemplary flow diagram according to one embodiment showing and describing a method of handling data in a processor, e.g., executing instructions in a processor, which in one embodiment includes processing and handling dense mass instructions, e.g., MMA ("ger") instructions, in a processor in accordance with one embodiment of the present disclosure. Although method 700 is described for convenience and without any intent to limit the present disclosure as including a series of steps and / or several steps, it should be understood that the process need not be performed as a series of steps, or the steps need not be performed in the order shown and described with respect to FIG. 7, or both, but that the process may be consolidated, or one or more steps may be performed simultaneously together, or both, or the steps may be performed in the order disclosed or in an alternating order.
[0052] The method 700 of FIG. 7 relates to processing data within a processor, and more particularly to handling dense math operations by using a dense math execution unit, e.g., an MMA execution unit. At 705, a dense math execution unit is provided. In one example, the dense math execution unit is a matrix multiply accumulator (MMA) unit. In one or more examples, the dense math execution unit can be multiple MMA units configured as an inference engine. Other dense math execution units are also contemplated. In one or more embodiments, an accumulator register file associated with the dense math execution unit is provided at 710. In one embodiment, the accumulator register file is local to one or more dense math execution units, and in one aspect, the accumulator register file is within the MMA unit. The accumulator register file preferably has a bit field width wider than the bit field width of a main register file in the processor. In one embodiment, the accumulator register file is 512 bits wide and the main register file in the processor is 128 bits wide. According to one aspect, two or more main register file entries are mapped to the accumulator register file. For example, four consecutive main register files are mapped to one accumulator register file.
[0053] In one or more embodiments, an accumulator register file is prepared at 715 in response to an instruction for a dense math execution unit operation. For example, preparing the accumulator register file when the accumulator register file is a source for a dense math execution unit operation. In one embodiment, preparing the accumulator register file includes synchronizing data in the accumulator register file with data in a main register file, e.g., a VS register file, or data in a main memory. Preparing the accumulator register file may further include clearing data in the accumulator register file, e.g., setting data in an accumulator register file entry to zero. In one or more embodiments, a dense math instruction, e.g., a “ger” instruction, may have no accumulator register file source data and the dense math instruction is considered to be cell priming. An accumulator register file is primed (when the data in the accumulator register file entry is set to zero) the first time the accumulator register file is written to from the main register file, from main memory, or as a result of a cell priming instruction. In one or more embodiments, the accumulator register file allocates an accumulator register file rename, the accumulator file is primed, and the value of the data in the accumulator register file is set to the value in the main register file, or set to the value in main memory, or set to zero.
[0054] In one or more embodiments, at 720, a dense math execution unit, e.g., an MMA, or an inference engine, or both, undergoes a dense math operation. That is, a dense math operation is performed using one or more dense math execution units, e.g., an inference engine or an MMA unit, or both. In one embodiment, at 725, the results of the dense math execution unit, e.g., the inference engine results or the MMA unit results, or both, are written back to an accumulator register file. That is, during the dense math execution unit operation, the accumulator register file is used as both a source and a target. The results of the dense math execution unit are preferably written back to the same target accumulator register file multiple times without renaming. That is, in one embodiment, a single accumulator register file target rename can be rewritten multiple times. In one or more aspects, in response to a dense math execution unit instruction, e.g., a "ger" instruction, no write-back is performed to the main register file; instead, an accumulator register local to the dense math execution unit, e.g., an MMA unit, stores the result, and the main register file does not store the result. In this manner, the dense math execution unit, e.g., an inference engine and / or an MMA unit, operates without renaming the main register file entry. In one embodiment, in response to the dense math execution unit writing the result back to the accumulator register, the accumulator register file entry is flagged or marked, e.g., marked dirty.
[0055] In one or more embodiments, at 730, the accumulator register file result is written back to the main register file and / or main memory. In one embodiment, when the dense math execution unit operation is completed, the accumulator register file result is written back to the main register file and / or main memory. In one embodiment, the accumulator register is de-readyed, the value in the accumulator register file is written to the main register file (or main memory), and the accumulator register file entry is deallocated. According to one embodiment, the write back to the main register file is in response to an instruction, for example, an instruction to move from an accumulator register file entry to the main register file (xxmfacc) and an instruction to move from an accumulator register file entry and store the instruction (stxacc). The results in the accumulator register are written back to the main register file even when a main register file entry that is mapped to an accumulator register file entry is sourced or targeted and the accumulator register file entry is dirty. In one aspect, a defined read accumulator instruction moves data from the accumulator register file to the main register file. In one embodiment, after the accumulator is read, a series of store operations, e.g., an "octo / quad word" store operation, reads the main register file and writes to main memory.
[0056] In one embodiment, the hardware de-prepares the accumulator register file when the accumulator register file entry is dirty and the accumulator register file entry is accessed by a main register. In one aspect, the hardware de-prepares the accumulator register when the main register file entry is targeted when the mapped accumulator register entry is prepared, even if the accumulator register was not dirty. The hardware runs a sequence to write all accumulator register file entries back to the main register file, the operations targeting the main register file entry are performed, and the respective accumulator register file entry is deallocated from the rename pool.
[0057] In one aspect, when a dense math instruction, such as a "ger" instruction, sources an accumulator register file that has not been prepared since the last unprepared (e.g., by xxmtacc or ldacc), the hardware prepares the accumulator register file entry. In one aspect, the hardware prepares the accumulator register file and runs a sequence to allocate (rename) the accumulator register file entry. The dense math instruction is then executed.
[0058] Although the exemplary embodiments described above are preferably implemented in hardware, such as in the units and circuits of a processor, various aspects of the exemplary embodiments can also be implemented in software. For example, it will be understood that each block of the flow diagram illustrated in FIG. 7 and combinations of blocks in the flow diagram can be implemented by computer program instructions. These computer program instructions can be provided to a processor or other programmable data processing device to produce a machine such that the instructions executed on the processor or other programmable data processing device produce means for performing the functions specified in one or more blocks of the flow diagram. These computer program instructions can also be stored in a computer readable memory or storage medium capable of directing the processor or other programmable data processing device to function in a particular manner to produce an article of manufacture including instruction means for performing the functions specified in one or more blocks of the flow diagram, such that the instructions stored in the computer readable memory or storage medium produce an article of manufacture including instruction means for performing the functions specified in one or more blocks of the flow diagram.
[0059] The blocks of the flowcharts thus support combinations of means for performing the specified functions, combinations of steps for performing the specified functions, and program instruction means for performing the specified functions. It will also be understood that each block of the flowcharts, and combinations of blocks of the flowcharts, can be implemented by a hardware-based special purpose computer system that performs the specified functions or steps, or by a combination of special purpose hardware and computer instructions.
[0060] The present invention may be, at any level of technical detail possible in integration, a system, a method, or a computer program product, or a combination thereof. The computer program product may include a computer-readable storage medium having computer-readable program instructions thereon for causing a processor to carry out aspects of the present invention.
[0061] The computer readable storage medium may be any tangible device capable of holding and storing instructions for use by an instruction execution device. The computer readable storage medium may be, for example, but not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination thereof. A non-exhaustive list of more specific examples of computer readable storage media includes portable computer diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disk read-only memory (CD-ROM), digital versatile disk (DVD), memory stick, floppy disk, mechanically encoded devices such as punch cards or raised structures in grooves having instructions recorded thereon, and any suitable combination thereof. As used herein, a computer-readable storage medium should not be construed as being, itself, a ephemeral signal, such as an electric wave or other freely propagating electromagnetic wave, an electromagnetic wave propagating in a waveguide or other transmission body (e.g., a light pulse traveling in a fiber optic cable), or an electrical signal transmitted through an electrical wire.
[0062] The computer readable program instructions described herein may be downloaded from a computer readable storage medium into the respective computing / processing device or may be downloaded to an external computer or storage device over a network, such as the Internet, a local area network, a wide area network, or a wireless network, or a combination thereof. The network may include copper transmission cables, optical transmission fiber, wireless transmission, routers, firewalls, switches, gateway computers, or edge servers, or a combination thereof. A network adapter card or network interface in each computing / processing device receives the computer readable program instructions from the network and transfers the computer readable program instructions to a computer readable storage medium in the respective computing / processing device for storage.
[0063] The computer readable program instructions for carrying out the operations of the present invention may be assembler instructions, instruction set architecture (ISA) instructions, machine instructions, machine dependent instructions, microcode, firmware instructions, state setting data, or configuration data for an integrated circuit, or may be source or object code written in any combination of one or more programming languages, including object oriented programming languages such as Smalltalk®, C++, and procedural programming languages such as the “C” programming language or the like. The computer readable program instructions may be executed entirely on the user's computer, partially on the user's computer, as a stand-alone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or remote server. In the last scenario above, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (e.g., via the Internet using an Internet Service Provider). In some embodiments, electronic circuitry including, for example, a programmable logic circuit, a field programmable gate array (FPGA), or a programmable logic array (PLA), may execute the computer readable program instructions to carry out aspects of the invention by utilizing state information of the computer readable program instructions to personalize the electronic circuitry.
[0064] Aspects of the present invention are described herein with reference to flowchart and / or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart and / or block diagrams, and combinations of blocks in the flowchart and / or block diagrams, can be implemented by computer readable program instructions.
[0065] These computer readable program instructions may be provided to a processor of a general purpose computer, a special purpose computer, or other programmable data processing apparatus forming a machine, in such a manner that the instructions, executed by the processor of that computer or other programmable data processing apparatus, produce means for implementing the functions / operations specified in the blocks of the flowcharts and / or block diagrams. These computer readable program instructions may further be stored on a computer readable storage medium capable of directing a computer, programmable data processing apparatus, or other device, or combination thereof, to function in a particular manner, in such a manner that the computer readable storage medium having instructions stored therein comprises an article of manufacture containing instructions for implementing aspects of the functions / operations specified in the blocks of the flowcharts and / or block diagrams.
[0066] These computer readable program instructions can further be loaded onto a computer, other programmable data processing apparatus or other device to cause the computer, other programmable apparatus or other device to perform a series of operational steps to produce a computer-implemented process, in a manner such that the instructions executed on the computer, other programmable apparatus or other device perform the functions / operations specified in the blocks of these flowcharts and / or block diagrams.
[0067] The flowcharts and block diagrams in the accompanying figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in the flowcharts or block diagrams may represent a module, segment, or portion of instructions, including one or more executable instructions for implementing a specified logical function. In some alternative implementations, the functions shown in the blocks may be performed in an order different from that shown in the figures. For example, two blocks shown in succession may in fact be executed substantially simultaneously, or the blocks may sometimes be executed in the reverse order depending on the functionality involved. It should also be noted that each block of the block diagrams and / or flowcharts, as well as combinations of blocks in the block diagrams and / or flowcharts, may be implemented by a hardware-based dedicated system that performs the specified functions or operations or implements a combination of dedicated hardware and computer instructions.
[0068] Further, systems according to various embodiments may include a processor and logic, the logic being integrated with and / or executable by the processor. The logic is configured to perform one or more of the process steps described herein. By integrated, it is meant that the processor has logic embedded therewith as hardware logic, such as an application specific integrated circuit (ASIC), field programmable gate array (FPGA), etc. By executable by the processor, it is meant that the logic is hardware logic, such as firmware, a portion of an operating system, a portion of an application program, etc., or any combination of hardware logic and software logic, accessible by the processor and configured to cause the processor to perform some function when executed by the processor. The software logic may be stored on local and / or remote memory of any memory type known in the art. Any processor known in the art, such as a software processor module and / or hardware processor, e.g., ASIC, FPGA, central processing unit (CPU), integrated circuit (IC), graphic processing unit (GPU), etc., may be used.
[0069] It will be apparent from the description set forth above that the various features of the above-described systems and / or methods can be combined in any manner to produce multiple combinations.
[0070] It will further be appreciated that embodiments of the present invention may be provided in the form of a service that is deployed for customers to provide services on demand.
[0071] The description of various embodiments of the present invention is provided for illustrative purposes, and is not intended to be exhaustive or limited to the disclosed embodiments. Many modifications and variations that do not depart from the scope and spirit of the described embodiments will be apparent to those skilled in the art. The terms used in this specification are selected to best explain the principles of the embodiments, practical applications, or technical improvements not found in the art on the market, or to enable other skilled in the art to understand the embodiments disclosed herein.
Claims
1. 1. A computer system for processing information, said computer system comprising: At least one processor; a main register file associated with said at least one processor, said main register file having a plurality of entries for storing data, one or more write ports for writing data to said main register file entries, and one or more read ports for reading data from said main register file entries; one or more execution units, including a dense mass execution unit; at least one accumulator register file having a plurality of entries for storing data, said at least one accumulator register file being associated with said dense math execution unit; the processor is configured to process data stored in the accumulator register file in the dense math execution unit, a result of the dense math execution unit being written to the accumulator register file; the processor is configured to write a result to a same accumulator register file entry multiple times, de-ready the accumulator register file entry that has been written multiple times, write resulting data from the accumulator register file entry that has been written multiple times to the main register file, and deallocate the de-ready accumulator register file entry. Computer system.
2. 2. The computer system of claim 1, wherein the processor is configured to write data from an accumulator register file to a plurality of main register file entries in response to an instruction accessing a main register file entry that is mapped to the accumulator register file.
3. 2. The computer system of claim 1, wherein the processor is configured to prepare the accumulator register file to receive data.
4. 4. The computer system of claim 3, wherein the processor is configured to prepare the accumulator register file in response to an instruction to store data in the accumulator register file.
5. 4. The computer system of claim 3, wherein in response to preparing an accumulator register file entry, the processor marks as busy the one or more main register file entries that are mapped to the prepared accumulator register file entry.
6. 2. The computer system of claim 1, wherein the accumulator register file is local to the dense math execution unit.
7. 7. The computer system of claim 6, wherein the dense math execution unit is a matrix multiply accumulator (MMA) unit and the accumulator register file is located within the MMA.
8. 2. The computer system of claim 1, wherein the accumulator register file has a bit field width greater than the main register file bit field width.
9. 9. The computer system of claim 8, wherein each entry in the accumulator register file is mapped to multiple main register file entries.
10. 2. The computer system of claim 1, wherein the processor comprises a vector scalar execution unit (VSU), the dense math execution unit is a matrix multiply accumulator (MMA) unit, the main register file is a VS register file located within the VSU, and the accumulator register file is mapped to a plurality of contiguous VS register file entries.
11. 1. A processor for processing information, said processor comprising: a main register file associated with said processor, said main register file having a plurality of entries for storing data, one or more write ports for writing data to the main register file entries, and one or more read ports for reading data from the main register file entries; one or more execution units, including a dense mass execution unit; at least one accumulator register file having a plurality of entries for storing data, said at least one accumulator register file being associated with said dense math execution unit, said at least one accumulator register file having a bit field width greater than a bit field width of said main register file; the processor is configured to process data stored in the accumulator register file within the dense math execution unit in a manner such that a result of the dense math execution unit is written multiple times to the same accumulator register file entry; the processor is configured to write data back to the main register file entry from the accumulator register file entry that has been written multiple times; the processor is further configured to prepare the accumulator register file, write a result to a same accumulator register file entry a plurality of times, de-preparing the accumulator register file entry that has been written a plurality of times, writing resulting data from the accumulator register file entry that has been written a plurality of times to the main register file, and deallocating the de-prepared accumulator register file entry. Processor.
12. 12. The processor of claim 11, wherein the processor is configured to map multiple main register file entries to a single accumulator register file entry in response to processing a dense mass instruction.
13. 12. The processor of claim 11, wherein the processor is configured to prepare the accumulator register file to receive data.
14. 12. The processor of claim 11, wherein the processor is configured to mark the accumulator register file as dirty in response to the dense math execution unit writing data to an accumulator register file entry of the plurality of accumulator register file entries.
15. 12. The processor of claim 11, wherein the one or more execution units comprise a vector scalar unit (VSU), the dense math execution unit is a matrix multiply accumulator (MMA) unit, the main register file is a vector scalar (VS) register file located within the VSU, and the processor is configured to map multiple consecutive VS register file entries to a single accumulator register file entry.
16. 1. A computer system for processing information, said computer system comprising: At least one processor; a main register file associated with said at least one processor, said main register file having a plurality of entries for storing data, one or more write ports for writing data to said main register file entries, and a plurality of read ports for reading data from said register file entries; one or more execution units, including a dense mass execution unit; at least one accumulator register file having a plurality of entries for storing data, said at least one accumulator register file having a plurality of entries for storing data, said at least one accumulator register file being associated with said dense math execution unit; one or more computer readable storage media; program instructions stored on the one or more computer-readable storage media for execution by the at least one processor; wherein the program instructions include: program instructions for causing the dense math execution unit to process data stored in the accumulator register file and write a result to the same accumulator register file entry multiple times; Including, in response to said processor processing a dense mass execution unit instruction; Mapping a single accumulator register file entry to multiple main register file entries; Write the result multiple times to the same accumulator register file entry, de-preparing the accumulator register file entry that has been written multiple times; writing the resulting data from the multiply written accumulator register file entries to the main register file; Deallocating the unprepared accumulator register file entry Further comprising program instructions: Computer system.
17. 1. A method of processing instructions in a processor, the method comprising: providing an accumulator register file associated with the dense math execution unit; executing dense math operations using the dense math execution unit; and writing to the accumulator register file a result of the dense math operation on data stored in the accumulator register file using the dense math execution unit; and Writing a result to the same accumulator register file entry multiple times, de-preparing the accumulator register file entry that has been written multiple times; writing the resulting data from the multiply written accumulator register file entry to a main register file associated with the processor; deallocating the de-prepared accumulator register file entry. The method includes:
18. 18. The method of claim 17, further comprising the dense math execution unit performing reads and writes to the accumulator register file without writing to the main register file.
19. 20. The method of claim 17, wherein the accumulator register file is both a source and a target during dense math execution unit operations.
Citation Information
Patent Citations
Digital signal processor with cascaded SIMD organization
US20040078554A1
Scalar / vector processor
US20050240644A1
Data Processing Device and Method
US20130205123A1
Deep vision processor
US20190012170A1
Stream processor with low power parallel matrix multiply pipeline
US20190171448A1
