Implicit Concurrency Control in Programming Model Runtime

Resolve Bottlenecks,
Find Innovative SolutionsGenerate Solutions

Solution Overview

Problem

Existing software systems face challenges in handling concurrency-related hazards due to the increasing complexity of simultaneous events, requiring additional programming expertise and leading to issues like bottlenecks, low-throughput, high-latency, and underutilization of processors, especially when dealing with shared resources.

Innovation Solution

A programming model that provides implicit concurrency control through a runtime environment, utilizing program unit definitions and instances with recursive compositions and creational patterns like singleton and multiton, enabling high-performance services by managing concurrency at the runtime level.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Productivity

If concurrent computing is implemented to improve throughput and reduce latency, then performance is improved, but programming complexity and difficulty of detecting and measuring increase

Engineering Contradiction:

ImprovethroughputVSAvoidprogramming complexity

Core Design Contradiction:

ProductivityVSDifficulty of detecting and measuring

Solution Approach 1:

The patent introduces an intermediary layer (the runtime environment and programming model) that mediates between the programmer and the concurrent execution system. This intermediary automatically handles concurrency control, resource management, and coordination, allowing programmers to write simpler code while the system manages the complexity of concurrent execution behind the scenes.

Inventive Principle:

Principle #24Intermediary (Mediator)

Solution Approach 2:

The system enables self-service by allowing the runtime environment to automatically manage concurrency control without requiring explicit programmer intervention. The programming model provides built-in mechanisms for automatic resource allocation, task scheduling, and conflict resolution, reducing the burden on programmers while maintaining high throughput and low latency performance.

Inventive Principle:

Principle #25Self-service

2Reliability

If explicit concurrency management techniques are used to solve concurrency hazards, then reliability is improved, but device complexity and ease of operation worsen

Engineering Contradiction:

Improveconcurrency safetyVSAvoidprogramming complexity

Core Design Contradiction:

ReliabilityVSDevice complexity

Solution Approach 1:

The patent extracts concurrency management complexity from the programming layer and relocates it to the runtime environment layer. By separating concerns in this manner, the programming language and application code remain simple while the runtime system handles all the complex concurrency control mechanisms, ensuring reliability without increasing programming complexity.

Inventive Principle:

Principle #2Taking out (Extraction)

Solution Approach 2:

The programming model provides universal concurrency control mechanisms that work across different types of concurrent operations and resources. Rather than requiring separate explicit management code for each concurrency scenario, the system offers a unified framework that automatically adapts to various concurrency patterns, reducing programming complexity while maintaining reliability.

Inventive Principle:

Principle #6Universality (Multi-functionality)

3Ease of operation

If sequential programming is used to simplify code and reduce programming complexity, then ease of operation is improved, but productivity and speed worsen

Engineering Contradiction:

Improveprogramming simplicityVSAvoidthroughput

Core Design Contradiction:

Ease of operationVSProductivity

Solution Approach 1:

The system dynamically adjusts the level of concurrency based on the program's needs and system resources. The runtime environment automatically determines when and how to execute operations concurrently, allowing the system to maintain programming simplicity while achieving high throughput through selective parallelization of independent operations.

Inventive Principle:

Principle #15Dynamics

Solution Approach 2:

The programming model ensures continuous useful action by automatically pipelineing independent operations and minimizing idle time. While maintaining sequential programming simplicity, the system overlaps the execution of independent tasks and keeps processors busy, thereby improving throughput without requiring the programmer to manage explicit concurrency.

Inventive Principle:

Principle #20Continuity of useful action

4Productivity

If more processor cores are utilized to improve throughput, then productivity is improved, but device complexity and ease of operation worsen

Engineering Contradiction:

ImprovethroughputVSAvoidsystem complexity

Core Design Contradiction:

ProductivityVSDevice complexity

Solution Approach 1:

The runtime environment serves as an intermediary that manages the complexity of multi-core utilization. It automatically distributes tasks across available processor cores, handles load balancing, and manages resource allocation, allowing the system to leverage multiple cores for high throughput while shielding programmers from the underlying complexity of parallel hardware management.

Inventive Principle:

Principle #24Intermediary (Mediator)

Data Source

PatentUS10310820B2Programming model and interpreted runtime environment for high performance services with implicit concurrency control

Publication Date: 2019.06.04 BASAL NUCLEI INC

AI summary

Disclosed is a programming model utilized for the definition of services to be operated on large sets of data with numerous responsibilities, the programming model comprising program units in a tree topology for high performance and implicit concurrency control, where each program unit definition comprises responsibilities defined in behaviors and configurations. A runtime environment may be utilized to provide implicit concurrency, parallelization, and concurrency control for operations executed on program unit instances.