A low-power computing method for artificial intelligence hardware chips

By combining bitmap-based streaming encoding and event-driven asynchronous routing mesh, the problem of excessive power consumption in unstructured sparse data processing in existing technologies is solved, achieving low-power sparse data computation and reducing the actual power consumption of the chip.

CN123115049APending Publication Date: 2026-11-17广州博玮科技有限公司
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611588888.4
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-10-14
Publication Date
2026-11-17

AI Technical Summary

Technical Problem

When processing unstructured sparse neural network data, existing AI hardware chips require complex index matching, indirect addressing, and centralized decoding control circuits. This results in dynamic power consumption and chip area overhead from the addressing and control logic far exceeding the power savings from skipping zero-value multiplication and addition operations. This limits the ability of edge AI chips to deploy high-compression-rate sparse models under stringent power constraints.

Method used

A bitmap joint streaming encoding method is used to divide the activation tensor and weight tensor into blocks, generate a joint bitmap and generate event data, and control the clock and power supply of the multiply-accumulate node through event-driven asynchronous routing grid and dynamic gating unit to achieve low-power computing.

Benefits of technology

By eliminating the need to store and retrieve large coordinate index arrays, reducing memory access power consumption and control logic circuit area, chip power consumption decreases as sparsity increases, avoiding the power inversion phenomenon where higher sparsity results in a larger proportion of control overhead.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123115049A_ABST
    Figure CN123115049A_ABST
Patent Text Reader

Abstract

This invention discloses a low-power computing method for artificial intelligence hardware chips. The method involves dividing the activation tensor and weight tensor into blocks to generate activation value bitmaps and weight bitmaps. A bitwise AND operation is performed on these two bitmaps to obtain a joint bitmap. Event data is generated based on the positions with bit values ​​of 1 in the joint bitmap, forming an event stream. During runtime, the joint bitmap is scanned bit by bit. Event data is forwarded to idle multiply-accumulate nodes via a routing grid using an asynchronous handshake mechanism. Positions with bit values ​​of 0 are directly truncated. Dynamic gating units deployed corresponding to the multiply-accumulate nodes control the clock and power supply of the multiply-accumulate nodes based on local request signals, causing idle multiply-accumulate nodes to enter a sleep state. This invention eliminates the need for coordinate index storage and centralized index matching circuits, reducing addressing and control power consumption, and is suitable for low-power computing of sparse neural networks in edge artificial intelligence chips.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This invention relates to the field of artificial intelligence hardware chip technology, specifically to a low-power computing method for artificial intelligence hardware chips. Background Technology

[0002] As large language models and various deep neural networks are rapidly deployed to the edge, edge AI chips generally face the dual pressures of milliwatt-level power consumption constraints and limited on-chip storage bandwidth. To reduce the computational and storage overhead of neural network models, the industry generally adopts model compression methods such as weight quantization and network pruning. Among them, unstructured sparsity refers to randomly setting redundant elements in the neural network tensor (activation value or weight) to zero without being constrained by a fixed ratio or fixed block rule. This method is considered to be one of the technical routes with better model compression effect because it can achieve a high compression rate with almost no loss of model accuracy. It is different from structured sparsity (such as 2:4 sparsity) that is distributed according to a fixed rule.

[0003] In traditional von Neumann architecture and systolic array computing platforms, the multiply-accumulate unit array takes the elements of a regularly arranged dense matrix one by one and performs multiplication and addition operations according to a fixed clock beat. This type of architecture is mainly designed for dense matrix multiplication and does not have a natural adaptability to the processing of unstructured sparse data.

