# US 2025/0094365 A1 · Kernel mapping to nodes in compute fabric

> Agents: this data is available as JSON from the patentgrep API and MCP server — see https://patentgrep.com/llms.txt

- Number: US 2025/0094365 A1
- Document ID: US20250094365A1
- Status: Published application
- Kind: A1
- Application number: 18/970,417
- Filed: 2024-12-05
- Published: 2025-03-20
- Earliest claimed: 2021-08-20
- Assignees: Micron Technology, Inc.
- Applicants: Micron Technology, Inc.
- Inventors: Gongyu Wang; Jason Eckhardt
- Web page: https://patentgrep.com/patent/US20250094365A1

## CPC

- G06F 13/1668: {Details of memory controller}
- G06F 13/161: {with latency improvement}
- G06F 13/4022: {using switching circuits, e.g. switching matrix, connection or expansion network (G06F13/4009 takes precedence)}
- G06F 15/7825: {Globally asynchronous, locally synchronous, e.g. network on chip}
- G06N 5/01: Dynamic search techniques; Heuristics; Dynamic trees; Branch-and-bound
- G06N 7/01: Probabilistic graphical models, e.g. probabilistic networks
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)
- G06N: COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS

## Abstract

A reconfigurable compute fabric can include multiple nodes, and each node can include multiple tiles with respective processing and storage elements. Compute kernels can be parsed into directed graphs and mapped to particular node or tile resources for execution. In an example, a branch-and-bound search algorithm can be used to perform the mapping. The algorithm can use a cost function to evaluate the resources based on capability, occupancy, or power consumption of the various node or tile resources.

## Claims

### Claim 1

An apparatus comprising:
a plurality of memory-compute tiles of a compute-near-memory system, wherein each tile in the compute-near-memory system is coupled to one or more adjacent tiles using a synchronous compute fabric and is coupled to one or more non-adjacent tiles using an asynchronous compute fabric, and wherein each tile comprises a respective functional unit and a memory circuit; and
a non-transitory processor-readable storage medium, the processor-readable storage medium including instructions that, when executed by a processor, cause the processor to:
receive an acyclic graph that represents multiple operations of a compute kernel for execution using at least a portion of the compute-near-memory system;
perform a resource search to identify candidate tiles in the compute-near-memory system to perform respective operations of the multiple operations using their respective functional units; and
assign the multiple operations to respective tiles of the identified candidate tiles based on results of the resource search and on timing information from the acyclic graph.

### Claim 2 (depends on 1)

The apparatus of claim 1, wherein at least one of the multiple operations depends on an intermediate compute result communicated between adjacent tiles using the synchronous compute fabric or the asynchronous compute fabric.

### Claim 3 (depends on 1)

The apparatus of claim 1, wherein each tile of the plurality of memory-compute tiles comprises:
first synchronous fabric inputs configured to receive information from one or more other tiles in a first node of the compute-near-memory system via the synchronous compute fabric;
first synchronous fabric outputs configured to provide information to the same one or more other tiles in the first node;
an asynchronous fabric input configured to receive information via the asynchronous compute fabric; and
an asynchronous fabric output configured to provide information to the asynchronous compute fabric.

### Claim 4 (depends on 3)

The apparatus of claim 3, wherein the memory circuit of each tile of the plurality of memory-compute tiles comprises:
a first tile-local memory configured to store one of (1) information from one of the first synchronous fabric inputs, (2) result information from the functional unit, and (3) information from the asynchronous fabric input; and
a second tile-local memory configured to store another one of the (1) information from one of the first synchronous fabric inputs, (2) result information from the functional unit, and (3) information from the asynchronous fabric input.

### Claim 5 (depends on 1)

The apparatus of claim 1, wherein the instructions further configure the processor to receive the compute kernel and, in response, provide the acyclic graph.

### Claim 6 (depends on 1)

The apparatus of claim 1, wherein the tiles of the identified candidate tiles are configured to perform the multiple operations to produce a final compute result corresponding to the compute kernel, and wherein the final compute result is determined using information exchanged between the tiles using the synchronous compute fabric and using the asynchronous compute fabric.

