# US 2026/0093537 A1 · Techniques for resource allocation and management

> Agents: this data is available as JSON from the patentgrep API and MCP server — see https://patentgrep.com/llms.txt

- Number: US 2026/0093537 A1
- Document ID: US20260093537A1
- Status: Published application
- Kind: A1
- Application number: 18/901,608
- Filed: 2024-09-30
- Published: 2026-04-02
- Earliest claimed: 2024-09-30
- Assignees: Dell Products L.P.
- Applicants: Dell Products L.P.
- Inventors: Maor Rahamim; Ashok Tamilarasan; Vamsi K. Vankamamidi
- Web page: https://patentgrep.com/patent/US20260093537A1

## CPC

- G06F 9/5016: {the resource being the memory}
- G06F 9/5027: {the resource being a machine, e.g. CPUs, Servers, Terminals}
- G06F 9/4881: {Scheduling strategies for dispatcher, e.g. round robin, multi-level priority queues}
- G06F 9/5011: {the resources being hardware resources other than CPUs, Servers and Terminals}
- G06F 9/52: Program synchronisation; Mutual exclusion, e.g. by means of semaphores
- G06F 9/524: {Deadlock detection or avoidance}
- G06F 9/526: {Mutual exclusion algorithms}
- G06F 2209/5011: Pool
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## Abstract

Techniques can include: maintaining a domain cursor and instance cursors; issuing, by a thread, a resource allocation request; and performing processing to allocate a resource instance, including: determining a domain from which to allocate a resource instance, wherein the domain cursor denotes a domain identifier (ID) identifying the domain, and wherein a first of the instance cursors corresponds to the domain; performing, based on the first instance cursor, unsuccessful attempts to obtain a free resource instance of the domain, wherein the first instance cursor is advanced to a next resource ID of the domain after each of the unsuccessful attempts; determining whether the unsuccessful attempts exceeds a maximum; and responsive to determining that the unsuccessful attempts exceeds the maximum, performing second processing including: placing the thread on a queue associated with one resource instance of the domain, wherein the thread waits on the queue to acquire said one resource instance.

## Claims

### Claim 1

A computer-implemented method comprising:
receiving K resource instances each assigned one of K resource identifiers (IDs), wherein the K resource IDs form a first range R1 of consecutive integers;
partitioning the K resource instances into D domains each of size S denoting that said each domain has S resource instances, wherein the S resource instances of said each domain have corresponding resource IDs that form a subrange of consecutive integers, and wherein each of the D domains is assigned one of D domain IDs, wherein the D domain IDs from a second range R2 of consecutive integers;
maintaining a domain cursor and D instance cursors, wherein the domain cursor identifies one of the D domain IDs of a next one of the D domains from which to allocate a resource instance, and wherein each of the D domains has a corresponding one of the D instance cursors denoting a resource ID of a next resource instance of said each domain from which to attempt resource instance allocation;
issuing, by a first thread, a resource allocation request; and
performing first processing to allocate one of the K resource instances for the resource allocation request, including:
determining, in accordance with the domain cursor, a first domain from which to allocate a resource instance, wherein the domain cursor denotes a first domain ID identifying the first domain, and wherein a first instance cursor of the D instance cursors corresponds to the first domain;
performing, based on the first instance cursor, a first plurality of unsuccessful attempts to obtain a resource instance of the first domain that is free, wherein each of the first plurality of unsuccessful attempts is an unsuccessful attempt to obtain a different resource instance of the first domain, wherein the first instance cursor is advanced to a next resource ID of the first domain after each of the first plurality of unsuccessful attempts;
determining whether the first plurality of unsuccessful attempts exceeds a maximum; and
responsive to determining that the first plurality of unsuccessful attempts exceeds the maximum, performing second processing including:
placing the first thread on a first wait queue associated with one resource instance of the first domain, wherein the first thread waits on the first wait queue to acquire said one resource instance of the first domain.

### Claim 2 (depends on 1)

The computer-implemented method of claim 1, wherein said placing includes:
adding the first thread to the first wait queue based on a FIFO (first in first out) ordering in which threads attempt to acquire said one resource instance.