[0004] Current mainstream neural network processors typically employ the following implementation method when processing unstructured sparse data: First, during the compiler or compressed sensing training phase, unstructured pruning is performed on the weight tensor, redundant weights are reset to zero, and the coordinates of non-zero weights are encoded and stored using compressed sparse row or compressed sparse column format, forming a storage structure that combines numerical arrays and index arrays. Second, during chip operation, the control unit initiates indirect addressing access to the on-chip memory based on the stored index array, retrieving the activation value corresponding to that index. Third, a centralized index matching decoder is set up within the chip to compare the retrieved weight index with the activation value index. The comparison process determines whether the two operands are allowed to be sent to the multiply-accumulate unit array for operation only when their coordinates match. Otherwise, the data is discarded or a new address matching is initiated. Finally, the data with successful index matching is uniformly scheduled into the multiply-accumulate unit array through the global synchronization bus, and the multiply-accumulate operation is completed according to a fixed clock cycle. The result is then summarized and output through the global accumulation tree. The existing implementation mentioned above includes components such as a pruning compression coding module, an indirect addressing controller, an index matching decoder, a global synchronization bus, a multiply-accumulate unit array, and a global accumulation tree. Each component completes the calculation sequentially through a serial process of data retrieval, addressing, comparison, and scheduling.

[0005] However, the existing implementation methods described above have significant inherent drawbacks. Since both weights and activation values ​​are stored independently with coordinate indices, the chip must initiate a memory indirect addressing operation for each pair of operands during operation. Indirect addressing physically involves address decoding, memory read channel switching, and a wide range of data line level toggles, resulting in dynamic power consumption and memory access latency far exceeding those of conventional sequential access methods. Furthermore, to ensure strict alignment of non-zero weights and non-zero activation values ​​in spatial coordinates, a centralized index matching decoder must be introduced to compare their coordinates one by one. This comparison process involves a large-scale comparator array and... Multiplexer networks account for a significant proportion of the chip's dynamic power consumption in terms of area and power consumption. The sum of the addressing power consumption and matching control power consumption often exceeds the computational power saved by skipping zero-value multiplication and addition operations when the sparsity is not extreme enough. This results in a power inversion phenomenon where the higher the sparsity, the greater the proportion of control overhead. As a result, unstructured sparse is difficult to achieve power consumption gains that match the theoretical compression rate in actual hardware. Therefore, the industry has been forced to compromise and adopt structured sparse in some scenarios. However, the compression rate and model accuracy preservation ability of structured sparse are significantly worse than those of unstructured sparse, and it is impossible to balance compression effect and hardware implementation efficiency.

[0006] In summary, when processing unstructured sparse data, existing AI hardware chips require complex index matching, indirect addressing, and centralized decoding control circuits to align non-zero activation values ​​with non-zero weights. This results in dynamic power consumption and chip area overhead from the addressing and control logic far exceeding the power savings from skipping zero-value multiplication and addition operations. This limits the ability of edge AI chips to deploy high-compression-rate sparse models under stringent power constraints. To address this, we propose a low-power computing method for AI hardware chips. Summary of the Invention

[0007] The technical problem this invention aims to solve is that when existing artificial intelligence hardware chips process unstructured sparse neural network data, the need to introduce complex index matching, indirect addressing, and centralized decoding control circuits to achieve the alignment operation of non-zero activation values ​​and non-zero weights results in dynamic power consumption and chip area overhead generated by the addressing and control logic far exceeding the power consumption gains from skipping zero-value multiplication and addition operations. This makes it difficult to truly realize the theoretical low power consumption advantage of unstructured sparse data in actual hardware.

[0008] To address the aforementioned technical problems, this invention provides a low-power computing method for artificial intelligence hardware chips. The method includes: dividing the activation tensor and weight tensor to be processed into blocks according to a preset block size to obtain multiple tensor blocks.

[0009] For each tensor block, the activation value sub-tensor and weight value sub-tensor are checked element by element to determine whether the value is zero, and an activation value bitmap and a weight bitmap are generated.

[0010] Perform a bitwise logical AND operation on the activation value bitmap and weight bitmap of the same tensor block to obtain a joint bitmap of the tensor block;

[0011] Based on the positions in the joint bitmap where the bit value is 1, non-zero activation values ​​and non-zero weight values ​​are extracted from the corresponding tensor blocks and packaged to generate event data. No event data is generated for the positions in the joint bitmap where the bit value is 0.

[0012] The combined bitmap and the corresponding event data are combined to form an event stream, which is then written into the on-chip event stream buffer.

[0013] The joint bitmap is scanned bit by bit, a route request signal is generated for the position with a bit value of 1, and the event data corresponding to the position is forwarded to the multiply-accumulate node in the idle state along the intersection of the routing grid. No route request signal is generated for the position with a bit value of 0.

