# US 11,907,718 B2 · Loop execution in a reconfigurable compute fabric using flow controllers for respective synchronous flows

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

- Number: US 11,907,718 B2
- Document ID: US11907718B2
- Status: Granted
- Kind: B2
- Application number: 17/405,371
- Filed: 2021-08-18
- Published: 2022-06-30
- Granted: 2024-02-20
- Earliest claimed: 2020-12-31
- Assignees: Micron Technology, Inc.
- Applicants: Micron Technology, Inc.
- Inventors: Douglas Vanesko; Bryan Hornung; Patrick Estep
- Web page: https://patentgrep.com/patent/US11907718B2

## CPC

- G06F 9/30065: {Loop control instructions; iterative instructions, e.g. LOOP, REPEAT}
- G06F 9/30072: {to perform conditional operations, e.g. using predicates or guards}
- G06F 9/30087: {Synchronisation or serialisation instructions}
- G06F 9/3009: {Thread control instructions}
- G06F 9/30189: {according to execution mode, e.g. mode flag}
- G06F 9/325: {for loops, e.g. loop detection or loop counter}
- G06F 9/3851: {from multiple instruction streams, e.g. multistreaming}
- G06F 9/3888: {controlled by a single instruction for multiple threads [SIMT] in parallel}
- G06F 15/7867: {with reconfigurable architecture}
- G06F 15/825: {Dataflow computers}
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## Abstract

Various examples are directed to systems and methods for executing a loop in a reconfigurable compute fabric. A first flow controller may initiate a first thread at a first synchronous flow to execute a first portion of a first iteration of the loop. A second flow controller may receive a first asynchronous message instructing the second flow controller to initiate a first thread at a second synchronous flow to execute a second portion of the first iteration. The second flow controller may determine that the first iteration of the loop is the last iteration of the loop to be executed and initiate the first thread at the second synchronous flow with a last iteration flag set.

## Claims

### Claim 1

A method, comprising:
initiating, by a first flow controller of a first synchronous flow, a first thread at the first synchronous flow, the first thread at the first synchronous flow to execute a first portion of a first iteration of a loop, the loop having a number of iterations, the first synchronous flow configured from a reconfigurable compute fabric comprising a set of multiple flow controllers and a set of multiple compute elements;
after initiating the first thread, initiating at least one thread to execute at least a portion of a second iteration of the loop;
receiving, by a second flow controller of a second synchronous flow, a first asynchronous message instructing the second flow controller to initiate a first thread at the second synchronous flow to execute a second portion of the first iteration of the loop, the second portion of the first iteration executing after the first portion of the first iteration;
determining, by the second flow controller, that the first iteration of the loop is a last iteration of the loop to be executed;
responsive to determining that the first iteration of the loop is the last iteration of the loop to be executed, initiating, by the second flow controller, the first thread at the second synchronous flow, the initiating comprising providing a first synchronous message to a first compute element of the second synchronous flow, the first synchronous message comprising a last iteration flag indicating that the first iteration is the last iteration of the loop to be executed; and
executing the first thread at the second synchronous flow, the executing comprising:
determining that the first synchronous message comprises the last iteration flag; and
responsive to determining that the first synchronous message comprises the last iteration flag, executing a first conditional operation, the first conditional operation being based at least in part on an output generated by the first iteration of the loop and at least in part on an output generated by the second iteration of the loop.

### Claim 2 (depends on 1)

The method of claim 1, further comprising executing a second thread at the second synchronous flow, the executing comprising:
providing a second synchronous message to the first compute element of the second synchronous flow;
determining that the second synchronous message does not comprise the last iteration flag; and
responsive to determining that the second synchronous message does not comprise the last iteration flag, omitting the first conditional operation.

### Claim 3 (depends on 1)

The method of claim 1, further comprising:
receiving, by the second flow controller, an iteration count indicating the number of iterations of the loop; and
comparing a number of threads previously initiated by the second flow controller to the iteration count.

### Claim 4 (depends on 3)

The method of claim 3, wherein the first asynchronous message comprises the iteration count.

### Claim 5 (depends on 3)

The method of claim 3, further comprising:
sending a second asynchronous message by a dispatch interface of the reconfigurable compute fabric to the first flow controller, the second asynchronous message instructing the first flow controller to begin execution of the loop; and
sending, by the dispatch interface, a third asynchronous message to the second flow controller, the third asynchronous message comprising the iteration count.

### Claim 6 (depends on 3)

The method of claim 3, further comprising programming the reconfigurable compute fabric to include the first synchronous flow and the second synchronous flow, the programming comprising providing the iteration count to the second flow controller.

### Claim 7 (depends on 3)

The method of claim 3, further comprising sending the first asynchronous message to the second flow controller by at least a portion of the first synchronous flow.

### Claim 8 (depends on 1)

The method of claim 1, further comprising:
after initiating the first thread at the first synchronous flow, initiating, by the first flow controller, a second thread at the first synchronous flow, the second thread at the first synchronous flow to execute the first portion of a second iteration of the loop;
before receiving the first asynchronous message, receiving, by the second flow controller, a second asynchronous message instructing the second flow controller to initiate a second thread at the second synchronous flow to execute a second portion of a second iteration of the loop;
determining, by the second flow controller, that the second iteration of the loop is not the last iteration of the loop to be executed; and
initiating, by the second flow controller, a second thread at the second synchronous flow, the initiating comprising providing a second synchronous message to the first compute element of the second synchronous flow that does not include the last iteration flag.

