Transactional API Function Scheduler for Dependency-Based Execution
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Transactional API protocols face performance bottlenecks due to high latency and network resource usage caused by sequential execution of function calls over high-latency interconnects, where intermediate responses incur transport delays and bandwidth penalties for unnecessary output variable arguments.
Innovation Solution
Implementing a function scheduler that reorders and serializes function execution based on data dependencies, using a memory manager to manage argument data storage and infer concurrency rules, allowing functions with valid dependencies to execute concurrently and minimizing data returned to the application.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If function calls are executed sequentially over high-latency interconnects, then data dependency correctness is maintained, but latency and network resource usage increase
Solution Approach 1:
The system performs preliminary analysis of function call dependencies before execution, identifying which functions can be executed concurrently. The scheduler pre-processes the function call sequence, determines execution ordering based on dependency graphs, and prepares concurrent execution plans ahead of time, allowing functions with no dependencies to be executed in parallel while maintaining correctness for dependent functions.
Solution Approach 2:
The execution model transitions from static sequential execution to dynamic concurrent execution. The scheduler dynamically adjusts the execution order and timing of function calls based on runtime dependency analysis, allowing the system to adaptively optimize performance while maintaining data dependency correctness through runtime scheduling decisions.
2Reliability
If all function calls are executed in prescribed sequence, then data dependency correctness is ensured, but productivity decreases
Solution Approach 1:
The system segments the function call execution into independent concurrent tasks by analyzing dependency relationships. Functions that do not depend on each other are segmented into separate execution threads or processes, allowing parallel execution. The dependency graph is segmented into independent execution units that can be processed concurrently, increasing overall throughput while maintaining correctness for dependent function pairs.
Solution Approach 2:
The scheduler ensures continuous utilization of compute resources by continuously issuing ready-to-execute functions to available executors. Instead of idle waiting periods between sequential function executions, the system maintains continuous useful action by overlapping the execution of multiple independent functions, keeping processors busy and maximizing productivity.
3Loss of information
If intermediate responses are returned for each function call, then application visibility is improved, but network bandwidth is consumed unnecessarily
Solution Approach 1:
The system extracts only the essential final results from concurrent function executions and returns them to the application, rather than returning intermediate responses for every function call. The scheduler identifies which function results are actually needed by the application and extracts only those for transmission, eliminating unnecessary network traffic while maintaining application visibility into required outcomes.
Solution Approach 2:
The system performs preliminary dependency analysis to determine which function results are actually needed by the application before executing functions. By analyzing the dependency graph and application requirements in advance, the system identifies minimal result sets that maintain application visibility, avoiding unnecessary network transmissions of intermediate values that the application does not require.
Data Source
AI summary
Embodiments described herein are generally directed to improving performance of a transactional API protocol by scheduling function calls based on data dependencies. In an example, a function associated with the transactional API is received that is to be carried out by an executer on behalf of an application. It is determined whether the function has a dependency on a value that is invalid. If so, execution of the function is delayed by causing a function ID of the function to be queued for a global memory reference associated with the value. After the value becomes valid, the function is caused to be executed by the executer. When the first function is determined to have no such dependency, the function may be immediately scheduled for execution by the executer without delay.