[0014] After receiving the routing request signal, the target multiply-accumulate node returns a response signal to the intersection that initiated the routing request signal;

[0015] The dynamic gating unit deployed corresponding to each multiply-accumulate node controls the opening and closing of the clock and power supply of the corresponding multiply-accumulate node according to the local routing request signal. During the period when no routing request signal is received, the clock and power supply of the corresponding multiply-accumulate node are disconnected to put it into a sleep state. After receiving the routing request signal, the clock and power supply of the corresponding multiply-accumulate node are restored.

[0016] The multiply-accumulate node, whose clock and power supply have been restored, performs multiply-accumulate operations on the non-zero activation values ​​and non-zero weight values ​​in the received event data to generate a partial sum;

[0017] The local sums of the outputs of multiple multiply-accumulate nodes are accumulated step by step to obtain the calculation result of the current tensor block.

[0018] The present invention also provides a low-power computing architecture for an artificial intelligence hardware chip, the architecture including a bitmap joint streaming encoding module, an on-chip event stream buffer, an event-driven asynchronous routing grid, a multiply-accumulate array composed of multiple multiply-accumulate nodes, multiple dynamic gating units deployed corresponding to each multiply-accumulate node, and an asynchronous reduction network. The bitmap joint streaming encoding module is used to perform the aforementioned bitmap generation, bitwise logical AND operation and event data packaging functions.

[0019] The on-chip event stream buffer is used to cache the generated event stream;

[0020] The event-driven asynchronous routing mesh is used for selective forwarding based on the joint bitmap;

[0021] The dynamic gating unit is used to implement fine-grained power consumption control on the multiply-accumulate node;

[0022] The asynchronous reduction network is used to summarize and accumulate the partial sums of the outputs of each multiply-accumulate node.

[0023] Compared with the prior art, the beneficial effects of the present invention by adopting the above technical solution are as follows:

[0024] 1. This invention uses bitmap joint streaming encoding to embed coordinate index information within the bit positions of the joint bitmap, eliminating the need for storing and retrieving a large coordinate index array. Event data is generated only at the position where the bit value of the joint bitmap is 1, reducing the frequency of storage access and the power consumption of memory access.

[0025] 2. This invention uses an event-driven asynchronous routing grid to replace the centralized index matching decoder and global synchronization bus with local asynchronous handshake signals. The positions where the bit value of the joint bitmap is 0 are directly truncated at the intersection of the routing grid without generating data line level flipping, which reduces the circuit area and power consumption occupied by the addressing and control logic.

[0026] 3. This invention uses a dynamic gating unit deployed one-to-one with the multiply-accumulate nodes to enable multiply-accumulate nodes that have not received a routing request signal to enter a sleep state in a timely manner, and restore clock and power supply only after receiving a valid routing request signal. This reduces the static power consumption of the multiply-accumulate array in the idle state, and makes the actual power consumption of the chip decrease accordingly with the increase of the actual sparsity of the neural network. This alleviates the power inversion problem in the prior art where the higher the sparsity, the greater the proportion of control overhead. Attached Figure Description

[0027] Figure 1 This is a flowchart illustrating the overall low-power computing process of the artificial intelligence hardware chip in this embodiment of the invention.

[0028] Figure 2 This is a flowchart of bitmap joint streaming encoding in an embodiment of the present invention;

[0029] Figure 3 This is a flowchart of event-driven asynchronous routing and dynamic gating operations in an embodiment of the present invention. Detailed Implementation

[0030] The following is in conjunction with the appendix Figure 1-3 The specific embodiments of the present invention will be further described below. It should be noted that the description of these embodiments is for the purpose of helping to understand the present invention, but does not constitute a limitation of the present invention.

[0031] To make the technical solutions and advantages of the present invention clearer, the present invention will be further described in detail below with reference to specific embodiments. It should be understood that the specific embodiments described herein are only for explaining the present invention and are not intended to limit the scope of protection of the present invention.

[0032] I. Overall Architecture Implementation Examples