### Claim 9

A reconfigurable compute fabric, comprising:
a first synchronous flow comprising a first flow controller and at least one compute element, the first flow controller programmed to initiate a first thread at the first synchronous flow to execute a first portion of a first iteration of a loop, the loop having a number of iterations and to, after initiating the first thread at the first synchronous flow, initiate at least one thread to execute at least a portion of a second iteration of the loop; and
a second synchronous flow comprising a second flow controller and at least one compute element, the second flow controller programmed to perform operations comprising:
receiving a first asynchronous message instructing the second flow controller to initiate a first thread at the second synchronous flow to execute a second portion of the first iteration, the second portion of the first iteration executed after the first portion of the first iteration; and
determining that the first iteration of the loop is a last iteration of the loop to be executed;
responsive to determining that the first iteration of the loop is the last iteration of the loop to be executed, initiating the first thread at the second synchronous flow, the initiating comprising providing a first synchronous message to a first compute element of the second synchronous flow, the first synchronous message comprising a last iteration flag indicating that the first iteration is the last iteration of the loop to be executed; and
executing the first thread at the second synchronous flow, the executing comprising:
determining that the first synchronous message comprises the last iteration flag; and
responsive to determining that the first synchronous message comprises the last iteration flag, executing a first conditional operation, the first conditional operation being based at least in part on an output generated by the first iteration of the loop and at least in part on an output generated by the second iteration of the loop.

### Claim 10 (depends on 9)

The reconfigurable compute fabric of claim 9, the second synchronous flow being programmed to execute the first thread at the second synchronous flow at least in part by performing operations further comprising:
providing a second synchronous message to the first compute element of the second synchronous flow;
determining that the second synchronous message does not comprise the last iteration flag; and
responsive to determining that the second synchronous message does not comprise the last iteration flag, omitting the first conditional operation.

### Claim 11 (depends on 9)

The reconfigurable compute fabric of claim 9, the second flow controller being programmed to perform operations further comprising:
receiving an iteration count indicating the number of iterations of the loop; and
comparing a number of threads previously initiated by the second flow controller to the iteration count.

### Claim 12 (depends on 11)

The reconfigurable compute fabric of claim 11, wherein the first asynchronous message comprises the iteration count.

### Claim 13 (depends on 11)

The reconfigurable compute fabric of claim 11, further comprising a dispatch interface programmed to perform operations comprising:
sending a second asynchronous message to the first flow controller, the second asynchronous message instructing the first flow controller to begin execution of the loop; and
sending a third asynchronous message to the second flow controller, the third asynchronous message comprising the iteration count.

### Claim 14 (depends on 11)

The reconfigurable compute fabric of claim 11, the reconfigurable compute fabric being programmed to include the iteration count at the second flow controller.

### Claim 15 (depends on 11)

The reconfigurable compute fabric of claim 11, the first synchronous flow being programmed to execute the first thread at the first synchronous flow at least in part by performing operations comprising sending the first asynchronous message to the second flow controller by at least a portion of the first synchronous flow.

### Claim 16 (depends on 9)

The reconfigurable compute fabric of claim 9, the first flow controller being further programmed to perform operations comprising: after initiating the first thread at the first synchronous flow, initiating a second thread at the first synchronous flow, the second thread at the first synchronous flow to execute the first portion of a second iteration of the loop; and
the second flow controller being further programmed to perform operations comprising:
before receiving the first asynchronous message, receiving a second asynchronous message instructing the second flow controller to initiate a second thread at the second synchronous flow to execute a second portion of a second iteration of the loop;
determining that the second iteration of the loop is not the last iteration of the loop to be executed; and
initiating a second thread at the second synchronous flow, the initiating comprising providing a second synchronous message to the first compute element of the second synchronous flow that does not include the last iteration flag.

### Claim 17

A non-transitory machine-readable medium comprising instructions stored thereon that, when executed at a reconfigurable compute fabric cause the reconfigurable compute fabric to execute operations comprising:
initiating, by a first flow controller of a first synchronous flow, a first thread at the first synchronous flow, the first thread at the first synchronous flow to execute a first portion of a first iteration of a loop, the loop having a number of iterations, the first synchronous flow configured from a reconfigurable compute fabric comprising a set of multiple of flow controllers and a set of multiple of compute elements;
after initiating the first thread, initiating at least one thread to execute at least a portion of a second iteration of the loop;
receiving, by a second flow controller of a second synchronous flow, a first asynchronous message instructing the second flow controller to initiate a first thread at the second synchronous flow to execute a second portion of the first iteration, the second portion of the first iteration executing after the first portion of the first iteration;
determining, by the second flow controller, that the first iteration of the loop is a last iteration of the loop to be executed;
responsive to determining that the first iteration of the loop is a last iteration of the loop to be executed, initiating, by the second flow controller, the first thread at the second synchronous flow, the initiating comprising providing a first synchronous message to a first compute element of the second synchronous flow, the first synchronous message comprising a last iteration flag indicating that the first iteration is the last iteration of the loop to be executed; and
executing the first thread at the second synchronous flow, the executing comprising:
determining that the first synchronous message comprises the last iteration flag; and
responsive to determining that the first synchronous message comprises the last iteration flag, executing a first conditional operation, the first conditional operation being based at least in part on an output generated by the first iteration of the loop and at least in part on an output generated by the second iteration of the loop.