### Claim 3 (depends on 2)

The computer-implemented method of claim 2, wherein said second processing includes:
detecting that said one resource instance is free and that the first thread is waiting in the first wait queue and is next in line to acquire said one resource instance based on the FIFO ordering; and
the first thread obtaining said one resource instance in response to said resource allocation request whereby said one resource instance is allocated to the first thread.

### Claim 4 (depends on 3)

The computer-implemented method of claim 3, wherein the first plurality of unsuccessful attempts is performed with respect to first consecutive resource IDs of respective first resource instances of the first domain.

### Claim 5 (depends on 4)

The computer-implemented method of claim 4, wherein each of the first plurality of unsuccessful attempts is a try-lock request that attempts to acquire a lock on a corresponding resource instance of the first domain that has a corresponding one of the first consecutive resource IDs.

### Claim 6 (depends on 5)

The computer-implemented method of claim 5, wherein the try-lock request of said each unsuccessful attempt results in third processing including:
determining that the lock, on the corresponding resource instance of the first domain having the corresponding one of the first consecutive resource IDs, is taken; and
responsive to determining that the lock is taken, returning false indicating that the try-lock request has failed and is unsuccessful, wherein failure to acquire the lock indicates that the corresponding resource instance of the first domain having the corresponding one of the first consecutive resource IDs is not free and already allocated.

### Claim 7 (depends on 6)

The computer-implemented method of claim 6, wherein execution of the first thread that issued the resource allocation request is not blocked in response to the first plurality of unsuccessful attempts.

### Claim 8 (depends on 7)

The computer-implemented method of claim 7, wherein in response to each of the first plurality of unsuccessful attempts to acquire one of the first resource instances, the first thread does not wait for the one resource instance to become free.

### Claim 9 (depends on 7)

The computer-implemented method of claim 7, wherein in response to a first unsuccessful attempt of the first plurality to acquire one of the first resource instances, the first thread attempts to acquire another one of the first resource instances.

### Claim 10 (depends on 5)

The computer-implemented method of claim 5, wherein the lock is an exclusive lock.

### Claim 11 (depends on 1)

The computer-implemented method of claim 1, further comprising:
responsive to determining that the first plurality of unsuccessful attempts does not exceed the maximum, performing third processing including:
performing, based on the first instance cursor, an additional attempt to obtain a first resource instance of the first domain, wherein the first resource instance has a first resource ID; and
responsive to determining that the first resource instance of the first domain is free, allocating the first resource instance to the first thread in response to said resource allocation request.

### Claim 12 (depends on 1)

The computer-implemented method of claim 1, wherein the first thread is a flush thread performing processing to flush an entry of a recorded write I/O operation from a log.

### Claim 13 (depends on 12)

The computer-implemented method of claim 12, wherein the K resource instances are K pages of back-end (BE) non-volatile storage used for storing metadata (MD).

### Claim 14 (depends on 13)

The computer-implemented method of claim 13, wherein the resource allocation request is a request by the flush thread for a free one of the K pages for storing a first MD page in connection with flushing the entry for the recorded write I/O operation from the log.

### Claim 15 (depends on 14)

The computer-implemented method of claim 14, wherein the recorded write I/O operation writes first content to a first logical address, and wherein the first MD page is included in a chain of MD pages used to map the first logical address to a physical storage location of the first content as stored on BE non-volatile storage.

### Claim 16 (depends on 1)

The computer-implemented method of claim 1, wherein the first processing includes:
advancing the domain cursor from the first domain ID denoting the first domain to a second domain ID identifying a second domain that is different from the first domain;
issuing, by a second thread, a second resource allocation request; and
performing third processing in accordance with the domain cursor to allocate a resource instance of the second domain for the second allocation request, wherein the third processing includes commencing attempts to locate a free resource instance of the second domain based on a current resource ID of the second domain identified by a second instance cursor of the D instance cursors, wherein the second instance cursor corresponds to the second domain.

### Claim 17 (depends on 1)

