Ticket-Based Shared Resource Access Control

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Existing mechanisms for accessing shared resources in multi-core processors often lead to unfair access and increased latency due to timing dependencies and cache coherence requirements, which limit scalability and fairness among execution units.

Innovation Solution

A hardware atomic unit issues unique tickets to execution units requesting access to a shared resource, with a current owner field indicating the ticket number of the unit in control, allowing units to access when their ticket matches the owner field, thereby ensuring fair and efficient access without cache coherence requirements.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Reliability

If locks are used to limit access to shared resources to one process at a time, then data collisions and corruption are prevented, but access fairness deteriorates due to timing dependencies and transmission delays

Engineering Contradiction:
Improvedata integrityVSAvoidaccess fairness
Core Design Contradiction:
ReliabilityVSEase of operation

Solution Approach 1:

The system assigns ticket numbers to execution units in advance before they actually need to access the shared resource. This preliminary assignment eliminates timing dependencies during the actual access request, as the ticket number is determined beforehand rather than depending on when the lock request is transmitted.

Inventive Principle:
Principle #10Preliminary action

Solution Approach 2:

A ticket counter acts as an intermediary between execution units and the shared resource. Instead of directly competing for locks, execution units receive tickets from this intermediary, and the ticket numbers determine access order. This mediator eliminates direct timing-based competition and ensures fair arbitration.

Inventive Principle:
Principle #24Intermediary (Mediator)

2Reliability

If execution units reattempt lock acquisition after backoff periods, then eventual access is achieved, but access time increases and starvation may occur for remote units

Engineering Contradiction:
Improveeventual accessVSAvoidaccess latency
Core Design Contradiction:
ReliabilityVSLoss of time

Solution Approach 1:

Ticket numbers are assigned in advance to execution units, establishing a predetermined access order before any backoff or reattempt logic is needed. This eliminates the time loss associated with repeated lock acquisition attempts, as the access sequence is already determined by the ticket numbering system.

Inventive Principle:
Principle #10Preliminary action

3Reliability

If cache coherence mechanisms are used to control ticket generation, then ticket uniqueness is ensured, but system scalability is limited

Engineering Contradiction:
Improveticket uniquenessVSAvoidsystem scalability
Core Design Contradiction:
ReliabilityVSAdaptability or versatility

Solution Approach 1:

The patent extracts the ticket generation function from the cache coherence mechanism. Instead of relying on cache coherence to ensure ticket uniqueness, the system uses a dedicated ticket counter that operates independently of cache coherence requirements, thereby removing the scalability limitation imposed by cache coherence protocols.

Inventive Principle:
Principle #2Taking out (Extraction)

Data Source

PatentUS9158597B2Controlling access to shared resource by issuing tickets to plurality of execution units
Publication Date: 2015.10.13 MICROSOFT TECHNOLOGY LICENSING LLC
  • US9158597B2 patent drawing
  • US9158597B2 patent drawing
  • US9158597B2 patent drawing

AI summary

Access to a shared resource by a plurality of execution units is organized and controlled by issuing tickets to each execution unit as they request access to the resource. The tickets are issued by a hardware atomic unit so that each execution unit receives a unique ticket number. A current owner field indicates the ticket number of the execution unit that currently has access to the shared resource. When an execution unit has completed its access, it releases the shared resource and increments the owner field. Execution units awaiting access to the shared resource periodically check the current value of the owner field and take control of the shared resource when their respective ticket values match the owner field.