Core Load-Store Alignment for Unaligned Memory Data

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Existing processor cores face challenges in handling unaligned data structures, as they do not align with the power-of-2 bit widths of local memory, leading to inefficiencies in data transfer and processing.

Innovation Solution

A processor architecture that includes load and store units with alignment circuitry to identify and store unaligned data structures across multiple data chunks, allowing them to be processed and stored in registers with matching widths, and subsequently aligned with local memory.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Ease of manufacture

If the local memory uses fixed power-of-2 bit widths for data transfer, then the memory interface is simplified and alignment is straightforward, but unaligned data structures cannot be efficiently handled

Engineering Contradiction:
Improvememory interface simplicityVSAvoidhandling of unaligned data structures
Core Design Contradiction:
Ease of manufactureVSAdaptability or versatility

Solution Approach 1:

The load unit segments unaligned data structures into multiple aligned data chunks that fit the power-of-2 memory interface width. Each chunk is processed separately and then reassembled, allowing the memory interface to maintain its fixed width while supporting unaligned data structures.

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The load unit acts as an intermediary between the fixed-width memory interface and variable-width unaligned data structures. It performs the conversion and alignment operations, shielding the memory interface from the complexity of handling unaligned data while enabling support for such structures.

Inventive Principle:
Principle #24Intermediary (Mediator)

2Reliability

If unaligned data structures are handled by reading multiple data chunks, then complete data structures can be retrieved, but the number of read cycles increases

Engineering Contradiction:
Improvecomplete data structure retrievalVSAvoidnumber of read cycles
Core Design Contradiction:
ReliabilityVSLoss of time

Solution Approach 1:

The system performs preliminary actions by pre-fetching and buffering data chunks that may be needed for unaligned data structures. The load unit prepares the data in advance by reading multiple chunks and assembling them, reducing the impact on subsequent processing operations.

Inventive Principle:
Principle #10Preliminary action

3Manufacturing precision

If unaligned data structures are assembled from multiple data chunks, then correct data is obtained, but the circuit complexity increases

Engineering Contradiction:
Improvedata structure assembly accuracyVSAvoidalignment circuitry complexity
Core Design Contradiction:
Manufacturing precisionVSDevice complexity

Solution Approach 1:

The alignment circuitry implements local quality by applying different processing operations to different parts of the data. Specifically, it identifies which data chunks contain portions of unaligned data structures and applies assembly operations only to those relevant chunks, rather than processing all data uniformly.

Inventive Principle:
Principle #3Local quality

Data Source

PatentUS20250370750A1Unaligned load and store in a core
Publication Date: 2025.12.04 XILINX INC
  • US20250370750A1 patent drawing
  • US20250370750A1 patent drawing
  • US20250370750A1 patent drawing

AI summary

Embodiments herein describe storing unaligned data structures in local memory that are then loaded into cores. For example, the data structures may have a length that is not a power of 2 so that they do not align with the width (or the bandwidth of the local memories). A load unit in the core can receive multiple data chunks from the local memory and identify an unaligned data structure that spans across the data chunks. The data structures can then be stored in a register as an aligned data structure as the width of the register may match the length of the data structure.