Pipeline Processor Equal Model Compensator Latency Management

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Pipeline processors face challenges in managing instruction latency, particularly in flexible scheduling and multiple register assignments, as existing models either write results too early (LTE) or too late (equal model), limiting processing flexibility and efficiency.

Innovation Solution

The introduction of an equal model compensator that stores and writes processing results in a register file based on instruction latency, allowing for flexible scheduling and efficient handling of pipeline flushes and restarts, including debugging and interrupt service routines, using a FIFO storage mechanism.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Adaptability or versatility

If the result of execution is written in the target register after maximum latency elapses (equal model), then flexible scheduling through multiple assignment of target register is improved, but processing speed deteriorates

Engineering Contradiction:
Improveflexible schedulingVSAvoidprocessing speed
Core Design Contradiction:
Adaptability or versatilityVSProductivity

Solution Approach 1:

The patent segments the write-back process by introducing a separate buffer memory that temporarily stores execution results. This allows the pipeline to continue processing subsequent instructions while the result is held in the buffer, enabling flexible scheduling without blocking the pipeline flow.

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The patent introduces a buffer memory as an intermediary component between the execution unit and the target register. This buffer acts as a mediator that holds execution results temporarily, allowing the pipeline to maintain high throughput while the result is prepared for write-back after the required latency period.

Inventive Principle:
Principle #24Intermediary (Mediator)

2Productivity

If the result of execution is written in the target register before maximum latency elapses (LTE model), then processing speed is improved, but flexible scheduling deteriorates

Engineering Contradiction:
Improveprocessing speedVSAvoidflexible scheduling
Core Design Contradiction:
ProductivityVSAdaptability or versatility

Solution Approach 1:

The patent performs preliminary action by writing the execution result to the buffer memory immediately after execution, before the maximum latency period elapses. This allows the pipeline to continue processing without waiting, while the result is prepared in advance for the final write-back to the target register.

Inventive Principle:
Principle #10Preliminary action

3Reliability

If pipeline flushing is performed for debugging or interrupt handling, then reliability is improved, but loss of time occurs due to pipeline emptying

Engineering Contradiction:
Improvedebugging capabilityVSAvoidpipeline flush time
Core Design Contradiction:
ReliabilityVSLoss of time

Solution Approach 1:

The patent creates a copy of the execution result in the buffer memory before pipeline flushing occurs. This allows the pipeline to be emptied for debugging or interrupt handling while the result is preserved in the buffer, eliminating the need to re-execute instructions after pipeline restoration.

Inventive Principle:
Principle #26Copying

Data Source

PatentUS9983932B2Pipeline processor and an equal model compensator method and apparatus to store the processing result
Publication Date: 2018.05.29 SAMSUNG ELECTRONICS CO LTD
  • US9983932B2 patent drawing
  • US9983932B2 patent drawing
  • US9983932B2 patent drawing

AI summary

A pipeline processor which meets a latency restriction on an equal model is provided. The pipeline processor includes a pipeline processing unit to process an instruction at a plurality of stages and an equal model compensator to store the results of the processing of some or all of the instructions located in the pipeline processing unit and to write the results of the processing in a register file based on the latency of each instruction.