Dependency Data Structure for Concurrent Task Execution

Resolve Bottlenecks,
Find Innovative SolutionsGenerate Solutions

Solution Overview

Problem

Developers face challenges in fully exploiting processing concurrency due to the difficulty in identifying and implementing concurrent processing tasks, which requires custom code and high development costs.

Innovation Solution

A systematic approach using dependency datastructures to register and manage processing tasks, where code units are represented as components with dependencies, and an execution manager identifies and executes components with satisfied dependencies, allowing for concurrent execution.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Productivity

If developers manually identify and implement concurrent processing tasks using custom code, then processing concurrency can be exploited, but development cost and complexity increase significantly

Engineering Contradiction:

Improveprocessing concurrency exploitationVSAvoiddevelopment complexity

Core Design Contradiction:

ProductivityVSDevice complexity

Solution Approach 1:

The execution manager automatically identifies and executes concurrent tasks by monitoring the dependency data structure for ready components, eliminating the need for developers to manually implement concurrency management code

Inventive Principle:

Principle #25Self-service

Solution Approach 2:

The system segments processing tasks into independent code units represented as components in the dependency data structure, allowing the execution manager to identify and execute independent segments concurrently without manual intervention

Inventive Principle:

Principle #1Segmentation

2Productivity

If developers write custom multi-threading and inter-thread communication code, then concurrent processing is achieved, but the code becomes more complex and error-prone

Engineering Contradiction:

Improveconcurrent processing capabilityVSAvoidcode complexity

Core Design Contradiction:

ProductivityVSDevice complexity

Solution Approach 1:

The execution manager acts as an intermediary between components, automatically managing thread creation, scheduling, and inter-thread communication based on the dependency data structure, thereby eliminating complex manual threading code

Inventive Principle:

Principle #24Intermediary (Mediator)

Solution Approach 2:

The patent replaces manual mechanical threading code with an automated execution manager that uses the dependency data structure to dynamically manage concurrency, substituting complex developer-written mechanics with an automated system

Inventive Principle:

Principle #28Mechanics substitution (Replace mechanical system)

3Productivity

If manual concurrency management is implemented, then processing tasks can run in parallel, but development time and cost increase

Engineering Contradiction:

Improveparallel processing efficiencyVSAvoiddevelopment time

Core Design Contradiction:

ProductivityVSLoss of time

Solution Approach 1:

The dependency data structure is built in advance to define all task dependencies, allowing the execution manager to automatically identify concurrent execution opportunities without requiring developers to manually analyze and prepare concurrency details during development

Inventive Principle:

Principle #10Preliminary action

Data Source

PatentUS8935705B2Execution of highly concurrent processing tasks based on the updated dependency data structure at run-time

Publication Date: 2015.01.13 BENEFITFOCUS COM INC

AI summary

A dependency datastructure represents a processing task. The dependency datastructure comprising a plurality of components, each component encapsulating a code unit. The dependency datastructure may include dependency arcs to inter-component dependencies. Dependencies that are not satisfied by components within the dependency datastructure may be represented as pseudo-components. An execution environment identifies components that can be executed (e.g., have satisfied dependencies), using the dependency datastructure and/or concurrency state metadata. The execution environment may identify and exploit concurrencies in the processing task, allowing for multiple components to be executed in parallel.