An isolated architecture, waveform display script object management method and system
By using an isolation architecture and handle mapping mechanism, the conflict between the script interpreter and internal object management in the waveform display is resolved, resulting in improved security and performance, simplified object management, and support for compatibility and scalability across multiple script environments.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- JULIN TECH (SHANGHAI) CO LTD
- Filing Date
- 2026-05-29
- Publication Date
- 2026-06-26
AI Technical Summary
In the existing technology, the script interpreter of the waveform display conflicts with the lifecycle management mechanism of the internal objects, resulting in problems such as memory leaks, illegal memory access, and high complexity in managing naming conflicts.
An isolation architecture is adopted, which achieves a clear separation between the script environment and internal object management through a handle mapping mechanism. Integer handles are used as the calling medium, and the life cycle of objects is managed through a two-way mapping and destruction callback mechanism.
It improves system security, performance, and maintainability, avoids memory leaks and illegal memory access, simplifies naming conflict management, and supports compatibility and scalability across different scripting environments.
Smart Images
Figure CN122287491A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of electronic design automation technology, and more particularly to an isolation architecture, a waveform display script object management method and system. Background Technology
[0002] In modern IC design verification workflows, engineers use waveform displays to view simulation waveforms for debugging. To improve debugging efficiency, these tools typically provide scripting interfaces (such as Tcl) for automation.
[0003] Existing technical solutions have the following problems: 1) Directly exposing internal object pointers to the script interpreter: Existing solutions directly wrap the tool's internal C++ object pointers as script objects. However, there is a fundamental conflict between the script interpreter's garbage collection mechanism and the internal object's lifecycle management mechanism, leading to blurred boundaries of memory management responsibility and making memory leaks or dangling pointer accesses more likely. Simultaneously, the script may illegally tamper with pointer values, directly damaging the tool's internal state, resulting in poor system security; 2) Existing solutions assign a unique string name to each internal object. Scripts operate on objects by name, requiring the maintenance of a global namespace, increasing the complexity of naming conflict management; each object operation requires a string hash lookup, resulting in significant performance overhead; and name mapping entries are not thoroughly cleaned up after object deletion, easily generating residual entries. Therefore, a solution is needed that can achieve a clear separation between the script environment and internal object management, improving system security, performance, and maintainability. Summary of the Invention
[0004] The purpose of this invention is to provide an isolation architecture, a waveform display script object management method and system. By designing a handle mapping mechanism across interpreter boundaries, a clear separation between the script environment and internal object management is achieved, thereby improving the system's security, performance and maintainability.
[0005] The technical solution provided by this invention is as follows: Firstly, this application provides an isolation architecture, including: The internal object layer includes an internal object factory, which is used to create internal objects corresponding to script commands; The handle mapping layer includes a handle allocation module and a bidirectional mapping module. The handle allocation module is used to allocate integer handles to the internal objects, and the bidirectional mapping module is used to maintain the bidirectional mapping relationship between the integer handles and the pointers to the internal objects. The script interface layer includes a set of custom commands adapted to the script syntax specification. The parameters and return values of each command in the set of custom commands conform to the basic data types of the script and do not contain internal object pointer information. The script interface layer is used to return the integer handle as a return value to the script.
[0006] In some implementations, the bidirectional mapping module includes a forward mapping subunit and a reverse mapping subunit. The forward mapping subunit is configured to quickly look up internal object pointers using integer handles and parse the internal objects during script operations. The reverse mapping subunit is configured to look up the corresponding integer handle through the internal object pointer and automatically clean up when the internal object is destroyed.
[0007] In some implementations, the handle allocation module is used to maintain a globally increasing sequence of handles and a pool of free handles. When a new integer handle needs to be allocated, the handle allocation module obtains a reused handle from the idle handle pool. If there is no available reused handle in the idle handle pool, a new incrementing handle is allocated from the handle sequence.
[0008] In some implementations, the handle mapping layer further includes: The handle recycling module is used to reclaim the integer handles when the script command execution ends; The security verification module is used to perform multiple verifications when accessing the internal object through the integer handle, including handle validity verification, object liveness verification, and object type consistency verification.
[0009] In some implementations, the integer handle is composed of a type identifier and a serial number, with the type identifier located in the high-order bits and the serial number located in the low-order bits.
[0010] In some implementations, the script interface layer is configured to include multiple operation interfaces, each of which processes the creation of multiple internal objects in parallel.
[0011] Secondly, this application provides a waveform display script object management method, applying the isolation architecture described in the first aspect, including the following steps: Initialize the handle mapping layer; When a script command requires the creation of a new first internal object, the internal object layer of the isolation architecture is invoked to create the first internal object. The first integer handle corresponding to the first internal object is allocated through the handle mapping layer of the isolation architecture, and a bidirectional mapping relationship is constructed between the first integer handle and the pointer of the first internal object. Register a destruction callback function on the first internal object; The first integer handle is returned to the script through the script interface layer of the isolation architecture.
[0012] In some implementations, when the script operates on the internal object through the first integer handle, it includes: The script interface layer receives the first integer handle passed by the script. The first integer handle is passed to the handle mapping layer for parsing; Perform checks on the validity of the execution handle, whether the object is alive, and whether the object type matches. After successful verification, return the pointer to the first internal object corresponding to the first integer handle; The operation of the internal object is performed based on the first internal object pointer.
[0013] In some implementations, the destruction of the first internal object includes: The callback function controls the handle mapping layer to perform cleanup operations. The first integer handle corresponding to the first internal object is found through the reverse mapping subunit of the handle mapping layer; The first integer handle is marked as invalid and recycled to the free handle pool of the handle mapping layer; Remove the entry corresponding to the first internal object from the forward mapping table of the forward mapping subunit of the handle mapping layer.
[0014] Thirdly, this application provides a waveform display script object management system, including a processor, which executes the call to the internal object layer of the isolation architecture described in the second aspect to create the first internal object.
[0015] The isolation architecture, waveform display script object management method and system provided by this invention have at least the following technical advantages: 1) Significantly improved security: The scripts in this solution can only operate on opaque integer handles and cannot directly access internal object pointers, completely eliminating the risk of system crashes caused by illegal memory access.
[0016] 2) Automated lifecycle management: This solution achieves automatic tracking of object lifecycle and timely reclamation of handle resources through bidirectional mapping and destruction callback mechanism, avoiding memory leak problems.
[0017] 3) Enhanced system maintainability: All cross-boundary object management logic in this solution is centralized in the handle mapping layer, with clear responsibilities, making it easy to debug and extend; adding new object types only requires registration in the mapping layer, without modifying the core logic of the script interface layer.
[0018] 4) Good compatibility and scalability: This solution does not depend on specific script interpreter implementation details and can be adapted to different versions of Tcl, Python and other script environments; at the same time, it supports batch operation optimization and reduces the context switching overhead between the script and the underlying system. Attached Figure Description
[0019] The preferred embodiments will now be described in a clear and easy-to-understand manner, with reference to the accompanying drawings, to further explain the above-mentioned characteristics, technical features, advantages, and implementation methods of this solution.
[0020] Figure 1 This is a system schematic diagram of one embodiment of the present invention; Figure 2 This is a flowchart illustrating an embodiment of the present invention; Figure 3 This is a flowchart illustrating another embodiment of the present invention; Figure 4 This is a flowchart illustrating another embodiment of the present invention.
[0021] The diagram is labeled as follows: 10 - Internal object layer; 20 - Handle mapping layer; 21 - Handle allocation module; 22 - Bidirectional mapping module; 221 - Forward mapping subunit; 222 - Reverse mapping subunit; 23 - Handle recycling module; 24 - Security verification module; 30 - Script interface layer. Detailed Implementation
[0022] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the specific implementation methods of the present invention will be described below with reference to the accompanying drawings. Obviously, the drawings described below are merely some embodiments of the present invention. For those skilled in the art, other drawings and other implementation methods can be obtained based on these drawings without any creative effort.
[0023] To keep the drawings concise, only the parts relevant to the invention are shown schematically in each figure, and they do not represent the actual structure of the product. Furthermore, for ease of understanding, in some figures, only one of components with the same structure or function is shown schematically, or only one is labeled. In this document, "one" can mean not only "only one" but also "more than one".
[0024] In modern IC design verification workflows, engineers use waveform displays to view simulation waveforms for debugging. To improve debugging efficiency, these tools typically provide scripting interfaces (such as Tcl) for automation.
[0025] Existing technical solutions have the following problems: 1) Directly exposing internal object pointers to the script interpreter: Existing solutions directly wrap the tool's internal C++ object pointers as script objects. However, there is a fundamental conflict between the script interpreter's garbage collection mechanism and the internal object's lifecycle management mechanism, leading to blurred boundaries of memory management responsibility and making memory leaks or dangling pointer accesses more likely. Simultaneously, the script may illegally tamper with pointer values, directly damaging the tool's internal state, resulting in poor system security; 2) Existing solutions assign a unique string name to each internal object. Scripts operate on objects by name, requiring the maintenance of a global namespace, increasing the complexity of naming conflict management; each object operation requires a string hash lookup, resulting in significant performance overhead; and name mapping entries are not thoroughly cleaned up after object deletion, easily generating residual entries. Therefore, a solution is needed that can achieve a clear separation between the script environment and internal object management, improving system security, performance, and maintainability.
[0026] The root cause of these problems is the attempt to manage internal objects within the script interpreter or through script mechanisms, leading to blurred management boundaries and mechanism mismatches. This solution, however, achieves a clear separation between the script environment and internal object management by designing a handle mapping mechanism across interpreter boundaries, thereby improving system security, performance, and maintainability. The following is a detailed description of this solution with reference to the accompanying diagrams: In one embodiment, refer to the appendix to the specification. Figure 1 This application provides an isolation architecture, including: an internal object layer 10, a handle mapping layer 20, and a script interface layer 30. The internal object layer 10 includes an internal object factory, which creates internal objects corresponding to script commands. That is, when an internal object operation needs to be performed via a script, the internal object factory can create the internal object corresponding to the script command. Internal objects can include waveform objects, cursor objects, measurement objects, bookmark objects, etc., and can be adjusted according to usage requirements; this application does not impose any restrictions. The internal object layer 10 of this solution remains unchanged from the existing internal object management system, and will not be described in detail here. The internal object layer 10 can interface with the handle mapping layer 20 through an adapter pattern. Furthermore, each internal object can register a destruction callback function at the time of creation to ensure that the handle mapping layer 20 is automatically notified for cleanup when the object is destroyed.
[0027] The handle mapping layer 20 includes a handle allocation module 21 and a bidirectional mapping module 22. A handle is a core concept in operating systems and low-level programming; essentially, it's an indirect reference mechanism that prevents the system from directly exposing object memory addresses, instead returning a system-managed identifier. Integer handles are integer indexes in the system resource table, not memory addresses. Integer handles possess the following characteristics: they are not pointers; they do not directly store object memory addresses but are indices in the handle table / descriptor table; they provide process isolation, ensuring that the handle values for the same kernel object differ across processes; they encapsulate permissions, allowing access masks (read / write / execute permissions) to be stored simultaneously in the table entries; and they act as a security barrier, preventing user-mode from deriving or tampering with kernel object addresses through handle values. Therefore, this scheme uses integer handles as the calling medium between scripts and internal object pointers. The handle allocation module 21 includes a handle allocator, used to allocate integer handles to internal objects and reclaim integer handles when internal objects are destroyed; the bidirectional mapping module 22 maintains the bidirectional mapping relationship between integer handles and internal object pointers.
[0028] Preferably, the bidirectional mapping module 22 includes a forward mapping subunit 221 and a reverse mapping subunit 222. The forward mapping subunit 221 is configured to quickly find the internal object pointer through the integer handle and parse the internal object during script operations. The reverse mapping subunit 222 is configured to find the corresponding integer handle through the internal object pointer and automatically clean up when the internal object is destroyed. In specific implementation, the forward mapping subunit 221 and the reverse mapping subunit 222 can be configured with corresponding forward mapping tables and reverse mapping tables, respectively. That is, the forward mapping subunit 221 maintains a forward mapping table to store the forward mapping relationship between the integer handle and the internal object pointer; the reverse mapping subunit 222 maintains a reverse mapping table to store the reverse mapping relationship between the internal object pointer and the integer handle. Of course, in other embodiments, a large mapping table can also be used to record the bidirectional mapping relationship between the integer handle and the internal object pointer, and this application does not impose any restrictions.
[0029] The script interface layer 30 includes a set of custom commands adapted to the script syntax specification. The parameters and return values of each command in the custom command set conform to the basic data types of the script and do not contain any internal object pointer information. The script interface layer 30 is used to return an integer handle as a return value to the script.
[0030] This solution employs a three-tier isolation architecture for object management. Scripts can only manipulate opaque integer handles and cannot directly access internal object pointers, thus avoiding the risk of system crashes due to illegal memory access. Furthermore, by setting up bidirectional mapping and a destruction callback mechanism, timely reclamation of handle resources can be achieved, preventing memory leaks. All cross-boundary object management logic in this solution is centralized in the handle mapping layer. Adding new object types only requires registration in the handle mapping layer without modifying the core logic of the script interface layer, further achieving isolation between the script interpreter and internal objects.
[0031] In one embodiment, based on the foregoing embodiments, the handle allocation module 21 maintains a globally incrementing handle sequence and an idle handle pool. When a new integer handle needs to be allocated, the handle allocation module 21 obtains a reused handle from the idle handle pool. If there is no available reused handle in the idle handle pool, a new incrementing handle is allocated from the handle sequence. The handle mapping layer 20 also includes a handle recycling module 23, which reclaims integer handles when the script command execution ends.
[0032] This scheme employs a strategy combining incremental allocation and recycling / reuse. The system maintains a globally increasing sequence of handles and a pool of free handles. When a new handle is needed, a reused handle is preferentially obtained from the free pool; if no reused handle is available, a new, incrementally increasing handle is allocated. Handle recycling can use a lazy cleanup strategy, releasing resources only when needed.
[0033] Preferably, the handle mapping layer 20 further includes a security verification module 24, which is used to perform multiple verifications when accessing internal objects through integer handles, including handle validity verification, object liveness verification, and object type consistency verification.
[0034] Specifically, this solution establishes a security verification mechanism to ensure secure access by performing multi-layered verification each time an object is accessed via a handle. The security verification mechanism includes: handle validity verification, which checks whether the handle is within a valid range and has not been marked as invalid; object liveness verification, which checks whether the mapped object is still in a valid state; and type consistency verification, which checks whether the object type meets the expected requirements of the operation command.
[0035] In one embodiment, based on the foregoing embodiments, the integer handle of this scheme is composed of a type identifier and a serial number, with the type identifier located in the high-order bits and the serial number located in the low-order bits. This encoding method enables the system to quickly perform type checks when parsing the handle. If the handle type does not match the type expected by the command, a type error can be returned immediately without performing a complete object lookup.
[0036] Preferably, the script interface layer of this solution is configured to include multiple operation interfaces, each of which processes the creation of multiple internal objects in parallel.
[0037] Specifically, this solution provides a batch operation interface for script scenarios that require creating or manipulating a large number of objects. This interface allows multiple objects to be processed in a single call, reducing the context switching overhead between the script and the underlying system. During access, a read-write lock mechanism is used, allowing multiple read operations to execute concurrently, while write operations have exclusive access, ensuring data consistency in a multi-threaded environment.
[0038] In one embodiment, this application provides a waveform display script object management method, applying the isolation architecture of the foregoing embodiments, as detailed in the appendix to the specification. Figure 2 When a script command needs to create a new internal object (such as a waveform cursor, measurement marker, etc.), the following sub-steps are executed: S100, Initialize the handle mapping layer.
[0039] Specifically, this solution initializes the handle mapping system when the waveform display starts. This system exists as a global singleton to ensure consistent handle management throughout the application's lifecycle. The initialization process includes allocating an initial handle pool, establishing an empty mapping table, and starting a monitoring thread.
[0040] S110. When a script command requires the creation of a new first internal object, the internal object layer of the isolated architecture is invoked to create the first internal object.
[0041] S120. Allocate a first integer handle corresponding to the first internal object through the handle mapping layer of the isolation architecture, and construct a bidirectional mapping relationship between the first integer handle and the pointer of the first internal object.
[0042] S130. Register a destruction callback function on the first internal object.
[0043] S140. Return the first integer handle to the script through the script interface layer of the isolation architecture.
[0044] Specifically, before operating on the target internal object via script, the object is created and a handle is allocated. Based on the script commands, the first internal object to be created is determined, and the internal object layer of the isolated architecture is invoked to create this first internal object. A first integer handle corresponding to the first internal object is allocated through the handle mapping layer, and a bidirectional mapping relationship is established between the first integer handle and the pointer to the first internal object. The first integer handle is returned to the script through the script interface layer, thus realizing object creation and handle allocation. Simultaneously, a destruction callback function is registered on the first internal object for subsequent object destruction.
[0045] In one embodiment, refer to the appendix to the specification. Figure 3When the script operates on an internal object through the first integer handle, the following sub-steps are executed: S10. Receive the first integer handle passed by the script through the script interface layer.
[0046] S11. Pass the first integer handle to the handle mapping layer for parsing to determine the first internal object pointer corresponding to the first integer handle.
[0047] S12. Perform handle validity checks, object liveness checks, and object type matching checks. Handle validity checks ensure the handle is within valid range and not marked as invalid; object liveness checks ensure the mapped object is still valid; type consistency checks ensure the object type meets the expected requirements of the operation command.
[0048] S13. After successful verification, return the pointer to the first internal object corresponding to the first integer handle.
[0049] S14. Perform operations on the internal object based on the pointer to the first internal object to complete the script operation.
[0050] Specifically, after object creation and handle allocation are completed, when the script needs to operate on the object through the handle, the previously obtained first integer handle is sent to the script interface layer. The script interface layer receives the first integer handle and passes it to the handle mapping layer for parsing, thereby obtaining the pointer to the first internal object corresponding to the first integer handle. After completing the handle validity check, the object liveness check, and the object type matching check, the pointer to the first internal object corresponding to the first integer handle can be returned, so that the script can execute the operation of the corresponding internal object through the first internal object pointer.
[0051] In one embodiment, refer to the appendix to the specification. Figure 4 When the first internal object is destroyed, the object destruction event triggers a pre-registered callback function, which executes the following sub-steps: S1. The handle mapping layer is controlled to perform cleanup operations according to the callback function.
[0052] S2. Find the first integer handle corresponding to the first internal object through the reverse mapping subunit of the handle mapping layer.
[0053] S3. Mark the first integer handle as invalid and reclaim it to the free handle pool of the handle mapping layer.
[0054] S4. Remove the entry corresponding to the first internal object from the forward mapping table of the forward mapping subunit of the handle mapping layer.
[0055] Specifically, after the operation of the internal object is completed through the script, the object is destroyed and resources are reclaimed. The callback function registered when the internal object is created controls the handle mapping layer to perform the cleanup operation. The reverse mapping subunit finds the first integer handle corresponding to the first internal object, marks the first integer handle as invalid and reclaims it to the idle handle pool of the handle mapping layer. At the same time, the entry corresponding to the first internal object is removed from the forward mapping table of the forward mapping subunit of the handle mapping layer, thus completing the object destruction and resource reclamation.
[0056] In addition, this solution provides diagnostic and debugging support. In debug mode, the handle mapping system records metadata information for each handle, including creation time, creation thread, call stack, and access count. When handle-related errors occur, the system can provide detailed diagnostic information to help developers quickly locate the root cause of the problem.
[0057] This solution also provides a tiered error handling strategy: for syntax-level errors, if detected during the command parameter parsing phase, the error is immediately returned to the script; for handle-level errors, if detected during the handle verification phase, the specific reason for the handle's invalidity is returned; for object-level errors, if detected during the object operation phase, error information related to the object's state is returned. All error information is in a structured format, including the error code, error description, relevant handle information, and optional debugging information, to generate an error report, which is then displayed to the user for review and adjustment.
[0058] In one embodiment, based on the foregoing embodiments, this application provides a waveform display script object management system, including a processor, which executes the internal object layer of the call isolation architecture of the foregoing embodiments to create a first internal object.
[0059] The isolation architecture, waveform display script object management method and system provided by this invention have at least the following technical advantages: 1) Significantly improved security: The scripts in this solution can only operate on opaque integer handles and cannot directly access internal object pointers, completely eliminating the risk of system crashes caused by illegal memory access.
[0060] 2) Automated lifecycle management: This solution achieves automatic tracking of object lifecycle and timely reclamation of handle resources through bidirectional mapping and destruction callback mechanism, avoiding memory leak problems.
[0061] 3) Enhanced system maintainability: All cross-boundary object management logic in this solution is centralized in the handle mapping layer, with clear responsibilities, making it easy to debug and extend; adding new object types only requires registration in the mapping layer, without modifying the core logic of the script interface layer.
[0062] 4) Good compatibility and scalability: This solution does not depend on specific script interpreter implementation details and can be adapted to different versions of Tcl, Python and other script environments; at the same time, it supports batch operation optimization and reduces the context switching overhead between the script and the underlying system.
[0063] It should be noted that the above embodiments can be freely combined as needed. The above description is only a preferred embodiment of the present invention. It should be pointed out that for those skilled in the art, several improvements and modifications can be made without departing from the principle of the present invention, and these improvements and modifications should also be considered within the scope of protection of the present invention.
Claims
1. An isolation architecture, characterized in that, include: The internal object layer includes an internal object factory, which is used to create internal objects corresponding to script commands; The handle mapping layer includes a handle allocation module and a bidirectional mapping module. The handle allocation module is used to allocate integer handles to the internal objects, and the bidirectional mapping module is used to maintain the bidirectional mapping relationship between the integer handles and the pointers to the internal objects. The script interface layer includes a custom command set adapted to the script syntax specification. The parameters and return values of each command in the custom command set conform to the basic data types of the script and do not contain the internal object pointer information. The script interface layer is used to return the integer handle as a return value to the script.
2. The isolation architecture according to claim 1, characterized in that, The bidirectional mapping module includes a forward mapping subunit and a reverse mapping subunit. The forward mapping subunit is configured to quickly look up the internal object pointer using the integer handle and parse the internal object during script operations. The reverse mapping subunit is configured to look up the corresponding integer handle through the internal object pointer and automatically clean up when the internal object is destroyed.
3. The isolation architecture according to claim 1, characterized in that, The handle allocation module is used to maintain a globally increasing sequence of handles and a pool of free handles. When a new integer handle needs to be allocated, the handle allocation module obtains a reused handle from the idle handle pool. If there is no available reused handle in the idle handle pool, a new incrementing handle is allocated from the handle sequence.
4. An isolation architecture according to claim 1, characterized in that, The handle mapping layer also includes: The handle recycling module is used to reclaim the integer handles when the script command execution ends; The security verification module is used to perform multiple verifications when accessing the internal object through the integer handle, including handle validity verification, object liveness verification, and object type consistency verification.
5. An isolation architecture according to claim 1, characterized in that, The integer handle is composed of a type identifier and a serial number, with the type identifier located in the high-order bits and the serial number located in the low-order bits.
6. An isolation architecture according to claim 1, characterized in that, The script interface layer is configured to include multiple operation interfaces, each of which processes the creation of multiple internal objects in parallel.
7. A method for managing waveform display script objects, characterized in that, Applying the isolation architecture according to any one of claims 1-6, comprising the steps of: Initialize the handle mapping layer; When a script command requires the creation of a new first internal object, the internal object layer of the isolation architecture is invoked to create the first internal object. The first integer handle corresponding to the first internal object is allocated through the handle mapping layer of the isolation architecture, and a bidirectional mapping relationship is constructed between the first integer handle and the pointer of the first internal object. Register a destruction callback function on the first internal object; The first integer handle is returned to the script through the script interface layer of the isolation architecture.
8. The waveform display script object management method according to claim 7, characterized in that, When the script operates on the internal object through the first integer handle, it includes: The script interface layer receives the first integer handle passed by the script. The first integer handle is passed to the handle mapping layer for parsing; Perform checks on the validity of the execution handle, whether the object is alive, and whether the object type matches. After successful verification, return the pointer to the first internal object corresponding to the first integer handle; The operation of the internal object is performed based on the first internal object pointer.
9. The waveform display script object management method according to claim 7, characterized in that, The destruction of the first internal object includes: The callback function controls the handle mapping layer to perform cleanup operations. The first integer handle corresponding to the first internal object is found through the reverse mapping subunit of the handle mapping layer; The first integer handle is marked as invalid and recycled to the free handle pool of the handle mapping layer; Remove the entry corresponding to the first internal object from the forward mapping table of the forward mapping subunit of the handle mapping layer.
10. A waveform display script object management system, characterized in that, Includes a processor that performs the invocation of the internal object layer of the isolation architecture as described in any one of claims 7-9 to create the first internal object.