# US 2024/0004584 A1 · DRAM Row Management for Processing in Memory

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

- Number: US 2024/0004584 A1
- Document ID: US20240004584A1
- Status: Published application
- Kind: A1
- Application number: 17/855,109
- Filed: 2022-06-30
- Published: 2024-01-04
- Earliest claimed: 2022-06-30
- Assignees: Advanced Micro Devices, Inc.
- Applicants: Advanced Micro Devices, Inc.
- Inventors: Niti Madan; Yasuko Eckert; Varun Agrawal; John Kalamatianos
- Web page: https://patentgrep.com/patent/US20240004584A1

## CPC

- G06F 3/0659: {Command handling arrangements, e.g. command buffers, queues, command scheduling}
- G11C 11/4096: Input/output [I/O] data management or control circuits, e.g. reading or writing circuits, I/O drivers or bit-line switches
- G06F 3/0604: {Improving or facilitating administration, e.g. storage management}
- G06F 3/0653: {Monitoring storage devices or systems}
- G06F 3/0679: {Non-volatile semiconductor memory device, e.g. flash memory, one time programmable memory [OTP]}
- G11C 7/1006: {Data managing, e.g. manipulating data before writing or reading out, data bus switches or control circuits therefor}
- G11C 7/12: Bit line control circuits, e.g. drivers, boosters, pull-up circuits, pull-down circuits, precharging circuits, equalising circuits, for bit lines
- G11C 7/22: Read-write [R-W] timing or clocking circuits; Read-write [R-W] control signal generators or management
- G11C 11/4076: Timing circuits (for regeneration management G11C11/406)
- G11C 11/4094: Bit-line management or control circuits
- G11C 2207/2272: Latency related aspects
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)
- G11C: STATIC STORES (semiconductor memory devices H10B)

## Abstract

In accordance with described techniques for DRAM row management for processing in memory, a plurality of instructions are obtained for execution by a processing in memory component embedded in a dynamic random access memory. An instruction is identified that last accesses a row of the dynamic random access memory, and a subsequent instruction is identified that first accesses an additional row of the dynamic random access memory. A first command is issued to close the row and a second command is issued to open the additional row after the row is last accessed by the instruction.

## Claims

### Claim 1

A method comprising:
obtaining a plurality of instructions for execution by a processing in memory component embedded in a dynamic random access memory;
identifying an instruction of the plurality of instructions that last accesses a row of the dynamic random access memory; and
issuing a command that closes the row after the row is last accessed by the instruction.

### Claim 2 (depends on 1)

The method of claim 1, further comprising issuing an additional command that opens an additional row of the dynamic random access memory, the additional command issued after the command.

### Claim 3 (depends on 2)

The method of claim 2, wherein the command is an auto-precharge command and the additional command is an activate command.

### Claim 4 (depends on 2)

The method of claim 2, further comprising identifying a subsequent instruction of the plurality of instructions that first accesses a new row of the dynamic random access memory, wherein the new row is the additional row.

### Claim 5 (depends on 4)

The method of claim 4, wherein the plurality of instructions includes one or more independent instructions to be executed after the instruction and before the subsequent instruction, the one or more independent instructions being executable without accessing a row of the dynamic random access memory.

### Claim 6 (depends on 5)

The method of claim 5, wherein the command causes the dynamic random access memory to close the row concurrently while the processing in memory component executes the one or more independent instructions.

### Claim 7 (depends on 5)

The method of claim 5, wherein the additional command causes the dynamic random access memory to open the additional row concurrently while the processing in memory component executes the one or more independent instructions.

### Claim 8 (depends on 5)

The method of claim 5, further comprising issuing the additional command based on a computation time of the one or more independent instructions exceeding a threshold.

### Claim 9 (depends on 1)

The method of claim 1, wherein the instruction is identified based on metadata encoded in the instruction indicating that the row is last accessed by the instruction.

### Claim 10 (depends on 1)

The method of claim 1, wherein the instruction is identified by comparing rows of the dynamic random access memory accessed by the plurality of instructions.

### Claim 11

A system comprising:
a dynamic random access memory;
a processing in memory component embedded in the dynamic random access memory; and
a memory controller to:
receive a plurality of instructions for execution by the processing in memory component;
compare rows of the dynamic random access memory accessed by the plurality of instructions;
identify an instruction that last accesses a row of the dynamic random access memory and a subsequent instruction that first accesses an additional row of the dynamic random access memory; and
issue a first command that closes the row and a second command that opens the additional row after the row is last accessed by the instruction.

### Claim 12 (depends on 11)

The system of claim 11, wherein the memory controller is configured to receive the plurality of instructions in an order in which the instructions are to be executed by the processing in memory component.

### Claim 13 (depends on 11)

The system of claim 11, further comprising a host processing unit configured to identify the instruction that last accesses the row during address translation and based on a comparison of the row accessed by the instruction to one or more subsequently received instructions.

### Claim 14 (depends on 11)

The system of claim 11, wherein the memory controller is configured to compare the rows accessed by the plurality of instructions when the instructions are enqueued for dispatch to the processing in memory component.

### Claim 15 (depends on 11)

The system of claim 11, wherein the first command causes the dynamic random access memory to close the row and the second command causes the dynamic random access memory to open the additional row concurrently while the processing in memory component executes one or more independent instructions, the one or more independent instructions being executable without accessing a row of the dynamic random access memory.

### Claim 16

A method comprising:
compiling a program to generate a plurality of instructions for execution by a processing in memory component embedded in a dynamic random access memory;
during the compiling, marking an instruction of the plurality of instructions with metadata indicating that the instruction last accesses a row of the dynamic random access memory; and
transmitting the plurality of instructions to a memory controller, the metadata directing the memory controller to issue a command that closes the row after the row is last accessed by the instruction.

### Claim 17 (depends on 16)

The method of claim 16, further comprising, during the compiling, identifying a subsequent instruction that first accesses an additional row of the dynamic random access memory.

### Claim 18 (depends on 17)

The method of claim 17, further comprising, during the compiling, marking the instruction with additional metadata identifying the additional row accessed by the subsequent instruction.

### Claim 19 (depends on 18)

The method of claim 18, wherein the additional metadata directs the memory controller to issue an additional command that opens the additional row after the row is last accessed by the instruction.

### Claim 20 (depends on 18)

The method of claim 18, wherein the instruction is marked with the additional metadata based on a computation time associated with one or more independent instructions exceeding a threshold value, the one or more independent instructions configured to be executed after the instruction and before the subsequent instruction and being executable without accessing a row of the dynamic random access memory.
