# US 12,602,262 B2 · Shared resource pool with periodic rebalancing in a multi-core system > Agents: this data is available as JSON from the patentgrep API and MCP server — see https://patentgrep.com/llms.txt - Number: US 12,602,262 B2 - Document ID: US12602262B2 - Status: Granted - Kind: B2 - Application number: 18/367,042 - Filed: 2023-09-12 - Published: 2025-03-13 - Granted: 2026-04-14 - Earliest claimed: 2023-09-12 - Assignees: Dell Products L.P. - Applicants: Dell Products L.P. - Inventors: Vladimir Shveidel; Jenny Derzhavetz - Web page: https://patentgrep.com/patent/US12602262B2 ## CPC - G06F 9/5077: {Logical partitioning of resources; Management or configuration of virtualized resources (specific details on emulation or internal functioning of virtual machines G06F9/455)} - G06F 9/505: {considering the load} - G06F 9/5083: {Techniques for rebalancing the load in a distributed system} - G06F 2209/5011: Pool - G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N) ## Abstract A percentage of the resource units contained in a shared resource pool of a data storage system is loaded into a global partition, and the resource units not loaded into the global partition are loaded into per-core partitions. Each per-core partition corresponds to one of multiple processor cores in the data storage system. Resource units are allocated from each one of the per-core partitions only to a work flow executing on the corresponding processor core. The number of available resource units in each one of the per-core partitions is periodically rebalanced by moving resource units between the global partition and that per-core partition. ## Claims ### Claim 1 A method comprising: loading a predetermined percentage of a plurality of resource units contained in a shared resource pool of a data storage system into a global partition within the shared resource pool; loading those resource units contained in the shared resource pool that were not loaded into the global partition into a plurality of per-core partitions within the shared resource pool, wherein each one of the per-core partitions corresponds to a respective one of a plurality of processor cores in the data storage system; for each one of the per-core partitions, allocating resource units from that per-core partition only to a work flow executing on the corresponding processor core; periodically rebalancing each one of the per-core partitions by moving resource units between the global partition and the per-core partition, wherein the rebalancing includes: calculating a local exhaustion time interval for the per-core partition, wherein the local exhaustion interval comprises an estimated amount of time until all resource units currently available in the per-core partition are exhausted, obtaining a target exhaustion time interval, and moving resource units from the global partition to the per-core partition in response to a determination that the local exhaustion time interval for the per-core partition is smaller than the target exhaustion time interval; and wherein periodically rebalancing at least one of the per-core partitions is triggered by a determination that an amount of time since a last time that rebalancing was performed on the per-core partition exceeds a maximum rebalance time interval. ### Claim 2 (depends on 1) The method of claim 1, wherein periodically rebalancing each one of the per-core partitions further comprises: moving resource units from the per-core partition to the global partition in response to a determination that the local exhaustion time interval for the per-core partition is larger than the target exhaustion time interval. ### Claim 3 (depends on 2) The method of claim 2, wherein periodically rebalancing each one of the per-core partitions further comprises: moving resource units from the per-core partition to the global partition in response to a determination that no pool operation has been performed on the per-core partition since a last time that the per-core partition was rebalanced. ### Claim 4 (depends on 3) The method of claim 3, wherein periodically rebalancing each one of the per-core partitions further comprises: moving resource units from the global partition to the per-core partition in response to a determination that the per-core partition is empty and an allocation request was issued by the work flow executing on the corresponding processor core. ### Claim 5 (depends on 1) The method of claim 1, wherein obtaining the target exhaustion time interval comprises calculating the target exhaustion time interval as an average of local exhaustion time intervals calculated for the plurality of per-core partitions. ### Claim 6 (depends on 1) The method of claim 1, wherein periodically rebalancing at least one of the per-core partitions is triggered by a determination made by monitoring logic executed after processing a pool operation on a per-core partition that an amount of time since a last time that rebalancing was performed on the per-core partition exceeds the maximum rebalance time interval. ### Claim 7 (depends on 1) The method of claim 1, wherein periodically rebalancing at least one of the per-core partitions is triggered by a determination that a per-core partition currently contains insufficient available resource units to perform an allocation request issued by the workflow executing on the corresponding processor core. ### Claim 8 (depends on 1) The method of claim 1, further comprising: executing a plurality of per-core heartbeat timer threads, wherein each one of the per-core heartbeat timer threads executes on a corresponding respective one of the processor cores; and wherein periodically rebalancing at least one of the per-core partitions is triggered by one of the per-core heartbeat timer threads determining that an amount of time since a last time that rebalancing was performed on the per-core partition corresponding to the processor core executing the per-core heartbeat timer exceeds the maximum rebalance time interval. ### Claim 9 A data storage system comprising: processing circuitry and a memory; a plurality of non-volatile data storage drives; and wherein the memory has program code stored thereon, wherein the program code, when executed by the processing circuitry, causes the processing circuitry to: load a predetermined percentage of a plurality of resource units contained in a shared resource pool of a data storage system into a global partition within the shared resource pool; load those resource units contained in the shared resource pool that were not loaded into the global partition into a plurality of per-core partitions within the shared resource pool, wherein each one of the per-core partitions corresponds to a respective one of a plurality of processor cores in the data storage system; for each one of the per-core partitions, allocate resource units from that per-core partition only to a work flow executing on the corresponding processor core; and periodically rebalance each one of the per-core partitions by moving resource units between the global partition and the per-core partition, at least in part by causing the processing circuitry to: calculate a local exhaustion time interval for the per-core partition, wherein the local exhaustion interval comprises an estimated amount of time until all resource units currently available in the per-core partition are exhausted; obtain a target exhaustion time interval, and move resource units from the global partition to the per-core partition in response to a determination that the local exhaustion time interval for the per-core partition is smaller than the target exhaustion time interval; and wherein the processing circuitry is triggered to periodically rebalance at least one of the per-core partitions by a determination that an amount of time since a last time that rebalancing was performed on the per-core partition exceeds a maximum rebalance time interval. ### Claim 10 (depends on 9) The data storage system of claim 9, wherein the program code, when executed by the processing circuitry, further causes the processing circuitry to periodically rebalance each one of the per-core partitions at least in part by causing the processing circuitry to: move resource units from the per-core partition to the global partition in response to a determination that the local exhaustion time interval for the per-core partition is larger than the target exhaustion time interval. ### Claim 11 (depends on 10) The data storage system of claim 10, wherein the program code, when executed by the processing circuitry, further causes the processing circuitry to periodically rebalance each one of the per-core partitions at least in part by causing the processing circuitry to: move resource units from the per-core partition to the global partition in response to a determination that no pool operation has been performed on the per-core partition since a last time that the per-core partition was rebalanced. ### Claim 12 (depends on 11) The data storage system of claim 11, wherein the program code, when executed by the processing circuitry, further causes the processing circuitry to periodically rebalance each one of the per-core partitions at least in part by causing the processing circuitry to: move resource units from the global partition to the per-core partition in response to a determination that the per-core partition is empty and an allocation request was issued by the work flow executing on the corresponding processor core. ### Claim 13 (depends on 9) The data storage system of claim 9, wherein the target exhaustion time interval is obtained by calculating the target exhaustion time interval as an average of local exhaustion time intervals calculated for the plurality of per-core partitions. ### Claim 14 (depends on 9) The data storage system of claim 9, wherein the program code, when executed by the processing circuitry, further causes the processing circuitry to trigger periodic rebalancing of at least one of the per-core partitions at least in part in response to a determination made by monitoring logic executed after processing a pool operation on the per-core partition that an amount of time since a last time that rebalancing was performed on the per-core partition exceeds the maximum rebalance time interval. ### Claim 15 (depends on 9) The data storage system of claim 9, wherein the program code, when executed by the processing circuitry, further causes the processing circuitry to trigger periodic rebalancing of at least one of the per-core partitions in response to a determination that the per-core partition currently contains insufficient available resource units to perform an allocation request issued by the workflow executing on the corresponding processor core. ### Claim 16 (depends on 9) The data storage system of claim 9, wherein the program code, when executed by the processing circuitry, further causes the processing circuitry to: execute a plurality of per-core heartbeat timer threads, wherein each one of the per-core heartbeat timer threads executes on a respective one of the processor cores; and trigger at least one of the per-core partitions to be periodically rebalanced when the heartbeat timer thread executing on the processor core corresponding to the per-core partition determines that an amount of time since a last time that rebalancing was performed on the per-core partition exceeds the maximum rebalance time interval. ### Claim 17 A computer program product including a non-transitory computer readable medium having instructions stored thereon, wherein the instructions, when executed on processing circuitry, cause the processing circuitry to perform steps including: loading a predetermined percentage of a plurality of resource units contained in a shared resource pool of a data storage system into a global partition within the shared resource pool; loading those resource units contained in the shared resource pool that were not loaded into the global partition into a plurality of per-core partitions within the shared resource pool, wherein each one of the per-core partitions corresponds to a respective one of a plurality of processor cores in the data storage system; for each one of the per-core partitions, allocating resource units from that per-core partition only to a work flow executing on the corresponding processor core; periodically rebalancing each one of the per-core partitions by moving resource units between the global partition and the per-core partition, wherein the rebalancing includes: calculating a local exhaustion time interval for the per-core partition, wherein the local exhaustion interval comprises an estimated amount of time until all resource units currently available in the per-core partition are exhausted, obtaining a target exhaustion time interval, and moving resource units from the global partition to the per-core partition in response to a determination that the local exhaustion time interval for the per-core partition is smaller than the target exhaustion time interval; and wherein periodically rebalancing at least one of the per-core partitions is triggered by a determination that an amount of time since a last time that rebalancing was performed on the per-core partition exceeds a maximum rebalance time interval.