LEDGER-BASED RESOURCE TRACKING

• US 20130325543A1
• Filed: 09/05/2012
• Published: 12/05/2013
• Est. Priority Date: 06/05/2012
• Status: Active Grant

• Current Assignee: Apple Inc.
• Original Assignee: Apple Inc.
• Inventors: Magee, James Michael, Vaishampayan, Umesh S., Nieuwejaar, Nils A.
• Granted Patent: US 9,123,010 B2
• Time in Patent Office: Days
• US Class Current: 705/7.25
• CPC Class Codes: G06F 11/3082 the data filtering being achieved by aggregating or compressing the monitored data
• CPC Class Codes: G06F 11/3093 Configuration details thereof, e.g. installation, enabling, spatial arrangement of the probes
• CPC Class Codes: G06F 11/3409 for performance assessment
• CPC Class Codes: G06F 11/3476 Data logging G06F11/14, G06F11/2205 take precedence
• CPC Class Codes: G06F 11/3495 for systems
• CPC Class Codes: G06F 2209/504 Resource capping
• CPC Class Codes: G06F 2209/508 Monitor
• CPC Class Codes: G06F 9/50 Allocation of resources, e.g. of the central processing unit [CPU]
• CPC Class Codes: G06F 9/5011 the resources being hardware resources other than CPUs, Servers and Terminals
• CPC Class Codes: G06F 9/5016 the resource being the memory
• CPC Class Codes: G06F 9/5027 the resource being a machine, e.g. CPUs, Servers, Terminals
• CPC Class Codes: G06Q 10/06 Resources, workflows, human or project management; Enterprise or organisation planning; Enterprise or organisation modelling
• CPC Class Codes: G06Q 10/06313 Resource planning in a project environment
• CPC Class Codes: Y02D 10/00 Energy efficient computing, e.g. low power processors, power management or thermal management

Abstract

Disclosed are systems, methods, and non-transitory computer-readable storage media for tracking and managing resource usage through a ledger feature that can trigger complex real-time reactions. The resource tracking can be managed through a ledger module and a ledger data structure. The ledger data structure can be updated each time a task requests a resource. Additionally, as part of the update, the ledger module can verify whether a resource has been over consumed. In response to the detection of an over consumption, the ledger module can set a flag. At some later pointer when the thread is in a stable, well-understood point, the ledger module can check if the flag has been set. If the flag has been set, the ledger module can call the appropriate callback function, which can react to the over consumption in a resource specific manner.

Claims

1. A computer-implemented method comprising:

receiving a resource request from a task, the task associated with a ledger object including a reference to a ledger template and a ledger entries object, wherein the resource is registered for tracking in the ledger template; and

updating a record of resources consumed in an entry corresponding to the resource in the ledger entries object, wherein the updating comprises comparing a balance of resources consumed against a predefined resource limit in the entry, and setting a flag when the balance exceeds the predefined limit.

2. The method of claim 1 further comprising:

in response to detecting, prior to returning the task to user space, that the flag is set, calling a first callback function associated with a first resource entry in the ledger entries object, wherein a first balance associated with the first resource entry exceeds a first predefined limit associated with the first resource entry.

3. The method of claim 2 further comprising:

identifying a second resource entry in the ledger entries object, wherein a second balance associated with the second resource entry exceeds a second predefined limit associated with the second resource entry; and

calling a second callback function associated with the second resource entry.

4. The method of claim 1 further comprising:

allocating the ledger object associated with the task prior to processing an initial request for a resource from the task, the allocating comprising allocating a ledger entries object with a number of entries corresponding to a current number of entries in the ledger template.

5. The method of claim 1, wherein the ledger entries object comprises at least one entry and the at least one entry is of a double-entry entry type.

6. The method of claim 5, wherein the balance is calculated on demand based on an allocation value and a deallocation value in the entry.

7. The method of claim 1, wherein the ledger template is referenced by a plurality of ledger objects.

8. The method of claim 2, wherein detecting that the flag is set occurs in response to detecting that execution of the task has reached the Asynchronous System Trap boundary.

9. A system comprising:

a processor;

a task;

a resource management module configured to control the processor to receive a resource request from the task; and

a ledger module configured to control the processor to update a resource consumption record related to the task, the resource consumption record stored in an entry corresponding to the resource in a ledger entries object associated with the task, wherein the updating comprises setting a flag when a resource consumption balance exceeds a limit specified in the entry.

10. The system of claim 9 further comprising:

a resource module configured to control the processor to perform the resource request.

11. The system of claim 9, wherein the resource request is a request to allocate or deallocate the resource and performing the resource request comprises allocating or deallocating the resource.

12. The system of claim 9 further comprising a user space, an asynchronous trap boundary, and a kernel space.

13. The system of claim 12 further comprising:

identifying that the flag is set when the task has reached the asynchronous trap boundary; and

calling a callback function specific to the resource.

14. The system of claim 9, wherein a resource is at least one of CPU cycles, memory, disk I/O, network I/O, or Mach ports.

15. A non-transitory computer-readable storage media storing instructions which, when executed by a computing device, causes the computing device to perform steps comprising:

receiving a request for a first resource from a task, the task associated with a ledger object including a reference to a ledger template and a ledger entries object, wherein the first resource is registered for tracking in the ledger template; and

updating a record of resources consumed in an entry corresponding to the first resource in the ledger entries object, wherein the updating comprises comparing a balance of resources consumed against a predefined resource limit in the entry, and setting a flag when the balance exceeds the predefined limit.

16. The non-transitory computer-readable storage media of claim 15 further comprising:

registering a second resource, the registering comprising cloning the ledger template to create a second ledger template and adding a new entry to the second ledger template for the second resource.

17. The non-transitory computer-readable storage media of claim 16, wherein the new entry comprises a unique resource identifier and a reference to a callback function.

18. The non-transitory computer-readable storage media of claim 16 further comprising:

allocating a second ledger object associated with a second task, the allocating comprising associating the second ledger object with the second ledger template and allocating a second ledger entries object with a number of entries corresponding to a current number of entries in the second ledger template.

19. The non-transitory computer-readable storage media of claim 16 further comprising:

detecting, prior to the task returning to user space, that the flag is set;

identifying a resource entry in the ledger entries object, wherein a balance associated with the resource entry exceeds a predefined limit associated with the resource entry; and

calling a callback function associated with the resource entry.

20. The non-transitory computer-readable storage media of claim 19, wherein the ledger template includes a reference to the callback function.

21. The non-transitory computer-readable storage media of claim 19, wherein the balance is calculated on demand.

22. A computer-implemented method comprising:

updating an entry corresponding to a resource in a ledger entry object specific to a task in response to receiving a request for the resource from the task, the updating comprising recording a resource consumption in the entry specified in the request, and setting a flag when a resource consumption balance for the entry exceeds a resource limit defined in the entry;

identifying that the flag is set prior to the task returning to user space; and

calling a callback function specific the resource.

23. The method of claim 22, wherein identifying that the flag is set occurs in response to detecting that the task has moved from kernel space to the Asynchronous System Trap boundary.

24. The method of claim 22, wherein setting the flag occurs while the task is in kernel mode.

25. The method of claim 22, wherein the callback function is specific to the resource, and further wherein the callback function is defined to react to an over consumption of the resource in a resource specific manner.