Non-blocking Application Object Framework Dependency Model
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current Application Object Frameworks (AOFs) are limited by blocking access, leading to sequential execution of threads and poor CPU utilization, as they cannot parallelize operations, resulting in inefficient performance and scalability.
Innovation Solution
A non-blocking AOF that identifies dependencies between operations and generates an optimized execution plan, allowing sequential execution of dependent operations and parallel execution of independent ones using promises, enabling asynchronous and parallel processing.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If blocking access is used in AOF, then thread execution is simple and sequential, but CPU utilization is poor and performance is degraded
Solution Approach 1:
The patent transforms the static blocking execution model into a dynamic non-blocking model where threads can be released and reused. The runtime layer dynamically manages thread states, allowing threads to transition from blocked to ready states, enabling the same thread to handle multiple requests sequentially rather than remaining blocked throughout the entire operation lifecycle.
Solution Approach 2:
The patent introduces a runtime layer as an intermediary between the application layer and the operating system. This runtime layer acts as a mediator that manages the complexity of non-blocking I/O operations, handling event loops, callback registration, and thread pool management, thereby shielding application developers from the complexity while enabling high CPU utilization.
2Device complexity
If sequential execution is used in AOF, then dependency management is simple, but scalability and responsiveness are poor
Solution Approach 1:
The patent segments the application execution into independent operations that can be executed in parallel. Each operation is treated as a separate unit with defined inputs and outputs, allowing the runtime layer to schedule and execute them concurrently while maintaining dependency relationships through the dependency model that tracks operation prerequisites and results.
Solution Approach 2:
The patent implements a feedback mechanism where the runtime layer continuously monitors operation completion status and uses this information to dynamically adjust the execution plan. When operations complete, their results are fed back to the dependency model, which then triggers the scheduling of dependent operations, creating a responsive system that adapts to actual execution progress rather than following a rigid sequential plan.
3Productivity
If non-blocking execution with parallelization is implemented, then CPU utilization and scalability improve, but dependency management complexity increases
Solution Approach 1:
The patent creates a universal dependency model that handles multiple types of operations (I/O, computation, database queries) and various dependency relationships (prerequisites, results, side effects) through a single unified framework. This universal model can represent any operation dependency graph, making the system scalable and adaptable to different application scenarios without requiring separate management mechanisms for each operation type.
Solution Approach 2:
The patent replaces the mechanical sequential execution model with an event-driven system where the runtime layer's event loop monitors operation completion and triggers subsequent operations. This substitution eliminates the need for explicit blocking calls and manual thread management, allowing the system to automatically handle complex dependency relationships through asynchronous event processing and callback mechanisms.
4Ease of manufacture
If blocking I/O operations are used, then implementation is simple, but memory usage increases due to thread blocking
Solution Approach 1:
The patent implements thread recovery by releasing blocked threads back to the thread pool after I/O operations are initiated. Instead of keeping threads blocked and occupying memory throughout the entire I/O duration, the system discards the blocking state and recovers the thread for reuse. When I/O operations complete, callbacks are invoked to handle results, eliminating the need for persistent thread occupation and reducing overall memory consumption.
Data Source
AI summary
Techniques are described for providing a non-blocking application object framework allowing parallelization of operation and function calls throughout an application executing within the framework. In one example, a dependency model associated with an application in a non-blocking application object framework is identified, where the application is associated with a plurality of operations and the dependency model defines at least one dependency between at least two of the operations. At runtime of the non-blocking application object framework, the identified dependency model is interpreted. An optimized execution plan of the application is automatically generated in the non-blocking application object framework based on the interpreted dependency model, wherein at least a first portion of the operations of the application are optimized in a sequential execution order based on dependencies defined in the dependency model. The application is then executed in the non-blocking application object framework based on the optimized execution plan.