CN113110928A - Multithreading starting method and multithreading starting system - Google Patents
Multithreading starting method and multithreading starting system Download PDFInfo
- Publication number
- CN113110928A CN113110928A CN202110429777.XA CN202110429777A CN113110928A CN 113110928 A CN113110928 A CN 113110928A CN 202110429777 A CN202110429777 A CN 202110429777A CN 113110928 A CN113110928 A CN 113110928A
- Authority
- CN
- China
- Prior art keywords
- driver
- resource
- thread
- accessed
- communication interface
- 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
- 238000000034 method Methods 0.000 title claims abstract description 51
- 238000004891 communication Methods 0.000 claims abstract description 45
- 230000006870 function Effects 0.000 claims description 43
- 230000007717 exclusion Effects 0.000 claims description 12
- 238000012545 processing Methods 0.000 claims description 6
- 238000004590 computer program Methods 0.000 claims description 4
- 230000004044 response Effects 0.000 claims description 3
- 238000012795 verification Methods 0.000 abstract description 19
- 238000004088 simulation Methods 0.000 abstract description 8
- 238000011161 development Methods 0.000 abstract description 7
- 230000008569 process Effects 0.000 description 7
- 238000013461 design Methods 0.000 description 2
- 238000010586 diagram Methods 0.000 description 2
- 230000002452 interceptive effect Effects 0.000 description 2
- 239000000463 material Substances 0.000 description 2
- 230000003287 optical effect Effects 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000010354 integration Effects 0.000 description 1
- 230000003993 interaction Effects 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 239000013307 optical fiber Substances 0.000 description 1
- 238000004904 shortening Methods 0.000 description 1
Images
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/48—Program initiating; Program switching, e.g. by interrupt
- G06F9/4806—Task transfer initiation or dispatching
- G06F9/4843—Task transfer initiation or dispatching by program, e.g. task dispatcher, supervisor, operating system
-
- 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/52—Program synchronisation; Mutual exclusion, e.g. by means of semaphores
- G06F9/526—Mutual exclusion algorithms
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The invention provides a thread starting method and a thread starting system, belongs to the field of system-on-chip chips, and can solve the problems that a C or C + + driver for multi-thread parallel starting is relatively complex and has a long period in the existing development in software and hardware combined simulation verification. The thread starting method comprises the following steps: the first driver sends a function calling instruction to the second driver through a preset communication interface; the second driver program runs the thread starting function according to the function calling instruction so as to send a plurality of thread starting instructions to the first driver program through a preset communication interface; the first driving program starts the corresponding threads according to the thread starting instructions.
Description
Technical Field
The disclosure belongs to the field of system-on-chip chips, and particularly relates to a multithreading starting method and a multithreading starting system.
Background
A System on Chip (SoC) Chip is a Chip with a very high integration level, has a very large logic scale, and is limited by an Electronic Design Automation (EDA) tool speed in System-level simulation verification, so that the simulation verification speed is slow. In order to improve the efficiency of simulation verification, part of the simulation verification can directly execute the C/C + + driver by using a Systemverilog DPI interface, and under the condition, the Systemverilog driver is mainly responsible for simulating a verification environment and providing an interactive interface between the C/C + + driver and a verification object, and the C/C + + driver is mainly responsible for specific control. In the actual development of the C/C + + driver, part of codes can involve multithread starting, but threads started by the C/C + + driver in a standard mode cannot call a DPI interface to directly interact with a verification object, and the C/C + + driver which involves multithread parallel starting is developed, so that the C/C + + driver is complex and has a long period.
Disclosure of Invention
The present disclosure is directed to at least one of the technical problems in the prior art, and provides a multithread starting method and a multithread starting system.
In a first aspect, the present disclosure provides a multithreading starting method, including:
the first driver sends a function calling instruction to the second driver through a preset communication interface;
the second driver program runs a thread starting function according to the function calling instruction so as to send a plurality of thread starting instructions to the first driver program through the preset communication interface;
and the first driving program starts a plurality of corresponding threads according to the thread starting instructions.
Optionally, the first driver starts a plurality of corresponding threads according to the plurality of thread start instructions, and then further includes:
a first thread running in the first driver sends a resource locking instruction to a second driver through the preset communication interface, wherein the resource locking instruction comprises resource information of a resource to be accessed;
in response to that the resource to be accessed is in an unlocked state, the second driver performs locking processing on the resource to be accessed according to the resource locking instruction, so that the resource to be accessed is in a locked state, and feeds back locking success information to a first thread running in the first driver;
and the first thread in the first driver accesses the resource to be accessed.
Optionally, the first thread in the first driver accesses the resource to be accessed, and then further includes:
the first thread in the first driver program sends a resource unlocking instruction to the second driver program through the preset communication interface, wherein the resource locking instruction comprises resource information of a resource to be unlocked;
and the second driver unlocks the corresponding resource according to the resource unlocking instruction so as to enable the resource to be unlocked to be in an unlocked state.
Optionally, the second driver performs locking processing on the resource to be accessed according to the resource locking instruction, so that the resource to be accessed is in a locked state, and then the method further includes:
a second thread running in the first driver program sends a resource locking instruction to the second driver program through the preset communication interface, wherein the resource locking instruction comprises resource information of the resource to be accessed;
and responding to the situation that the resource to be accessed is in a locked state, the second driver program monitors the state of the resource to be accessed, and when the situation that the resource to be accessed is in an unlocked state is monitored, the second driver program locks the resource to be accessed, so that the resource to be accessed is in the locked state, and the second driver program feeds back locking success information to the second thread running in the first driver program.
Optionally, the first driver starts a plurality of corresponding threads according to the plurality of thread start instructions, and before starting, the method further includes:
the first driver sends a mutual exclusion lock function initialization instruction to the second driver through the preset communication interface;
and the second driving program initializes the self mutual exclusion lock function according to the mutual exclusion lock function initialization instruction.
Optionally, the first driver is written in a C language or a C + + language; and the second driver is written by adopting Systemverilog language.
Optionally, the sending, by the second driver, a plurality of thread start instructions to the first driver through the preset communication interface includes:
and the second driver sends a plurality of thread starting instructions to the first driver through the preset communication interface in a non-waiting execution mode.
Optionally, the preset communication interface includes: a DPI-C interface.
In a second aspect, the present disclosure provides a multi-threaded start-up system comprising: a first driver and a second driver;
the first driver is used for sending a function calling instruction to the second driver through a preset communication interface;
the second driver is used for running a thread starting function according to the function calling instruction so as to send a plurality of thread starting instructions to the first driver through the preset communication interface;
the first driver is further configured to start a plurality of corresponding threads according to the plurality of thread start instructions.
In a third aspect, the present disclosure provides a computer readable storage medium having stored thereon a computer program which, when executed by a processor, implements the multi-thread boot method as provided above.
Drawings
FIG. 1 is a schematic diagram of an exemplary chip emulation verification environment;
fig. 2 is a flowchart illustrating a multithread starting method according to an embodiment of the disclosure;
FIG. 3 is a flowchart illustrating another multithread starting method according to an embodiment of the disclosure;
FIG. 4 is a flowchart illustrating a multithread starting method according to an embodiment of the present disclosure;
fig. 5 is a flow chart of yet another multithreading starting method for use in embodiments of the present disclosure.
Detailed Description
For a better understanding of the technical aspects of the present disclosure, reference is made to the following detailed description taken in conjunction with the accompanying drawings.
Unless otherwise defined, technical or scientific terms used herein shall have the ordinary meaning as understood by one of ordinary skill in the art to which this disclosure belongs. The use of "first," "second," and similar terms in this disclosure is not intended to indicate any order, quantity, or importance, but rather is used to distinguish one element from another. Also, the use of the terms "a," "an," or "the" and similar referents do not denote a limitation of quantity, but rather denote the presence of at least one. The word "comprising" or "comprises", and the like, means that the element or item listed before the word covers the element or item listed after the word and its equivalents, but does not exclude other elements or items. The terms "connected" or "coupled" and the like are not restricted to physical or mechanical connections, but may include electrical connections, whether direct or indirect. "upper", "lower", "left", "right", and the like are used merely to indicate relative positional relationships, and when the absolute position of the object being described is changed, the relative positional relationships may also be changed accordingly.
Fig. 1 is a schematic structural diagram of an exemplary chip emulation verification environment, and as shown in fig. 1, a sytemeric driver 20 and a C/C + + driver 30 together form a chip emulation verification environment 10, and then are imported into an EDA tool 50 together with a verification object 40 for compiling and running. The Systemverilog driver is mainly responsible for simulating a verification environment and providing an interactive interface between the C/C + + driver and a verification object, and the C/C + + driver is mainly responsible for specific control. In the actual development of the C/C + + driver, part of codes can involve multithreading operation, but a sub-thread started by the C/C + + driver in a standard mode cannot call a DPI interface to directly interact with a verification object, and the development of the C/C + + driver involving multithreading parallel starting is complex and has a long period.
In order to solve at least one of the above technical problems and enable a chip emulation verification process to be separated from an operating system and a driver to be directly loaded, an embodiment of the present disclosure provides a multithread starting method and a multithread starting system. The multithreading starting method and the multithreading starting system provided by the embodiments of the present disclosure will be described in further detail with reference to the accompanying drawings and the detailed description.
In a first aspect, an embodiment of the present disclosure provides a multithread starting method, and fig. 2 is a schematic flowchart of the multithread starting method provided by the embodiment of the present disclosure, as shown in fig. 2, the multithread starting method includes the following steps:
in step S201, the first driver sends a function call instruction to the second driver through a preset communication interface.
In the embodiment of the present disclosure, the first driver and the second driver establish a communication connection through a preset communication interface, the first driver may be an original driver corresponding to the chip to be verified, wherein a plurality of threads may be provided, and the second driver may be a driver written for facilitating multi-thread starting and may be composed of a plurality of thread starting functions. In the simulation verification process, the first driver can directly call the preset communication interface, establish communication connection with the second program and send a function call instruction to the second program. The function call instruction may include the number of threads to be started at the same time, for example, 4 threads may be started at the same time. It is understood that the number of threads may be set according to the type of the chip to be verified, and is not listed here.
In step S202, the second driver runs the thread start function according to the function call instruction, so as to send a plurality of thread start instructions to the first driver through the preset communication interface.
In step S202, the second driver receives the function call instruction sent by the first driver, and may run a thread start function in the second program, where the thread start function may generate a plurality of thread start instructions in the running process, where each thread start instruction may start a thread correspondingly.
In step S203, the first driver starts a plurality of corresponding threads according to the plurality of thread start instructions.
In step S203, after receiving the thread instruction sent by the second driver, the first driver may start a plurality of corresponding threads, so that the chip to be tested operates, and thus, whether the chip to be tested is normal is determined.
In the embodiment of the disclosure, the second program is provided with the thread starting function, and the first program can directly call and run the thread starting function of the second program by using the preset communication interface to start the corresponding thread, so that the plurality of threads can be directly started by combining the preset communication interface without depending on the operating system, and therefore, a driver program which excessively depends on the operating system does not need to be developed, the development cycle of the driver program can be shortened, and the chip simulation verification efficiency is greatly improved.
In some embodiments, fig. 3 is a flowchart illustrating another multithread starting method according to an embodiment of the present disclosure, as shown in fig. 3, the method includes the above steps S201 to S203, where in step S203, the first driver starts a plurality of threads according to a plurality of thread starting instructions, and then further includes:
step S204, a first thread running in the first driver sends a resource locking instruction to the second driver through a preset communication interface, wherein the resource locking instruction comprises resource information of a resource to be accessed.
In step S204, for example, two threads are started simultaneously, and both threads need to access the same resource, one of the threads may be referred to as a first thread, and the other thread may be referred to as a second thread. Because the same resource can be accessed by only one thread at the same time, when the first thread needs to access the resource, the first thread can send a resource locking instruction to the second driver through the preset communication interface, and inquire the resource information of the resource to be accessed so as to ensure that the first thread can access the resource at the moment.
S205, in response to the fact that the resource to be accessed is in an unlocked state, the second driver performs locking processing on the resource to be accessed according to the resource locking instruction, so that the resource to be accessed is in a locked state, and feeds back locking success information to the first thread running in the first driver.
S206, the first thread in the first driving program accesses the resource to be accessed.
In step S205 and step S206, when the resource to be accessed is in the unlocked state, the first thread may access the resource, and the second program may lock the resource to be accessed according to the resource locking instruction and feed back the locking success information to the first thread, so that the resource to be accessed may be in the locked state to prevent other threads (e.g., the second thread) from accessing the resource, and avoid mutual interference between different threads, thereby effectively solving the mutual exclusion problem between different threads.
In some embodiments, as shown in fig. 3, the thread starting method includes steps S201 to S206 described above, and in step S206, the first thread in the first driver accesses the resource to be accessed, and then further includes:
step S207, the first thread in the first driver sends a resource unlocking instruction to the second driver through the preset communication interface, where the resource locking instruction includes resource information of the resource to be unlocked.
And step S208, the second driver unlocks the corresponding resource according to the resource unlocking instruction so as to enable the resource to be unlocked to be in an unlocked state.
In steps S207 and S208, during the process that the first thread accesses a certain resource, the resource is in a locked state, and other threads can be prevented from accessing the resource. After the first thread finishes accessing the resource, the first thread can send a resource unlocking instruction to the second driver through the preset communication interface so as to unlock the resource. After receiving the resource unlocking instruction, the second driver may unlock the resource, so that the resource is in an unlocked state, and at this time, the resource may be prepared for access by other threads.
In some embodiments, fig. 4 is a schematic flowchart of a thread starting method provided by an embodiment of the present disclosure, as shown in fig. 4, the thread starting method includes the above steps S201 to S205, and in step S205, the second driver locks the resource to be accessed according to the resource locking instruction, so that the resource to be accessed is in a locked state, and then further includes:
s401, a second thread running in the first driver sends a resource locking instruction to the second driver through a preset communication interface, wherein the resource locking instruction comprises resource information of a resource to be accessed.
S402, responding to the situation that the resource to be accessed is in the locked state, the second driver monitors the state of the resource to be accessed, and when the situation that the resource to be accessed is in the unlocked state is monitored, locking processing is carried out on the resource to be accessed, so that the resource to be accessed is in the locked state, and locking success information is fed back to a second thread running in the first driver.
In steps S401 and S402, when the second thread needs to access the resource, the second thread may perform a locking process on the resource, similar to the above-mentioned first thread accessing the resource, to prevent other threads from accessing the resource. The second thread can monitor the state of the resource in real time, and when the fact that the resource is in the unlocking state after the fact that the access of the first thread is finished is monitored, the second thread can lock the resource so as to access the resource.
In some embodiments, fig. 5 is a schematic flowchart of a thread starting method according to an embodiment of the present disclosure, as shown in fig. 5, the thread starting method includes the above steps S201 to S203, and in step S203, the first driver starts a corresponding plurality of threads according to a plurality of thread starting instructions, before further including:
step 501, the first driver sends a mutual exclusion lock function initialization instruction to the second driver through a preset communication interface.
Step 502, the second driver initializes the mutual exclusion lock function according to the mutual exclusion lock function initialization instruction.
In steps S501 and S502, an initialization instruction may be sent to the second driver to initialize the mutex function in the second driver, so as to ensure that each thread can access a certain resource. After the access of each thread is finished, the mutual exclusion lock function can be initialized so as to ensure that the function is normal when each thread is opened next time.
In some embodiments, the first driver is written in C language or C + + language; the second driver is written in Systemverilog language.
It should be noted that, the first driver is written in C language or C + + language; the second driver is compiled by adopting Systemverilog language, and the multithreading characteristic and semaphore design of the Systemverilog language can easily meet the multithreading unlocking and the inter-thread mutual exclusion locking function, so that the development period of compiling the driver by C language or C + + language can be shortened, and the chip simulation verification efficiency is greatly improved.
In some embodiments, the second driver sends a plurality of thread starting instructions to the first driver through the preset communication interface, including: and the second driver sends a plurality of thread starting instructions to the first driver through the preset communication interface in a non-waiting execution mode.
It should be noted that the multi-thread start may be performed in a wait-free execution manner, and the code of the multi-thread start is fork.
In some embodiments, the preset communication interface comprises: a DPI-C interface.
It should be noted that the preset communication interface may be a DPI-C interface, that is, a direct programming interface, and may implement direct interaction between the C or C + + driver and the systeverilog driver, so that the driver may be loaded without an operating system, thereby shortening the development period of the C or C + + driver.
In a second aspect, an embodiment of the present disclosure provides a multi-thread boot system, including: a first driver and a second driver; the first driver is used for sending a function calling instruction to the second driver through a preset communication interface; the second driver is used for running the thread starting function according to the function calling instruction so as to send a plurality of thread starting instructions to the first driver through the preset communication interface; the first driver is further configured to start the corresponding plurality of threads according to the plurality of thread start instructions.
In the multithreading starting system provided by the embodiment of the present disclosure, the first driver and the second driver interact with each other through the preset communication interface, and the multithreading starting method can be executed.
In a third aspect, the present disclosure provides a computer-readable storage medium, on which a computer program is stored, where the computer program, when executed by a processor, implements the multithread starting method in any of the above embodiments. The implementation principle and the beneficial effect are the same as those of the multithread starting method, and are not described herein again.
More specific examples (a non-exhaustive list) of the computer-readable medium would include the following: an electrical connection (electronic device) having one or more wires, a portable computer diskette (magnetic device), a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber device, and a portable read-only memory (CDROM). Additionally, the computer-readable medium could even be paper or another suitable medium upon which the program is printed, as the program can be electronically captured, via for instance optical scanning of the paper or other medium, then compiled, interpreted or otherwise processed in a suitable manner if necessary, and then stored in a computer memory.
It should be understood that portions of the present invention may be implemented in hardware, software, firmware, or a combination thereof. In the above embodiments, the various steps or methods may be implemented in software or firmware stored in memory and executed by a suitable instruction execution system. For example, if implemented in hardware, as in another embodiment, any one or combination of the following techniques, which are known in the art, may be used: a discrete logic circuit having a logic gate circuit for implementing a logic function on a data signal, an application specific integrated circuit having an appropriate combinational logic gate circuit, a Programmable Gate Array (PGA), a Field Programmable Gate Array (FPGA), or the like.
It will be understood by those skilled in the art that all or part of the steps carried by the method for implementing the above embodiments may be implemented by hardware related to instructions of a program, which may be stored in a computer readable storage medium, and when the program is executed, the program includes one or a combination of the steps of the method embodiments.
In addition, functional units in the embodiments of the present invention may be integrated into one processing module, or each unit may exist alone physically, or two or more units are integrated into one module. The integrated module can be realized in a hardware mode, and can also be realized in a software functional module mode. The integrated module, if implemented in the form of a software functional module and sold or used as a separate product, may also be stored in a computer readable storage medium. The storage medium may be a read-only memory, a magnetic or optical disk, or the like.
In the description herein, references to the description of the term "one embodiment," "some embodiments," "an example," "a specific example," or "some examples," etc., mean that a particular feature, structure, material, or characteristic described in connection with the embodiment or example is included in at least one embodiment or example of the invention. Furthermore, the particular features, structures, materials, or characteristics described may be combined in any suitable manner in any one or more embodiments or examples. Furthermore, various embodiments or examples and features of different embodiments or examples described in this specification can be combined and combined by one skilled in the art without contradiction.
Furthermore, the terms "first", "second" and "first" are used for descriptive purposes only and are not to be construed as indicating or implying relative importance or implicitly indicating the number of technical features indicated. Thus, a feature defined as "first" or "second" may explicitly or implicitly include at least one such feature. In the description of the present invention, "a plurality" means two or more unless specifically defined otherwise.
Any process or method descriptions in flow charts or otherwise described herein may be understood as representing modules, segments, or portions of code which include one or more executable instructions for implementing specific logical functions or steps of the process, and alternate implementations are included within the scope of the preferred embodiment of the present invention in which functions may be executed out of order from that shown or discussed, including substantially concurrently or in reverse order, depending on the functionality involved, as would be understood by those reasonably skilled in the art of the present invention.
The logic and/or steps represented in the flowcharts or otherwise described herein, e.g., an ordered listing of executable instructions that can be considered to implement logical functions, can be embodied in any computer-readable medium for use by or in connection with an instruction execution system, apparatus, or device, such as a computer-based system, processor-containing system, or other system that can fetch the instructions from the instruction execution system, apparatus, or device and execute the instructions. For the purposes of this description, a "computer-readable medium" can be any means that can contain, store, communicate, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device.
It is to be understood that the above embodiments are merely exemplary embodiments that are employed to illustrate the principles of the present disclosure, and that the present disclosure is not limited thereto. It will be apparent to those skilled in the art that various changes and modifications can be made therein without departing from the spirit and scope of the disclosure, and these are to be considered as the scope of the disclosure.
Claims (10)
1. A method for multi-threaded booting, comprising:
the first driver sends a function calling instruction to the second driver through a preset communication interface;
the second driver program runs a thread starting function according to the function calling instruction so as to send a plurality of thread starting instructions to the first driver program through the preset communication interface;
and the first driving program starts a plurality of corresponding threads according to the thread starting instructions.
2. The method of claim 1, wherein the first driver launches a corresponding plurality of threads according to a plurality of the thread launch instructions, and thereafter further comprising:
a first thread running in the first driver sends a resource locking instruction to a second driver through the preset communication interface, wherein the resource locking instruction comprises resource information of a resource to be accessed;
in response to that the resource to be accessed is in an unlocked state, the second driver performs locking processing on the resource to be accessed according to the resource locking instruction, so that the resource to be accessed is in a locked state, and feeds back locking success information to a first thread running in the first driver;
and the first thread in the first driver accesses the resource to be accessed.
3. The method of claim 2, wherein a first thread in the first driver accesses the resource to be accessed, and thereafter further comprising:
the first thread in the first driver program sends a resource unlocking instruction to the second driver program through the preset communication interface, wherein the resource locking instruction comprises resource information of a resource to be unlocked;
and the second driver unlocks the corresponding resource according to the resource unlocking instruction so as to enable the resource to be unlocked to be in an unlocked state.
4. The multithread starting method of claim 2, wherein the second driver locks the resource to be accessed according to the resource locking instruction, so that the resource to be accessed is in a locked state, and then further comprising:
a second thread running in the first driver program sends a resource locking instruction to the second driver program through the preset communication interface, wherein the resource locking instruction comprises resource information of the resource to be accessed;
and responding to the situation that the resource to be accessed is in a locked state, the second driver program monitors the state of the resource to be accessed, and when the situation that the resource to be accessed is in an unlocked state is monitored, the second driver program locks the resource to be accessed, so that the resource to be accessed is in the locked state, and the second driver program feeds back locking success information to the second thread running in the first driver program.
5. The method of claim 1, wherein the first driver launches a corresponding plurality of threads according to a plurality of the thread launch instructions, and further comprising:
the first driver sends a mutual exclusion lock function initialization instruction to the second driver through the preset communication interface;
and the second driving program initializes the self mutual exclusion lock function according to the mutual exclusion lock function initialization instruction.
6. The multithreading method of claim 1, wherein the first driver is written in a C language or a C + + language; and the second driver is written by adopting Systemverilog language.
7. The multithreading method of claim 1, wherein the second driver sends a plurality of thread start instructions to the first driver via the predetermined communication interface, and the method comprises:
and the second driver sends a plurality of thread starting instructions to the first driver through the preset communication interface in a non-waiting execution mode.
8. The multithreading method of claim 1, wherein the default communication interface comprises: a DPI-C interface.
9. A multi-threaded boot system, the multi-threaded boot system comprising: a first driver and a second driver;
the first driver is used for sending a function calling instruction to the second driver through a preset communication interface;
the second driver is used for running a thread starting function according to the function calling instruction so as to send a plurality of thread starting instructions to the first driver through the preset communication interface;
the first driver is further configured to start a plurality of corresponding threads according to the plurality of thread start instructions.
10. A computer-readable storage medium, on which a computer program is stored, which, when being executed by a processor, carries out the multithread starting method according to any one of claims 1 to 8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110429777.XA CN113110928A (en) | 2021-04-21 | 2021-04-21 | Multithreading starting method and multithreading starting system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110429777.XA CN113110928A (en) | 2021-04-21 | 2021-04-21 | Multithreading starting method and multithreading starting system |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN113110928A true CN113110928A (en) | 2021-07-13 |
Family
ID=76719363
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110429777.XA Pending CN113110928A (en) | 2021-04-21 | 2021-04-21 | Multithreading starting method and multithreading starting system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113110928A (en) |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20110161539A1 (en) * | 2009-12-31 | 2011-06-30 | International Business Machines Corporation | Opportunistic use of lock mechanism to reduce waiting time of threads to access a shared resource |
| CN102567122A (en) * | 2010-12-27 | 2012-07-11 | 北京国睿中数科技股份有限公司 | Communication interface method of processor reference model under multiple simulation and verification platforms |
| CN102725735A (en) * | 2011-11-02 | 2012-10-10 | 华为技术有限公司 | Method and system for multithreading collaborative simulations |
| CN108345452A (en) * | 2017-01-23 | 2018-07-31 | 阿里巴巴集团控股有限公司 | A kind of thread management method and device |
-
2021
- 2021-04-21 CN CN202110429777.XA patent/CN113110928A/en active Pending
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20110161539A1 (en) * | 2009-12-31 | 2011-06-30 | International Business Machines Corporation | Opportunistic use of lock mechanism to reduce waiting time of threads to access a shared resource |
| CN102567122A (en) * | 2010-12-27 | 2012-07-11 | 北京国睿中数科技股份有限公司 | Communication interface method of processor reference model under multiple simulation and verification platforms |
| CN102725735A (en) * | 2011-11-02 | 2012-10-10 | 华为技术有限公司 | Method and system for multithreading collaborative simulations |
| CN108345452A (en) * | 2017-01-23 | 2018-07-31 | 阿里巴巴集团控股有限公司 | A kind of thread management method and device |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN105511969B (en) | Method for mutual exclusion between cross-process threads | |
| US8694997B2 (en) | Deterministic serialization in a transactional memory system based on thread creation order | |
| US20080098264A1 (en) | Program debug method and apparatus | |
| CN104008060B (en) | Method for detecting compatibility of plug-in and host, and detection server | |
| CN106681836B (en) | Semaphore creation method and semaphore creation device | |
| US7574696B2 (en) | Multiprocessor application interface requiring no utilization of a multiprocessor operating system | |
| CN106716348A (en) | Shared resources in a data processing appartus for executing a plurality of threads | |
| US8595726B2 (en) | Apparatus and method for parallel processing | |
| CN107544815A (en) | A kind of startup method and device of multicomputer system | |
| KR101875225B1 (en) | Process, computer program, and device for security of intermediate code of programming for the execution thereof by a virtual machine | |
| US9715356B2 (en) | Method, apparatus and system for determining a merged intermediate representation of a page | |
| CN108345452B (en) | Thread management method and device | |
| CN111666210A (en) | Chip verification method and device | |
| CN112181388B (en) | Initializing method and device of SDK (software development kit) component, storage medium and control terminal | |
| US9021483B2 (en) | Making hardware objects and operations thread-safe | |
| US11599342B2 (en) | Pathname independent probing of binaries | |
| CN113110928A (en) | Multithreading starting method and multithreading starting system | |
| WO2007049284A1 (en) | Memory access control | |
| CN110289043B (en) | Storage device testing method and device and electronic device | |
| CN104346306A (en) | System and method of high integrity DMA operation | |
| US9395987B2 (en) | Method and device for detecting a race condition | |
| US8510543B1 (en) | Firmware supporting multiple boot paths | |
| EP4318211A1 (en) | Method for inspecting code under weak memory order architecture, and corresponding device | |
| CN106648911B (en) | Key jitter removal method and device | |
| CN112415307B (en) | ATS instrument resource control method for parallel test |
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 | ||
| CB02 | Change of applicant information |
Address after: 230088 north, 9th floor, B1 building, animation base, 800 Wangjiang West Road, high tech Zone, Hefei City, Anhui Province Applicant after: Hongjing Microelectronics Technology Co.,Ltd. Address before: 230088 north, 9th floor, B1 building, animation base, 800 Wangjiang West Road, high tech Zone, Hefei City, Anhui Province Applicant before: HEFEI MACROSILICON TECHNOLOGY CO.,LTD. |
|
| CB02 | Change of applicant information |