# US 2025/0085970 A1 · Semantic ordering for parallel architecture with compute slices

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

- Number: US 2025/0085970 A1
- Document ID: US20250085970A1
- Status: Published application
- Kind: A1
- Application number: 18/826,260
- Filed: 2024-09-06
- Published: 2025-03-13
- Earliest claimed: 2023-09-07
- Assignees: Ascenium, Inc.
- Applicants: Ascenium, Inc.
- Inventors: Jacob John Vorland Taylor
- Web page: https://patentgrep.com/patent/US20250085970A1

## CPC

- G06F 9/30043: {LOAD or STORE instructions; Clear instruction}
- G06F 9/3824: {Operand accessing}
- G06F 9/3834: {Maintaining memory consistency}
- G06F 9/3836: {Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution}
- G06F 9/3851: {from multiple instruction streams, e.g. multistreaming}
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## Abstract

Techniques for managing compute slice tasks are disclosed. A processing unit comprising compute slices, load-store units (LSUs), a control unit, and a memory system is accessed. The compute slices are coupled. Each compute slice includes an LSU which is coupled to a predecessor LSU and a successor LSU. A compiled program is executed as the control unit distributes slice tasks to the compute slices for execution. A slice task, which includes a load instruction, is distributed to a current compute slice. The current compute slice can execute the slice task speculatively. A previously executed store instruction is committed to memory by a predecessor LSU. Address aliasing is checked between an address associated with the previously executed store instruction and the load address associated with the load instruction. The slice task running on the current compute slice can be cancelled when aliasing is detected.

## Claims

### Claim 1

A processor-implemented method for memory operations comprising:
accessing a processing unit comprising a plurality of compute slices, a plurality of load-store units (LSUs), a control unit, and a memory system, wherein each compute slice within the plurality of compute slices includes at least one execution unit and is coupled to a successor compute slice and a predecessor compute slice, wherein each compute slice within the plurality of compute slices includes a unique LSU in the plurality of LSUs, and wherein each LSU in the plurality of LSUs is coupled to a successor LSU and a predecessor LSU;
distributing a current slice task, by the control unit, to a current compute slice in the plurality of compute slices, wherein the current compute slice includes a current LSU, wherein the current slice task includes a load instruction, and wherein the current compute slice is not a head slice;
saving, in an entry of a load address buffer (LAB) within the current LSU, a load address associated with the load instruction;
checking for address aliasing between the entry of the LAB and a store address associated with a previously executed store instruction; and
executing the load instruction.

### Claim 2 (depends on 1)

The method of claim 1 wherein the checking did not detect address aliasing.

### Claim 3 (depends on 1)

The method of claim 1 wherein the previously executed store instruction was executed by the current LSU.

### Claim 4 (depends on 3)

The method of claim 3 further comprising collecting, in a store buffer within the current LSU, address data associated with the previously executed store instruction.

### Claim 5 (depends on 4)

The method of claim 4 wherein the checking includes the address data that was collected in the store buffer within the current LSU.

### Claim 6 (depends on 5)

The method of claim 5 further comprising returning data, for the load instruction, from the previously executed store instruction, wherein the checking detected address aliasing.

### Claim 7 (depends on 6)

The method of claim 6 wherein the checking includes a second previously executed store instruction.

### Claim 8 (depends on 6)

The method of claim 6 wherein the current slice task includes a second load instruction.

### Claim 9 (depends on 1)

The method of claim 1 wherein the previously executed store instruction was executed by the predecessor LSU, wherein the previously executed store instruction was committed to an architectural state, and wherein the predecessor LSU is in an active state.

### Claim 10 (depends on 9)

The method of claim 9 further comprising propagating, by the predecessor LSU to the current LSU, the store address associated with the previously executed store instruction.

### Claim 11 (depends on 10)

The method of claim 10 wherein the checking detects address aliasing.

### Claim 12 (depends on 11)

The method of claim 11 further comprising cancelling the current slice task.

