Load/store unit for a tensor engine and methods for loading or storing a tensor

Abstract

A method for processing a tensor is described including obtaining a first register for a number of items in the tensor. One or more second registers for a number of items in a first and a second axis of the tensor are obtained. A stride in the first and the second axis is obtained A next item in the tensor is obtained using the stride in the first axis and a first offset register, when the first register indicates the tensor has additional items to process and the second registers indicate the next item resides in the first axis. A next item in the tensor is obtained using the stride in the first axis and the second axis, the first offset register, and a second offset register. The first register and a second register is modified. The first and the second offset registers are modified.

Description

BACKGROUND

Applications like machine learning (ML), deep learning (DL), natural language processing (NLP), and machine vision (MV) are becoming more complex over time and being developed to handle more sophisticated tasks. Computing devices, however, have not advanced at a pace where they can effectively handle the needs of these new applications. Without sufficiently advanced computing paradigms, ML, DL, NLP, and MV applications, for example, cannot reach their full potential.

A tensor engine is a specialized processor in an ASIC that has the capability to make a computer more effective at handling ML, DL, NLP, and MV applications. The tensor engine is an AI accelerator specifically designed for neural network machine learning, and can be utilized via TensorFlow software, for example. Tensor engines typically implement the linear algebra needed to process an inference using a model in the neural network. In the above implementation, the tensor engine performs the operations that are not handled by a DNN (such as convolutions).

Tensor engines usually receive multi-dimensional arrays from memory with the data to perform the linear algebra upon. The tensor engine needs to execute a nested loop structure to process the multi-dimensional arrays. This computation is very expensive since it involves pointers, loop variables, and multiplication operations. The number of instructions needed to implement nested loops in tensor engines makes them inadequate for high performance computing applications.

SUMMARY

One embodiment is a method for processing a tensor. The method comprises obtaining a first register for a number of items in the tensor, obtaining one or more second registers for a number of items in a first and a second axis of the tensor, obtaining a stride in the first and the second axis, obtaining a next item in the tensor using the stride in the first axis and a first offset register, when the first register indicates the tensor has additional items to process and the second registers indicate the next item resides in the first axis, obtaining a next item in the tensor using the stride in the first axis and the second axis, the first offset register, and a second offset register, when the first register indicates the tensor has additional items to process, and the second registers indicate the next item resides in the second axis of the tensor, modifying the first register and one or more of the second registers, and modifying at least one of the first and the second offset registers.

Another embodiment is a load/store unit (LDSU) for a tensor engine. The LDSU comprises a first register for storing values associated with a number of items in a tensor, a plurality of second registers for storing a number of items in a first and a second axis of the tensor, a plurality of offset registers associated with the first and the second axis, a first and a second stride register associated with the first and the second axis, a tensor walking module configured to obtain a next item in the tensor using a first stride register and a first offset register, when the first register indicates the tensor has additional items to process and the second registers indicate the next item resides in the first axis of the tensor, the tensor walking module further configured to obtain a next item in the tensor using the first and the second stride registers, the first offset register, and a second offset register, when the first register indicates the tensor has additional items to process, and the second registers indicate the next item resides in the second axis of the tensor, an iteration tracking module configured to modify the first and the second registers, and a striding module configured to modify at least one of the first offset register or the second offset register.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram of a tensor engine with a load/store unit (LDSU) according to one embodiment.

FIG. 2 is a diagram that illustrates a prior art three-dimensional tensor walking process according to one embodiment.

FIG. 3 is a top-view of a tensor engine with an LDSU according to one embodiment.

FIG. 4 is a top-view of a compute element that can be used in a tensor engine with an LDSU according to one embodiment

FIG. 5 is a top-view of a node with a tensor engine with an LDSU that resides in an ML accelerator according to one embodiment.

FIG. 6 is a block diagram illustrating details of the operation of an LDSU according to one embodiment.

FIG. 7 is a block diagram illustrating details of the operation of an LDSU according to one embodiment.

FIG. 8 is a block diagram illustrating details of the operation of an LDSU according to one embodiment.

FIG. 9 is a block diagram illustrating details of the operation of an LDSU according to one embodiment.