[0033] The low-power computing architecture of the artificial intelligence hardware chip provided in this embodiment includes a bitmap joint streaming encoding module, an on-chip event stream buffer, an event-driven asynchronous routing grid, a multiply-accumulate array composed of multiple multiply-accumulate nodes, multiple dynamic gating units deployed corresponding to each multiply-accumulate node, and an asynchronous reduction network. All of the above components can be deployed within the same chip underlying computing architecture. The bitmap joint streaming encoding module can be deployed on the chip preprocessing unit, or the corresponding encoding function can be deployed on the offline compiler side, whereby the compiler pre-compiles the encoding and loads the encoding result into the chip on-chip memory.

[0034] The connection relationships and data flow between the components are as follows: The input of the bitmap joint streaming encoding module is the activation tensor and weight tensor to be processed, and its output is an event stream composed of the joint bitmap and the corresponding event data. This output is buffered by the on-chip event stream buffer and then sent to the event-driven asynchronous routing grid in batches.

[0035] The event-driven asynchronous routing mesh selectively forwards event data to idle multiply-accumulate nodes based on the bit values ​​of the joint bitmap.

[0036] The dynamic gating unit is deployed one-to-one with each multiply-accumulate node, and controls the opening and closing of the clock tree branch and power rail of the corresponding multiply-accumulate node according to the routing request signal issued by the event-driven asynchronous routing mesh.

[0037] The results of the multiply-accumulate operations at each node are accumulated step by step by the asynchronous reduction network and then output to the on-chip output buffer.

[0038] II. Examples of Bitmap Joint Streaming Coding Method

[0039] In this embodiment, the bitmap joint streaming coding module's processing of the activation tensor and weight tensor includes the following:

[0040] First, the activation tensor and weight tensor to be processed are divided into blocks according to a preset block size, resulting in several tensor blocks of length N, where N is the number of elements contained in each block. This number can be configured according to the chip hardware resources during the compilation or preprocessing stage. For example, N can be configured as sixty-four or one hundred and twenty-eight. The activation value sub-tensor in the i-th block is denoted as the activation value part of that block, and the weight value sub-tensor is denoted as the weight value part of that block.

[0041] Secondly, for each block, the activation value sub-tensor and weight value sub-tensor are checked element by element to determine whether the value is zero, and an activation value bitmap and a weight bitmap are generated. Both are bit strings of length N, and the rule for the value of each bit is: if the element at the corresponding position is non-zero, then the bit position is 1.

[0042] If the element at the corresponding position is zero, then the bit position is 0. Taking a block containing eight elements as an example, if the first, third, and sixth elements in the activation value sub-tensor are non-zero and the rest are zero, then the bits at the corresponding positions in the activation value bitmap are 1, 0, 1, 0, 0, 1, 0, 0 in sequence.

[0043] If the first, fourth, and sixth elements of the weight subtensor are non-zero, and the rest are zero, then the bits at the corresponding positions in the weight bitmap are 1, 0, 0, 1, 0, 1, 0, 0, respectively.

[0044] Next, perform a bitwise logical AND operation on the activation value bitmap and weight bitmap of the same block to obtain the joint bitmap of the block. That is, the bit of the joint bitmap is set to 1 only when both the activation value bitmap and the weight bitmap are 1 at the same bit position; otherwise, it is set to 0. Following the example above, the joint bitmap corresponding to this block is 1, 0, 0, 0, 0, 1, 0, 0 in sequence. That is, only the first and sixth positions are valid calculation positions where the activation value and weight are both non-zero, and the remaining positions do not need to participate in the actual multiplication and addition operations.

[0045] Then, based on the positions of bits with a value of 1 in the combined bitmap, the corresponding non-zero activation values ​​and non-zero weight values ​​are extracted from the original block and packaged into event data in sequence. Each event data carries the following: a numerical pair consisting of a non-zero activation value and a non-zero weight value, the relative position encoding of the bit in the block, and a valid flag bit. No event data is generated for the bit positions corresponding to zero values, thus eliminating the need for storage and transmission of zero-value elements at the physical level. Using the above example, this block ultimately generates only two event data, corresponding to the numerical pairs at the first and sixth positions in the combined bitmap, respectively.