### Claim 7 (depends on 1)

The apparatus of claim 1, wherein the compute kernel includes a nested loop.

### Claim 8 (depends on 1)

The apparatus of claim 1, wherein the instructions to perform the resource search include instructions to configure the processor to perform a branch-and-bound search to map respective operations of the multiple operations to different tiles in a first node of the system.

### Claim 9

A compute near memory system comprising:
a plurality of memory-compute nodes, wherein each of the nodes comprises tiles that are coupled using an asynchronous compute fabric and a synchronous compute fabric, wherein the tiles comprise respective functional units that are configured to perform operations in parallel to provide a final compute result based on a compute kernel; and
a controller configured to:
receive the compute kernel;
parse the compute kernel to provide an acyclic graph that represents multiple operations;
perform a resource search to identify candidate tiles in the system to perform respective operations of the multiple operations using their respective functional units; and
assign the multiple operations to respective tiles of the identified candidate tiles based on results of the resource search and based on timing information from the acyclic graph.

### Claim 10 (depends on 9)

The system of claim 9, wherein each of the tiles is coupled to one or more tiles using the synchronous compute fabric and is coupled to one or more other tiles using the asynchronous compute fabric.

### Claim 11 (depends on 10)

The system of claim 10, wherein respective portions of the synchronous compute fabric couple adjacent pairs of the tiles, and respective portions of the asynchronous compute fabric couple non-adjacent pairs of the tiles.

### Claim 12 (depends on 10)

The system of claim 10, wherein at least one of the multiple operations depends on an intermediate compute result communicated between tiles using the synchronous compute fabric or the asynchronous compute fabric.

### Claim 13 (depends on 9)

The system of claim 9, wherein the final compute result is based on intermediate compute results determined using the respective functional units corresponding to multiple tiles; and
wherein the intermediate compute results are communicated between the tiles using at least one of the synchronous compute fabric and the asynchronous compute fabric.

### Claim 14 (depends on 9)

The system of claim 9, wherein the compute kernel includes a nested loop.

### Claim 15 (depends on 9)

The system of claim 9, wherein the resource search includes using a branch-and-bound search to map respective ones of the multiple operations to different tiles in a first node of the system.

### Claim 16 (depends on 9)

The system of claim 9, wherein the resource search includes evaluation of a cost function associated with each of the candidate tiles.

### Claim 17 (depends on 16)

The system of claim 16, wherein the evaluation of the cost function includes determining, for each candidate tile:
a capability of the candidate tile to perform a particular operation;
an occupancy characteristic of the candidate tile; and
a latency characteristic of the candidate tile.

### Claim 18 (depends on 9)

The system of claim 9, wherein the acyclic graph represents multiple different parallel operations, and wherein the controller is configured to assign the multiple different parallel operations to respective tiles of the identified candidate tiles for concurrent processing.

### Claim 19

An apparatus comprising:
a plurality of memory-compute tiles of a compute-near-memory system, wherein each tile in the compute-near-memory system is coupled to one or more adjacent tiles using a first compute fabric and is coupled to one or more non-adjacent tiles using a second compute fabric, and wherein each tile comprises a respective functional unit and a memory circuit; and
a non-transitory processor-readable storage medium, the processor-readable storage medium including instructions that, when executed by a processor, cause the processor to:
receive an acyclic graph that represents multiple operations of a compute kernel for execution using at least a portion of the compute-near-memory system;
perform a resource search to identify candidate tiles in the compute-near-memory system to perform respective operations of the multiple operations using their respective functional units; and
assign the multiple operations to respective tiles of the identified candidate tiles based on results of the resource search and on timing information from the acyclic graph.

### Claim 20 (depends on 19)

The apparatus of claim 19, wherein the instructions to perform the resource search include instructions to configure the processor to perform a branch-and-bound search to map respective operations of the multiple operations to different tiles in a first node of the system.