FIG. 10 is a block diagram illustrating details of the operation of an LDSU according to one embodiment.

FIG. 11 is a block diagram illustrating details of the operation of an LDSU according to one embodiment.

FIG. 12 is a block diagram illustrating details of a striding module according to one embodiment.

FIG. 13 is a block diagram illustrating details of a walking module according to one embodiment.

FIG. 14 is a flowchart illustrating the operation of a tensor engine with an LDSU according to one embodiment.

FIG. 15 is a flowchart illustrating the operation of a tensor walking module according to one embodiment.

FIG. 16 is a flowchart illustrating the operation of a method for processing a tensor according to one embodiment.

DETAILED DESCRIPTION

The present application discloses a load/store unit (LDSU) as well as example machine-learning (ML) accelerators that can take advantage of the benefits provided by the LDSU. In some embodiments, the LDSU is configured for operation with a tensor engine. The following description contains specific information pertaining to implementations in the present disclosure. The Figures in the present application and their accompanying Detailed Description are directed to merely example implementations. Unless noted otherwise, like or corresponding elements among the Figures may be indicated by like or corresponding reference numerals. Moreover, the Figures in the present application are generally not to scale and are not intended to correspond to actual relative dimensions.

Referring to FIG. 1, a memory 150 can have a plurality of tensors 100, 102, 104, and 106. A tensor is an n-dimensional array of items, where each of the items are of a primitive data type 165. Each of the tensors 100-106 can have a different number of dimensions and/or primitive data types 165. The primitive data type 165 can vary depending on the system that processes tensors 100-106 and the type of tensors. The primitive data type 165 can also be hard coded into a system that only processes a certain type of tensor with a fixed data type. In some embodiments, primitive data type 165 (e.g., item type) can include, but is not limited to, various bit lengths representing integers, floating point numbers, or boolean values. Examples include bits, bytes, integers, words, boolean values, (brain floating-point) BF-16, or FP-32, and the like.

Tensor engine 120 includes register bank 140 and compute elements 170. Compute elements 170 are configured to perform one or more mathematical operations on the data obtained from register bank 140 and optionally write the results back to register bank 140. LDSU 111 includes an access module 130. In operation, the LDSU 111 uses the access module 130 to read the tensor 100 from the memory 150 and to write the tensor 100 to the register bank 140. Alternatively, although not shown explicitly in FIG. 1, the LDSU 111 uses the access module 130 to read the tensor 100 from the register bank 140 and to write the tensor 100 to the memory 150.

LDSU 111 includes a loop tracking module 192 (e.g., an iteration tracking module), an index tracking module 193, an addressing module 194, a walking module 195, a striding module 196, and a layout module 197. The modules 192-197 can be implemented in hardware, software, firmware, or any applicable combination of these elements. The tensor 100 can be obtained by walking through each data element of data type 165 in the tensor 100 using one or more of the modules 192-197. LDSU 111 walks through tensor 100 using a memory 190 which can be loaded in advance of the processing tensor 100, either from a compiler, a host, or any applicable form of input capable of setting up memory 190 in advance of execution. The memory can be updated when each item from tensor 100 is accessed by the LDSU 111. In one embodiment, when the LDSU 111 is moved to the next position in tensor 100 an effective address (e.g., in a memory region) for the next item is computed which can be used by the access module 130 to read the next item from memory 150 or register bank 140.

Memory 190 can include one or more registers. At least some of the registers correspond to a first counter for the number of items in tensor 100 and a second counter for the number of items in each of a plurality of dimensions of tensor 100 (e.g., the size of the arrays for C, H, and W). In one embodiment, the first counter is set to the number of items in tensor 100 and for each step, the counter is decremented until it reaches zero, at which time the system knows it has reached the end of tensor 100. Other implementations for the first counter are possible as well. The second counter can be set as indices for each dimension of tensor 100, such that for each step the second counter can be used to determine whether the next step in tensor 100 is in the current dimension, or whether the last item in the current dimension has been reached and the next stride is in the next axis of tensor 100 that needs to be traversed. In one embodiment, the first counter can be determined by taking the indices for each dimension representing the number of items in each dimension and taking the product of all of the values.