[0046] Finally, several event data generated from the same block are sequentially encapsulated into an event stream, and a corresponding joint bitmap is attached to the beginning of the event stream as auxiliary identification information for the event stream. The bit width of the joint bitmap is the same as the block size N, and it is written into the on-chip event stream buffer along with the event stream for event-driven asynchronous routing mesh to read and schedule.

[0047] With the above encoding method, the coordinate information is implicit in the position of each bit in the joint bitmap. The downstream module can directly determine the position of each event data in the original block based on the joint bitmap without having to maintain and read the independent coordinate index array. This eliminates the storage and access overhead caused by the combination of numerical array and index array in the traditional compressed sparse row and compressed sparse column storage formats.

[0048] III. Examples of Event-Driven Asynchronous Routing and Dynamic Gating Methods

[0049] In this embodiment, during chip operation, the on-chip event stream buffer sends the joint bitmap corresponding to a certain block and its subsequent event data sequence to the input port of the event-driven asynchronous routing grid in sequence. The event-driven asynchronous routing grid is set with multiple intersections arranged in a matrix, and the routing controller scans the joint bitmap bit by bit.

[0050] For positions with a bit value of 1 in the joint bitmap, the routing controller generates a routing request signal and transmits the event data corresponding to that position step by step along the intersections in the routing grid. For positions with a bit value of 0 in the joint bitmap, the routing controller does not generate a routing request signal or generate corresponding data transmission. This position is directly truncated at the intersection of the hardware grid, and no data line level flip occurs. Therefore, this part of the position does not generate additional dynamic flip power consumption.

[0051] Each intersection in the routing mesh forwards event data carrying a routing request signal to the currently idle multiply-accumulate node according to its local arbitration logic. Each multiply-accumulate node sets a busy / idle status register. After completing a multiply-accumulate operation and sending the partial sum into the asynchronous reduction network, it sets its own busy / idle status register to the idle state and reports it to the adjacent intersection via the status feedback line. Based on the received busy / idle status information, the intersection uses a round-robin arbitration method to determine the target multiply-accumulate node from the idle multiply-accumulate nodes that meet the candidate forwarding conditions.

[0052] When the target multiply-accumulate node receives the routing request signal, it returns a response signal to the cross point that initiated the request, completing an asynchronous handshake. The entire forwarding process does not depend on the global synchronization clock tick, meaning that the forwarding times between each cross point in the routing mesh can be independent and do not need to be synchronized under a unified clock tick.

[0053] The dynamic gating unit, which is deployed one-to-one with each multiply-accumulate node, continuously monitors the local routing request signal: during the period when no routing request signal is received, the dynamic gating unit controls the clock tree branch of the corresponding multiply-accumulate node to disconnect and simultaneously cuts off the power supply to its power rail, so that the multiply-accumulate node enters a local sleep state.

[0054] Once the local routing request signal arrives, the dynamic gating unit restores the clock and power supply of the multiply-accumulate node within a preset wake-up delay time. This wake-up delay time is less than the chip's main clock cycle, so it will not significantly affect the chip's overall computing throughput.

[0055] The multiply-accumulate node whose clock and power supply have been restored performs multiply-accumulate operations on the non-zero activation values ​​and non-zero weight values ​​carried in the received event data, generates a partial sum, and sends the operation completion status back to the routing mesh through an acknowledgment signal, while sending the partial sum into the asynchronous reduction network.

[0056] The asynchronous reduction network asynchronously accumulates the local sums of the outputs of each multiply-accumulate node within the same block in a tree structure to obtain the calculation result of the block, and writes it back to the on-chip output buffer.

[0057] After all event data in the current block has been processed, the event-driven asynchronous routing grid moves on to scanning and scheduling the next block of the joint bitmap, repeating the above process until the calculation of the entire tensor is completed.

