Buffer Construct for Concurrent Memory Access Control

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Conventional approaches to parallelism in systems with multiple processing resources are error-prone and inefficient, often leading to conflicts among concurrent tasks accessing a common memory region due to manual thread and memory region lock management.

Innovation Solution

A buffer construct is used as a data structure to represent a common memory region, allowing synchronized access and exclusive control by individual tasks, preventing conflicts through state information that ensures only one task can access the memory at a time, and enables timely passing of the buffer construct to other tasks for seamless data pipeline operations.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Productivity

If manual thread and memory region lock management is used to facilitate parallelism, then processing tasks can be performed concurrently, but conflicts among concurrent tasks accessing common memory region occur

Engineering Contradiction:
Improveparallel processing efficiencyVSAvoidmemory access conflict prevention
Core Design Contradiction:
ProductivityVSReliability

Solution Approach 1:

The patent introduces a buffer construct as an intermediary data structure that mediates access between multiple concurrent tasks and the common memory region. This buffer construct contains state information that tracks which task currently has access rights, preventing direct conflicts. The buffer construct acts as a controlled interface that serializes memory access while allowing tasks to proceed concurrently through the processing pipeline.

Inventive Principle:
Principle #24Intermediary (Mediator)

2Reliability

If manual memory region lock management is implemented, then concurrent access to memory can be controlled, but the approach becomes error-prone and complex

Engineering Contradiction:
Improvememory access controlVSAvoidthread and lock management complexity
Core Design Contradiction:
ReliabilityVSDevice complexity

Solution Approach 1:

The buffer construct implements self-service by automatically managing its own state information and access rights without requiring external lock management mechanisms. Each task can independently query and modify the buffer construct's state to determine whether it has access rights, eliminating the need for complex manual locking protocols. The construct self-regulates concurrent access through its internal state machine.

Inventive Principle:
Principle #25Self-service

3Speed

If direct memory access operations are used by multiple concurrent tasks, then data processing speed is improved, but conflicts in accessing common memory region increase

Engineering Contradiction:
Improvedata processing speedVSAvoidmemory access conflicts
Core Design Contradiction:
SpeedVSObject-affected harmful factors

Solution Approach 1:

The patent segments the common memory region access by introducing a buffer construct that divides access rights into discrete, manageable units. Instead of allowing unrestricted direct memory access by multiple tasks simultaneously, the buffer construct segments access control into sequential phases where each task receives temporary exclusive access rights. This segmentation maintains high processing speeds by allowing pipelined execution while preventing conflicts through structured access phases.

Inventive Principle:
Principle #1Segmentation

Data Source

PatentUS8433830B2Systems and methods for using a shared buffer construct in performance of concurrent data-driven tasks
Publication Date: 2013.04.30 OL SECURITY LLC
  • US8433830B2 patent drawing
  • US8433830B2 patent drawing
  • US8433830B2 patent drawing

AI summary

Disclosed herein are techniques to execute tasks with a computing device. A first task is initiated to perform an operation of the first task. A buffer construct that represents a region of memory accessible to the operation of the first task is created. A second task is initiated to perform of an operation of the second task that is configured to be timed to initiate in response to the buffer construct being communicated to the second task from the first task.