The loop tracking module 192 can access one or more registers to determine when the end of the tensor has been reached. The index tracking module 193 can access one or more registers for each dimension of the tensor to determine if it is the end of the tensor or the last element in a dimension. After the LDSU 111 moves to the next item, the loop tracking module 192 and the index tracking module 193 update, decrement, increment, and/or otherwise modify the registers.

Addressing module 194 can be used to determine the effective address for the next item in the tensor each time LDSU 111 moves to the next item. In the embodiment where memory 150 has a plurality of registers, the addressing module 194 uses a base register and one or more offset registers to provide the effective address (e.g., in a memory region) to the access module 130. The base register can have a value that corresponds to the memory location (e.g., memory region) where the first bit of the first item in the tensor resides, either in memory 150 or register bank 140.

Striding module 196 can be used to determine the stride in each of the dimensions of tensor 100. The stride values can be stored in memory 190 in a stride register for each dimension, for example. In one embodiment, a compiler, host, or other process loads the stride registers in advance of processing a tensor. At each step in the processing of the tensor, the striding module 196 updates the appropriate stride registers to correspond to the next position of the LDSU 111.

Walking module 195 can be used to move the LDSU 111 to the next item in tensor 100 so that the access module 130 can obtain (load or store) the next item from either memory 150 or register bank 140. In one embodiment, memory 190 includes a plurality of offset registers, at least one for each dimension of tensor 100. To obtain the next item in tensor 100 and/or to move the LDSU 111 to the next position, the current values in the offset registers are added together. In one embodiment, additional LDSUs 111B and additional tensor engines 120B are used such that each of tensors 102, 104, and 106 have their own LDSU and tensor engine that can operate in parallel with LDSU 111 and tensor engine 120. In one embodiment, an optional layout module 197 is used which makes the manner and/or order in which tensor walking module 195 walks through tensor 100 configurable. The order can be set at compile time in advance of the processing tensor 100, either from a compiler, a host, or any applicable form of input capable of setting up memory 190 and/or providing input and output to the layout module 197. In embodiments where registers are used for each dimension of the tensor, the registers can form a 2-dimensional array where the layout module 155 selects each row for processing in the order specified by the layout and the tensor is processed accordingly.

FIG. 2 is a diagram that illustrates a prior art three-dimensional tensor walking process. Tensor 210 is shown as being three-dimensional having dimensions of height (H) 200, width (W) 202, and depth (C) 204, also called channel. Tensor 210 is made up of elements of primitive data type 265. Tensor 210 is shown as having a height of 5, a width of 2, and a channel size of 5. In other examples, any number of height, width, and channel sizes can be used as well as an arbitrary number of dimensions. To walk the 3-dimensional tensor 210 using a prior art scheme, three nested loops are required. For example, the following pseudo-code could be applied to tensor 210, if processed in C, H, W order.

• • for (C=0; C<5; C++);
  • {
    • for (H=0; H<5; H++);
    • {
      • for (W=0; W<2; W++);
      • {
        • // find effective address
        • // load or store next item of tensor 210;
    • }
    • }
  • }

Using three nested loops to process tensor 210 is inefficient for use in an ML accelerator. The computation to find the effective address occurs at every step of the loop as well as pointer math with array indices. The size and amount of tensors that are typically processed coupled with the number of inefficient operations makes the prior art tensor engine of FIG. 2 inadequate for modern applications such as DLRM, machine vision, and the like. As will be understood by someone having ordinary skill in the art, and in the subsequent description, various embodiments the use LDSUs are capable of processing n-dimensional tensors without any nested loop structure and the associated drawbacks therewith.

FIG. 3 shows an overview of one implementation of a tensor engine 120 with an LDSU 111. Each tensor engine in a system may be assigned to perform a portion of, for example, inference calculations for the specific machine learning model being used by an ML processor. Tensor engines in different nodes (not shown) in an ML processor can perform the machine learning tasks in parallel or in sequence. Machine learning computations of ML processor may be performed in one or more tensor engines, forming a data flow between the LDSUs and the tensor engines. Various implementations for the tensor engine 120 can be used without departing from the scope of the present application. The current embodiment includes LDSU 111, an instruction sequencer 320, a register bank 140, and compute elements 300, 302, 304, 306, 308, 310, 312, 314, 316, and 318. Other embodiments can have other configurations and can have any number of compute elements.

One example of a compute element 400 is shown in FIG. 4. FIG. 4 can correspond to the structure of compute elements 300-318 not specifically shown in FIG. 3, although that is not required. Compute element 400 includes multiplexers 152, Ra registers 154, Rb registers 156, arithmetic logic units (ALUs) 160, adders 162, and Rg registers 164. Tensor engine 120 uses instruction sequencer 320 to perform register write, accumulate, and register read operations in a manner known in the art. For example, tensor engine 120 may write two values to registers Ra 154 and Rb 156, accumulate them with the aid of ALU 160, and save the result in register Rg 164. Thereafter two more values are written into registers Ra 154 and Rb 156, are accumulated with the aid of ALU 160, read from ALU 160 and added to the previous content in register Rg 164 and written into register Rg 164. This routine may repeat again, for example, up to 32 times to generate a 32-bit output from each output register of the tensor engine 120. In one embodiment, tensor engine 120 is a single-instruction, multiple data processor using an instruction set purpose-designed for execution of machine learning algorithms.

Referring now to FIG. 5, a top-view of a node 504 that resides in ML accelerator 500 is shown according to one embodiment. In one implementation, DNN 106 is implemented in electronic form and resides within an ASIC 588. DNN 106 can perform, for example, multiply-accumulate operations to execute either a convolution function or a dot product function as required by neural networks of the ML accelerator 500. The node 504 includes an LDSU 111, tensor engine 120, message router 110, level one static random-access memory (L1SRAM) 112, and level two static random-access memory (L2SRAM) 114. L1SRAM 112 can serve as scratchpad memory for each node 504, while L2SRAM 114 functions as the primary memory for each node and stores the weights of a machine learning model in close physical proximity to DNN 106 and tensor engine 120, and also stores any intermediate results required to execute the machine learning model. In one implementation, the L1SRAM 112 is optional. Weights are used in each layer of a neural network within each ML processor in, for example, inference calculations, each layer being typically implemented by several nodes in ML processor.

Activations from an originating node in ML processor or from an originating node in another ML processor in the ML accelerator 500 are streamed into a destination node in the ML processor. DNN 106 and tensor engine 120 perform computations on the streamed activations using the weights stored in L2SRAM 114. By pre-loading weights into L2SRAM 114 of each node 504, ML models (also referred to as execution graphs) are pre-loaded in each ML processor of the ML accelerator 500.

In general, a machine learning model is distributed onto one or more nodes where each node might execute several neurons. In the embodiment of FIG. 5, activations flowing between neurons in the same node are exchanged via memory whereas activations that move between nodes can utilize PIC 592 and be placed in the memory of the destination node. Input activations stream to nodes that are allocated to each neuron of the ML model (or each node of execution graph). Output activations, (i.e., results of computations using input activations and the pre-loaded weights), are transmitted in part using PIC 592 to the next node in the same ML processor or another ML processor.

In the implementation of FIG. 5, although not required for other embodiments, a message containing the packet data arrives through a photonic network situated on the PIC 592 and is received at the optical/electrical interface 134, which can be for example a photo diode and related circuit. The message can then be buffered in electronic form in a register such as FIFO 136 (“first in first out” register). An address contained in the message header is then examined by electronic message router 110, and the electronic message router determines which port and which destination the message should be routed to. For example, the message can be routed to a destination tile through electrical/optical interface 138, which can be for example a driver for an optical modulator. Examples of applicable modulator technology include EAM (“electro-absorptive modulator” or “electro-absorption modulator”), MZI (“Mach Zender Interferometer”), Ring modulator, and QCSE EAM (“Quantum Confined Stark Effect electro-absorptive modulator”). In this example, the message is routed to the destination determined by electronic message router 110 using an optical path situated on the PIC 592. As another example, the electronic message router 110 may determine that the destination of the message is L1SRAM 112, L2SRAM 114, DNN 106 or tensor engine 120. In that case, the message would be routed to local port 142.

FIGS. 6-11 are block diagrams illustrating details of the operation of an LDSU according to one embodiment. Referring to FIG. 6, LDSU 111 includes a memory 190. The memory includes registers for dimension 600, index 602, stride 604, and offset 606. In the current embodiment, each column of registers 600-606 has four rows. Any number of rows can be used. In the current embodiment, tensor 100 has three dimensions so only 3 rows of registers 600-606 are needed, so the fourth row of registers is loaded with zeroes and remains in that state while tensor 100 is being processed. If subsequently a 4-dimensional tensor was processed, then the fourth row of the registers could be used. In addition, memory 190 also has a base address register 610. The value loaded into the base address register 610 corresponds to the memory address in memory 150, which is the first bit of the first item of tensor 100. Memory 190 also includes an item counting register 612 and an index counting register 614. In the current embodiment, the item counter 612 is loaded with the product of the size of the three dimensions in the tensor, in this case (2×5×3). The item counter can be decremented whenever the LDSU 111 moves to the next item, for example, in order to track when the last item of tensor 100 is reached. The index counting register 614 is associated with the index column of registers 602. The index counting register 614 can be modified whenever the LDSU 111 moves to the next item and compared to the size of the current dimension, for example, in order to track when the next stride needs to account for the stride in the next axis of the tensor that is to be traversed.

Referring now to FIG. 7, the dimension column of registers 600 is loaded with values from a compiler or host. The values represent the number of items in each axis of tensor 100. In the current embodiment, tensor 100 has a height of 5, a width of 2, and a channel dimension of 3. A first item counting register 612 can be set to the product of each value in the dimension column of registers 600. In one embodiment, the product of these values can be stored in the loop counter register 612 and decremented each time the LDSU 111 is moved to the next position. The index column of registers 602 is set to zero and the offset registers 606 are also set to zero. This results in a first item of the tensor 700 being fetched in memory 150 at the address corresponding to the value stored in the base address register 610 of the memory 190 or otherwise determined by the addressing module 194. Typically, the value in the base address register is a number that corresponds to a memory address in memory 150 (e.g., in a memory region) and the initial item in tensor 100 starts at this memory address. Thus, access module 130 can fetch the first item using only the value in the base address register and loading the item at the memory location corresponding to that value. The stride column of registers 604 is loaded with the stride values to allow the next portion of tensor 100 to be fetched in the next iteration shown in FIG. 8.

FIG. 8 shows how memory 190 is modified in order to move LDSU 111 to the next position so item 800 can be obtained, loaded, stored, read, written, and/or otherwise accessed in memory 150 or register bank 140. At this step, the index tracking module 193 can set the first row of the index column of register to 1. The striding module 196 is called which sets the first-row register in the offset column 606 to 4. This can cause tensor walking module 195 to move the LDSU 111 to the next position corresponding to the new offset value in the first row of the offset column of registers 606. Thereafter, an effective address can be obtained by the addressing module 194 using the new offset value in the first row of the offset column of registers 606 and adding it to the value in the base address register yielding the location of the first bit of item 800 in the memory 150. Thereafter, the loop count registers 612 can be modified, for example by the loop tracking module 192, so the system can track when the last item of the tensor 100 has been reached. This operation can occur, for example, each time a next item in tensor 100 is obtained and/or each time the LDSU 111 is moved to a next position.

