Cross-scheduling In-memory Database Jobs via Mock Libraries
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In-memory database as a service on cloud platforms face challenges with job scheduling due to monolithic cluster architectures, which struggle to scale with increasing complexity and concurrent users, leading to slow service creation and deletion times, and resource allocation inefficiencies.
Innovation Solution
Implementing a cross-scheduling strategy that clusters jobs with similar service requests, where a primary job script is compiled and executed first, followed by secondary scripts, using a mock library to simulate service calls, allowing for delayed compilation and efficient resource reuse, thereby optimizing scheduling and resource management.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If a monolithic cluster architecture is used for job scheduling, then the system structure is simple, but the system cannot scale with increasing complexity and concurrent users, leading to slow service creation and deletion times
Solution Approach 1:
The patent divides the monolithic scheduling system into multiple independent scheduler frameworks operating at different levels. A two-level scheduler architecture is implemented where a global scheduler manages high-level resource allocation while local schedulers handle specific job scheduling tasks. This segmentation allows the system to scale by adding more local schedulers without increasing the complexity of the global coordination mechanism, thereby improving service creation and deletion speeds while maintaining manageable system complexity.
Solution Approach 2:
The patent introduces a hierarchical dimension to the scheduling architecture by implementing multi-level schedulers. Instead of a flat monolithic structure, the system organizes schedulers in layers with different responsibilities and scopes. This dimensional transformation allows the system to handle increased complexity and concurrency by distributing scheduling decisions across multiple levels, improving productivity without proportionally increasing overall system complexity.
2Adaptability or versatility
If multiple independent scheduler frameworks are implemented, then resource allocation flexibility improves, but resource requests from some jobs cannot be satisfied because the scheduler believes there are no available resources when another independent scheduler framework could offer the same resource
Solution Approach 1:
The patent merges the resource visibility of multiple independent scheduler frameworks by implementing a shared resource pool or centralized resource registry that all schedulers can access. This allows each scheduler to see and allocate from the same pool of available resources, eliminating the problem where one scheduler incorrectly believes resources are unavailable when another scheduler could provide them. The merging maintains allocation flexibility while ensuring consistent resource state across all scheduler frameworks.
Solution Approach 2:
The patent implements feedback mechanisms where schedulers continuously exchange information about resource availability and allocation status. When one scheduler framework allocates or releases resources, this information is fed back to other scheduler frameworks in real-time or near-real-time. This feedback loop ensures that all schedulers have accurate and up-to-date information about resource availability, preventing allocation conflicts and improving reliability while maintaining the flexibility of multiple independent scheduler frameworks.
3Productivity
If job scripts are compiled and executed sequentially, then resource management is simple, but service creation and deletion times are slow
Solution Approach 1:
The patent implements preliminary action by pre-compiling job scripts and pre-allocating resources before they are actually needed for service creation or deletion. Job scripts are compiled in advance and stored in a cached form, and resources are pre-provisioned based on predicted workload patterns. This preliminary preparation eliminates the need for time-consuming compilation and resource allocation during critical service operations, significantly improving creation and deletion speeds while managing complexity through automated pre-processing pipelines.
Solution Approach 2:
The patent ensures continuity of useful action by implementing overlapping execution phases where job script compilation, resource allocation, and service creation operations occur in parallel rather than strictly sequentially. While one job script is being executed, another can be compiled in the background, and resource allocation can begin before the script completes. This continuous overlapping of useful actions maximizes resource utilization and improves service creation and deletion speeds, with complexity managed through coordinated scheduling of parallel operations.
Data Source
AI summary
In an example embodiment, a new solution is provided for an in-memory database provided in a cloud as a service that enables “job cross running” instead of “parallel job running.” Specifically, job scripts are clustered based on a shared service. A primary job script in the cluster is compiled and executed, but secondary job scripts in the cluster are not compiled until after the execution of the primary job script has begun. A mock library is inserted into each of the secondary job scripts to cause service calls for the shared service in the secondary job scripts to be replaced with mock service calls. The secondary job scripts are then scheduled and executed, and upon completion the primary job script is permitted to delete the shared service.