Techniques are disclosed to operate binary objects across private address spaces. In various embodiments, a shared memory segment is allocated for two address spaces, the first comprising a home address space and the second comprising a target address space. One or more executable modules are loaded in the home address space. One or more program call routines and an environment to schedule system request blocks (SRB) are built in the home address space. The environment to schedule system request blocks is configured to be used to schedule an SRB into the target address space, the SRB comprising information configured to cause the target address space to cause an associated one of the executable modules to execute.
Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. A system, comprising: a memory; and a processor coupled to the memory and configured to: allocate a shared memory segment of the memory for two address spaces, the first comprising a home address space and the second comprising a target address space; load one or more executable modules in the home address space; and build in the home address space one or more program call routines and an environment to schedule system request blocks; wherein the environment to schedule system request blocks is configured to be used to schedule an SRB into the target address space, the SRB comprising information configured to cause the target address space to cause an associated one or more of the executable modules to execute; wherein the target address space is configured to execute the executable module from the shared memory segment; wherein the target address space uses an asynchronous exit routine to execute the executable module; wherein a cross-memory post is sent by the target address space to the home address to signal completion of the executable module.
This invention relates to a system for managing shared memory and inter-process communication in a computing environment. The system addresses the challenge of efficiently executing modules across different address spaces while minimizing data duplication and ensuring proper synchronization. The system includes a memory and a processor that allocates a shared memory segment accessible by two address spaces: a home address space and a target address space. The home address space loads one or more executable modules and constructs program call routines and an environment to schedule system request blocks (SRBs). These SRBs contain instructions that trigger the execution of associated modules in the target address space. The target address space retrieves and executes the modules directly from the shared memory, avoiding redundant data transfers. Execution in the target address space is managed asynchronously using an exit routine, which allows the system to handle tasks without blocking the home address space. Upon completion, the target address space sends a cross-memory post to the home address space, signaling that the module has finished executing. This mechanism ensures efficient coordination between the two address spaces while maintaining data consistency and reducing overhead. The system is particularly useful in multi-process or distributed computing environments where shared memory and asynchronous operations are critical for performance.
2. The system of claim 1 , wherein the processor is further configured to identify a task control block (TCB) associated with the target address space.
A system for managing task control blocks (TCBs) in a computing environment addresses the challenge of efficiently tracking and accessing process-related metadata in virtualized or multi-tasking systems. The system includes a processor configured to identify a TCB associated with a target address space, enabling the operating system or hypervisor to locate and manage process-specific data structures. The TCB contains critical information such as process state, memory mappings, and execution context, which are essential for context switching, process scheduling, and system security. By associating the TCB with the target address space, the system ensures that the correct process metadata is retrieved during operations like process creation, termination, or inter-process communication. This mechanism improves system efficiency by reducing the overhead of searching for TCBs and enhances reliability by preventing incorrect process metadata access. The system may also include additional components, such as memory management units or scheduling algorithms, to further optimize task handling in complex computing environments. The invention is particularly useful in virtualized systems where multiple processes or virtual machines share hardware resources, requiring precise and rapid access to TCB data.
3. The system of claim 1 , wherein an SRB unit of the target address space resumes upon completion of the executable module.
A system for managing address spaces in a computing environment includes a target address space with a service request block (SRB) unit. The SRB unit is configured to handle service requests within the target address space, such as executing an executable module. The system ensures that the SRB unit resumes its operations upon completion of the executable module, allowing the target address space to continue processing subsequent service requests. This mechanism prevents the SRB unit from being indefinitely blocked or stalled after executing a module, ensuring efficient resource utilization and uninterrupted service request handling. The system may also include a source address space that initiates the service request, with the SRB unit facilitating communication between the source and target address spaces. The resumption of the SRB unit ensures that the target address space remains responsive to further requests from the source address space or other components. This approach is particularly useful in multi-address space environments where reliable and timely service request processing is critical.
4. The system of claim 1 , wherein the executable module comprises a function.
A system for executing software modules includes a processor and a memory storing an executable module. The executable module contains a function that performs a specific operation when called. The system is designed to address the problem of efficiently managing and executing modular software components, particularly in environments where functions need to be dynamically loaded or invoked. The function within the executable module is structured to handle inputs, process data, and produce outputs, enabling modular and reusable code execution. The system ensures that the function is properly initialized and executed within the correct context, improving reliability and performance. The memory stores the executable module, which may include additional functions or subroutines, while the processor handles the execution of the function based on predefined parameters or user inputs. This approach enhances software flexibility, allowing for dynamic updates and modifications without requiring full system recompilation. The system is particularly useful in applications where modularity, scalability, and efficient resource management are critical, such as in embedded systems, real-time applications, or distributed computing environments. The function within the executable module is designed to be self-contained, reducing dependencies and improving maintainability. The system ensures that the function is executed in a controlled manner, with proper error handling and resource management to prevent system failures. This modular approach simplifies software development, testing, and deployment, making it easier to integrate new features or modify existing ones. The system is optimized for performance, ensuring that the function executes efficiently while minimizing overhead. The me
5. The system of claim 1 , wherein the executable module provides shared access to a file or other stored object.
A system for managing access to digital files or stored objects in a computing environment. The system includes a processing unit and a memory storing an executable module that controls access to files or objects. The executable module enforces access permissions, ensuring that only authorized users or processes can read, modify, or delete the files or objects. The system may also include a network interface for remote access and a storage device for storing the files or objects. The executable module can track access attempts, log activities, and generate reports on file usage. The system may further include a user interface for configuring access rules and monitoring access patterns. The shared access feature allows multiple users or processes to interact with the same file or object simultaneously, with the system managing conflicts and ensuring data consistency. The system may also support version control, allowing users to track changes over time and revert to previous versions if needed. The executable module can enforce granular permissions, such as read-only, write-only, or execute permissions, and may integrate with authentication systems to verify user identities before granting access. The system is designed to improve collaboration and security in environments where multiple users need to access shared resources.
6. The system of claim 1 , wherein the executable module provides managed access to a specialty engine.
A system provides managed access to a specialty engine, enabling controlled interaction with specialized computational or processing capabilities. The specialty engine may include high-performance computing resources, artificial intelligence models, or domain-specific algorithms optimized for tasks such as data analysis, simulation, or machine learning. The system ensures secure and efficient access to these resources, preventing unauthorized use while allowing authorized users to leverage the engine's capabilities. Access control mechanisms, such as authentication, authorization, and usage monitoring, are implemented to govern interactions with the specialty engine. The system may also include logging and reporting features to track usage patterns and performance metrics. This approach enhances resource utilization, security, and operational efficiency in environments where specialized computational power is required. The system is particularly useful in industries like finance, healthcare, or scientific research, where precise and controlled access to high-performance engines is critical. By managing access to the specialty engine, the system ensures that computational resources are used effectively while maintaining compliance with security and operational policies.
7. The system of claim 1 , wherein the target address space executes the executable code via an API or other service call.
Technical Summary: This invention relates to a system for executing code within a target address space using an application programming interface (API) or other service call. The system addresses the challenge of securely and efficiently running executable code in a controlled environment, such as a virtual machine or isolated process, while maintaining isolation between different execution contexts. The system includes a host environment that manages the execution of code in one or more target address spaces. These address spaces are isolated regions of memory where the executable code operates independently of the host environment. The host environment provides mechanisms to load and initialize the executable code in the target address space, ensuring proper setup before execution. The target address space is configured to execute the loaded code through an API or service call, allowing the host environment to trigger the execution in a controlled manner. This approach enables secure interaction between the host and the target address space, preventing unauthorized access or interference. The system may also include features to monitor and manage the execution, such as tracking resource usage or enforcing security policies. By using an API or service call to initiate execution, the system ensures that the code runs in a predictable and controlled manner, reducing the risk of errors or security vulnerabilities. This method is particularly useful in environments where isolation and security are critical, such as cloud computing, virtualization, or sandboxed applications. The system may also support dynamic loading and unloading of code, allowing for flexible and adaptable execution environments.
8. A method, comprising: allocating a shared memory segment of a memory for two address spaces, the first comprising a home address space and the second comprising a target address space; loading one or more executable modules in the home address space; and building in the home address space one or more program call routines and an environment to schedule system request blocks; wherein the environment to schedule system request blocks is configured to be used to schedule an SRB into the target address space, the SRB comprising information configured to cause the target address space to cause an associated one or more of the executable modules to execute; wherein the target address space is configured to execute the executable module from the shared memory segment; wherein the target address space uses an asynchronous exit routine to execute the executable module; wherein a cross-memory post is sent by the target address space to the home address to signal completion of the executable module.
This invention relates to a method for executing modules across different address spaces using shared memory and asynchronous communication. The problem addressed is efficient inter-process communication and execution in systems where modules need to run in separate address spaces while minimizing overhead and ensuring proper synchronization. The method involves allocating a shared memory segment accessible by both a home address space and a target address space. Executable modules are loaded into the home address space, which also builds program call routines and an environment to schedule system request blocks (SRBs). The SRB scheduling environment is configured to dispatch SRBs to the target address space, where each SRB contains instructions to execute an associated module from the shared memory. The target address space runs the module asynchronously, using an exit routine to signal completion. Upon finishing execution, the target address space sends a cross-memory post to the home address space to indicate completion. This approach enables secure and efficient cross-address space execution by leveraging shared memory for data access and asynchronous signaling for synchronization, reducing the need for explicit inter-process communication mechanisms. The method ensures that modules execute in isolated address spaces while maintaining coordination between them.
9. The method of claim 8 , further comprising identifying a task control block (TCB) associated with the target address space.
A system and method for managing task control blocks (TCBs) in a computing environment involves identifying a TCB associated with a target address space. The TCB is a data structure that contains information about a process or task, including its execution state, resource allocation, and address space. The method includes accessing the TCB to retrieve or modify process-related data, ensuring proper synchronization and security when interacting with the target address space. This approach enables efficient process management, resource tracking, and secure access control within an operating system or virtualized environment. The technique is particularly useful in systems where multiple processes share or compete for address space resources, requiring precise identification and handling of TCBs to maintain system stability and performance. By associating a TCB with a specific address space, the system can enforce access permissions, track resource usage, and manage process execution states effectively. This method supports secure and efficient process isolation, inter-process communication, and system-level resource management.
10. The method of claim 8 , wherein an SRB unit of the target address space resumes upon completion of the executable module.
A system and method for managing address spaces in a computing environment involves a target address space that includes a service request block (SRB) unit. The SRB unit is responsible for handling service requests within the address space. The method includes executing an executable module within the target address space, where the executable module performs specific operations. Upon completion of the executable module, the SRB unit of the target address space resumes its operations. This ensures that the SRB unit can continue processing service requests after the executable module has finished executing. The resumption of the SRB unit may involve restoring its state, reinitializing its components, or continuing from the point where it was paused. The method may also include mechanisms to ensure that the resumption of the SRB unit does not interfere with other operations in the address space. The system may further include additional address spaces, each with their own SRB units, to manage service requests independently. The method ensures efficient handling of service requests by allowing the SRB unit to resume operations seamlessly after the completion of the executable module.
11. The method of claim 8 , wherein the executable module comprises a function.
Technical Summary: This invention relates to software systems, specifically methods for managing executable modules within a computing environment. The problem addressed involves efficiently handling and executing modular code components, particularly in systems where modularity, reusability, and dynamic execution are critical. The invention describes a method for processing an executable module, where the module includes a function. The executable module is designed to be dynamically loaded, executed, or integrated into a larger software system. The function within the module performs a specific task or operation, allowing the module to be modular and reusable. The method ensures that the module can be properly initialized, executed, and managed within the system, enabling flexible and scalable software architectures. The executable module may be part of a larger system where multiple such modules interact, allowing for dynamic extension or modification of functionality without requiring full system recompilation. The function within the module can be invoked by other parts of the system, enabling modular programming practices. The method ensures that the module is correctly loaded, its dependencies are resolved, and its function is executed in the appropriate context. This approach is particularly useful in environments where software components need to be dynamically loaded, such as plugin systems, runtime environments, or modular applications. The invention improves software maintainability, reusability, and adaptability by allowing functions to be encapsulated within executable modules that can be managed independently.
12. The method of claim 8 , wherein the executable module provides shared access to a file or other stored object.
A system and method for managing executable modules in a computing environment addresses the challenge of securely and efficiently sharing resources, such as files or stored objects, among multiple users or processes. The invention involves an executable module that facilitates shared access to a file or other stored object, ensuring that authorized users or processes can interact with the resource while maintaining security and integrity. The executable module may include mechanisms for authentication, authorization, and access control to prevent unauthorized access or modifications. Additionally, the module may support concurrent access, allowing multiple users or processes to interact with the shared resource simultaneously without conflicts. The system may also include logging and monitoring features to track access patterns and detect potential security breaches. This approach improves resource utilization and collaboration while reducing the risk of data corruption or unauthorized access. The invention is particularly useful in distributed computing environments, cloud-based systems, and multi-user applications where shared access to resources is essential.
13. The method of claim 8 , wherein the executable module provides managed access to a specialty engine.
A method for providing managed access to a specialty engine within a computing system. The specialty engine is a specialized processing unit designed to perform specific computational tasks more efficiently than a general-purpose processor. The method involves deploying an executable module that acts as an intermediary between a user application and the specialty engine. This module manages the interaction by receiving task requests from the application, translating them into commands compatible with the specialty engine, and handling the data transfer between the application and the engine. The module also ensures proper resource allocation, error handling, and performance optimization. The specialty engine may include hardware accelerators, co-processors, or other specialized processing units tailored for tasks such as cryptography, machine learning, or signal processing. The method improves efficiency by offloading specialized tasks from the main processor, reducing latency and power consumption. The executable module may also include security features to prevent unauthorized access to the specialty engine. This approach enhances system performance while maintaining compatibility with existing software architectures.
14. A computer program product embodied in a non-transitory computer readable medium and comprising computer instructions for: allocating a shared memory segment of a memory for two address spaces, the first comprising a home address space and the second comprising a target address space; loading one or more executable modules in the home address space; and building in the home address space one or more program call routines and an environment to schedule system request blocks; wherein the environment to schedule system request blocks is configured to be used to schedule an SRB into the target address space, the SRB comprising information configured to cause the target address space to cause an associated one or more of the executable modules to execute; wherein the target address space is configured to execute the executable module from the shared memory segment; wherein the target address space uses an asynchronous exit routine to execute the executable module; wherein a cross-memory post is sent by the target address space to the home address to signal completion of the executable module.
This invention relates to a computer program product for managing shared memory and inter-process communication in a computing environment. The system addresses the challenge of efficiently executing modules across different address spaces while minimizing data duplication and ensuring proper synchronization. The invention involves allocating a shared memory segment accessible by two address spaces: a home address space and a target address space. The home address space loads one or more executable modules and constructs program call routines and an environment to schedule system request blocks (SRBs). These SRBs contain instructions that trigger the execution of associated modules in the target address space. The target address space retrieves and executes the modules directly from the shared memory, avoiding redundant data transfers. Execution in the target address space is managed asynchronously using an exit routine, which allows the system to handle tasks without blocking the home address space. Upon completion, the target address space sends a cross-memory post to the home address space, signaling that the module has finished executing. This mechanism ensures efficient coordination between address spaces while maintaining data consistency and reducing overhead. The approach is particularly useful in multi-process or distributed computing environments where shared resources must be managed securely and efficiently.
Cooperative Patent Classification codes for this invention. Click any code to explore related patents in that topic.
April 28, 2017
January 7, 2020
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.