The computer-implemented method of claim 1, wherein the maximum is equal to S.

### Claim 18

A system comprising:
one or more processors; and
one or more memories comprising code stored thereon that, when executed, performs a method comprising:
receiving K resource instances each assigned one of K resource identifiers (IDs), wherein the K resource IDs form a first range R1 of consecutive integers;
partitioning the K resource instances into D domains each of size S denoting that said each domain has S resource instances, wherein the S resource instances of said each domain have corresponding resource IDs that form a subrange of consecutive integers, and wherein each of the D domains is assigned one of D domain IDs, wherein the D domain IDs from a second range R2 of consecutive integers;
maintaining a domain cursor and D instance cursors, wherein the domain cursor identifies one of the D domain IDs of a next one of the D domains from which to allocate a resource instance, and wherein each of the D domains has a corresponding one of the D instance cursors denoting a resource ID of a next resource instance of said each domain from which to attempt resource instance allocation;
issuing, by a first thread, a resource allocation request; and
performing first processing to allocate one of the K resource instances for the resource allocation request, including:
determining, in accordance with the domain cursor, a first domain from which to allocate a resource instance, wherein the domain cursor denotes a first domain ID identifying the first domain, and wherein a first instance cursor of the D instance cursors corresponds to the first domain;
performing, based on the first instance cursor, a first plurality of unsuccessful attempts to obtain a resource instance of the first domain that is free, wherein each of the first plurality of unsuccessful attempts is an unsuccessful attempt to obtain a different resource instance of the first domain, wherein the first instance cursor is advanced to a next resource ID of the first domain after each of the first plurality of unsuccessful attempts;
determining whether the first plurality of unsuccessful attempts exceeds a maximum; and
responsive to determining that the first plurality of unsuccessful attempts exceeds the maximum, performing second processing including:
placing the first thread on a first wait queue associated with one resource instance of the first domain, wherein the first thread waits on the first wait queue to acquire said one resource instance of the first domain.

### Claim 19

One or more non-transitory computer-readable media comprising code stored thereon that, when executed, performs a method comprising:
receiving K resource instances each assigned one of K resource identifiers (IDs), wherein the K resource IDs form a first range R1 of consecutive integers;
partitioning the K resource instances into D domains each of size S denoting that said each domain has S resource instances, wherein the S resource instances of said each domain have corresponding resource IDs that form a subrange of consecutive integers, and wherein each of the D domains is assigned one of D domain IDs, wherein the D domain IDs from a second range R2 of consecutive integers;
maintaining a domain cursor and D instance cursors, wherein the domain cursor identifies one of the D domain IDs of a next one of the D domains from which to allocate a resource instance, and wherein each of the D domains has a corresponding one of the D instance cursors denoting a resource ID of a next resource instance of said each domain from which to attempt resource instance allocation;
issuing, by a first thread, a resource allocation request; and
performing first processing to allocate one of the K resource instances for the resource allocation request, including:
determining, in accordance with the domain cursor, a first domain from which to allocate a resource instance, wherein the domain cursor denotes a first domain ID identifying the first domain, and wherein a first instance cursor of the D instance cursors corresponds to the first domain;
performing, based on the first instance cursor, a first plurality of unsuccessful attempts to obtain a resource instance of the first domain that is free, wherein each of the first plurality of unsuccessful attempts is an unsuccessful attempt to obtain a different resource instance of the first domain, wherein the first instance cursor is advanced to a next resource ID of the first domain after each of the first plurality of unsuccessful attempts;
determining whether the first plurality of unsuccessful attempts exceeds a maximum; and
responsive to determining that the first plurality of unsuccessful attempts exceeds the maximum, performing second processing including:
placing the first thread on a first wait queue associated with one resource instance of the first domain, wherein the first thread waits on the first wait queue to acquire said one resource instance of the first domain.

### Claim 20 (depends on 19)

The one or more computer-readable media of claim 19, wherein said placing includes:
adding the first thread to the first wait queue based on a FIFO (first in first out) ordering in which threads attempt to acquire said one resource instance.