CN117369980A - Shared data processing system for EDA software - Google Patents
Shared data processing system for EDA software Download PDFInfo
- Publication number
- CN117369980A CN117369980A CN202210762490.3A CN202210762490A CN117369980A CN 117369980 A CN117369980 A CN 117369980A CN 202210762490 A CN202210762490 A CN 202210762490A CN 117369980 A CN117369980 A CN 117369980A
- Authority
- CN
- China
- Prior art keywords
- data
- module
- sharing
- entity
- target
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000012545 processing Methods 0.000 title claims abstract description 13
- 230000000977 initiatory effect Effects 0.000 claims abstract description 48
- 238000000034 method Methods 0.000 claims abstract description 17
- 230000008569 process Effects 0.000 claims abstract description 14
- 238000004590 computer program Methods 0.000 claims abstract description 11
- 238000013475 authorization Methods 0.000 claims description 23
- 230000006870 function Effects 0.000 claims description 10
- 230000007246 mechanism Effects 0.000 claims description 5
- 230000004044 response Effects 0.000 claims description 3
- 238000013461 design Methods 0.000 description 7
- 238000005516 engineering process Methods 0.000 description 6
- 238000010586 diagram Methods 0.000 description 2
- 230000000694 effects Effects 0.000 description 2
- 238000013467 fragmentation Methods 0.000 description 2
- 238000006062 fragmentation reaction Methods 0.000 description 2
- 230000003993 interaction Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000015556 catabolic process Effects 0.000 description 1
- 238000006731 degradation reaction Methods 0.000 description 1
- 238000001514 detection method Methods 0.000 description 1
- 230000010354 integration Effects 0.000 description 1
- 238000012917 library technology Methods 0.000 description 1
- 230000009467 reduction Effects 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5011—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resources being hardware resources other than CPUs, Servers and Terminals
- G06F9/5022—Mechanisms to release resources
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5011—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resources being hardware resources other than CPUs, Servers and Terminals
- G06F9/5016—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resources being hardware resources other than CPUs, Servers and Terminals the resource being the memory
Abstract
The present invention relates to a shared data processing system for EDA software running in a single process in a stand-alone environment, the system comprising at least one data initiating module, N data usage modules { U } 1 ，U 2 ，…U N A data sharing module, a processor, and a memory storing a computer program; each data initiating module and each data using module are connected with the data sharing module; the data sharing module is used for generating a shared type data entity in the memory resource based on the shared data type registration request sent by the data initiating module, and logging out the shared type data entity in the memory resource based on the shared data type logging-out request sent by the data initiating module; the shared type data entity is in a single instance mode. The invention improves the resource utilization efficiency of EDA software data sharing and improves the robustness and maintainability of EDA software.
Description
Technical Field
The invention relates to the technical field of computers, in particular to a shared data processing system of EDA software.
Background
Along with miniaturization of components and advanced evolution of processes, the circuit design scale is larger and larger, along with the increase of the integration level of the components, data mass of circuit design is increased by depending on EDA (Electronic Design Automation) design tool software (EDA software for short), and the EDA software faces the problems of large consumption of hardware resources and the like. EDA software typically needs to run in a single process in a stand-alone environment due to privacy and other factors.
In the prior art, EDA software typically shared data using two modes: (1) Using a single instance mode data entity for sharing use by a data use module; (2) Shared data is processed using dynamic on-demand creation, run-out, and release. However, the period of the single-instance mode data entity in mode (1) is equal to the operation period of EDA software, and memory resources are occupied at the stage of no use. Although the mode (2) can avoid occupying memory resources, frequent memory creation and release operations bring about a large amount of I/O overhead, large consumption of resources such as CPU and the like, and easy occurrence of memory fragmentation problems, thereby causing the degradation of EDA software performance or usability. In addition, in the existing data sharing process, the shared data entity is generally shared through a common C++ pointer, the validity cannot be verified, but the EDA software is easy to crash due to the use of an invalid pointer. And because of the many-to-many and various dependency relations of the data initiating module and the data using module, the relation of the modules is complex, and the maintainability of EDA software is low. Therefore, how to improve the resource utilization efficiency of EDA software data sharing and the robustness and maintainability of EDA software are technical problems to be solved.
Disclosure of Invention
The invention aims to provide a shared data processing system of EDA software, which improves the resource utilization efficiency of EDA software data sharing and the robustness and maintainability of EDA software.
The present invention provides a shared data processing system for EDA software running in a single process in a stand-alone environment, the system comprising at least one data initiating module, N data usage modules { U } 1 ，U 2 ，…U N A data sharing module, a processor, and a memory storing a computer program; each data initiating module and each data using module are connected with the data sharing module; the data sharing module is used for generating a shared type data entity in the memory resource based on the shared data type registration request sent by the data initiating module, and based on the shared data sent by the data initiating moduleThe shared data type logout request logs out the shared type data entity in the memory resource; the sharing type data entity is in a single instance mode;
when the processor executes the computer program, the following steps are implemented:
step S1, U n Sending a target sharing type data use request to the data sharing module, U j A value range of N is 1 to N for the j-th data use module;
step S2, the data sharing module judges whether the corresponding target sharing type data entity in the memory resource is effective, if so, the data sharing module sends the data to the U n Transmitting the target authorization token, executing step S3, and if invalid, transmitting the target authorization token to U n Sending an invalid data application response; the target authorization token is valid after the target sharing type data entity is registered to the time before the target sharing type data entity is logged out, and is invalid after the target sharing type data entity is logged out;
step S3, U n Sending a target entity handle acquisition request to the data sharing module based on a valid target authorization token;
step S4, the data sharing module transmits the data to the U n Transmitting a target entity handle;
step S5, U n And accessing a target sharing type data entity based on the target entity handle, executing a target function based on the target sharing type data entity, and invalidating the target entity handle when the execution of the target function is completed.
Compared with the prior art, the invention has obvious advantages and beneficial effects. By means of the technical scheme, the EDA software sharing data processing system provided by the invention can achieve quite technical progress and practicability, has wide industrial utilization value, and has at least the following advantages:
the invention avoids the shared data from occupying memory resources in the unused stage by precisely controlling the life cycle of the shared data in the single-case mode, and the life cycle can be set to be a cycle meeting the requirements of all data using modules, thereby reducing the I/O operation cost caused by frequently creating and releasing the memory, reducing the CPU resource consumption and improving the EDA software performance; in addition, the problem that the handle effectiveness cannot be verified due to the fact that a common pointer is used is avoided through the mode of authorizing the token and the target entity handle, and the robustness of EDA software is improved. The invention simplifies the dependency relationship between the data initiating module and the data using module, which is many-to-many and various, by arranging the data sharing module, so that the data initiating module and the data using module are decoupled, and the maintainability of EDA software is improved.
The foregoing description is only an overview of the present invention, and is intended to be implemented in accordance with the teachings of the present invention, as well as the preferred embodiments thereof, together with the following detailed description of the invention, given by way of illustration only, together with the accompanying drawings.
Drawings
FIG. 1 is a schematic diagram of a shared data processing system of EDA software provided by an embodiment of the present invention;
fig. 2 is a schematic diagram of an interaction process among a data initiating module, a data using module and a data sharing module according to an embodiment of the present invention.
Detailed Description
In order to further describe the technical means and effects of the present invention for achieving the intended purpose, the following detailed description refers to the specific implementation of an EDA software shared data processing system and its effects according to the present invention with reference to the accompanying drawings and preferred embodiments.
Embodiments of the present invention provide a shared data processing system for EDA (Electronic Design Automation) software that operates in a single process in a stand-alone environment. As shown in fig. 1, the system comprises at least one data initiating module, N data using modules { U } 1 ，U 2 ，…U N A data sharing module, a processor and a memory storing a computer program, each data initiating module and each data using module being connected to the data sharing module, the data sharing module being in particular connectable to the data initiating module or to the data using module via an application program interface (API: application Program Interface)The data use module communicates. The data initiating module is a module for providing shared data, and the data using module is a module for using the shared data. For example, the EDA design generation module is a data initiation module and the EDA design detection module is a data usage module. It should be noted that the data initiation module may also be a data usage module, and preferably, the data initiation module and the data usage module are in a many-to-many relationship. The data sharing module simplifies the dependency relationship between the data initiating module and the data using module, which is many-to-many and various, so that the data initiating module and the data using module are decoupled, and the maintainability of EDA software is improved.
The data sharing module is used for generating a shared type data entity in the memory resource based on the shared data type registration request sent by the data initiating module, and logging out the shared type data entity in the memory resource based on the shared data type logging-out request sent by the data initiating module; the shared type data entity is in a single instance mode, and the single instance mode refers to that one shared data corresponds to one class and one class corresponds to one instance only. The single-instance mode can be realized by adopting a C++ container technology or a tool library technology, and the C++ template technology ensures that one class corresponds to only one instance, so that the effective management of multiple types of shared data resources is realized, and the description is not repeated here. However, it should be noted that other ways of implementing the single embodiment mode also fall within the protection scope of the present invention, and are not listed here.
Therefore, the life cycle starting point of the shared data entity is determined through the shared data type registration request sent by the data initiating module, the life cycle end point of the shared data entity is determined through the shared data type cancellation request sent by the data initiating module, and compared with the life cycle of the shared data entity in the mode (1) in the background technology which is equal to the EDA software running cycle, the embodiment of the invention can accurately control the life cycle of the shared data in the single-case mode, and the shared data is prevented from occupying memory resources in the unused stage. Compared with the mode (2) which is created with use and released with use in the background art, the invention reduces the I/O operation cost caused by frequently creating and releasing the memory, reduces the CPU resource consumption, and avoids the problem of EDA software performance or usability reduction caused by the memory fragmentation problem. The life cycle of the sharing type data entity in the single instance mode is set to be capable of meeting the use requirements of all corresponding data use modules, the start point of the life cycle of each sharing data is earlier than the start time of the first sharing data, and the end point of the life cycle is later than the end time of the last sharing data.
When the processor executes the computer program, the following steps are implemented:
step S1, U n Sending a target sharing type data use request to the data sharing module, U j The value range of N is 1 to N for the j-th data use module.
Step S2, the data sharing module judges whether the corresponding target sharing type data entity in the memory resource is effective, if so, the data sharing module sends the data to the U n Transmitting the target authorization token, executing step S3, and if invalid, transmitting the target authorization token to U n And sending an invalid data application response, and ending the current flow.
The target authorization token is valid after the target sharing type data entity is registered to before the target sharing type data entity is logged out, and is invalid after the target sharing type data entity is logged out. It should be noted that, only if the target shared type data entity exists in the memory resource and the data sharing module does not receive the request for canceling the target shared type data entity, the target shared type data entity is valid. If the target shared type data entity does not exist in the memory resource or exists, but the data sharing module has received the request for canceling the target shared type data entity, the target shared type data entity is invalid.
Step S3, U n And sending a target entity handle acquisition request to the data sharing module based on the valid target authorization token.
U is as follows n It is necessary to detect the target authorization before using the target authorization tokenIf the right token is valid, step S3 is executed again, and if not, the use of the target shared data is abandoned.
Step S4, the data sharing module transmits the data to the U n The target entity handle is sent.
It should be noted that, for the same target shared type data entity, multiple data usage modules may be used, so the data sharing module may send corresponding target entity handles to the multiple data usage modules, and each data usage module accesses the target shared type data entity based on the received corresponding target entity handle. Furthermore, the target entity handle is configured to be used only once and not to be duplicated, thereby ensuring the validity of the target entity handle.
As an embodiment, step S3 and step S4 may be performed specifically based on a c++ smart pointer. It is understood that other existing implementations are within the scope of this application. The embodiment of the invention avoids the problem that the handle effectiveness cannot be verified caused by using the common pointer, and avoids the problem that the log-off resources cannot be released caused by directly using the quotation technology mode for borrowing by using the authorization token management mode by using the mode of instantly exchanging the entity handle for use, thereby improving the robustness of EDA software.
Step S5, U n And accessing a target sharing type data entity based on the target entity handle, executing a target function based on the target sharing type data entity, and invalidating the target entity handle when the execution of the target function is completed.
Wherein U is n The access target sharing type data entity comprises read access and/or write access, and if the access target sharing type data entity comprises the read access and the write access, a corresponding read-write mechanism is set, wherein the read-write mechanism comprises read-before-write or read-before-write. And is determined according to the application scene.
It should be noted that, the target entity handle may be configured to automatically fail after the execution of the target function is completed, or an application interface may be set, and the target entity handle may be returned through the application interface after the execution is completed. Authorization token after failure of target entity handleIs still valid if U n And (5) the target shared type data entity is needed to be reused later, and the steps S3-S5 are directly executed based on the valid token.
As one embodiment, the system includes M data usage modules { I } 1 ，I 2 ，…I M M is a positive integer of 1 or more. When the processor executes the computer program, the following steps are also implemented:
step S10, I i Sending a first shared data type registration request to the data sharing module, I i And for the ith data initiating module, the value range of i is 1 to M.
Step S20, the data sharing module judges whether a corresponding first sharing type data entity exists in the current memory resource, and if the corresponding first sharing type data entity does not exist, the first sharing type data entity is generated in the memory resource.
Wherein, generating the first shared type data entity in the memory resource determines the life cycle start point of the shared type data entity. It should be noted that, the shared type data entity is in a single instance mode, each shared type corresponds to one shared type data entity, for example, each shared type data entity corresponds to one class of c++, and it can be understood that other existing implementation technologies also fall within the protection scope of the present invention. Each shared type data entity can only be registered once, and if the shared type data entity is registered, the registration is not repeated, so that the memory resource is saved.
As an embodiment, when the processor executes the computer program, the following steps are also implemented:
step S100, I j Sending a second shared data type cancellation request to the data sharing module, I j And j is a j-th data initiating module, and the value range of j is 1 to M.
Step 200, the data sharing module stops sending the corresponding authorization token issuing operation of the second sharing type data entity, and performs invalidation processing on the issued authorization token of the second sharing type data entity.
It should be noted that, after the issued authorization token of the second shared type data entity is invalidated, the issued authorization token of the second shared type data entity is in an invalid state, and the data usage module holding the authorization token of the second shared type data entity cannot initiate the obtaining request of the corresponding entity handle any more.
It will be appreciated that after step S200 is performed, there may still be some data usage modules that have acquired the corresponding entity handle, and the corresponding objective function has not yet been finished in the process of accessing the second shared type data entity, so that a corresponding buffer mechanism needs to be set to ensure that the execution of the corresponding objective function is completed. As an embodiment, the step S200 further includes:
and step S300, judging whether all the handles sent by the data sharing module are invalid, if yes, releasing the memory resources corresponding to the second sharing type data entity, otherwise, after all the handles sent by the data sharing module are invalid, releasing the memory resources corresponding to the second sharing type data entity.
The step S300 ensures the safety of the memory use of the last data use module through a slow release technology, and improves the robustness of EDA software.
And releasing the memory resources corresponding to the second shared type data entity, so that the second shared type data entity does not occupy the memory resources in the non-use stage, and the reasonable utilization of hardware resources is realized. It should be noted that the first shared data type and the second shared data type are the same type or are different types; i i And I j The same data initiation module or a different data initiation module. That is, for the same shared data, the transmitted shared data type registration request and the transmitted shared data type cancellation request may be the same data initiation module, or may be different data initiation modules. For example, in some application scenarios, the data initiating module sending a shared data type registration request may have exited the system when the end of the lifecycle of the shared data is reachedThus requiring other data initiation modules to send shared data type cancellation requests. The data initiating module and the data using module are the same module or different modules.
Based on the steps described in the embodiments of the present invention, fig. 2 further illustrates an interaction process between the data initiating module, the data using module and the data sharing module, and it should be noted that, for convenience of illustration, only one data initiating module and only one data using module are illustrated in fig. 2, but the number of data initiating modules and the number of data using modules may be multiple.
It should be noted that some exemplary embodiments are described as a process or a method depicted as a flowchart. Although a flowchart depicts steps as a sequential process, many of the steps may be implemented in parallel, concurrently, or with other steps. Furthermore, the order of the steps may be rearranged. The process may be terminated when its operations are completed, but may have additional steps not included in the figures. The processes may correspond to methods, functions, procedures, subroutines, and the like.
According to the embodiment of the invention, the life cycle of the shared data in the single-case mode is accurately controlled, so that the shared data is prevented from occupying memory resources in the unused stage, the life cycle can be set to be a cycle meeting the requirements of all data using modules, the I/O operation cost caused by frequently creating and releasing the memory is reduced, the CPU resource consumption is reduced, and the EDA software performance is improved; in addition, the problem that the handle effectiveness cannot be verified due to the fact that a common pointer is used is avoided through the mode of authorizing the token and the target entity handle, and the robustness of EDA software is improved. The invention simplifies the dependency relationship between the data initiating module and the data using module, which is many-to-many and various, by arranging the data sharing module, so that the data initiating module and the data using module are decoupled, and the maintainability of EDA software is improved.
The present invention is not limited to the above-mentioned embodiments, but is intended to be limited to the following embodiments, and any modifications, equivalents and modifications can be made to the above-mentioned embodiments without departing from the scope of the invention.
Claims (10)
1. A shared data processing system for EDA software, characterized in that,
the EDA software operates in a single process in a stand-alone environment, and the system includes at least one data initiating module, N data usage modules { U } 1 ，U 2 ，…U N A data sharing module, a processor, and a memory storing a computer program; each data initiating module and each data using module are connected with the data sharing module; the data sharing module is used for generating a shared type data entity in the memory resource based on the shared data type registration request sent by the data initiating module, and logging out the shared type data entity in the memory resource based on the shared data type logging-out request sent by the data initiating module; the sharing type data entity is in a single instance mode;
when the processor executes the computer program, the following steps are implemented:
step S1, U n Sending a target sharing type data use request to the data sharing module, U j A value range of N is 1 to N for the j-th data use module;
step S2, the data sharing module judges whether the corresponding target sharing type data entity in the memory resource is effective, if so, the data sharing module sends the data to the U n Transmitting the target authorization token, executing step S3, and if invalid, transmitting the target authorization token to U n Sending an invalid data application response; the target authorization token is valid after the target sharing type data entity is registered to the time before the target sharing type data entity is logged out, and is invalid after the target sharing type data entity is logged out;
step S3, U n Based on a valid target authorization token to the dataThe sharing module sends a target entity handle acquisition request;
step S4, the data sharing module transmits the data to the U n Transmitting a target entity handle;
step S5, U n And accessing a target sharing type data entity based on the target entity handle, executing a target function based on the target sharing type data entity, and invalidating the target entity handle when the execution of the target function is completed.
2. The system of claim 1, wherein the system further comprises a controller configured to control the controller,
the system includes M data usage modules { I } 1 ，I 2 ，…I M When the processor executes the computer program, the following steps are also implemented:
step S10, I i Sending a first shared data type registration request to the data sharing module, I i The value range of i is 1 to M for the ith data initiating module;
step S20, the data sharing module judges whether a corresponding first sharing type data entity exists in the current memory resource, and if the corresponding first sharing type data entity does not exist, the first sharing type data entity is generated in the memory resource.
3. The system of claim 2, wherein the system further comprises a controller configured to control the controller,
when the processor executes the computer program, the following steps are also implemented:
step S100, I j Sending a second shared data type cancellation request to the data sharing module, I j For the j-th data initiating module, the value range of j is 1 to M;
step 200, the data sharing module stops sending the corresponding authorization token issuing operation of the second sharing type data entity, and performs invalidation processing on the issued authorization token of the second sharing type data entity.
4. The system of claim 3, wherein the system further comprises a controller configured to control the controller,
the step S200 further includes:
and step S300, judging whether all the handles sent by the data sharing module are invalid, if yes, releasing the memory resources corresponding to the second sharing type data entity, otherwise, after all the handles sent by the data sharing module are invalid, releasing the memory resources corresponding to the second sharing type data entity.
5. The system of claim 3, wherein the system further comprises a controller configured to control the controller,
the first shared data type and the second shared data type are of the same type or of different types; i i And I j The same data initiation module or a different data initiation module.
6. The system of claim 1, wherein the system further comprises a controller configured to control the controller,
the data initiating module and the data using module are the same module or different modules.
7. The system of claim 1, wherein the system further comprises a controller configured to control the controller,
in the step S4, the target entity handle is configured to be used only once and not to be copied.
8. The system of claim 1, wherein the system further comprises a controller configured to control the controller,
each sharing type corresponds to a sharing type data entity, and each sharing type data entity corresponds to a class of C++.
9. The system of claim 1, wherein the system further comprises a controller configured to control the controller,
step S3 and step S4 are performed based on the c++ smart pointer.
10. The system of claim 1, wherein the system further comprises a controller configured to control the controller,
in the step S5, U n Access toThe target sharing type data entity comprises read access and/or write access, and if the target sharing type data entity comprises the read access and the write access, a corresponding read-write mechanism is set, wherein the read-write mechanism comprises read-before-write or read-before-write.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210762490.3A CN117369980A (en) | 2022-06-29 | 2022-06-29 | Shared data processing system for EDA software |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210762490.3A CN117369980A (en) | 2022-06-29 | 2022-06-29 | Shared data processing system for EDA software |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN117369980A true CN117369980A (en) | 2024-01-09 |
Family
ID=89406416
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202210762490.3A Pending CN117369980A (en) | 2022-06-29 | 2022-06-29 | Shared data processing system for EDA software |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117369980A (en) |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103268224A (en) * | 2013-05-08 | 2013-08-28 | 中国科学院微电子研究所 | Software operating platform based on web accessing manner |
| US20140280496A1 (en) * | 2013-03-14 | 2014-09-18 | Thoughtwire Holdings Corp. | Method and system for managing data-sharing sessions |
| CN110990858A (en) * | 2019-12-11 | 2020-04-10 | 中山大学 | Cross-cloud resource sharing system and method based on distributed information flow control |
| CN113271364A (en) * | 2021-07-16 | 2021-08-17 | 湖南红普创新科技发展有限公司 | Sharing system, method, computer device and storage medium of service arrangement data |
| CN113792318A (en) * | 2021-09-18 | 2021-12-14 | 上海数据交易中心有限公司 | Data authorization method and device, computer readable storage medium and computer equipment |
-
2022
- 2022-06-29 CN CN202210762490.3A patent/CN117369980A/en active Pending
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20140280496A1 (en) * | 2013-03-14 | 2014-09-18 | Thoughtwire Holdings Corp. | Method and system for managing data-sharing sessions |
| CN103268224A (en) * | 2013-05-08 | 2013-08-28 | 中国科学院微电子研究所 | Software operating platform based on web accessing manner |
| CN110990858A (en) * | 2019-12-11 | 2020-04-10 | 中山大学 | Cross-cloud resource sharing system and method based on distributed information flow control |
| CN113271364A (en) * | 2021-07-16 | 2021-08-17 | 湖南红普创新科技发展有限公司 | Sharing system, method, computer device and storage medium of service arrangement data |
| CN113792318A (en) * | 2021-09-18 | 2021-12-14 | 上海数据交易中心有限公司 | Data authorization method and device, computer readable storage medium and computer equipment |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN100422940C (en) | System and method of arbitrating access of threads to shared resources within a data processing system | |
| US8689221B2 (en) | Speculative thread execution and asynchronous conflict events | |
| US6226717B1 (en) | System and method for exclusive access to shared storage | |
| JP2531881B2 (en) | Concurrent control method | |
| US7650467B2 (en) | Coordination of multiprocessor operations with shared resources | |
| US20060259674A1 (en) | Apparatus and method for granting access to a hardware interface shared between multiple software entities | |
| WO2013080434A1 (en) | Dynamic process/object scoped memory affinity adjuster | |
| JP2002358136A (en) | Method and system for controlling use of software program | |
| CN101566977A (en) | Method, device and system of processor accessing shared data | |
| US8850129B2 (en) | Memory ordered store system in a multiprocessor computer system | |
| JP2008512787A (en) | System and method for secure running bus protection without deadlock of resources | |
| US20030163745A1 (en) | Method to reduce power in a computer system with bus master devices | |
| CN113742660A (en) | Application program permission management system and method | |
| CN117369980A (en) | Shared data processing system for EDA software | |
| EP0217350B1 (en) | Data transfer control unit and system | |
| US11294729B2 (en) | Resource provisioning for multiple invocations to an electronic design automation application | |
| EP4170503A1 (en) | Data reading method, data writing method, device, and system | |
| Dasari et al. | WCET analysis considering contention on memory bus in COTS-based multicores | |
| CN117539802B (en) | Cache operation method, system and related device | |
| CN114880036B (en) | Debugging method of debugging module for processing multi-core access in RISC-V system | |
| US20230244955A1 (en) | Decision Diagram-Based Management of a Computer System or its Part | |
| JPH07160645A (en) | Common resource exclusive control method in multiprocessor system | |
| US9223730B2 (en) | Virtual system management mode device and control method thereof | |
| JP2503287B2 (en) | Multi-function computer with survival confirmation function | |
| CN115202884A (en) | Method for reading, reading and writing lock of high-performance system based on polling and application |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |