Patent Publication Number: US-2021182025-A1

Title: Accelerating 2d convolutional layer mapping on a dot product architecture

Description:
CROSS-REFERENCE TO RELATED APPLICATION(S) 
     The present application claims priority to and the benefit of U.S. Provisional Patent Application Ser. No. 62/947,423, filed Dec. 12, 2019 and entitled “ACCELERATING 2D CONVOLUTIONAL LAYER MAPPING ON A DOT PRODUCT ARCHITECTURE,” the entire content of which is hereby expressly incorporated by reference. 
    
    
     FIELD 
     One or more aspects of embodiments according to the present disclosure relate to processing circuits, and more particularly to a processing circuit for accelerating two dimensional (2D) convolutional layer mapping on a dot product architecture. 
     BACKGROUND 
     Neural networks may, in operation, perform tensor operations (e.g., tensor multiplications and convolutions) involving large numbers of multiplications and additions. If performed by a general purpose central processing unit, or even a graphics processing unit (which may be better suited to such a task) the performing of these operations may be relatively slow and incur a relatively high energy cost per operation. For example, in small devices (e.g., mobile, hand-held devices), which may have tightly constrained power budgets, the power consumption associated with the use of a general purpose central processing unit, or of a graphics processing unit, may not be ideal. 
     The above information in the Background section is only for enhancement of understanding of the background of the technology and therefore it should not be construed as admission of existence or relevancy of the prior art. 
     SUMMARY 
     This summary is provided to introduce a selection of features and concepts of embodiments of the present disclosure that are further described below in the detailed description. This summary is not intended to identify key or essential features of the claimed subject matter, nor is it intended to be used in limiting the scope of the claimed subject matter. One or more of the described features may be combined with one or more other described features to provide a workable device. 
     Aspects of example embodiments of the present disclosure relate to processing circuits, and more particularly to a processing circuit for accelerating two dimensional (2D) convolutional layer mapping on a dot product architecture. 
     In some embodiments, a method for performing a convolution operation includes storing, by a processor, a convolution kernel in a first storage device of the processor, the convolution kernel having dimensions x by y, wherein x is a number of rows in the convolution kernel and y is a number of columns in the convolution kernel; storing, by the processor, in a second storage device of the processor, a first subset of element values of an input feature map having dimensions n by m, wherein n is a number of rows in the input feature map and m is a number of columns in the input feature map; performing a first simultaneous multiplication, by the processor, of each value of the first subset of element values of the input feature map with a first element value from among the x*y elements of the convolution kernel; for each remaining value of the x*y elements of the convolution kernel, performing, by the processor, a simultaneous multiplication of the remaining value with a corresponding subset of element values of the input feature map; for each simultaneous multiplication, storing, by the processor, result of the simultaneous multiplication in an accumulator connected to the processor; and outputting, by the processor, the values of the accumulator as a first row of an output feature map (OFM). 
     In some embodiments, outputting the values of the accumulator as the first row of the OFM includes adding, by the processor, results of plurality of simultaneous multiplications stored in the accumulator to generate the first row of the OFM. In some embodiments, the first storage device includes a cache memory connected to the processor, and wherein the second storage device includes a plurality of registers located in a processing element (PE) of a multiply-accumulate (MAC) tile of the processor, wherein the plurality of registers are 9-bit registers. 
     In some embodiments, the method further includes shifting, by the processor, the first subset of element values one register to the left in the plurality of registers. In some embodiments, the method further includes broadcasting, by the processor, the first element value from among x*y elements of the convolution kernel to the second storage device; and broadcasting, by the processor, a second element value from among the x*y elements of the convolution kernel to the second storage device, wherein the first subset of element values of the input feature map includes values in first to p−th column of first row of the input feature map, and a second subset of element values of the input feature map includes values in second to (p+1)−th column of first row of the input feature map. 
     In some embodiments, the convolution kernel having the dimension x by y is a weight matrix, the weight matrix including a plurality of weight values, the plurality of weight values of the weight matrix are being stored in a cache memory connected to the processor, and wherein the input feature map having the dimension n by m includes a plurality of activation values. In some embodiments, the processor includes a plurality of multiply-accumulate (MAC) tiles, each MAC tile including an array of processing element (PE) including a plurality of PE rows and a plurality of PE columns, each PE column of the plurality of PE columns including a plurality of PEs and an adder tree. 
     In some embodiments, each MAC tile further includes a cache memory including a plurality of parallel activation lanes, each activation lane being corresponding to a row of the array of PEs in the MAC tile. In some embodiments, each PE of the plurality of PEs includes a plurality of registers configured to store the plurality of activation values of the input feature map, a multiplier connected to the plurality of registers and configured to multiply activations from the input feature map by the weight values from the cache memory, and a PE accumulator connected to the multiplier and configured to add an output from the multiplier to a value from the plurality of registers and store the result in the plurality of registers. In some embodiments, the array of PEs in the MAC tile includes eight PE columns, wherein each PE column of the eight PE columns of the MAC tile includes sixteen PEs. 
     In some embodiments, a system for performing a convolution operation includes a memory and a processor in communication with the memory, wherein the processor is configured to: store, in a first storage device of the processor, a convolution kernel having dimensions x by y, wherein x is a number of rows in the convolution kernel and y is a number of columns in the convolution kernel; store, in a second storage device connected to the processor, a first subset of element values of an input feature map having dimensions n by m, wherein n is a number of rows in the input feature map and m is a number of columns in the input feature map; perform, a first simultaneous multiplication of each value of the first subset of element values of the input feature map with a first element value from among the x*y elements of the convolution kernel; for each remaining value of the x*y elements of the convolution kernel, perform, a simultaneous multiplication of the remaining value with a corresponding subset of element values of the input feature map; for each simultaneous multiplication, store, result of the simultaneous multiplication in an accumulator connected to the processor; and output the values of the accumulator as a first row of an output feature map (OFM). 
     In some embodiments, the processor is further configured to output the values of the accumulator as the first row of the OFM by adding results of plurality of simultaneous multiplications stored in the accumulator to generate the first row of the OFM. In some embodiments, the first storage device includes a cache memory connected to the processor, and wherein the second storage device includes a plurality of registers located in a processing element (PE) of a multiply-accumulate (MAC) tile of the processor, wherein the plurality of registers are 9-bit registers. In some embodiments, the processor is further configured to: shift, the first subset of element values one register to the left in the plurality of registers. 
     In some embodiments, the processor is further configured to: broadcast the first element value from among x*y elements of the convolution kernel to the second storage device; and broadcast a second element value from among the x*y elements of the convolution kernel to the second storage device. In some embodiments, the convolution kernel having the dimension x by y is a weight matrix, the weight matrix including a plurality of weight values, the plurality of weight values of the weight matrix are being stored in a cache memory connected to the processor, and wherein the input feature map having the dimension n by m includes a plurality of activation values, wherein the processor includes a plurality of multiply-accumulate (MAC) tiles, each MAC tile including an array of processing element (PE) including a plurality of PE rows and a plurality of PE columns, each PE column of the plurality of PE columns including a plurality of PEs and an adder tree. 
     In some embodiments, each MAC tile further includes a cache memory including a plurality of parallel activation lanes, each activation lane being corresponding to a row of the array of PEs in the MAC tile, wherein the array of PEs in the MAC tile includes eight PE columns, wherein each PE column of the eight PE columns of the MAC tile includes sixteen PEs. In some embodiments, each PE of the plurality of PEs includes a plurality of registers configured to store the plurality of activation values of the input feature map, a multiplier connected to the plurality of registers and configured to multiply activations from the input feature map by the weight values from the cache memory, and a PE accumulator connected to the multiplier and configured to add an output from the multiplier to a value from the plurality of registers and store the result in the plurality of registers. 
     In some embodiments, a method includes performing a first simultaneous multiplication, by a processor, of each value of a first subset of element values of a first matrix with a first element value from among x*y elements of a second matrix; for each remaining value of the x*y elements of the second matrix, performing, by the processor, a simultaneous multiplication of the remaining value with a corresponding subset of element values of the first matrix; for each simultaneous multiplication, storing, by the processor, result of the simultaneous multiplication in an accumulator connected to the processor; and outputting, by the processor, the values of the accumulator as a first row of an output feature map (OFM). 
     In some embodiments, the method further includes storing, by a processor, the second matrix in a first storage device of the processor, the second matrix having dimensions x by y, wherein x is a number of rows in the second matrix and y is a number of columns in the second matrix; storing, by the processor, in a second storage device connected to the processor, the first subset of element values of the first matrix having dimensions n by m, wherein n is a number of rows in the first matrix and m is a number of columns in the first matrix; and storing, by the processor, in the second storage device, a second subset of element values of the first matrix, wherein the first subset of element values of the first matrix includes values in first to p−th column of first row of the first matrix, the second subset of element values of the first matrix includes values in second to (p+1)−th column of first row of the first matrix. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       These and other features of some example embodiments of the present disclosure will be appreciated and understood with reference to the specification, claims, and appended drawings, wherein: 
         FIGS. 1-2  illustrate example architectures of a processing element (PE), according to some embodiments of the present disclosure; 
         FIG. 3  illustrates mapping planar convolution to a multiply-accumulate (MAC) tile, according to some embodiments of the present disclosure; 
         FIG. 4  illustrates an example two-dimensional (2D) input feature map (IFM), according to some embodiments of the present disclosure; 
         FIGS. 5A-5M  illustrate in details regarding the determination of a first row of an output feature map (OFM), according to some embodiments of the present disclosure; 
         FIGS. 5N-5W  illustrate in details regarding the determination of a second row of the OFM, according to some embodiments of the present disclosure. 
     
    
    
     DETAILED DESCRIPTION 
     The detailed description set forth below in connection with the appended drawings is intended as a description of some example embodiments of a system and method for accelerating two dimensional (2D) convolutional layer mapping on a dot product architecture provided in accordance with the present disclosure and is not intended to represent the only forms in which the present disclosure may be constructed or utilized. The description sets forth the features of the present disclosure in connection with the illustrated embodiments. It is to be understood, however, that the same or equivalent functions and structures may be accomplished by different embodiments that are also intended to be encompassed within the scope of the disclosure. As denoted elsewhere herein, like element numbers are intended to indicate like elements or features. 
     Convolutional neural networks (CNN) are types of neural networks that may be used for image processing, for example, image classification, image clustering, object recognition, etc. CNNs may be desirable over related art machine learning methods on applications such as image classification, tracking, detection, etc. CNNs may be used to extract features from an input image, for example, a wide range of features from an input image may be extracted through convolution using filters having weights that are learned during the training of the neural network. The extracted features may be combined to determine an output. However, CNNs may be involved in increased number of computational operations compared to the related art machine learning methods. 
     A CNN may include a convolution layer and a fully-connected layer. The convolution layer and the fully-connected layer may be different in terms of performing computation and memory access. For example, in CNN, the fully connected layer may perform fewer computations compared to the convolution layer, however, may access memory intensively and therefore may be largely responsible for the performance degradation of the CNN. Convolution layers in the CNN may hold most of computations and may have increasing number of parameters compared to the fully connected layer. A convolutional layer may be a layer in a neural network in which the neurons share weights. The input to the convolutional layer may be an input image or an output of a preceding layer, and the output of the layer may be a feature map. 
     In CNN, 2D data arrays may be used as input of the convolution layer and in such a case the output of the convolution layer may be 2D data arrays as well. With the 2D input arrays, the convolution layer may perform computations that are 2D convolutions sliding over the input arrays. In CNN computations, a kernel or a filter may be a 2D array of weights, which may be repeatedly used to perform convolution over the input 2D arrays. For example, the kernel may slide over the 2D input data to perform an elementwise multiplication with the section of the input array it is currently on, and then add the results into an output pixel (e.g., each output pixel is a dot product of the kernel and a corresponding portion of the 2D input data). This process may be repeated for every location the kernel slides over to convert a 2D array of features (e.g., 2D input data array on input feature map) into another 2D array of features (e.g., 2D output data array or output feature map). 
     In CNN, 3D data arrays may be used as inputs to the convolution layer. For example, a 3D input array having dimension of H×W×D may be convolved with F kernels of dimension H×W×D and a stride of length S. Stride may be defined as the step size of the kernel when sliding along the input array. For example, a stride of 1 may indicate that the kernel slides through the input array element by element. Each 3D kernel of dimension H×W×D from among the F kernels may slide with a stride S across the 3D input array and during each shift, each element or weight of the 3D kernel is multiplied and added with each pair-wise input element from the overlapping region of the 3D input array. As such, CNN may perform an extensive number of iterative operations compared to a fully connected network (e.g., Filter size=h*w*D; Input size =H*VV*D). 
     The convolution layer of the CNN which may perform multiply-accumulate (MAC) operations, may use most of the execution time of the CNN. A MAC operation may compute the product of two numbers and may add that product to an accumulator. Neural network accelerators (e.g., Resnet-152) may reduce the number of computations in convolution layers or the number of memory accesses in the CNN. In order to reduce the execution time of the convolution layer, high speed accelerators may use specific structure that accelerate the computation performed in the convolution layer by executing a large amount of MAC operations in parallel by the PEs. 
     Neural Networks with 2D convolutions, such as MobileNet, may be used to reduce the number of computational operations in the convolution layer. For example, to perform high speed MAC operation, information in the input array of the convolution layer or input feature map information and filter or kernel weight information of current layer may be uploaded to the memory. The uploaded information may be processed by processing elements (PE) which are based on MAC operation to generate the output feature map information for next layer, which are then stored in the memory. A neural processor including MAC tiles or MAC array may take advantage of sparsity in the input feature map (IFM) to accelerate the completion of a calculation, by advancing certain multiplication and addition operations out of turn, so as to make use of a multiplier that would otherwise perform a multiplication by zero, when an element of the IFM equals zero. 
     In some cases, 2D convolution layers of the CNN may map poorly on dot product architectures, because the 2D convolution layer may only utilize a fraction of a 16×16 MAC array (for example, only the diagonal elements of the 16×16 MAC array). For example, in some cases, the under-utilization of the dot product architectures may be caused by only using one out of the 16 rows of the MAC array at a time. 
     In some embodiments, a neural processor may be configured to calculate a convolution or a tensor product of an input feature map (IFM) (or a tensor of “activations”) with a multi-dimensional array (or tensor) of weights (e.g., kernel), to form an output feature map (OFM). 
     In some embodiments, the neural processor includes a plurality of static random access memory (SRAM) bank sets. In some embodiments, each of the plurality of SRAM bank sets includes four SRAM banks. In some embodiments, the plurality of SRAM bank sets are connected to MAC tiles through an interconnect fabric, for example, an input feature map (IFM) delivery fabric. In some embodiments, the interconnect fabric or the IFM delivery fabric may bring input activation maps stored in SRAM bank sets to MAC tiles for subsequent computation. 
     In some embodiments, the MAC tiles are also connected to SRAM bank sets via another interconnect fabric, for example, an output feature map (OFM) delivery fabric that transmits computed results from MAC tiles to SRAM bank sets for storage. In some embodiments, the MAC tiles are also connected to a reduction tree or a reduction fabric. In some embodiments, the IFM delivery fabric may be a segmented bus, and, as a result, each one of the SRAM bank sets may be associated with a corresponding one of the MAC tiles. 
     In some embodiments, each MAC tile may contain a PE array of PE columns. In some embodiments, each PE column contains a plurality of PEs and an adder tree. In some embodiments, each PE array contains eight PE columns and each PE column contains sixteen PEs and an adder tree. 
     In some embodiments, each PE may include a plurality of registers, e.g., a register file containing 18 registers (e.g., 18 9-bit registers) that may be referred to as “weight buffers”, and a multiplier. In some embodiments, the multiplier multiplies input activations by weights. Subsequently, the adder tree in each MAC column sums up (e.g., fold or accumulate) resulting products from the plurality of PEs (e.g., sixteen PEs) in the column to form a dot product. 
     In some embodiments, each MAC tile also includes a cache. In some embodiments, the cache may reduce SRAM reads for input feature maps by caching IFM values received from SRAM. In some embodiments, the cache contains a plurality of parallel “activation lanes,” each activation lane corresponding to a “row” of the PE array in the MAC column. 
     In some embodiments, input activations from cache may be fetched (e.g., fetched into an IFM activations buffer) while also omitting zero-valued activations, when possible, to realize sparse activation computation. Next, numerical type of activations may be converted into sign-and-8 bit-magnitude format. The resulting converted plurality of activation values may be broadcasted in parallel to the PE array such that each activation lane brings an input activation value to the corresponding multiplier units in the corresponding row of PEs. In some embodiments, each column of PEs, the results are accumulated in an accumulator in the return unit. In some embodiments, after accumulation of product values in possible multiple cycles, the result will be returned back to SRAM. The return unit quantize back the large accumulated value to small precision, once all the computations for a pixel is added together. 
       FIGS. 1-2  illustrate example architectures of a PE. In some embodiments, as shown in  FIGS. 1-2 , each PE  103  may also contain an accumulator register  122 . In some embodiments, an “accumulator” (e.g., accumulator register  122 ) may be a combination of an adder and a register that is configured to add an input value to the contents of the register, and overwrite the contents of the register with the sum. In some embodiments, the 
     PE  103  may also incorporate another accumulator register  124  in addition to the accumulator register  122 . In such a case, the accumulator register  122  may be part of the weight buffer  116 . The accumulator register  124  may be configured to add the output from the multiplier  118  to an input value from the weight buffer  116  to the contents of the register, and the accumulator register  122  may be configured to store the sum to the weight buffer  116 , or overwrite the contents of the weight buffer  116  with the sum from the accumulator register  124 . 
     In some embodiments, the weight buffer  116  may have eighteen 1 Byte (B) elements. In some embodiments, in 2D convolution mode, twelve of the eighteen 1B elements of the weight buffer  116  may be used to store activations and rest of the six 1B elements of the weight buffer  116  may be decomposed into two 3B accumulators (e.g., accumulator registers  122  and  124 ). 
     In some embodiments, the two accumulator registers  122  and  124  may accumulate and store the result of the prior round of accumulation. While, in some embodiments, one of the accumulator registers  122  and  124  may be used for accumulating, and the stored result from the other one of the accumulator registers  122  and  124  may be sent to return unit gradually. This way, stall time may be minimized. 
       FIG. 3  illustrates mapping planar convolution to a MAC tile, according to some embodiments of the present disclosure. 
     As shown in  FIG. 3 , an IFM  202  with a certain length (e.g., a length of sixteen) may be referred to as a “IFM slice”. An IFM slice may have planar coordinates (x, y) and a depth channel index d associated with it (e.g., IFM [x, y, d:d+15]). In some embodiments, a tile  208  (e.g., a MAC tile) may receive one IFM slice at a time from on-chip SRAM (e.g., SRAM bank sets) containing a 3D IFM tensor, where each input IFM slice contains values for sixteen depth channels from index, e.g., d to d+15,inclusive at planar location (x, y) in the input layer (in  FIG. 2  only seven channels or depth channels have been shown). 
     Similarly, an OFM vector  206  with a certain length (e.g., the length of eight) may be referred to as an “OFM slice”. An OFM slice may have planar coordinates (x, y) and depth channel index d associated with it as indices into the associated OFM tensor (e.g., OFM [x, y, d:d+7]). In some embodiments, the tile  209  may produce OFM slices as output. In some embodiments, the output OFM vectors  206  (OFM slices) from tiles  208  may need to be further reduced by the reduction tree or reduction fabric to complete the OFM vector computation, before transmitting the final OFM vector result over OFM delivery fabric for storage in SRAM banks. 
     In the example embodiment of  FIG. 3 , the kernel  204  may have length and width different than the IFM  202 , however, the kernel  204  may have the same depth as the IFM  202 . In some embodiments, the kernel  204  may slide along height and width of the IFM  202 , and at each sliding position, element-wise multiplication and addition may be performed, which results in a single element of an OFM slice. In order to determine the OFM vector  206  with depth channel index d (e.g., OFM [x, y, d:d+7]), eight kernels  204  (e.g., same number of kernels as the depth of the OFM vector  206 ) may be applied to the IFM  202 , where each kernel  204  from among the eight kernels may produce an OFM channel. 
     In some embodiments, the tile  208  may include sixteen rows or sixteen lanes and eight columns. In some embodiments, during each cycle of operation (e.g., during each cycle of the clock), each of the sixteen multipliers in a column  210  may form a respective product from two factors at its inputs, each of the adders may form a sum of some of those sixteen products at its inputs. 
     Further details of the computation of OFM  206  using a neural processor incorporating tiles (e.g., tile  208 ) is discussed with respect to  FIGS. 1C-1H  of U.S. patent application Ser. No. 16/446,610, filed on Jun. 19, 2019, the entire content of which is hereby incorporated by reference. 
       FIG. 4  illustrates an example 2D IFM  400 . In some embodiments,  FIG. 4  shows how an IFM is split to pieces, where each piece is processed by a MAC tile (either using the same tile in different rounds or multiple tiles at the same time). In some example embodiments, during 2D (e.g., depthwise) convolution operation, the 2D IFM  400  may be divided into sections (e.g.,  402 ,  404 ) with eight columns wide (e.g., labeled bit 0 to bit 8 in this example). Each of the eight column wide sections  402 ,  404  may be processed in sequence. In some embodiments, each tile (e.g., a MAC tile) of a neural processor may process sixteen output channels. In some embodiments, the tile array of a neural processor may be configured to process the maximum number of output channels (e.g., all of the output channels of an output feature map (OFM)). For example, to process 64 output channels, the tile array of a neural processor may be configured as 4×4 tile array, so that 64 (e.g., 4×16 rows) channels may be processed at one time. 
     In some embodiments, because, there are four channels that feed the tile (e.g., a MAC tile) from SRAM, the first output pixel may take ((2+Kx−1)*Ky) cycles to calculate, which may be the number of cycles required to read the data for the first pixel. In this case, Kx and Ky are the dimensions of the 2D kernel. In some embodiments, each additional output pixel may take (Kx*Ky) cycles to calculate as SRAM reads may be overlapped with the calculations using the IFM already placed in the weight register. In some embodiments, to process each column of the IFM (e.g., IFM  400 ), additional data equal to the kernel minus  1  columns may be desired to process the IFM  400  columns in an IFM section (e.g., section  402 ) (for example, for a 2D kernel of size 3×3 (e.g., 3 rows and 3 columns), 3−1=2 additional columns of data may be needed to process the IFM  400 , as shown in  FIG. 4 ). Moreover, the hardware inside each tile (e.g., a MAC tile) of a neural processor may be rearranged and repurposed, in some embodiments. 
     In some embodiments, methods for computing convolutions may take into consideration the repeated use of the same convolution kernel (e.g., the same weights) across an input feature map (IFM) and may also take into consideration the repeated use of the same values of the IFM for multiple output values of the OFM. Such methods for computing convolution may maintain an accumulator for each output pixel of a current row of the OFM. In such a case, for each weight of the convolution kernel, the elements (e.g., activations) of the IFM are loaded in the weight registers. The loaded elements of the IFM are be multiplied by the current weight of the convolution kernel, and added to the accumulator. Next, the loaded elements are shifted to be multiplied by the next weight of the kernel, and additional elements from the IFM are loaded to the weight registers to be multiplied by the next weight of the convolution kernel. As a result, multiple values of the IFM that are multiplied by the same weight of the convolution kernel, are multiplied by that same weight in parallel, thereby increasing the number of operations completed per clock cycle, and previously loaded values are reused for multiplication by the next weight, thereby reducing the amount of data that is transferred. 
       FIGS. 5A-5W  illustrate an example method of determining a 2D OFM from a 2D IFM and a 2D kernel of weights. 
     In the example embodiment of  FIGS. 5A-5W , the weights in the kernel  504  may be placed in a cache  529  while the IFM is read into weight registers  528  (e.g., weight buffer  116  of  FIGS. 1-2 ). 
       FIGS. 5A-5M  illustrate in details regarding the determination of a first row  506  of the OFM  508  (e.g., an example for 3*3 convolution with stride one and no padding). 
       FIG. 5B  illustrates the details of the step  510  of  FIG. 5A . As shown in  FIG. 5B , at  510 , the four read channels  527  (e.g., the segmented IFM delivery fabric) load data from the positions [0,0], [0,2], [0,4], and [0,6] of the first row of the IFM  502  matrix from SRAM (e.g., SRAM bank set including four SRAM blocks) into four weight registers from a plurality (e.g., eight) of weight registers  528  (e.g., weight buffer  116  of  FIGS. 1-2 ). 
     Next, as shown in  FIG. 5C  the four read channels  527  load data from positions [0,1], [0,3], [0,5], and [0,7] of the first row of the IFM  502  matrix from SRAM into other four weight registers from among the eight weight registers  528 . The cache  529  (e.g., a Zigzag cache) broadcasts the weight value W 0  at position [0,0] of the kernel  504 . The multipliers in each column (e.g., a PE column of a MAC tile) may multiply the IFM values in the IFM matrix  502  positions [0,0]-[0,7] loaded in the weight registers  528  with W 0 , and load the results into a first set of accumulators (e.g., accumulator register  122  of  FIG. 2 ). 
       FIG. 5D  illustrates the details of the step  512 . As shown in  FIG. 5D , one read channel loads data from the position [0,8] of the first row of the IFM  502  matrix from SRAM into the weight register  528  for the eighth column of the IFM matrix  502 , while the IFM values loaded in the previous cycle (e.g., the IFM values in the IFM matrix  502  positions [0,0]-[0,7]) may be shifted to the left to the adjacent columns of the weight registers  528 , as shown in  FIG. 5D . The cache  529  broadcasts the weight value W 1  at position [0, 1] of the weight matrix  504 . The multipliers in each column (e.g., a PE column of a MAC tile) may multiply the IFM values in the IFM matrix  502  positions [0,1]-[0,8] loaded in the weight registers  528  with W 1 , and the results of the multiplications may be accumulated into the first set of accumulators (e.g., accumulator register  122  of  FIG. 2 ). 
       FIG. 5E  illustrates the details of the step  514 . As shown in  FIG. 5E , one read channel loads data from the position [0,9] of the first row of the IFM  502  matrix from SRAM into the weight register  528  for the ninth column of the IFM matrix  502 , while the IFM values loaded in the previous cycle (e.g., the IFM values in the IFM matrix  502  positions [0,1]-[0,8]) may be shifted to the left to the adjacent columns of the weight registers  528 , as shown in  FIG. 5E . The cache  529  may broadcast the value W 2  at position [0, 2]. The multipliers in each column (e.g., a PE column of a MAC tile) may multiply the IFM values in the IFM  502  matrix position [0,2]-[0,9] loaded in the weight registers with W 2 , and the results of the multiplications may be accumulated into the first set of accumulators (e.g., accumulator register  122  of  FIG. 2 ). At this stage, the processor has completed the first set of calculations for the convolution to determine the OFM  508 . Data from the positions [0,0]-[0,9] of the first row of the IFM  502  matrix may not be used in the next calculations (e.g., may not be needed for the next calculation) and therefore may not be saved in the weight registers  528  (e.g., the data from the first row of the IFM  502  may be discarded from or overwritten in the weight registers  528 ). 
       FIGS. 5F-5G  illustrate the details of step  516 . As shown in  FIG. 5F , the four read channels  527  (e.g., the segmented IFM delivery fabric) load data from the positions [1,0], [1,2], [1,4], and [1,6] of the second row of the IFM  502  matrix from SRAM (e.g., SRAM bank set including four SRAM blocks) into four weight registers from a plurality (e.g., eight) of weight registers  528  (e.g., weight buffer  116  of  FIGS. 1-2 ). Next, as shown in  FIG. 5G  the four read channels  527  load data from positions [1,1], [1,3], [1,5], and [1,7] of the second row of the IFM  502  matrix from SRAM into other four weight registers from among the eight weight registers  528 . The cache  529  (e.g., a Zigzag cache) broadcasts the weight value W 3  at position [1,0] of the weight matrix (or kernel)  504 . The multipliers in each column (e.g., a PE column of a MAC tile) may multiply the IFM values in the IFM matrix  502  positions [1,0]-[1,7] loaded in the weight registers  528  with W 3 , and load the results into a first set of accumulators (e.g., accumulator register  122  of  FIG. 2 ). 
       FIG. 5H  illustrates the details of the step  518 . As shown in  FIG. 5H , one read channel loads data from the position [1,8] of the second row of the IFM  502  matrix from SRAM into the weight register  528  for the eighth column of the IFM matrix  502 , while the IFM values loaded in the previous cycle (e.g., the IFM values in the IFM matrix  502  positions [1,0]-[1,7]) may be shifted to the left to the adjacent columns of the weight registers  528 , as shown in  FIG. 5H . The cache  529  broadcasts the weight value W 4  at position [1,1] of the weight matrix  504 . The multipliers in each column (e.g., a PE column of a MAC tile) may multiply the IFM values in the IFM matrix  502  positions [1,1]-[1,8] loaded in the weight registers  528  with W 4 , and the results of the multiplications may be accumulated into the first set of accumulators (e.g., accumulator register  122  of  FIG. 2 ). 
       FIG. 51  illustrates the details of the step  520 . As shown in  FIG. 51 , one read channel loads data from the position [1,9] of the second row of the IFM  502  matrix from 
     SRAM into the weight register  528  for the ninth column of the IFM matrix  502 , while the IFM values loaded in the previous cycle (e.g., the IFM values in the IFM matrix  502  positions [1,1]-[1,8]) may be shifted to the left to the adjacent columns of the weight registers  528 , as shown in  FIG. 51 . The cache  529  may broadcast the value W 5  at position [1, 2]. The multipliers in each column (e.g., a PE column of a MAC tile) may multiply the IFM values in the IFM  502  matrix position [1,2]-[1,9] loaded in the weight registers with W 5 , and the results of the multiplications may be accumulated into the first set of accumulators (e.g., accumulator register  122  of  FIG. 2 ). At this stage, the processor has completed the second set of calculations for the convolution to determine the OFM  508 . Data from the positions [1,0]-[1,9] of the first row of the IFM  502  matrix may be used in the next calculations and therefore may be saved in the weight registers  528 . 
       FIGS. 5J-5K  illustrate the details of step  522 . As shown in  FIG. 5J , the four read channels  527  (e.g., the segmented IFM delivery fabric) load data from the positions [2,0], [2,2], [2,4], and [2,6] of the second row of the IFM  502  matrix from SRAM (e.g., SRAM bank set including four SRAM blocks) into four weight registers from a plurality (e.g., eight) of weight registers  528  (e.g., weight buffer  116  of  FIGS. 1-2 ). Next, as shown in  FIG. 5K  the four read channels  527  load data from positions [2,1], [2,3], [2,5], and [2,7] of the third row of the IFM  502  matrix from SRAM into other four weight registers from among the eight weight registers  528 . The cache  529  (e.g., a Zigzag cache) broadcasts the weight value W 6  at position [2,0] of the weight matrix  504 . The multipliers in each column (e.g., a PE column of a MAC tile) may multiply the IFM values in the IFM matrix  502  positions [2,0]-[2,7] loaded in the weight registers  528  with W 6 , and load the results into a first set of accumulators (e.g., accumulator register  122  of  FIG. 2 ). 
       FIG. 5L  illustrates the details of the step  524 . As shown in  FIG. 5L , one read channel loads data from the position [2,8] of the third row of the IFM  502  matrix from SRAM into the weight register  528  for the eighth column of the IFM matrix  502 , while the IFM values loaded in the previous cycle (e.g., the IFM values in the IFM matrix  502  positions [2,0]-[2,7]) may be shifted to the left to the adjacent columns of the weight registers  528 , as shown in  FIG. 5L . The cache  529  broadcasts the weight value W 7  at position [2, 1] of the weight matrix  504 . The multipliers in each column (e.g., a PE column of a MAC tile) may multiply the IFM values in the IFM matrix  502  positions [2,1]-[2,8] loaded in the weight registers  528  with W 7 , and the results of the multiplications may be accumulated into the first set of accumulators (e.g., accumulator register  122  of  FIG. 2 ). 
       FIG. 5M  illustrates the details of the step  526 . As shown in  FIG. 5M , one read channel loads data from the position [2,9] of the third row of the IFM  502  matrix from SRAM into the weight register  528  for the ninth column of the IFM matrix  502 , while the IFM values loaded in the previous cycle (e.g., the IFM values in the IFM matrix  502  positions [2,1]-[2,8]) may be shifted to the left to the adjacent columns of the weight registers  528 , as shown in  FIG. 5M . The cache  529  may broadcast the value W 8  at position [2, 2]. The multipliers in each column (e.g., a PE column of a MAC tile) may multiply the IFM values in the IFM  502  matrix position [2,2]-[2,9] loaded in the weight registers with W 8 , and the results of the multiplications may be accumulated into the first set of accumulators (e.g., accumulator register  122  of  FIG. 2 ). At this stage, the processor has completed the next set of calculations for the convolution to determine the OFM  508 . Data from the positions [2,0]-[2,9] of the IFM  502  matrix may be used in the next calculations and therefore may be saved in the weight registers  528 . 
     The results from  510  to  526  may be added to determine the first row  506  of the OFM  508 . 
       FIGS. 5N-5W  illustrate in details regarding the determination of a second row  530  of the OFM  508 . 
       FIG. 5O  illustrates the details of the step  532  of  FIG. 5N . As shown in  FIG. 5O , at  532 , the four read channels  527  (e.g., the segmented IFM delivery fabric) load data from the positions [3,0], [3,2], [3,4], and [3,6] of the fourth row of the IFM  502  matrix from SRAM (e.g., SRAM bank set including four SRAM blocks) into four weight registers from a plurality (e.g., eight) of weight registers  528  (e.g., weight buffer  116  of  FIGS. 1-2 ). The cache  529  may broadcast the value W 0  at position [0, 0]. The multipliers in each column (e.g., a PE column of a MAC tile) may multiply the IFM values in the IFM  502  matrix position [1,0]-[1,7] loaded in the weight registers with W 0 , and the results of the multiplications may be accumulated into a second set of accumulators (e.g., accumulator register  122  of  FIG. 2 ), while first set of accumulators may be written back into SRAM banks (e.g., SRAM bank sets). 
       FIG. 5P  illustrates the details of the step  534 . As shown in  FIG. 5P , read channels  527  load data from positions [3,1], [3,3], [3,5], and [3,7] of the fourth row of the IFM  502  matrix from SRAM into other four weight registers from among the eight weight registers  528 . The cache  529  (e.g., a Zigzag cache) broadcasts the weight value W 1  at position [1,1] of the weight matrix  504 . The multipliers in each column (e.g., a PE column of a MAC tile) may multiply the IFM values in the IFM matrix  502  positions [1,1]-[1,8] loaded in the weight registers  528  with W 1 , and load the results into the second set of accumulators (e.g., accumulator register  122  of  FIG. 2 ). The first set of accumulators continue to be written back into SRAM banks (e.g., SRAM bank sets). Data from the IFM matrix  502  position [1,0]-[1,7] may not be needed and therefore will be replaced by the data in the IFM  502  data position [3,0]-[3,7]. 
       FIG. 5Q  illustrates the details of the step  536 . As shown in  FIG. 5Q , one read channel loads data from the position [ 3 , 8 ] of the IFM  502  matrix from SRAM into the weight register  528  for the eighth column of the IFM matrix  502 , while the IFM values loaded in the previous cycle (e.g., the IFM values in the IFM matrix  502  positions [3,0]-[3,7]) may be shifted to the left to the adjacent columns of the weight registers  528 , as shown in  FIG. 5Q . The cache  529  broadcasts the weight value W 2  at position [0, 2] of the weight matrix  504 . The multipliers in each column (e.g., a PE column of a MAC tile) may multiply the IFM values in the IFM matrix  502  positions [1,2]-[1,9] loaded in the weight registers  528  with W 2 , and the results of the multiplications may be accumulated into the second set of accumulators (e.g., accumulator register  122  of  FIG. 2 ). Data from the positions [1,1]-[1,8] of the IFM  502  matrix may not be used in the next calculations and therefore may be replaced by the data in the IFM  502  data position [3,1]-[3,8]. 
       FIG. 5R  illustrates the details of step  538 . As shown in  FIG. 5R , one read channel loads data from the position [3,9] of the forth row of the IFM  502  matrix from SRAM into the weight register  528  for the ninth column of the IFM matrix  502 , while the IFM values loaded in the previous cycle (e.g., the IFM values in the IFM matrix  502  positions [3,1]-[3,8]) may be shifted to the left to the adjacent columns of the weight registers  528 , as shown in  FIG. 5R . The cache  529  may broadcast the value W 3  at position [2, 0]. The multipliers in each column (e.g., a PE column of a MAC tile) may multiply the IFM values in the IFM  502  matrix position [2,0]-[2,7] loaded in the weight registers with W 3 , and the results of the multiplications may be accumulated into the first set of accumulators (e.g., accumulator register  122  of  FIG. 2 ). At this stage, the processor has completed the second set of calculations for the convolution to determine the OFM  508 . Data from the positions [1,2]-[1,9] of the IFM  502  matrix may be used in the next calculations and therefore may be saved in the weight registers  528 . Data from the positions [1,2]-[1,9] of the second row of the IFM  502  matrix may not be used in the next calculations and therefore will be replaced by the data in the IFM  502  data position [3,2]-[3,9]. 
       FIG. 5S  illustrates the details of step  540 . As shown in  FIG. 5F , the four read channels  527  (e.g., the segmented IFM delivery fabric) load data from the positions [4,0], [4,2], [4,4], and [4,6] of the fifth row of the IFM  502  matrix from SRAM (e.g., SRAM bank set including four SRAM blocks) into four weight registers from a plurality (e.g., eight) of weight registers  528  (e.g., weight buffer  116  of  FIGS. 1-2 ). The cache  529  (e.g., a Zigzag cache) broadcasts the weight value W 4  at position [1,1] of the weight matrix  504 . The multipliers in each column (e.g., a PE column of a MAC tile) may multiply the IFM values in the IFM matrix  502  positions [2,1]-[2,8] loaded in the weight registers  528  with W 4 , and load the results into the second set of accumulators (e.g., accumulator register  122  of  FIG. 2 ). 
       FIG. 5T  illustrates the details of the step  542 . As shown in  FIG. 5T , read channels  527  load data from positions [4,1], [4,3], [4,5], and [4,7] of the fifth row of the IFM  502  matrix from SRAM into other four weight registers from among the eight weight registers  528 . The cache  529  (e.g., a Zigzag cache) broadcasts the weight value W 5  at position [1,2] of the weight matrix  504 . The multipliers in each column (e.g., a PE column of a MAC tile) may multiply the IFM values in the IFM matrix  502  positions [2,2]-[2,9] loaded in the weight registers  528  with W 5 , and load the results into the second set of accumulators (e.g., accumulator register  122  of  FIG. 2 ). Data from the IFM matrix  502  position [2,0]-[2,7] may not be needed and therefore will be replaced by the data in the IFM  502  data position [4,0]-[4,7]. 
       FIG. 5U  illustrates the details of the step  544 . As shown in  FIG. 5U , one read channel loads data from the position [ 4 , 8 ] of the IFM  502  matrix from SRAM into the weight register  528  for the eighth column of the IFM matrix  502 , while the IFM values loaded in the previous cycle (e.g., the IFM values in the IFM matrix  502  positions [4,0]-[4,7]) may be shifted to the left to the adjacent columns of the weight registers  528 , as shown in  FIG. 5U . The cache  529  broadcasts the weight value W 6  at position [2, 0] of the weight matrix  504 . The multipliers in each column (e.g., a PE column of a MAC tile) may multiply the IFM values in the IFM matrix  502  positions [3,0]-[3,7] loaded in the weight registers  528  with W 6 , and the results of the multiplications may be accumulated into the second set of accumulators (e.g., accumulator register  122  of  FIG. 2 ). Data from the positions [2,1]-[2,8] of the IFM  502  matrix may not be used in the next calculations and therefore will be replaced by the data in the IFM  502  data position [3,1]-[3,8]. 
       FIG. 5V  illustrates the details of the step  546 . As shown in  FIG. 5V , one read channel loads data from the position [4,9] of the fifth row of the IFM  502  matrix from SRAM into the weight register  528  for the ninth column of the IFM matrix  502 , while the IFM values loaded in the previous cycle (e.g., the IFM values in the IFM matrix  502  positions [4,1]-[4,8]) may be shifted to the left to the adjacent columns of the weight registers  528 , as shown in  FIG. 5V . The cache  529  may broadcast the value W 7  at position [2, 1]. The multipliers in each column (e.g., a PE column of a MAC tile) may multiply the IFM values in the IFM  502  matrix position [3,1]-[3,8] loaded in the weight registers with W 7 , and the results of the multiplications may be accumulated into the first set of accumulators (e.g., accumulator register  122  of  FIG. 2 ). At this stage, the processor has completed the next set of calculations for the convolution to determine the OFM  508 . Data from the position [3,0]-[3,9] of the IFM matrix  502  will be used in the next calculations and may be saved as shown in  FIG. 5V . Data from the positions [2 ,2]-[2,9] may not be used in the next calculations and therefore will be replaced by the data in the IFM  502  data position [3,2]-[3,9]. 
       FIG. 5W  illustrates the details of the step  548  of  FIG. 5N . As shown in  FIG. 5W , at  548 , the four read channels  527  (e.g., the segmented IFM delivery fabric) load data from the positions [5,0], [5,2], [5,4], and [5,6] of the IFM  502  matrix from SRAM (e.g., SRAM bank set including four SRAM blocks) into four weight registers from a plurality (e.g., eight) of weight registers  528  (e.g., weight buffer  116  of  FIGS. 1-2 ). The cache  529  may broadcast the value W 8  at position [2, 2]. The multipliers in each column (e.g., a PE column of a MAC tile) may multiply the IFM values in the IFM  502  matrix position [3,2]-[3,9] loaded in the weight registers with W 8 , and the results of the multiplications may be accumulated into a second set of accumulators (e.g., accumulator register  122  of  FIG. 2 ), and the second set of accumulators may be written back into SRAM banks. (e.g., SRAM bank sets) during the next cycle. In some embodiments, the first set of accumulators may be used to accumulate the multiplications results starting the next cycle. 
     The results from  532  to  548  may be added to determine the second row  530  of the OFM  508 . While the computation of the second row  530  is described above in reference to  FIGS. 5N-5W , one of skill in the art would understand that the remaining rows of the OFM  508  can be computed based on the data in the remaining rows of the IFM  502  using substantially similar operations. Similarly, portions of the OFM  508  corresponding to the remaining eight column wide sections (e.g., the second eight column wide section  404 ) of the IFM  502  can be computed using similar operations, starting with computing the first row of the OFM  508  as described above in reference to  FIGS. 5A-5M , and computing the remaining rows of the OFM  508  as described above in reference to  FIGS. 5N-5W . 
     It will be understood that, although the terms “first”, “second”, “third”, etc., may be used herein to describe various elements, components, regions, layers and/or sections, these elements, components, regions, layers and/or sections should not be limited by these terms. These terms are only used to distinguish one element, component, region, layer or section from another element, component, region, layer or section. Thus, a first element, component, region, layer or section discussed herein could be termed a second element, component, region, layer or section, without departing from the scope of the present disclosure. 
     Spatially relative terms, such as “beneath”, “below”, “lower”, “under”, “above”, “upper” and the like, may be used herein for ease of description to describe one element or feature&#39;s relationship to another element(s) or feature(s) as illustrated in the figures. It will be understood that such spatially relative terms are intended to encompass different orientations of the device in use or in operation, in addition to the orientation depicted in the figures. For example, if the device in the figures is turned over, elements described as “below” or “beneath” or “under” other elements or features would then be oriented “above” the other elements or features. Thus, the example terms “below” and “under” can encompass both an orientation of above and below. The device may be otherwise oriented (e.g., rotated 90 degrees or at other orientations) and the spatially relative descriptors used herein should be interpreted accordingly. In addition, it will also be understood that when a layer is referred to as being “between” two layers, it can be the only layer between the two layers, or one or more intervening layers may also be present. 
     The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the present disclosure. As used herein, the terms “substantially,” “about,” and similar terms are used as terms of approximation and not as terms of degree, and are intended to account for the inherent deviations in measured or calculated values that would be recognized by those of ordinary skill in the art. 
     As used herein, the singular forms “a” and “an” are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms “comprises” and/or “comprising”, when used in this specification, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof. As used herein, the term “and/or” includes any and all combinations of one or more of the associated listed items. Expressions such as “at least one of,” when preceding a list of elements, modify the entire list of elements and do not modify the individual elements of the list. Further, the use of “may” when describing embodiments of the present disclosure refers to “one or more embodiments of the present disclosure”. Also, the term “exemplary” is intended to refer to an example or illustration. As used herein, the terms “use,” “using,” and “used” may be considered synonymous with the terms “utilize,” “utilizing,” and “utilized,” respectively. 
     It will be understood that when an element or layer is referred to as being “on”, “connected to”, “coupled to”, or “adjacent to” another element or layer, it may be directly on, connected to, coupled to, or adjacent to the other element or layer, or one or more intervening elements or layers may be present. In contrast, when an element or layer is referred to as being “directly on”, “directly connected to”, “directly coupled to”, or “immediately adjacent to” another element or layer, there are no intervening elements or layers present. 
     Any numerical range recited herein is intended to include all sub-ranges of the same numerical precision subsumed within the recited range. For example, a range of “1.0 to 10.0” is intended to include all subranges between (and including) the recited minimum value of 1.0 and the recited maximum value of 10.0, that is, having a minimum value equal to or greater than 1.0 and a maximum value equal to or less than 10.0, such as, for example, 2.4 to 7.6. Any maximum numerical limitation recited herein is intended to include all lower numerical limitations subsumed therein and any minimum numerical limitation recited in this specification is intended to include all higher numerical limitations subsumed therein. 
     In some embodiments, one or more outputs of the different embodiments of the methods and systems of the present disclosure may be transmitted to an electronics device coupled to or having a display device for displaying the one or more outputs or information regarding the one or more outputs of the different embodiments of the methods and systems of the present disclosure. 
     The electronic or electric devices and/or any other relevant devices or components according to embodiments of the present disclosure described herein may be implemented utilizing any suitable hardware, firmware (e.g. an application-specific integrated circuit), software, or a combination of software, firmware, and hardware. For example, the various components of these devices may be formed on one integrated circuit (IC) chip or on separate IC chips. Further, the various components of these devices may be implemented on a flexible printed circuit film, a tape carrier package (TCP), a printed circuit board (PCB), or formed on one substrate. Further, the various components of these devices may be a process or thread, running on one or more processors, in one or more computing devices, executing computer program instructions and interacting with other system components for performing the various functionalities described herein. The computer program instructions are stored in a memory which may be implemented in a computing device using a standard memory device, such as, for example, a random access memory (RAM). The computer program instructions may also be stored in other non-transitory computer readable media such as, for example, a CD-ROM, flash drive, or the like. Also, a person of skill in the art should recognize that the functionality of various computing devices may be combined or integrated into a single computing device, or the functionality of a particular computing device may be distributed across one or more other computing devices without departing from the spirit and scope of the exemplary embodiments of the present disclosure. 
     Although exemplary embodiments of system and method for accelerating two dimensional (2D) convolutional layer mapping on a dot product architecture have been specifically described and illustrated herein, many modifications and variations will be apparent to those skilled in the art. Accordingly, it is to be understood that a system and method for accelerating two dimensional (2D) convolutional layer mapping on a dot product architecture according to principles of this disclosure may be embodied other than as specifically described herein. The present disclosure is also defined in the following claims, and equivalents thereof.