API Resource Tracking via Reference Counting

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Monitoring computer program resource usage is challenging due to the varied operations these resources are involved in, and existing techniques are not effectively improved using CUDA or other parallel computing platforms.

Innovation Solution

The implementation of graph-based programming models, such as CUDA, HIP, and oneAPI, that utilize reference counting to track the creation and deletion of graph handles and objects, allowing for efficient management of resource usage through API calls like User Object Create, Retain, and Release, ensuring proper destruction of resources when no longer needed.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Measurement precision

If reference counting is implemented to track resource usage, then resource management accuracy is improved, but system complexity increases

Engineering Contradiction:
Improveresource usage tracking accuracyVSAvoidsystem complexity
Core Design Contradiction:
Measurement precisionVSDevice complexity

Solution Approach 1:

The system automatically tracks resource usage through reference counting without requiring manual intervention. The API monitoring mechanism self-services by automatically incrementing and decrementing reference counts based on API calls, eliminating the need for manual resource tracking while maintaining high accuracy.

Inventive Principle:
Principle #25Self-service

Solution Approach 2:

Reference counts serve as an intermediary mechanism between resource creation/deletion operations and the actual resource management. Instead of directly complex resource tracking, the system uses simple integer counters as mediators to monitor and control resource lifecycle, reducing overall system complexity.

Inventive Principle:
Principle #24Intermediary (Mediator)

2Productivity

If parallel computing platforms like CUDA are used to monitor resource usage, then monitoring efficiency is improved, but implementation difficulty increases

Engineering Contradiction:
Improvemonitoring efficiencyVSAvoidimplementation difficulty
Core Design Contradiction:
ProductivityVSEase of manufacture

Solution Approach 1:

The resource monitoring function is segmented into independent reference count operations that can be executed in parallel. Each API call that creates, retains, or releases resources generates independent counting operations that can be processed concurrently without interference, enabling efficient parallel monitoring.

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The reference counting mechanism is designed to be universal and applicable across different parallel computing platforms including CUDA, HIP, and oneAPI. By creating a platform-agnostic interface that handles resource tracking, the system achieves multi-functionality without increasing implementation difficulty on specific platforms.

Inventive Principle:
Principle #6Universality (Multi-functionality)

3Productivity

If graph-based programming models are implemented, then resource allocation optimization is improved, but learning curve increases

Engineering Contradiction:
Improveresource allocation optimizationVSAvoidlearning curve
Core Design Contradiction:
ProductivityVSEase of operation

Solution Approach 1:

The graph-based programming model automatically manages resource allocation through reference counting without requiring manual intervention from developers. The system self-services by tracking dependencies and automatically releasing resources when reference counts reach zero, optimizing resource allocation without increasing the learning curve.

Inventive Principle:
Principle #25Self-service

Solution Approach 2:

The reference counting mechanism provides continuous feedback on resource usage states. When reference counts change, the system immediately adjusts resource allocation accordingly, creating a feedback loop that optimizes resource management automatically without requiring complex manual configuration or deep understanding of the programming model.

Inventive Principle:
Principle #23Feedback

Data Source

PatentUS20220334899A1Application programming interface to monitor resource usage
Publication Date: 2022.10.20 NVIDIA CORP
  • US20220334899A1 patent drawing
  • US20220334899A1 patent drawing
  • US20220334899A1 patent drawing

AI summary

Apparatuses, systems, and techniques to generate one or more data structures to be used to monitor use of information by a computer program. In at least one embodiment, one or more data structures to be used to monitor use of information by a computer program are generated, based on, for example, CUDA or other parallel computing platform code.