Vector Processor Segmented Data Processing Efficiency

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Current vector processors face inefficiencies when processing data segments of varying lengths, as they require mode changes and additional instructions to handle non-native segment lengths, leading to suboptimal performance in cellular communication applications.

Innovation Solution

A method for executing segmented operations on vector processors that allows results to be collected and delivered in a result vector, maintaining vector mode processing efficiency, with the ability to handle arbitrary segment sizes and support intra-vector operations like addition, extremal value, and XOR operations, using dedicated opcodes, extra arguments, or an internal state machine.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Adaptability or versatility

If mode changes and additional instructions are used to handle non-native segment lengths, then the vector processor can process varying segment lengths, but processing efficiency deteriorates due to suboptimal performance

Engineering Contradiction:
Improveability to handle non-native segment lengthsVSAvoidprocessing efficiency
Core Design Contradiction:
Adaptability or versatilityVSProductivity

Solution Approach 1:

The vector processor divides the vector into multiple segments of arbitrary lengths, allowing each segment to be processed independently. This segmentation enables the processor to handle varying segment lengths efficiently without requiring mode changes, as the segmented structure naturally accommodates different length requirements while maintaining continuous vector mode operation.

Inventive Principle:
Principle #1Segmentation

2Productivity

If continuous vector mode operations are maintained, then processing efficiency is improved, but the ability to handle arbitrary segment sizes is limited

Engineering Contradiction:
Improveprocessing efficiencyVSAvoidability to handle arbitrary segment sizes
Core Design Contradiction:
ProductivityVSAdaptability or versatility

Solution Approach 1:

The vector processor employs dynamic segment length configuration, where the segment length can be arbitrarily specified based on the processing requirements. This dynamic capability allows the processor to adapt to different segment sizes while maintaining continuous vector mode operations, resolving the contradiction between efficiency and adaptability.

Inventive Principle:
Principle #15Dynamics

3Loss of time

If results are collected and delivered in a result vector without mode changes, then processing time is reduced, but additional instructions are required to manage result collection

Engineering Contradiction:
Improveprocessing timeVSAvoidadditional instructions for result collection
Core Design Contradiction:
Loss of timeVSDevice complexity

Solution Approach 1:

A dedicated result vector serves as an intermediary structure for collecting segmented operation results. This result vector acts as a buffer that accumulates results from multiple segmented operations, allowing the processor to maintain continuous vector mode operation without mode changes. The result collection mechanism is integrated into the vector processing pipeline, reducing the need for additional control instructions.

Inventive Principle:
Principle #24Intermediary (Mediator)

Data Source

PatentUS8856492B2Method for vector processing
Publication Date: 2014.10.07 NXP BV
  • US8856492B2 patent drawing
  • US8856492B2 patent drawing
  • US8856492B2 patent drawing

AI summary

The present application relates to a method for processing data in a vector processor. The present application relates also to a vector processor for performing said method and a cellular communication device comprising said vector processor. The method for processing data in a vector processor comprises executing segmented operations on a segment of a vector for generating results, collecting the results of the segmented operations, and delivering the results in a result vector in such a way that subsequent operations remain processing in vector mode.