Vector Accumulator Instructions for Large Integer Addition

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Current processing systems face inefficiencies in performing computations on large number integers due to the need for multiple instructions when using scalar or vector arithmetic, which increases processing time and reduces efficiency for cryptographic operations like RSA algorithms.

Innovation Solution

Implementing accumulate top (ACCT) and accumulate bottom (ACCB) instructions that divide large number integers into blocks, storing each block in vector registers and performing computations using these instructions to reduce the number of operations required, specifically using two instructions (ACCT and ACCB) to produce results for modular exponentiation.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Reliability

If scalar arithmetic is used to perform computations on large number integers, then the computation can be performed on each block sequentially, but the processing time increases and processing efficiency decreases

Engineering Contradiction:
Improvecomputation accuracyVSAvoidprocessing efficiency
Core Design Contradiction:
ReliabilityVSProductivity

Solution Approach 1:

The patent divides large number integers into multiple blocks and uses vector registers to store multiple blocks simultaneously. Each vector register contains multiple lanes, where each lane stores a block of the large number integer. This segmentation allows parallel processing of multiple blocks within a single instruction, resolving the contradiction between sequential processing accuracy and processing efficiency.

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The patent transitions from scalar arithmetic (one block at a time) to vector arithmetic (multiple blocks simultaneously) by introducing a new dimension of parallelism. Vector registers provide multiple lanes that can process different blocks concurrently, effectively moving from one-dimensional sequential processing to multi-dimensional parallel processing, thereby improving processing efficiency while maintaining computation accuracy.

Inventive Principle:
Principle #17Another dimension (Dimensionality change)

2Productivity

If vector arithmetic is used to perform computations on large number integers by tracking carry bits, then computations on multiple blocks can be performed simultaneously, but the number of instructions increases and processing efficiency decreases

Engineering Contradiction:
Improveparallel processing capabilityVSAvoidinstruction complexity
Core Design Contradiction:
ProductivityVSDevice complexity

Solution Approach 1:

The patent merges the carry bit tracking functionality into the vector accumulation instructions themselves. The accumulate instructions (ACCT and ACCB) inherently handle carry propagation across block boundaries by designing the vector register architecture to support continuous carry chains through all lanes. This merging eliminates the need for separate carry tracking instructions, reducing instruction complexity while maintaining parallel processing capability.

Inventive Principle:
Principle #5Merging (Combining)

Solution Approach 2:

The vector accumulate instructions serve multiple functions simultaneously: they perform arithmetic operations on multiple blocks in parallel, track carry bits across block boundaries, and produce final results all within a single instruction type. This multi-functionality reduces the total number of instructions needed compared to traditional vector arithmetic approaches that require separate instructions for each function.

Inventive Principle:
Principle #6Universality (Multi-functionality)

3Reliability

If multiple instructions are used to perform computations on each block of large number integer, then complete computation can be achieved, but the processing time increases

Engineering Contradiction:
Improvecomputation completenessVSAvoidprocessing time
Core Design Contradiction:
ReliabilityVSLoss of time

Solution Approach 1:

The patent implements continuous carry propagation across all blocks within a single instruction execution. The vector register architecture is designed so that carry bits flow continuously from one lane to the next without interruption, allowing the computation to complete in one continuous action rather than requiring multiple discrete instructions. This continuity maintains computation completeness while minimizing processing time.

Inventive Principle:
Principle #20Continuity of useful action

Solution Approach 2:

The patent prepares the vector registers in advance with all blocks of the large number integers loaded into appropriate lanes before the accumulate instruction is executed. The carry chain is pre-configured across all lanes, so when the instruction executes, all arithmetic operations and carry propagations occur simultaneously in a single clock cycle, eliminating the need for multiple sequential instructions and reducing processing time while ensuring complete computation.

Inventive Principle:
Principle #10Preliminary action

Data Source

PatentUS20240319964A1Large number integer addition using vector accumulation
Publication Date: 2024.09.26 ADVANCED MICRO DEVICES INC
  • US20240319964A1 patent drawing
  • US20240319964A1 patent drawing
  • US20240319964A1 patent drawing

AI summary

A processor includes one or more processor cores configured to perform accumulate top (ACCT) and accumulate bottom (ACCB) instructions. To perform such instructions, at least one processor core of the processor includes an ACCT data path that adds a first portion of a block of data to a first lane of a set of lanes of a top accumulator and adds a carry-out bit to a second lane of the set of lanes of the top accumulator. Further, the at least one processor core includes an ACCB data path that adds a second portion of the block of data to a first lane of a set of lanes of a bottom accumulator and adds a carry-out bit to a second lane of the set of lanes of the bottom accumulator.