# US 2026/0086978 A1 · Method of notifying a process or programmable atomic operation traps

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

- Number: US 2026/0086978 A1
- Document ID: US20260086978A1
- Status: Published application
- Kind: A1
- Application number: 19/198,833
- Filed: 2025-05-05
- Published: 2026-03-26
- Earliest claimed: 2020-10-20
- Assignees: Micron Technology, Inc.
- Applicants: Micron Technology, Inc.
- Inventors: Tony Brewer
- Web page: https://patentgrep.com/patent/US20260086978A1

## CPC

- G06F 15/7867: {with reconfigurable architecture}
- G06F 15/82: data or demand driven
- G06F 9/3004: {to perform operations on memory}
- G06F 9/30087: {Synchronisation or serialisation instructions}
- G06F 9/3861: {Recovery, e.g. branch miss-prediction, exception handling (error detection or correction G06F11/00)}
- G06F 9/4406: {Loading of operating system}
- G06F 15/7825: {Globally asynchronous, locally synchronous, e.g. network on chip}
- G06F 15/7896: {Modular architectures, e.g. assembled from a number of identical packages}
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## Abstract

Disclosed in some examples, are methods, systems, programmable atomic units, and machine-readable mediums that provide an exception as a response to the calling processor. That is, the programmable atomic unit will send a response to the calling processor. The calling processor will recognize that the exception has been raised and will handle the exception. Because the calling processor knows which process triggered the exception, the calling processor (e.g., the Operating System) can take appropriate action, such as terminating the calling process. The calling processor may be a same processor as that executing the programmable atomic transaction, or a different processor (e.g., on a different chiplet).

## Claims

### Claim 1

A memory controller, the memory controller comprising:
a processor;
a memory partitioned into a plurality of partitions, one or more partitions storing a first instruction set stored by a second processor that is communicatively coupled to the memory controller across a communications interface;
the processor configured to:
receive a command to execute the first instruction set, the command specifying a partition index of the plurality of partitions;
responsive to receiving the command:
identifying a number of partitions used by the first instruction set and an instruction execution limit;
causing execution of the first instruction set by executing instructions in a partition of the plurality of partitions specified by the partition index and instructions in any subsequent partitions until either an exception occurs, or a partition limit corresponding to the number of partitions is hit; and
sending a response to the second processor indicating either a completion of the first instruction set or an exception condition.

### Claim 2 (depends on 1)

The memory controller of claim 1, wherein the exception occurs and wherein the response includes a program counter value indicating an instruction being executed when the exception condition occurred.

### Claim 3 (depends on 2)

The memory controller of claim 2, wherein the response includes memory state information comprising contents of one or more memory locations at a time the exception condition occurred.

### Claim 4 (depends on 2)

The memory controller of claim 2, wherein the response includes register state information comprising contents of one or more processor registers at a time the exception condition occurred.

### Claim 5 (depends on 1)

The memory controller of claim 1, wherein the processor is further configured to:
terminate execution of the first instruction set upon detecting the exception condition; and
execute a return instruction that generates the response indicating the exception condition.

### Claim 6 (depends on 5)

The memory controller of claim 5, wherein the exception condition comprises exceeding the instruction execution limit.

### Claim 7 (depends on 5)

The memory controller of claim 5, wherein the exception condition comprises executing an instruction located in a partition having an index greater than a sum of the partition index and the number of partitions.

### Claim 8 (depends on 1)

The memory controller of claim 1, wherein the first instruction set comprises atomic operations to be performed on data stored in a memory device controlled by the memory controller.

### Claim 9 (depends on 8)

The memory controller of claim 8, wherein the memory device comprises random access memory (RAM).

### Claim 10 (depends on 1)

The memory controller of claim 1, wherein the processor is further configured to:
set a hazard bit corresponding to a memory location accessed by the first instruction set before beginning execution; and
clear the hazard bit after completing execution or encountering the exception condition.

### Claim 11

A non-transitory machine-readable medium, storing instructions for controlling a memory controller, the instructions, which when executed, cause a machine to perform operations comprising:
receiving a command to execute a first instruction set, the command specifying a partition index of a plurality of partitions in a memory;
responsive to receiving the command:
identifying a number of partitions used by the first instruction set and an instruction execution limit;
causing execution of the first instruction set by executing instructions in a partition of the plurality of partitions specified by the partition index and instructions in any subsequent partitions until either an exception occurs, or a partition limit corresponding to the number of partitions is hit; and
sending a response to a second processor indicating either a completion of the first instruction set or an exception condition.

### Claim 12 (depends on 11)

The non-transitory machine-readable medium of claim 11, wherein the operation of sending the response further comprises including a program counter value indicating an instruction being executed when the exception condition occurred.

### Claim 13 (depends on 12)

The non-transitory machine-readable medium of claim 12, wherein the operation of sending the response further comprises including memory state information comprising contents of one or more memory locations at a time the exception condition occurred.

### Claim 14 (depends on 12)

The non-transitory machine-readable medium of claim 12, wherein the operation of sending the response further comprises including register state information comprising contents of one or more processor registers at a time the exception condition occurred.

### Claim 15 (depends on 11)

The non-transitory machine-readable medium of claim 11, wherein the operations further comprise:
terminating execution of the first instruction set upon detecting the exception condition; and
executing a return instruction that generates the response indicating the exception condition.

### Claim 16 (depends on 15)

The non-transitory machine-readable medium of claim 15, wherein the exception condition comprises exceeding the instruction execution limit.

### Claim 17 (depends on 15)

The non-transitory machine-readable medium of claim 15, wherein the exception condition comprises executing an instruction located in a partition having an index greater than a sum of the partition index and the number of partitions.

### Claim 18 (depends on 11)

The non-transitory machine-readable medium of claim 11, wherein the first instruction set comprises atomic operations to be performed on data stored in a memory device controlled by the memory controller.

### Claim 19 (depends on 18)

The non-transitory machine-readable medium of claim 18, wherein the memory device comprises random access memory (RAM).

### Claim 20 (depends on 11)

The non-transitory machine-readable medium of claim 11, wherein the operations further comprise:
setting a hazard bit corresponding to a memory location accessed by the first instruction set before beginning execution; and
clearing the hazard bit after completing execution or encountering the exception condition.
