Context Communication APIs for Hierarchical Resource Synchronization

The patent segments computational contexts into hierarchical levels (device-level contexts and stream-level sub-contexts). Each context encapsulates a specific set of resources and operational state, allowing fine-grained management and isolation. This segmentation enables efficient resource utilization by allocating memory and resources only to active contexts rather than maintaining all resources globally, directly addressing the contradiction between productivity and resource consumption.

The patent dynamically changes resource allocation parameters based on context activation and deactivation. When contexts are pushed onto or popped from stacks, resource allocation parameters (memory buffers, register files, execution units) are adjusted accordingly. This dynamic parameter adjustment allows the system to optimize resource consumption for the currently active computational tasks while maintaining the capability to rapidly switch between different computational states, improving both efficiency and resource utilization.

The patent introduces context stacks as intermediary data structures that mediate between multiple software programs and the underlying hardware resources. Each thread maintains its own context stack, serving as a local intermediary that manages context transitions without requiring complex global synchronization. The push/pop operations on context stacks provide a simple interface for context switching, eliminating the need for complex inter-thread synchronization mechanisms while enabling efficient resource sharing between programs.

Each computational stream maintains its own context stack and manages its own context transitions independently through self-service push/pop operations. This self-management approach eliminates the need for centralized synchronization control, as each thread autonomously handles its context state without interfering with others. The independent context management enables resource sharing while minimizing synchronization complexity, as threads only need to manage their own stacks rather than coordinate with a central controller.