bgRFC Interface Dependency Scheduling for Distributed Systems
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The current queued remote function call (qRFC) protocol faces limitations in resource allocation and management, leading to increased processing demands and potential system overload due to inefficient resource determination and load balancing, especially in distributed business applications.
Innovation Solution
The introduction of a background remote function call (bgRFC) interface calculates data dependencies at the time of data storage, allowing for efficient scheduling and resource allocation, minimizing resource usage and improving runtime behavior by distinguishing between dependent and independent queues and providing feedback on resource status.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If queued RFC (qRFC) protocol is used to manage data transfer between applications, then data transfer reliability and processing order are improved, but resource allocation efficiency and system throughput deteriorate due to inefficient resource determination and load balancing
Solution Approach 1:
The patent applies preliminary action by calculating data dependencies at the time of data storage in the queue, rather than waiting until execution time. This allows the system to pre-determine resource requirements and generate execution schedules in advance, improving both reliability through proper dependency management and productivity by reducing runtime overhead for resource determination
Solution Approach 2:
The patent implements dynamics by introducing adaptive load balancing mechanisms that dynamically adjust resource allocation based on current system state and queue characteristics. The system can modify scheduling decisions in real-time based on resource availability and dependency complexity, optimizing both reliability and throughput under varying conditions
2Manufacturing precision
If qRFC protocol processes all function calls with full dependency checking, then processing accuracy and order guarantee are improved, but processing time and computational overhead increase
Solution Approach 1:
The patent applies segmentation by dividing the dependency checking process into distinct phases: initial dependency calculation at storage time, and streamlined execution-phase processing. This segmentation allows comprehensive dependency analysis to be performed when data is queued, while execution can proceed more efficiently with pre-computed dependency information, maintaining processing accuracy while reducing time loss
Solution Approach 2:
By performing dependency calculations preliminarily during data storage rather than at execution time, the system ensures processing order accuracy is established in advance. This preliminary action eliminates the need for repeated dependency checking during execution, significantly reducing processing time while maintaining the same level of ordering precision
3Power
If more resources are allocated to handle increased inter-application communication, then system capacity and processing power are improved, but resource management complexity and administration overhead increase
Solution Approach 1:
The patent implements self-service by enabling the system to automatically determine resource requirements based on data dependencies and generate appropriate execution schedules without external intervention. The automated resource determination and load balancing mechanisms reduce administration overhead while effectively utilizing available processing power, allowing the system to self-manage resource allocation even as capacity increases
Data Source
AI summary
A system, computer program product and method of processing function calls in a distributed application environment are provided. A number of function calls for communication from a sending application to a receiving application are queued in a database. Dependencies among at least a portion of the function calls that are being queued are determined while the function calls are stored in the queues. A schedule of execution of the function calls is then generated based on the determined dependencies.