Cross-Thread Interrupt Controller for Multi-Thread Processor Bottlenecks

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Existing multi-thread processor systems face challenges in efficiently managing and handling interrupts between threads, particularly in scenarios where one thread needs to request interrupts from another, and in handling a disproportionate number of interrupts, which can lead to processing bottlenecks and inefficiencies.

Innovation Solution

A cross-thread interrupt processor with separate interrupt controllers for each thread, featuring request registers, interrupt count registers, interrupt acknowledge registers, and interrupt mask registers, allows threads to request and acknowledge interrupts, with mechanisms to defer interrupts based on threshold values, ensuring efficient handling and processing of multiple interrupt requests and acknowledgments.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Device complexity

If a single interrupt controller is used for multiple threads, then device complexity is reduced, but interrupt management efficiency deteriorates due to inability to track and prioritize interrupts per thread

Engineering Contradiction:
Improveinterrupt controller structureVSAvoidinterrupt handling efficiency
Core Design Contradiction:
Device complexityVSProductivity

Solution Approach 1:

The interrupt controller is segmented into separate controllers for each thread (first interrupt controller for first thread, second interrupt controller for second thread). Each controller independently tracks interrupt requests, counts, and priorities specific to its associated thread, enabling efficient per-thread interrupt management without requiring a complex unified controller.

Inventive Principle:
Principle #1Segmentation

2Device complexity

If interrupt requests are not tracked per thread, then device complexity is reduced, but processing bottlenecks occur when one thread has disproportionate interrupt load

Engineering Contradiction:
Improveinterrupt tracking mechanismVSAvoidthread processing time
Core Design Contradiction:
Device complexityVSLoss of time

Solution Approach 1:

Each thread's interrupt controller includes an interrupt count register that tracks the number of pending interrupt requests for that specific thread. The controller provides feedback by comparing this count against a threshold value, allowing the thread to make informed decisions about whether to assert interrupts immediately or defer them, thereby preventing processing bottlenecks from disproportionate interrupt loads.

Inventive Principle:
Principle #23Feedback

3Productivity

If interrupt threshold mechanism is added, then interrupt handling efficiency is improved, but device complexity increases due to additional registers and control logic

Engineering Contradiction:
Improveinterrupt processing efficiencyVSAvoidinterrupt controller registers
Core Design Contradiction:
ProductivityVSDevice complexity

Solution Approach 1:

The interrupt controller merges multiple functions into integrated components: the request register, interrupt count register, threshold comparison logic, and assertion control are combined in a single controller unit. This consolidation achieves efficient threshold-based interrupt handling while minimizing the overall complexity increase compared to having completely separate controllers for each thread.

Inventive Principle:
Principle #5Merging (Combining)

Data Source

PatentUS7657683B2Cross-thread interrupt controller for a multi-thread processor
Publication Date: 2010.02.02 CEREMORPHIC INC
  • US7657683B2 patent drawing
  • US7657683B2 patent drawing
  • US7657683B2 patent drawing

AI summary

An interrupt controller for a dual thread processor has for a first thread, an interrupt request register accessible to the second thread, an interrupt count accessible to the second thread, and an interrupt acknowledge accessible to the first thread. Additionally, the interrupt controller has, for a second thread, an interrupt request register accessible to the first thread, an interrupt count accessible to the first thread, and an interrupt acknowledge accessible to the second thread. Each interrupt controller separately has a counter for each request which increments upon assertion of a request and decrements upon assertion of an acknowledgement.