FIG. 9 shows how memory 190 is modified in order to move LDSU 111 to the next position so item 900 can be obtained, loaded, stored, read, written, and/or otherwise accessed in memory 150 or register bank 140. At this step, the index tracking module 193 can set the second row of the index column of registers 602 to 1 and the first row of the index column of registers 602 to 0. The striding module 196 is called which sets the second-row register in the offset column 606 to 8 and the first-row register in the offset column 606 to 0. This can cause tensor walking module 195 to move the LDSU 111 to the next position corresponding to the new offset value (which is obtained by adding the values in the first-row and second-row registers of the offset column of registers 606. Thereafter, an effective address can be obtained by the addressing module 194 using the new offset value in the first and second rows of the offset column of registers 606 and adding it to the value in the base address register yielding the location of the first bit of item 900 in the memory 150. In operation, a second counting module or counter, such as index counting register 614 can be used to determine when a last item in any given dimension of tensor 100 is reached. For example, in FIG. 9, the second counter can be used to ensure that the dimension value in any of the registers in the dimension column of registers 600 is always larger than the index value in any of the registers in the index column of registers 602 in the same row. Once the index value equals the dimension value in the registers, the system determines that the last item in the dimension has been reached. In response, the index for the current dimension is modified and/or set to zero and the next dimension or row in the index column or registers 602 is incremented. Moreover, the stride in the next dimension is determined such that the stride for the next item 900 accounts for the stride in the next dimension.

FIG. 10 shows how memory 190 is modified in order to move LDSU 111 to the next position so item 1000 can be obtained, loaded, stored, read, written, and/or otherwise accessed in memory 150 or register bank 140. At this step, index tracking module 193 can set the first row of the index column of registers 602 to 1. The striding module 196 is called which sets the first-row register in the offset column 606 to 4. This can cause tensor walking module 195 to move the LDSU 111 to the next position corresponding to the new offset value (which is obtained by adding the values in the first-row and second-row registers of the offset column of registers 606). Thereafter, an effective address can be obtained by the addressing module 194 using the new offset value in the first and second rows of the offset column of registers 606 and adding it to the value in the base address register yielding the location of the first bit of item 1000 in the memory 150.

FIG. 11 shows how memory 190 is modified in order to move LDSU 111 to the next position so item 1100 can be obtained, loaded, stored, read, written, and/or otherwise accessed in memory 150 or register bank 140. At this step, index tracking module 193 can set the first row of the index column of registers 602 to 0 and the second row of the index column of registers 602 to 2. The striding module 196 is called which sets the first-row register in the offset column 606 to 0 and the second-row register in the offset column 606 to 16. This can cause tensor walking module 195 to move the LDSU 111 to the next position corresponding to the new offset value (which is obtained by adding the values in the first-row and second-row registers of the offset column of registers 606). Thereafter, an effective address can be obtained by the addressing module 194 using the new offset value in the first and second rows of the offset column of registers 606 and adding it to the value in the base address register yielding the location of the first bit of item 1100 in the memory 150.

As will be understood by someone having ordinary skill in the art, the process repeats over an arbitrary height, width, channel, and any additional dimensions of any tensor the system walks. Moreover, the system can support any number of tensors and any arbitrary size for the primitive data elements from one bit to BFP-32, for example. Furthermore, the registers in memory 190 of LDSU 111 can be laid out, by a compiler, for example, such that user or the input data is capable of determining the order that the dimensions are walked. In one embodiment, the height dimension can be walked first, and in another embodiment the channel dimension can be walked first, for example. This could provide advantages and/or optimizations for different types of input data sets when used by a system that takes advantage of a tensor engine with LDSU 111. In one embodiment, a layout module 155 can be used which can receive input from the compiler, a user interface, or other system to enable the rows in memory 190 to be traversed in an arbitrary order. It should also be noted that anywhere the present disclosure describes a tensor being obtained from a memory, various embodiments could also obtain the tensor from a register bank in the tensor engine itself, or elsewhere. Moreover, when an effective address is determined, it can be used to load or store a tensor at the determined address.

FIG. 12 is a block diagram illustrating details of striding module 196 according to one embodiment. Offset register 1202 and stride register 1204 represent an arbitrary row of registers in memory 190 of the LDSU 111. An adder 1200 can be used to add the current offset with the stride each time the LDSU 111 moves to the next position.

FIG. 13 is a block diagram illustrating details of the tensor walking module 195 and the addressing module 194 according to one embodiment. An offset column of registers 1310 in the tensor walking module 195 has current offset values for each dimension of a tensor that is being walked. Adders 1300, 1301, and 1302 are used in this embodiment to combine 4 dimensions together and sum them with a value in a base address register 1320 using adder 1303 in the addressing module 194. The result is placed in an effective address register 1306. The values stored in the effective address register 1306 can be used by the access module 130 to obtain, load, store, read, write, and/or otherwise access either memory 150 or register bank 140 to obtain an item in an n-dimensional tensor.

FIG. 14 is a flowchart illustrating the operation of a tensor engine with an LDSU according to one embodiment. At operation 1400, a system, such as an ML accelerator, a general-purpose computing device, or other execution environment determines it needs to read or write an n-dimensional tensor to or from a memory location. At operation 1402, a first counter, such as an item counter, a loop counter, or other variable is set to the number of items in the tensor. This could occur, for example, by taking the product of the number of elements in each dimension of the tensor and storing it in a register. At operation 1404, a second counter, or set of counters, such as an index counter or register, is set to the number of elements in each dimension of the tensor. This could be stored in a plurality of registers in the memory of the LDSU, with at least one register for each dimension of the tensor to store the number of items and current index position in the current dimension, so it can be compared against the number of elements in the dimension. For example, when the number of elements equals the current index position, a system can determine it has reached the last item in a given dimension.

When there are more items at operation 1406 to obtain, read, write, load, store, and/or otherwise access, the tensor can be walked as follows. The next item is obtained at operation 1408 using the stride in any of the applicable dimensions and any values in the offset registers. One embodiment uses a striding module for each axis of the tensor that is being traversed, which enables the system to update offset registers every time the LDSU is moved without needing any nested loop operations. At operation 1410, the effective address of the next item is computed. An address module can be used to add a value in a base register with the current offset values summed from a tensor walking module 195, for instance. At operation 1412, the next item is read, written, loaded, stored, and/or otherwise accessed in a memory location using the effective address. Thereafter, at operation 1414, the first and the second counters are modified.

When there are no more items at operation 1406, the last item in the tensor was reached. Control can return to the main system, ML accelerator, computing device, or other process at operation 1400 that called the LDSU functionality and/or otherwise needed to process a tensor. Operation 1400 repeats until the LDSU functionality needs to be called again and operation 1400 becomes true.

FIG. 15 is a flowchart illustrating the operation of a tensor walking module according to one embodiment. At operation 1500, an order to traverse the axes of an n-dimensional tensor is set. At operation 1502, an optional operation of setting a size of a primitive data type that makes up items in the tensor. At operation 1504, an item counter is set to the number of items in the tensor. At operation 1506, a plurality of index counters are set to the number of items in each dimension of the tensor. The tensor can be processed one item at a time, in a deterministic fashion, until the last item is obtained. When the last item is obtained at operation 1508, the process ends. Otherwise, there are more items in the tensor, so at operation 1510 the system determines which dimensions to stride into depending on the position in the tensor of the next item. If the previous item was the last item in the current axis at operation 1510, then the next axis to traverse is obtained at operation 1512. At operation 1514, the stride is modified to account for striding into the next dimension to obtain the next item in the tensor.

Thereafter, or if the current item was not the last item at operation 1510, the next item is obtained using the stride and any existing offsets at operation 1516. At operation 1518, the effective address of the next item is computed. At operation 1520, the next item is read, written, loaded, stored, and/or otherwise accessed to or from a memory location such as a memory or a register bank. At operation 1522, the item counter is modified. At operation 1524, the indices for the current dimensions being traversed are modified. The process repeats at operation 1508 until the last item in the tensor is processed.

FIG. 16 is a flowchart illustrating the operation of a method 1600 for processing a tensor. At operation 1602, a first register is obtained for a number of items in the tensor. At operation 1604, one or more second registers are obtained for a number of items in a first and a second axis of the tensor. At operation 1606, a stride is obtained in the first and the second axis. At operation 1608, a next item in the tensor is obtained using the stride in the first axis and a first offset register, when the first register indicates the tensor has additional items to process and the second registers indicate the next item resides in the first axis. At operation 1610, a next item in the tensor is obtained using the stride in the first axis and the second axis, the first offset register, and a second offset register, when the first register indicates the tensor has additional items to process, and the second registers indicate the next item resides in the second axis of the tensor. At operation 1612, the first register and one or more of the second registers is modified. At operation 1614, at least one of the first and the second offset registers is modified.

Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are disclosed as example forms of implementing the claims.

Claims

1. A method for processing a tensor, comprising: obtaining a first register for a number of items in the tensor;obtaining one or more second registers for a number of items in a first and a second axis of the tensor;obtaining a stride in the first and the second axis;obtaining a next item in the tensor using the stride in the first axis and a first offset register, when the first register indicates the tensor has additional items to process and the second registers indicate the next item resides in the first axis;obtaining a next item in the tensor using the stride in the first axis and the second axis, the first offset register, and a second offset register, when the first register indicates the tensor has additional items to process, and the second registers indicate the next item resides in the second axis of the tensor;modifying the first register and one or more of the second registers; andmodifying at least one of the first and the second offset registers.

2. The method of claim 1, further comprising determining an effective address of the next item using a base address for the tensor in a memory region and one or more values stored in the first and the second offset registers.

3. The method of claim 2, further comprising reading the next item at the effective address.

4. The method of claim 2, further comprising writing the next item to the effective address.

5. The method of claim 1, wherein obtaining a next item in the tensor in a first axis further comprises determining an order for traversing the tensor.

6. The method of claim 2, wherein determining an effective address of the next item using a base address for the tensor in a memory region and one or more values stored in the first and the second offset registers further comprises: setting a channel, a height, or a width as the first axis.

7. The method of claim 1, wherein obtaining a stride uses a primitive data type associated with the tensor.

8. The method of claim 7, wherein the primitive data type is selected from the group consisting of bits, bytes, integers, words, boolean values, (brain floating-point) BF-16, or FP-32.

9. The method of claim 1, wherein modifying the first register and one or more of the second registers includes incrementing or decrementing the first register and one or more of the second registers.

10. The method of claim 1, wherein modifying at least one of the first and the second offset registers includes one or more of adding a first value in the first offset register to the stride in the first axis and adding a second value in the second offset register to the stride in the second axis.

11. A load/store unit (LDSU) for a tensor engine comprising: a first register for storing values associated with a number of items in a tensor;a plurality of second registers for storing a number of items in a first and a second axis of the tensor;a plurality of offset registers associated with the first and the second axis;a first and a second stride register associated with the first and the second axis;a tensor walking module configured to obtain a next item in the tensor using a first stride register and a first offset register, when the first register indicates the tensor has additional items to process and the second registers indicate the next item resides in the first axis of the tensor,the tensor walking module further configured to obtain a next item in the tensor using the first and the second stride registers, the first offset register, and a second offset register, when the first register indicates the tensor has additional items to process, and the second registers indicate the next item resides in the second axis of the tensor;an iteration tracking module configured to modify the first and the second registers; anda striding module configured to modify at least one of the first offset register or the second offset register.

12. The LDSU of claim 11, comprising an address module configured to determine an effective address of the next item using a base address for the tensor in a memory region and one or more values stored in the first and the second offset registers.

13. The LDSU of claim 12, further comprising an access module is configured to read the next item at the effective address.

14. The LDSU of claim 13, wherein the access module is further configured to write the next item to the effective address.

15. The LDSU of claim 11, further comprising a layout module is used to determine an order for traversing a plurality of dimensions of the tensor.

16. The LDSU of claim 15, wherein a first dimension of the plurality of dimensions is selected from the group consisting of a channel, a height, and a width.

17. The LDSU of claim 11, wherein the striding module uses an item type associated with the tensor to modify the first offset register or the second offset register.

18. The LDSU of claim 17, wherein the item type is selected from the group consisting of bits, bytes, integers, words, boolean values, (brain floating-point) BF-16, or FP-32.

19. The LDSU of claim 11, wherein the iteration tracking module modifies the first and second registers by incrementing or decrementing values in the first and the second registers.

20. The LDSU of claim 11, wherein the striding module modifies at least one of the first offset register or the second offset register by adding a first value in the first offset register to a second value in the first stride register and adding a third value in the second offset register to a fourth value in the second stride register.