[0058] In this embodiment, the actual power consumption of the chip decreases as the network sparsity increases: the higher the sparsity, the fewer the number of positions with a bit value of 1 in the joint bitmap, the fewer the number of routing request signals to be generated and the number of event data to be forwarded, the fewer the number of multiply-accumulate nodes participating in the actual multiply-accumulate operation, the more the proportion of multiply-accumulate nodes entering the sleep state, and the switching power consumption of the routing mesh itself and the static leakage power consumption of the multiply-accumulate array decrease accordingly. Since this invention does not rely on a centralized index matching decoder and explicit indirect addressing operations, the circuit structure of the routing mesh and the dynamic gating unit itself is relatively simple, and the overhead generated is much less than the power consumption generated by the centralized index matching decoder and indirect addressing controller in the prior art. Therefore, the power consumption inversion phenomenon in the prior art, where the increase in sparsity leads to an increase in the proportion of control overhead and thus offsets the sparsity gains, will not occur.

[0059] IV. Other Implementation Methods

[0060] In an alternative implementation, the bitmap joint streaming encoding module may not use a fixed block size to uniformly divide the tensor. Instead, it dynamically adjusts the block size and generates a joint bitmap of the corresponding length based on the actual non-zero element distribution density of each row or channel of the tensor. A block length identifier field is added to the event stream header to support the downstream module's parsing of the variable-length joint bitmap. In scenarios with sparse and uneven distribution, this implementation can further improve the utilization rate of the joint bitmap and the overall encoding compression ratio. The remaining processing flow is consistent with the aforementioned embodiments.

[0061] In another alternative implementation, the asynchronous handshake between the intersection point and the multiply-accumulate node in the event-driven asynchronous routing mesh can be replaced by a single-line asynchronous communication method that transmits request and response information based on the number of signal transitions, instead of a two-signal handshake consisting of a routing request signal and a response signal. This further reduces the switching power consumption of the routing mesh itself. The above alternative implementation is consistent with the aforementioned embodiment in terms of the technical ideas of selective forwarding based on the joint bitmap, direct truncation of zero-value positions, and implementation of local power consumption control of the multiply-accumulate node in combination with dynamic gating units. All of these can achieve the low-power computing effect described in this invention.

[0062] It should be noted that the multiply-accumulate node described in this invention can be a single multiply-accumulate operation unit within a chip, or it can be a multiply-accumulate subarray composed of multiple multiply-accumulate operation units;

[0063] The deployment relationship between dynamic gating units and multiply-accumulate nodes can be one-to-one, or one dynamic gating unit can control a group of multiply-accumulate nodes. The specific granularity of the correspondence can be configured according to the actual layout needs of the chip. The above are only some embodiments of the present invention. All equivalent substitutions or improvements made on the basis of the technical solution of the present invention should be included within the protection scope of the present invention.

[0064] Although the present invention has been disclosed above with reference to preferred embodiments, it is not intended to limit the present invention. Any person skilled in the art can make possible changes and modifications without departing from the spirit and scope of the present invention. Therefore, any modifications, equivalent changes and alterations made to the above embodiments based on the technical essence of the present invention without departing from the content of the technical solution of the present invention shall fall within the protection scope defined by the claims of the present invention.

Claims

1. A low-power computing method for an artificial intelligence hardware chip, characterized in that, include: The activation tensor and weight tensor to be processed are divided into blocks according to a preset block size, resulting in multiple tensor blocks; For each tensor block, the activation value sub-tensor and weight value sub-tensor are checked element by element to determine whether the value is zero, and an activation value bitmap and a weight bitmap are generated. Perform a bitwise logical AND operation on the activation value bitmap and weight bitmap of the same tensor block to obtain a joint bitmap of the tensor block; Based on the positions where the bit value is 1 in the joint bitmap, non-zero activation values ​​and non-zero weight values ​​are extracted from the corresponding tensor blocks and packaged to generate event data. No event data is generated for the positions where the bit value is 0 in the joint bitmap, and no memory coordinate index is allocated for these positions. This makes the coordinate information completely implicit in the position of each bit in the joint bitmap without the need to maintain an independent coordinate index array. As a result, the centralized index matching decoder and indirect addressing controller are eliminated in the circuit structure. The combined bitmap and the corresponding event data are combined to form an event stream, which is then written into the on-chip event stream buffer. The joint bitmap is scanned bit by bit, a route request signal is generated for the position with a bit value of 1, and the event data corresponding to the position is forwarded to the multiply-accumulate node in the idle state along the intersection of the routing grid. No route request signal is generated for the position with a bit value of 0. After receiving the routing request signal, the target multiply-accumulate node returns a response signal to the intersection that initiated the routing request signal; The dynamic gating unit deployed corresponding to each multiply-accumulate node controls the opening and closing of the clock and power supply of the corresponding multiply-accumulate node based on the local routing request signal: disconnecting the clock and power supply of the corresponding multiply-accumulate node during the time period when no routing request signal is received, so that the multiply-accumulate node enters a sleep state. Upon receiving a routing request signal, restore the clock and power supply to the corresponding multiply-accumulate node; The multiply-accumulate node, whose clock and power supply have been restored, performs multiply-accumulate operations on the non-zero activation values ​​and non-zero weight values ​​in the received event data to generate a partial sum; The local sums of the outputs of multiple multiply-accumulate nodes are accumulated step by step to obtain the calculation result of the current tensor block.

