Command System Bypassing Cache for Payload Delegates

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Current multi-core processing systems face inefficiencies due to memory latency and cache resource limitations, particularly in multi-threaded environments where conflicts over shared resources and frequent cache updates hinder performance.

Innovation Solution

A command system that includes a direct command module to bind payloads with program delegates, flushing them from external memory to minimize cache updates and optimize processor execution by bypassing cache memory access, utilizing a payload repository and payload identifiers for efficient data transfer and execution.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Speed

If data is copied into CPU cache from external memory, then data access speed is improved, but cache memory is polluted and update frequency increases

Engineering Contradiction:
Improvedata access speedVSAvoidcache update time
Core Design Contradiction:
SpeedVSLoss of time

Solution Approach 1:

The system pre-loads payload data from external memory into a dedicated payload repository in external memory before it is needed by delegates. This preliminary action ensures that when delegates execute, the data is already positioned and ready, eliminating the need for frequent cache updates and polluting during delegate execution.

Inventive Principle:
Principle #10Preliminary action

Solution Approach 2:

A command module acts as an intermediary between external memory and delegates, managing payload data transfer. The command module binds delegates to payloads and orchestrates data movement, allowing delegates to access data without direct cache access, thereby reducing cache pollution and update overhead.

Inventive Principle:
Principle #24Intermediary (Mediator)

2Productivity

If multiple threads access shared memory locations, then parallel processing capability is improved, but memory latency increases

Engineering Contradiction:
Improveparallel processing capabilityVSAvoidmemory latency
Core Design Contradiction:
ProductivityVSLoss of time

Solution Approach 1:

The system segments memory access by dedicating specific payload repositories to specific threads or delegate groups. Each thread can access its assigned payload data directly from external memory through the command module without contending for shared cache resources with other threads, thereby maintaining parallel processing capability while reducing memory latency.

Inventive Principle:
Principle #1Segmentation

3Speed

If cache memory is used to store payload data, then data access speed is improved, but cache resource consumption increases

Engineering Contradiction:
Improvedata access speedVSAvoidcache memory usage
Core Design Contradiction:
SpeedVSQuantity of substance

Solution Approach 1:

The system extracts payload data storage from the cache memory subsystem and places it in dedicated payload repositories in external memory. This extraction allows cache memory to be reserved for critical instruction and data caching, while payload data resides in external memory repositories, reducing cache resource consumption while maintaining efficient access through the command module binding mechanism.

Inventive Principle:
Principle #2Taking out (Extraction)

Data Source

PatentUS10095627B2Method and system for efficient communication and command system for deferred operation
Publication Date: 2018.10.09 OXIDE INTERACTIVE INC
  • US10095627B2 patent drawing
  • US10095627B2 patent drawing
  • US10095627B2 patent drawing

AI summary

A method and system for efficiently executing a delegate of a program by a processor coupled to an external memory. A payload including state data or command data is bound with a program delegate. The payload is mapped with the delegate via the payload identifier. The payload is pushed to a repository buffer in the external memory. The payload is flushed by reading the payload identifier and loading the payload from the repository buffer. The delegate is executed using the loaded payload.