Floating Point Remainder Unit with Embedded Status

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Existing floating point systems face challenges with implicit serialization issues, difficulty in optimizing floating point code due to global flags, and inefficient integration of traps, particularly when performing floating point operations and remainder operations with embedded status information.

Innovation Solution

A floating point remainder unit that encodes status information within the result, eliminating the need for separate storage and allowing concurrent execution of multiple instructions by embedding status flags in the floating point operand, thereby reducing serialization and improving performance.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Reliability

If status information is stored in separate global flags, then status information can be maintained, but implicit serialization issues occur and concurrent execution is prevented

Engineering Contradiction:
Improvestatus information maintenanceVSAvoidconcurrent execution capability
Core Design Contradiction:
ReliabilityVSProductivity

Solution Approach 1:

The patent segments the floating point result structure into multiple fields, embedding status information directly within the result operand rather than using separate global flags. This segmentation allows status information to be carried locally with each result, enabling concurrent execution without serialization conflicts.

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The patent merges status information with the floating point result operand by embedding it in the same data structure. This combining eliminates the separation between computation results and status flags, allowing both to be processed and executed concurrently without requiring separate status register access.

Inventive Principle:
Principle #5Merging (Combining)

2Reliability

If global flags are used for status information, then status can be tracked, but code optimization becomes difficult

Engineering Contradiction:
Improvestatus trackingVSAvoidcode optimization capability
Core Design Contradiction:
ReliabilityVSEase of manufacture

Solution Approach 1:

The floating point result structure becomes self-sufficient by carrying its own status information embedded within it. Each result operand independently contains its status flags, eliminating dependence on external global flag registers and enabling compilers to optimize code without worrying about side effects on shared status state.

Inventive Principle:
Principle #25Self-service

3Reliability

If traps are integrated separately from floating point operations, then trap handling is possible, but integration efficiency is reduced

Engineering Contradiction:
Improvetrap handling capabilityVSAvoidintegration efficiency
Core Design Contradiction:
ReliabilityVSProductivity

Solution Approach 1:

The patent merges trap-related status information with the floating point operation results by embedding condition codes and status flags directly in the result structure. This integration allows trap handling to occur naturally as part of the floating point execution pipeline, improving efficiency by eliminating separate trap integration overhead.

Inventive Principle:
Principle #5Merging (Combining)

Data Source

PatentUS7613762B2Floating point remainder with embedded status information
Publication Date: 2009.11.03 ORACLE AMERICAN INC
  • US7613762B2 patent drawing
  • US7613762B2 patent drawing
  • US7613762B2 patent drawing

AI summary

A system for providing a floating point remainder comprises an analyzer circuit configured to determine a first status of a first floating point operand and a second status of a second floating point operand based upon data within the first floating point operand and the second floating point operand, respectively. In addition, the system comprises a results circuit coupled to the analyzer circuit. The results circuit is configured to assert a resulting floating point operand containing the remainder of the first floating point operand and the second floating point operand and a resulting status embedded within the resulting floating point operand.