Object Cache Controller Hardware Access Control
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing computer architectures struggle with efficient and scalable access control for memory objects in distributed systems, particularly in high-performance computing environments, where processes with elevated privileges can bypass operating system checks, leading to complex memory access management and security vulnerabilities.
Innovation Solution
An object-based compute node architecture with an object management unit and object cache, utilizing unique task and memory object identifiers, and an object storage firewall to enforce access rights at the hardware level, ensuring tasks access only authorized memory objects without relying on the operating system.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If operating system access control mechanisms are used to protect memory objects, then access control is provided at the software level, but protection is lost once data is moved into main memory and processes with elevated privileges can bypass checks
Solution Approach 1:
The patent replaces the software-based operating system access control mechanisms with a hardware-based object cache controller that enforces access control directly in the memory subsystem. The controller verifies correspondence between task object identifiers and memory object identifiers at the hardware level, preventing privileged processes from bypassing security checks through system calls or privilege escalation.
Solution Approach 2:
The object cache controller acts as an intermediary between compute cores and the distributed store, intercepting and verifying all memory access requests. It maintains identification tags that link task objects to their authorized memory objects, serving as a security gateway that filters unauthorized access attempts before they reach the memory subsystem.
2Reliability
If processes issue system calls for enhanced privileges to access memory objects, then access control is enforced, but CPU is frequently interrupted leading to waste of compute cycles
Solution Approach 1:
The system performs preliminary access control verification by the object cache controller before memory access operations are executed by the CPU. The controller checks the correspondence between task object identifiers and memory object identifiers in advance, allowing the CPU to proceed with compute-intensive operations without interruption for privilege checks, thus eliminating system call overhead.
3Reliability
If access control is implemented in multicore multi-node machines with each node running its own operating system, then distributed memory access control is provided, but orchestration and synchronization becomes extremely complex
Solution Approach 1:
The patent segments the access control functionality from the operating system and embeds it in the hardware object cache controller on each compute node. Each controller independently manages its local cache and enforces access control policies, eliminating the need for complex inter-node orchestration and synchronization of access control state. The segmentation isolates security management to local hardware components.
Solution Approach 2:
Each object cache controller autonomously verifies access control decisions using identification tags stored in its local cache, without requiring intervention from remote nodes or centralized coordination. The controller self-manages the verification process by comparing task object identifiers with memory object identifiers, making the system self-sufficient at each node and eliminating synchronization overhead.
4Speed
If object cache stores memory object fragments for fast access, then access speed is improved, but unauthorized tasks may access cached data from other tasks
Solution Approach 1:
The patent applies local quality by associating each cache line with specific identification tags that uniquely identify the authorized task object and memory object combination. Each cache entry has its own security context embedded in the tags, allowing the controller to verify access rights on a per-cache-line basis. This granular local verification ensures that even though data is cached locally for fast access, unauthorized tasks cannot access cache lines belonging to other tasks.
Data Source
Figure 1~2
Figure 3
Figure 4
AI summary
A compute node and related method for secure memory access on a distributed store as global computer main memory are disclosed. Memory objects are composed of a plurality of fragments accessible on the distributed store. The compute node comprises a compute core for executing tasks that require memory object fragments as inputs, an object management unit for mapping logical addresses of memory object fragments to unique physical addresses of the distributed store, an object cache and object cache controller. Identification tags for unique combinations of task object identifier (TOID) and a data object identifier (OID) are stored in a tag memory for each line of the object cache. The cache controller allows access to a cache line if the task object and data object in an access command of the compute core matches the stored identification tags for this cache line.