Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. A method for internal temporary storage, transfer, and sharing of message data, comprising: accessing, by a server, a first contiguous portion of memory for a first thread of a first program of a plurality of executing programs; transferring, by the server, data associated with the first thread into the first contiguous portion of memory; placing, by the server, the first contiguous portion of memory in a memory repository that includes a plurality of contiguous portions of memory selectively accessible to the plurality of executing programs, to make the first contiguous portion of memory available for access by at least a second thread of a second program of the plurality of executing programs; assigning, by the server, an identifier to the first contiguous portion of memory; accessing, by the server, the first contiguous portion of memory for the second thread; transferring, by the server, the data associated with the first thread from the first contiguous portion of memory to memory specifically associated with the second thread; removing the data from the first contiguous portion of memory after the first contiguous portion of memory is accessed at least twice; and rendering the first contiguous portion of memory unassigned after the data in the first contiguous portion of memory has been removed; wherein the method is implemented in a fixed-gate shared subsystem.
This invention relates to a system for temporary storage, transfer, and sharing of message data between multiple executing programs in a fixed-gate shared subsystem. The problem addressed is efficient inter-program communication and data sharing in a constrained environment where direct memory access between programs is restricted. The method involves a server that manages memory allocation and data transfer. The server accesses a contiguous block of memory for a first thread of a first program and transfers the thread's associated data into this block. This block is then placed in a shared memory repository, making it accessible to other programs. The server assigns a unique identifier to the block, allowing other threads to locate and access it. When a second thread of a second program needs the data, the server retrieves the block, transfers the data to the second thread's memory, and then removes the data from the shared block after it has been accessed at least twice. Finally, the block is unassigned and made available for reuse. The system ensures secure and efficient data sharing while maintaining memory integrity in a fixed-gate shared subsystem, where direct memory access between programs is restricted.
2. The method of claim 1 , in which accessing the first contiguous portion of memory for the second thread comprises the second thread possessing the identifier and requesting access to the first contiguous portion of memory.
This invention relates to memory access control in multi-threaded computing environments, specifically addressing the challenge of efficiently managing concurrent access to shared memory regions while maintaining data integrity and performance. The system involves a method for controlling access to a first contiguous portion of memory by multiple threads, where each thread is assigned a unique identifier. The second thread, which possesses the identifier, requests access to the first contiguous portion of memory. The method ensures that only authorized threads with the correct identifier can access the memory portion, preventing unauthorized or conflicting access. The system may also include a mechanism for the first thread to grant or deny access to the second thread based on predefined rules or conditions. This approach enhances security and coordination in multi-threaded applications by enforcing controlled access to shared memory regions, reducing the risk of data corruption and improving system stability. The invention is particularly useful in high-performance computing, real-time systems, and applications requiring strict memory access control.
3. The method of claim 1 , in which the data transferred into the first contiguous portion of memory comprises a complete message.
A system and method for managing data transfer in memory involves partitioning memory into contiguous portions to optimize storage and retrieval of data. The invention addresses inefficiencies in conventional memory management where fragmented data storage leads to increased access times and reduced performance. By dividing memory into contiguous blocks, the system ensures that related data is stored together, improving access speed and reducing overhead. The method includes transferring data into a first contiguous portion of memory, where the data comprises a complete message. This ensures that the entire message is stored in a single, uninterrupted block, eliminating the need to access multiple fragmented locations. The system may also include transferring additional data into a second contiguous portion of memory, where the additional data is related to the first data. This allows for efficient grouping of related data, further enhancing performance. The invention may also involve dynamically adjusting the size of the contiguous portions based on the size of the data being transferred. This ensures optimal use of memory space while maintaining the benefits of contiguous storage. The system may further include mechanisms for tracking the boundaries of the contiguous portions to prevent data overlap and ensure proper alignment. By implementing this method, the system achieves faster data access, reduced memory fragmentation, and improved overall performance in data-intensive applications. The contiguous storage approach is particularly beneficial in systems where low-latency data retrieval is critical, such as real-time processing and high-performance computing environments.
4. A computer program product, comprising: a non-transitory computer-readable medium comprising code to perform operations including: accessing, by a server, a first contiguous portion of memory for a first thread of a first program of a plurality of executing programs; transferring, by the server, data associated with the first thread into the first contiguous portion of memory; placing, by the server, the first contiguous portion of memory in a memory repository that includes a plurality of contiguous portions of memory selectively accessible to the plurality of executing programs, to make the first contiguous portion of memory available for access by at least a second thread of a second program of the plurality of executing programs; assigning, by the server, an identifier to the first contiguous portion of memory; accessing, by the server, the first contiguous portion of memory for the second thread; transferring, by the server, the data associated with the first thread from the first contiguous portion of memory to memory specifically associated with the second thread; removing the data from the first contiguous portion of memory after the first contiguous portion of memory is accessed at least twice; and rendering the first contiguous portion of memory unassigned after the data in the first contiguous portion of memory has been removed; wherein the computer program product comprises a fixed-gate shared subsystem.
This invention relates to memory management in a computing environment where multiple programs execute concurrently. The problem addressed is efficient sharing and reuse of memory portions among different threads of different programs, ensuring data integrity and minimizing memory fragmentation. The solution involves a server that manages a memory repository containing contiguous memory portions accessible to multiple executing programs. The server accesses a first contiguous memory portion for a first thread of a first program and transfers associated data into this portion. This portion is then placed in the memory repository, assigned an identifier, and made available for access by at least a second thread of a second program. The server retrieves the data from the memory portion for the second thread, removes the data after the portion is accessed at least twice, and unassigns the portion for reuse. The system operates as a fixed-gate shared subsystem, ensuring controlled and secure memory sharing. This approach optimizes memory utilization by reusing memory portions while maintaining data isolation and reducing fragmentation.
5. The computer program product of claim 4 , in which accessing the first contiguous portion of memory for the second thread comprises the second thread possessing the identifier and requesting access to the first contiguous portion of memory.
This invention relates to memory access control in multi-threaded computing environments, specifically addressing the challenge of efficiently managing concurrent access to shared memory regions by multiple threads. The problem arises when multiple threads attempt to access the same memory region simultaneously, leading to conflicts, race conditions, or performance bottlenecks. The invention provides a solution by implementing a mechanism that allows a second thread to access a first contiguous portion of memory by possessing a specific identifier and requesting access to that memory region. The identifier serves as a key that grants the second thread permission to access the memory, ensuring controlled and synchronized access. The system includes a memory management module that verifies the identifier before granting access, preventing unauthorized or conflicting access attempts. Additionally, the invention may involve pre-allocating memory regions and associating them with specific identifiers to streamline access requests. This approach improves thread coordination, reduces contention, and enhances overall system performance by ensuring that memory access is both secure and efficient. The solution is particularly useful in high-performance computing, real-time systems, and multi-core processors where memory access conflicts can significantly impact performance.
6. The computer program product of claim 4 , in which the data transferred into the first contiguous portion of memory comprises a complete message.
A system and method for optimizing memory management in computer systems, particularly for handling data transfers involving complete messages. The invention addresses inefficiencies in memory allocation and data transfer processes, where fragmented memory usage and incomplete message handling can lead to performance bottlenecks and increased latency. The solution involves a computer program product that manages memory allocation by dividing memory into contiguous portions, ensuring that complete messages are transferred into a first contiguous portion of memory. This approach minimizes fragmentation and ensures that entire messages are processed efficiently without partial transfers. The system may also include mechanisms for validating the integrity of the transferred data and managing subsequent memory operations based on the successful transfer of complete messages. By ensuring that messages are fully contained within a single contiguous memory block, the invention improves data processing speed, reduces overhead, and enhances system reliability. The method is particularly useful in high-performance computing environments where efficient memory utilization is critical.
7. An apparatus, comprising: a memory; and a processor coupled to the memory, in which the processor is configured to execute operations including: accessing, by a server, a first contiguous portion of memory for a first thread of a first program of a plurality of executing programs; transferring, by the server, data associated with the first thread into the first contiguous portion of memory; placing, by the server, the first contiguous portion of memory in a memory repository that includes a plurality of contiguous portions of memory selectively accessible to the plurality of executing programs, to make the first contiguous portion of memory available for access by at least a second thread of a second program of the plurality of executing programs; assigning, by the server, an identifier to the first contiguous portion of memory; accessing, by the server, the first contiguous portion of memory for the second thread; transferring, by the server, the data associated with the first thread from the first contiguous portion of memory to memory specifically associated with the second thread; removing the data from the first contiguous portion of memory after the first contiguous portion of memory is accessed at least twice; and rendering the first contiguous portion of memory unassigned after the data in the first contiguous portion of memory has been removed; wherein the apparatus comprises a fixed-gate shared subsystem.
This invention relates to memory management in a shared computing environment, specifically addressing the challenge of efficiently allocating and deallocating contiguous memory portions among multiple executing programs and threads. The system includes a server with a processor and memory, where the processor manages a memory repository containing multiple contiguous memory portions accessible to various executing programs. The server accesses a first contiguous memory portion for a first thread of a first program, transfers the thread's associated data into this portion, and places it in the repository, making it available to other threads. The server assigns an identifier to this memory portion for tracking. When a second thread of a second program accesses the same memory portion, the server transfers the data from the first thread to the second thread's memory. After the memory portion is accessed at least twice, the data is removed, and the portion is unassigned, freeing it for reuse. The system operates as a fixed-gate shared subsystem, ensuring controlled and efficient memory sharing among concurrent programs. This approach optimizes memory utilization by reallocating memory portions dynamically while maintaining data integrity and accessibility across different threads and programs.
8. The apparatus of claim 7 , in which accessing the first contiguous portion of memory for the second thread comprises the second thread possessing the identifier and requesting access to the first contiguous portion of memory.
This invention relates to memory access control in multi-threaded computing systems, specifically addressing the challenge of managing concurrent access to shared memory regions while maintaining data integrity and performance. The system involves a memory management apparatus that allocates contiguous portions of memory to different threads, where each thread is assigned a unique identifier. The apparatus ensures that only threads possessing the correct identifier can request and gain access to their designated memory portions. This prevents unauthorized or conflicting access, reducing the risk of data corruption or race conditions in multi-threaded environments. The apparatus further includes mechanisms to verify the identifier before granting access, ensuring secure and efficient memory utilization. The invention is particularly useful in high-performance computing, real-time systems, and applications requiring strict memory isolation between threads. By enforcing access control through identifiers, the system enhances thread safety and system stability while optimizing memory management.
9. The apparatus of claim 7 , in which the data transferred into the first contiguous portion of memory comprises a complete message.
A system for managing data transfer in memory involves a memory controller that allocates a first contiguous portion of memory for receiving data and a second contiguous portion for storing the data. The memory controller transfers data into the first portion, where the data comprises a complete message, and then moves the data from the first portion to the second portion. The system ensures efficient data handling by separating the incoming data buffer from the storage buffer, reducing fragmentation and improving performance. The memory controller may also include a buffer manager to oversee the allocation and deallocation of memory portions, ensuring optimal use of available memory resources. The apparatus is designed to handle high-speed data transfers while maintaining data integrity and minimizing latency. This approach is particularly useful in systems requiring real-time data processing, such as communication networks or embedded systems, where efficient memory management is critical. The separation of incoming and storage buffers prevents data corruption and ensures that incoming data is processed without interference from other operations. The system may also include error-checking mechanisms to verify data integrity during transfer.
Unknown
June 16, 2020
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.