Hierarchical Interrupt Register Structure for Long-Running Recovery Actions

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Existing computing systems face performance bottlenecks due to excessive processing time spent handling interrupts, particularly when numerous or long-running interrupts require significant processing resources, leading to reduced system performance and functionality.

Innovation Solution

A hierarchical interrupt register structure is implemented, where root-level registers indicate interrupts at lower levels, allowing a system interrupt handler to selectively route interrupts to error handlers based on interrupt class and recovery time, enabling efficient handling and minimizing system interrupt handler occupancy.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Device complexity

If the system interrupt handler processes all interrupts directly, then interrupt handling is simple, but system performance deteriorates due to excessive processing time

Engineering Contradiction:
Improveinterrupt handling structureVSAvoidsystem performance
Core Design Contradiction:
Device complexityVSProductivity

Solution Approach 1:

The patent segments the interrupt handling structure into a hierarchical system with root-level registers and lower-level registers. The root-level register structure divides interrupt handling into multiple levels, allowing the system interrupt handler to quickly identify and delegate specific interrupt types to specialized error handlers, thereby reducing processing time and improving system performance

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The patent introduces an intermediary hierarchical register structure between the system interrupt handler and the error handlers. This intermediary structure enables efficient routing of interrupts by providing a structured interface that allows the system interrupt handler to quickly identify and delegate interrupts to appropriate error handlers without direct complex interactions

Inventive Principle:
Principle #24Intermediary (Mediator)

2Ease of operation

If the system interrupt handler handles long-running recovery actions, then all interrupts are processed centrally, but processing time increases reducing available time for computing threads

Engineering Contradiction:
Improvecentralized interrupt handlingVSAvoidprocessing time
Core Design Contradiction:
Ease of operationVSLoss of time

Solution Approach 1:

The patent extracts long-running recovery actions from the central system interrupt handler and delegates them to specialized error handlers. By taking out these time-consuming operations from the main interrupt handling path, the system minimizes the time the system interrupt handler is occupied, allowing computing threads to resume execution more quickly

Inventive Principle:
Principle #2Taking out (Extraction)

Solution Approach 2:

The patent implements preliminary action by pre-organizing error handlers and their associated registers in a hierarchical structure before interrupts occur. This pre-arranged structure allows the system interrupt handler to quickly identify and delegate appropriate interrupts without requiring complex decision-making during interrupt processing, thereby reducing processing time

Inventive Principle:
Principle #10Preliminary action

Data Source

PatentUS9519532B2Handling system interrupts with long-running recovery actions
Publication Date: 2016.12.13 LENOVO ENTERPRISE SOLUTIONS (SINGAPORE) PTE LTD
  • US9519532B2 patent drawing
  • US9519532B2 patent drawing
  • US9519532B2 patent drawing

AI summary

A method, processor, and computer system for handling interrupts within a hierarchical register structure. The method includes receiving at a root-level register an indication of an interrupt occurring at a lower level register in the register structure, using a system interrupt handler to invoke an error handler assigned to a set of registers of the structure that includes the lower level register, and using the invoked error handler to handle the interrupt and return to the system interrupt handler.