AMD Patents a Way to Stop Its Ray Tracing Hardware From Asking for the Same Data Twice

By Patentlyze Team · Updated Jun 26, 2026

When thousands of rays hit the same surface at the same time, AMD's graphics hardware can end up asking for the exact same texture data hundreds of times over. This patent describes a circuit that spots those duplicate requests before they go out and collapses them into one.

What AMD's opacity micro-map memory fix actually does

Imagine a crowded stadium where hundreds of people all text the same question to the same information hotline at the same moment. The hotline is flooded with identical messages, and it has to answer each one separately even though the answer is the same for all of them. That's roughly what happens inside a GPU during ray tracing.

Ray tracing works by simulating light rays bouncing off surfaces. A feature called opacity micro-maps stores fine-grained detail about which parts of a surface are transparent or solid, so rays know whether to pass through or bounce. In a modern GPU, thousands of rays can hit nearby surfaces at the same time, and each one might ask for the same opacity data stored at the same memory address.

AMD's patent describes hardware that watches for those duplicate requests as they come in. If the first request is still waiting on a reply from memory when a second identical request arrives, the hardware simply notes it and waits. When the data finally comes back, it answers all the pending requests at once, cutting down on wasted memory traffic.

How AMD's circuit tracks and merges pending memory requests

Opacity micro-maps are compact lookup tables stored in memory that tell a ray tracer how opaque a surface is at a very fine scale. Think of them as high-resolution stencils layered over simple geometry: instead of modeling every leaf on a tree as a full 3D mesh, you store a grid of transparency values and let the ray tracing engine consult that grid at intersection time.

The problem is parallelism. A GPU launches enormous numbers of rays simultaneously, and in many scenes those rays converge on the same objects. That means many rays end up requesting opacity data from the same memory address at nearly the same moment. Each request normally triggers a separate round trip to memory, even though the answer is identical for all of them.

AMD's patent adds a small tracking mechanism inside the opacity micro-map hardware. When a memory request goes out for a given address, the circuit records that request as "pending." If a new evaluation request arrives for the same address before the first reply has come back, no second memory request is issued. Instead, that new request is queued alongside the first one.

When the memory finally returns the data, the circuit fans it out to every queued request at once. The key steps are:

• Log the first outbound memory request and its target address
• Compare incoming requests against all pending addresses
• Suppress duplicate outbound requests and hold the callers
• Broadcast the returned data to all waiting evaluations simultaneously

What this means for GPU ray tracing performance

Memory bandwidth is one of the tightest bottlenecks in real-time ray tracing. Every unnecessary round trip to video memory burns bandwidth and adds latency (delay), which forces the GPU to stall and wait instead of rendering. Cutting redundant requests for opacity data directly reduces that pressure, especially in scenes with heavy foliage, fences, or transparent materials where opacity micro-maps are doing the most work.

For you as a player or creator, the practical benefit would be smoother, faster ray-traced frames in complex scenes without needing more memory bandwidth on the chip. It's the kind of behind-the-scenes efficiency fix that can add several frames per second in the exact scenes where ray tracing tends to slow down the most.

Editorial commentary on a publicly published patent application. Not legal advice.