Bounded Resource Allocation via Process Spawning
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Distributed computing systems face challenges in resource allocation, leading to system crashes and performance bottlenecks due to processes exceeding available resources, as they often rely on infinite memory assumptions and shared resource models that result in resource contention and unpredictable performance.
Innovation Solution
A method of allocating bounded computing resources to processes, allowing them to request and spawn new processes with predetermined finite resource allocations, ensuring exclusive and guaranteed resource availability, thereby preventing resource overuse and enabling predictable execution.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If processes are allowed to request additional resources on-demand with the assumption of infinite memory, then application development becomes simpler and processes can adapt to changing computational demands, but the sum total of resources requested by user processes may exceed the resources on the node, leading to system crashes
Solution Approach 1:
The system segments the monolithic process model into multiple process instances, each with bounded resources. When a process needs more resources, instead of expanding its own allocation indefinitely, it spawns child processes that share the parent's resource pool. This segmentation prevents any single process from consuming all resources and causing system failure.
Solution Approach 2:
The system introduces dynamic resource allocation through process spawning. A parent process can dynamically create child processes based on computational needs, and each process can be terminated when no longer needed. This dynamic creation and destruction of processes allows the system to adapt to changing demands while maintaining bounded resource usage at any given time.
2Ease of operation
If Docker containers are allowed to use as much memory as the host kernel allows without resource constraints, then containers have flexibility to use available resources, but when a process overuses resources the host kernel terminates processes to free up memory, making the system susceptible to crashes
Solution Approach 1:
The system applies preliminary action by establishing resource bounds and process spawning mechanisms before resource exhaustion occurs. Instead of allowing processes to grow unbounded and then reacting to crashes, the system proactively structures resource allocation so that processes can request resources through controlled spawning, preventing the conditions that lead to kernel-mediated process termination.
3Productivity
If Kubernetes pods share memory resources, then resource utilization efficiency improves, but a resource-hungry container can lead to other containers in the pod being starved of resources
Solution Approach 1:
The system segments the shared resource pool into discrete process allocations. Each process receives a bounded allocation from the parent's resource pool, ensuring that no single process can monopolize resources and starve others. This segmented allocation maintains efficiency through shared access while preventing resource starvation through enforced bounds.
4Adaptability or versatility
If conventional systems allow memory sharing and use of memory allocation functions like malloc(), then applications can dynamically allocate memory, but these systems suffer from the same problems of resource overuse and system crashes
Solution Approach 1:
The system replaces the traditional single-process dynamic allocation model with a segmented multi-process model. Each process has bounded resources and can spawn children when needing more resources. This segmentation maintains the adaptability of dynamic allocation while preventing the reliability issues of unbounded resource consumption that plague conventional systems.
Data Source
AI summary
There is provided a method of computing resource allocation. The method comprises allocating a first bounded amount of computing resources forming a first set of computing resources; exclusively assigning the first set of computing resources to a first process of a computer program; receiving a request from the first process for additional computing resources; in response to the request from the first process, allocating a second bounded amount of computing resources forming a second set of computing resources; and spawning a second process from the first process and exclusively assigning the second set of computing resources to the second process; wherein this method may be repeated indefinitely by the first process, second process, or any other process created according to this method. By following this method, a process does not control the amount of computing resources allocated to that process (i.e., itself), but instead controls the amount of computing resources allocated to its child processes.