2. The method according to claim 1, characterized in that, The event data also carries the relative position encoding of the event data within the corresponding tensor block and a valid flag bit.

3. The method according to claim 1, characterized in that, The combined bitmap serves as auxiliary identification information for the corresponding event stream, is appended to the start position of the event stream, and is written together with the event data into the on-chip event stream buffer.

4. The method according to claim 1, characterized in that, For positions in the combined bitmap where the bit value is 0, the data line is truncated at the intersection of the routing grid without causing a data line level flip.

5. The method according to claim 1, characterized in that, The wake-up delay required for the dynamic gating unit to restore the clock and power supply of the corresponding multiply-accumulate node is less than the main clock cycle of the chip.

6. The method according to claim 1, characterized in that, The preset block size is dynamically adjusted based on the actual non-zero element distribution density of the corresponding row or channel in the activation tensor and weight tensor to be divided, and a block length identifier field is added to the header of the corresponding event stream.

7. A low-power computing architecture for an artificial intelligence hardware chip, characterized in that, include: The system includes a bitmap joint streaming encoding module, an on-chip event stream buffer, an event-driven asynchronous routing mesh, a multiply-accumulate array consisting of multiple multiply-accumulate nodes, multiple dynamic gating units deployed corresponding to each multiply-accumulate node, and an asynchronous reduction network. The bitmap joint streaming encoding module is used to divide the activation tensor and weight tensor into blocks to generate activation value bitmaps and weight bitmaps. The activation value bitmap and weight bitmap of the same block are subjected to bitwise logical AND operation to obtain a joint bitmap. Non-zero activation values ​​and non-zero weight values ​​are extracted from the positions of the bit value 1 in the joint bitmap and packaged to generate event data. The joint bitmap and the corresponding event data are combined to form an event stream and output to the on-chip event stream buffer. The on-chip event stream buffer is used to cache the event stream and send the event stream into the event-driven asynchronous routing grid in sequence; The event-driven asynchronous routing mesh includes multiple intersections arranged in a matrix, used to scan the joint bitmap bit by bit, generate a routing request signal for positions with a bit value of 1 and forward the corresponding event data to the multiply-accumulate node in the idle state, and not generate a routing request signal for positions with a bit value of 0. Each of the aforementioned dynamic gating units is connected to the corresponding multiply-accumulate node via a clock control line and a power control line, and is used to control the opening and closing of the clock tree branch and power rail of the corresponding multiply-accumulate node according to the local routing request signal; The asynchronous reduction network is connected to the output of the multiply-accumulate array and is used to perform step-by-step accumulation of the partial sums output by each multiply-accumulate node.

8. The architecture according to claim 7, characterized in that, The intersection of the event-driven asynchronous routing mesh is connected to the corresponding multiply-accumulate node via request signal lines and response signal lines. The intersection completes an asynchronous handshake after receiving the response signal returned by the target multiply-accumulate node.

9. The architecture according to claim 7, characterized in that, The dynamic gating unit is used to control the disconnection and restoration of the clock tree branch of the corresponding multiply-accumulate node, as well as the disconnection and restoration of the power rail of the corresponding multiply-accumulate node.

10. The architecture according to claim 7, characterized in that, The asynchronous reduction network adopts a tree structure, and asynchronously accumulates the local parts output by each multiply-accumulate node within the same tensor block to obtain the calculation result of the tensor block.