### Claim 13 (depends on 12)

The method of claim 12 further comprising forwarding, by the current LSU to the successor LSU, an alias detected signal.

### Claim 14 (depends on 13)

The method of claim 13 further comprising cancelling execution of a successor slice task associated with the successor LSU.

### Claim 15 (depends on 10)

The method of claim 10 wherein the checking does not detect address aliasing.

### Claim 16 (depends on 15)

The method of claim 15 further comprising forwarding, by the current LSU to the successor LSU, the store address associated with the previously executed store instruction.

### Claim 17 (depends on 16)

The method of claim 16 wherein the checking includes the successor LSU.

### Claim 18 (depends on 15)

The method of claim 15 further comprising storing, in a skid buffer within the current LSU, the store address that was propagated, wherein a back-to-back store commit sequence occurs.

### Claim 19 (depends on 18)

The method of claim 18 wherein the back-to-back store commit sequence includes committing, by the current LSU, one or more other store instructions, one cycle after the predecessor LSU commits the previously executed store instruction.

### Claim 20 (depends on 19)

The method of claim 19 further comprising forwarding, by the current LSU to the successor LSU, one or more other store addresses associated with the one or more other store instructions.

### Claim 21 (depends on 20)

The method of claim 20 further comprising forwarding, by the current LSU to the successor LSU, the store address associated with the previously executed store instruction from the skid buffer.

### Claim 22 (depends on 1)

The method of claim 1 wherein the plurality of compute slices is coupled in a ring configuration.

### Claim 23 (depends on 1)

The method of claim 1 wherein the plurality of LSUs is coupled in a ring configuration.

### Claim 24 (depends on 1)

The method of claim 1 wherein the checking occurs in a single cycle.

### Claim 25 (depends on 1)

The method of claim 1 wherein the head slice is a compute slice which is pointed to by a head pointer within the control unit.

### Claim 26

A computer program product embodied in a non-transitory computer readable medium for task processing, the computer program product comprising code which causes one or more processors to generate semiconductor logic for:
accessing a processing unit comprising a plurality of compute slices, a plurality of load-store units (LSUs), a control unit, and a memory system, wherein each compute slice within the plurality of compute slices includes at least one execution unit and is coupled to a successor compute slice and a predecessor compute slice, wherein each compute slice within the plurality of compute slices includes a unique LSU in the plurality of LSUs, and wherein each LSU in the plurality of LSUs is coupled to a successor LSU and a predecessor LSU;
distributing a current slice task, by the control unit, to a current compute slice in the plurality of compute slices, wherein the current compute slice includes a current LSU, wherein the current slice task includes a load instruction, and wherein the current compute slice is not a head slice;
saving, in an entry of a load address buffer (LAB) within the current LSU, a load address associated with the load instruction;
checking for address aliasing between the entry of the LAB and a store address associated with a previously executed store instruction; and
executing the load instruction.

### Claim 27

A computer system for task processing comprising:
a memory which stores instructions;
one or more processors coupled to the memory, wherein the one or more processors, when executing the instructions which are stored, are configured to:
access a processing unit comprising a plurality of compute slices, a plurality of load-store units (LSUs), a control unit, and a memory system, wherein each compute slice within the plurality of compute slices includes at least one execution unit and is coupled to a successor compute slice and a predecessor compute slice, wherein each compute slice within the plurality of compute slices includes a unique LSU in the plurality of LSUs, and wherein each LSU in the plurality of LSUs is coupled to a successor LSU and a predecessor LSU;
distribute a current slice task, by the control unit, to a current compute slice in the plurality of compute slices, wherein the current compute slice includes a current LSU, wherein the current slice task includes a load instruction, and wherein the current compute slice is not a head slice;
save, in an entry of a load address buffer (LAB) within the current LSU, a load address associated with the load instruction;
check for address aliasing between the entry of the LAB and a store address associated with a previously executed store instruction; and
execute the load instruction.
