CN114253837A - Multithreading debugging method and system for ATE (automatic test equipment) tester program and tester table - Google Patents
Multithreading debugging method and system for ATE (automatic test equipment) tester program and tester table Download PDFInfo
- Publication number
- CN114253837A CN114253837A CN202111387510.5A CN202111387510A CN114253837A CN 114253837 A CN114253837 A CN 114253837A CN 202111387510 A CN202111387510 A CN 202111387510A CN 114253837 A CN114253837 A CN 114253837A
- Authority
- CN
- China
- Prior art keywords
- function
- debugging
- executed
- thread
- breakpoint
- 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.)
- Granted
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Debugging And Monitoring (AREA)
Abstract
The invention provides a multithreading debugging method and system of an ATE (automatic test equipment) tester program and a tester table. The method comprises the following steps: setting a current breakpoint of a test machine program through an upper computer, and sending a function name of a function to be executed to the test machine program; the debugging thread continuously receives the function name sent by the upper computer, translates the function name into an actual function address and fills a relevant variable value to obtain a process internal address; executing the function to be executed in a preset test machine process, and feeding back an execution result to an upper computer; and when the function names are completely sent and all the functions to be executed are completely executed, the debugging thread executes the current breakpoint. The invention realizes the breakpoint debugging of the test machine program by constructing a debugging thread independent of other threads, and other threads can normally run when the debugging thread is in a breakpoint state, thereby realizing the tests of single step debugging, breakpoint information query, function call and the like without being limited by multiple threads.
Description
Technical Field
The invention relates to the field of semiconductor chip testing, in particular to a multithreading debugging method and system of an ATE (automatic test equipment) tester program and a tester table.
Background
Ate (automatic Test equipment) is an automatic Test device, which is an aggregate of high-performance computer-controlled Test instruments, and is a Test system composed of a tester and a computer, and the computer controls Test hardware by running instructions of a tester program. Semiconductor ATE is used to test the integrity of the function and performance of an integrated circuit, and is an important device for ensuring the quality of the integrated circuit in the production and manufacturing process of the integrated circuit.
In the chip testing process, except for a testing machine table, a sorting machine and a chip to be tested, software is important and controls the whole testing process and the cooperation among all parts. Generally, a test factory writes and debugs a test program before formal batch testing, can strictly debug and pass the test program after various hardware problems, software problems and configuration problems are eliminated, and can only put into operation in formal batch after a chip is normally tested. The debug function is important in the process of testing the programming. Developers often need to step through, modify configurations, execute functions to quickly call through test programs.
The debugging function of the testing machine is essentially different from that of a common debugging tool (such as gdb of linux): the debugging function is an internal function embedded in the testing machine and is not a single program. In addition, a large amount of machine data information needs to be displayed graphically in the single-step debugging process to help developers to debug, and common tester manufacturers can develop similar debugging functions by themselves.
At present, a common debugging means of ATE equipment is to use Windows debug api of Windows itself to implement a set of debugging functions, and a schematic diagram of a principle of the scheme is shown in fig. 1 of the specification. However, the set of api does not support the non-stop mode, that is, as long as a breakpoint is entered, all threads stop, which limits many function debugging and information collection related to other threads. For efficient chip testing, the tester programs are multi-threaded. By adopting the windows debug api, once a breakpoint, single step debugging or other function calls at the breakpoint are realized, functions deployed on other threads can be stopped, and functions on other related threads can not be called or information can not be acquired, so that a great deal of limitation and inconvenience are brought to the debugging process of the test program.
In addition, another scheme for simulating gdb of Linux to debug the ATE device in a mingw environment is shown in fig. 2 in the specification. However, this scheme apparently uses gdb interface, and debugs the tester program through gdb, but actually calls Windows debug api, and does not support non-stop mode, and has the same disadvantages as the above scheme, and multi-thread debugging cannot be realized.
Therefore, a solution for multi-thread debugging of a tester program is needed to solve the above problems.
Disclosure of Invention
In view of this, the present invention provides a multithreading debugging method, system and test machine for ATE tester program, and the specific scheme is as follows:
a multithreading debugging method of an ATE tester program comprises the following steps:
setting a current breakpoint of a test machine program through an upper computer, taking a function to be executed before the current breakpoint as a function to be executed, and sending a function name of the function to be executed to the test machine program through the upper computer;
a debugging thread is configured in the test machine program, the debugging thread continuously receives the function name sent by the upper computer, the function name is translated into an actual function address through a preset address translator, and a relevant variable value is filled in the actual function address to obtain an in-process address; wherein the debugging thread is independent of other threads in the tester program;
executing the function to be executed in the process of a preset test machine according to the in-process address, and feeding back an execution result to the upper computer;
and when the upper computer sends all the function names of all the functions to be executed before the current breakpoint and all the functions to be executed are completely executed, the debugging thread executes the current breakpoint and waits for receiving a new function name.
In a particular embodiment, when a current breakpoint is selected to be skipped, the debugging thread stops executing the current breakpoint;
and the upper computer continuously sends the function name of the function to be executed in the test machine program to the test machine program, and the debugging thread receives the new function name.
In a specific embodiment, the multithread debugging method further includes:
setting all functions and global variables related in the debugging process as a dynamic link library;
if the function to be executed is recorded in the test machine program, the debugging thread translates the function name of the function to be executed into an actual function address through the dynamic link library, and fills in a relevant variable value to obtain an address in a process.
In one particular embodiment, when the debugging thread executes a current breakpoint,
in the test machine program, other threads except the debugging thread run normally;
the debugging thread may call functions of other threads or obtain information of other threads.
In a specific embodiment, the multithread debugging method further includes:
modifying variable values of internal functions located inside the tester process;
and a process function translator is preset in the debugging thread, the address translation is carried out on the internal function through the process function translator, the modified variable value is filled in, and a process address is obtained and executed so as to realize the debugging of the internal function.
In a specific embodiment, the multithread debugging method further includes:
and after the in-process address is obtained, adding the in-process address into a preset execution queue, and sequentially executing the functions in the execution queue, thereby realizing multi-user debugging.
A multi-threaded debugging system of an ATE tester program, the multi-threaded debugging system comprising:
breakpoint setting unit: the device comprises an upper computer, a function module and a test machine program, wherein the upper computer is used for setting a breakpoint of the test machine program, taking a function which needs to be executed before the current breakpoint as a function to be executed, and sending a function name of the function to be executed to the test machine program through the upper computer;
an address translation unit: the testing machine program is provided with a debugging thread which is used for continuously receiving the function name sent by the upper computer through the debugging thread, translating the function name into an actual function address through a preset address translator and filling a relevant variable value into the actual function address to obtain an address in a process; wherein the debugging thread is independent of other threads in the tester program;
a function execution unit: the function to be executed is executed in the process of a preset test machine according to the in-process address, and an execution result is fed back to the upper computer;
a breakpoint execution unit: and the debugging thread is used for executing the current breakpoint and waiting for receiving a new function name when the upper computer sends all the function names of all the functions to be executed before the current breakpoint and the functions to be executed are all executed.
In one embodiment, the multi-threaded debugging system further comprises,
a breakpoint skipping unit: the debugging thread is used for stopping executing the current breakpoint when the current breakpoint is selected to be skipped; and the upper computer continuously sends the function name of the function to be executed in the test machine program to the test machine program, and the debugging thread receives the new function name.
In one embodiment, the multi-thread debugging system further comprises:
setting all functions and global variables related in the debugging process as a dynamic link library;
if the function to be executed is recorded in the test machine program, the debugging thread translates the function name of the function to be executed into an actual function address through the dynamic link library, and fills in a relevant variable value to obtain an address in a process.
A test machine platform is applied to ATE equipment, and a software module of the test machine platform is configured with the multithreading debugging system.
Has the advantages that: the invention provides a multithreading debugging method and system of an ATE (automatic test equipment) tester program and a tester table, which solve the problem of breakpoints caused by multithreading in the debugging process of the tester program. The scheme of the invention can be suitable for debugging the test machine program in mainstream operation environments such as Windows environment. The breakpoint debugging of the tester program is realized by constructing a debugging thread independent of other threads, and the breakpoint debugging is not limited by multiple threads in the tester program and is not limited by the number of debugging functions. When the debugging thread is in a breakpoint state, other threads can normally run, the debugging thread can randomly acquire the information of other threads without being influenced by breakpoints, the requirements of a developer on testing such as single step debugging, breakpoint information query and function call in a multi-thread testing machine program are met, and the limitation of multi-thread is avoided.
Drawings
FIG. 1 is a schematic diagram of a debugging scheme of the present invention;
FIG. 2 is a schematic diagram of another debugging scheme of the present invention;
FIG. 3 is a flowchart illustrating a multi-thread debugging method according to an embodiment of the present invention;
FIG. 4 is a schematic diagram of a multithread debugging method according to an embodiment of the present invention;
FIG. 5 is a schematic diagram illustrating a debugging thread principle according to an embodiment of the present invention;
FIG. 6 is a schematic diagram illustrating a debugging thread principle capable of multi-user debugging according to an embodiment of the present invention;
FIG. 7 is a block diagram of a multi-thread debugging system according to an embodiment of the present invention.
In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings needed to be used in the embodiments will be briefly described below, it should be understood that the following drawings only illustrate some embodiments of the present invention and therefore should not be considered as limiting the scope, and for those skilled in the art, other related drawings can be obtained according to the drawings without inventive efforts.
Reference numerals: 1-a breakpoint setting unit; 2-an address translation unit; 3-a function execution unit; 4-a breakpoint execution unit; 5-breakpoint skip cell.
Detailed Description
Hereinafter, various embodiments of the present disclosure will be described more fully. The present disclosure is capable of various embodiments and of modifications and variations therein. However, it should be understood that: there is no intention to limit the various embodiments of the present disclosure to the specific embodiments disclosed herein, but rather, the disclosure is to cover all modifications, equivalents, and/or alternatives falling within the spirit and scope of the various embodiments of the present disclosure.
The terminology used in the various embodiments of the disclosure is for the purpose of describing particular embodiments only and is not intended to be limiting of the various embodiments of the disclosure. As used herein, the singular forms are intended to include the plural forms as well, unless the context clearly indicates otherwise. Unless otherwise defined, all terms (including technical and scientific terms) used herein have the same meaning as commonly understood by one of ordinary skill in the art to which the various embodiments of the disclosure belong. The terms (such as those defined in commonly used dictionaries) should be interpreted as having a meaning that is consistent with their meaning in the context of the relevant art and will not be interpreted in an idealized or overly formal sense unless expressly so defined herein in various embodiments.
Example 1
The embodiment 1 of the invention discloses a multithreading debugging method of an ATE (automatic test equipment) test machine program, which realizes the single-step debugging function of the multithreading test machine program by setting an independent debugging thread. The multithread debugging method flow block diagram specification is shown in fig. 3, and the specific scheme is as follows:
a multithreading debugging method of an ATE (automatic test equipment) tester program can be suitable for a Windows environment, and comprises the following steps:
101. setting a breakpoint of a test machine program through an upper computer, taking a function to be executed before the current breakpoint as a function to be executed, and sending a function name of the function to be executed to the test machine program through the upper computer;
102. a debugging thread is configured in a test machine program, the debugging thread continuously receives a function name sent by an upper computer, the function name is translated into an actual function address through a preset address translator, and a relevant variable value is filled to obtain an address in a process;
103. executing the function to be executed in the process of a preset test machine according to the address in the process, and feeding back an execution result to an upper computer;
104. and when the upper computer sends all the function names of all the functions to be executed before the current breakpoint and the functions to be executed are completely executed, the debugging thread executes the current breakpoint and waits for receiving the new function names.
In addition, when the user chooses to skip the current breakpoint, the multithread debugging method further comprises the following steps:
105. when the current breakpoint is skipped, the debugging thread stops executing the current breakpoint, the upper computer continuously sends the function name of the function to be executed in the test machine program to the test machine program, and the debugging thread receives the new function name.
The principle of the multithread debugging method provided by the embodiment is schematically shown in the attached figure 4 of the specification. The breakpoint debugging of the tester program is realized by constructing a debugging thread independent of other threads, and the breakpoint debugging is not limited by multiple threads in the tester program and is not limited by the number of debugging functions. When the debugging thread is in a breakpoint state, other threads can normally run, the debugging thread can randomly acquire the information of other threads without being influenced by breakpoints, the requirements of a developer on testing such as single step debugging, breakpoint information query and function call in a multi-thread testing machine program are met, and the limitation of multi-thread is avoided.
It should be noted that the multithread debugging method provided by the embodiment is not limited to the Windows environment, and can achieve the same effect in the Linux environment. Under the Windows environment, the existing debugging tool can not realize non stop debugging, and all threads of the whole process stop when a breakpoint is reached. This problem also exists in the Linux environment.
101. The upper computer is used for setting a breakpoint of the test machine program, taking a function which needs to be executed before the current breakpoint as a function to be executed, and sending a function name of the function to be executed to the test machine program.
In this embodiment, a user writes a tester program on the host computer and then sets a breakpoint. In fact, the upper computer does not really set a breakpoint, but sends the name of the function in the test program until the breakpoint stops, so that the breakpoint effect is realized. Therefore, the user can control parameters such as specific position, specific time and the like of the breakpoint through the number and the time of the functions transmitted by the upper computer. The function to be executed includes any function involved in the tester program. For example, in the description of fig. 4, other internal functions in the tester program can also be manually input into the tester by the user, set corresponding breakpoints, and sent to the debugging process for debugging.
Because the upper computer can continuously send all the functions to be executed before the breakpoint, when all the functions before the breakpoint are sent, the upper computer can stop sending the function names, the test machine program can not receive the related function names, and further the related functions can not be executed, so that the breakpoint is realized. Preferably, the function name of the function to be executed is transferred to the test machine program through the Socket, so that the data transmission flow is simplified, and the transmission efficiency is improved.
Socket (Socket) is an abstraction of an endpoint for two-way communication between application processes on different hosts in a network. A socket is the end of a process's communication over a network and provides a mechanism for application layer processes to exchange data using a network protocol. In terms of the position, the socket uplink application process and the socket downlink network protocol stack are interfaces through which the application program communicates through the network protocol, and are interfaces through which the application program interacts with the network protocol stack. Socket can be regarded as an endpoint in the respective communication connection when two network applications communicate, which is a logical concept. It is an API (application programming interface) for interprocess communication in a network environment, and is also a communication endpoint that can be named and addressed, each socket in use having its type and a process connected to it.
Before the breakpoint is set, the multithread debugging method further comprises the following steps: and setting all functions and global variables involved in the debugging process as a dynamic link library. A dynamic Link library (dll) is a library that contains code and data that can be used by multiple programs simultaneously. In the embodiment, all interface programs and public global variables used by a user are made into the DLL, so that the update can be more easily applied to each module without influencing other parts of the program. And the DLL uses less resources, and when a plurality of programs use the same function library, the DLL can reduce the repeated amount of codes loaded in a disk and a physical memory.
102. The testing machine program is configured with a debugging thread, the debugging thread continuously receives the function name sent by the upper computer, the function name is translated into an actual function address through a preset address translator, and a relevant variable value is filled in the actual function address to obtain an address in the process.
The present embodiment provides a debug thread that is independent of other threads in the tester program. The principle structure of the debugging thread is shown in figure 5 in the specification. The debugging thread is an independent thread and does not influence the running of other threads, so that a user can randomly execute other functions and call any function at the breakpoint of the debugging thread. Even if the debugging thread is executing the current breakpoint, other threads except the debugging thread in the test machine program can normally run without being influenced by the breakpoint, and the defect of the multi-thread test machine program when the breakpoint is in progress is overcome.
The multithreading debugging method further comprises the following steps: if the function to be executed is recorded in the test machine program, the test machine program translates the function name of the function to be executed into an actual function address through the dynamic link library, and fills in a relevant variable value to obtain an address in the process. The DLL has the advantages that any plurality of debugging functions can be placed in the DLL, subsequent processing is not needed, and mapping to calling functions in the actual running process is facilitated. The test thread can be translated by an address translator according to the function name of the function to be executed sent by the upper computer. If the function to be executed is a function in the test program, the debugging thread can translate the actual function address through the DLL, then the variable value is filled in to obtain the address in the process, and the execution is started.
Similarly, the user can modify the variable value for debugging, and the translator is also added with an in-process function translator, so that the address translation can be performed on other functions in the process, and the debugging by a tester program developer is facilitated. The multithreading debugging method further comprises the following steps: modifying the variable value of an internal function positioned in the process of the tester; and a process function translator is preset in the debugging thread, the address translation is carried out on the internal function through the process function translator, the modified variable value is filled in, the process address is obtained and executed, and the internal function is debugged.
103. And executing the function to be executed in the process of the preset test machine according to the address in the process, and feeding back an execution result to the upper computer. In the description and the attached fig. 5, after the in-process address is acquired, the in-process address is directly executed in the tester process. In this embodiment, the tester process includes all threads of the tester, all threads being under the tester process. The execution mode is suitable for a single-user debugging scene, and each user executes the next function after feedback is obtained. For a multi-user debugging scenario, the multi-process debugging method provided by the embodiment introduces an execution queue. And after the in-process address is obtained, adding the in-process address into a preset execution queue, and executing the functions in the execution queue in sequence so as to realize multi-user debugging. The debugging threads added to the execution queue are shown in figure 6 of the specification.
Each time a function is executed in a single step, one debugging thread is executed, and the result is returned to the upper computer. At the breakpoint, other functions can be manually input or global variables can be queried to execute i, and the result can be returned to the upper computer. The multithreading debugging method provided by the embodiment obtains the feedback result and returns the feedback result to the user according to the user input, and simulates a gdb environment, so that multithreading debugging is realized.
104. And when the upper computer sends all the function names of all the functions to be executed before the current breakpoint and the functions to be executed are completely executed, the debugging thread executes the current breakpoint and waits for receiving the new function names.
At the breakpoint, the user can optionally perform other functions, and call any function, such as single step debugging, breakpoint information query, function call, and other test means. When the debugging thread executes the current breakpoint, other threads except the debugging thread in the tester program normally run, so that the related information of other threads can be acquired. In the single-step debugging process, other functions can be called at will to modify variables for debugging, and the debugging thread can call functions of other threads or acquire information of other threads, as shown in fig. 4 in the specification, the debugging thread can acquire relevant information through an upper computer.
The embodiment provides a multithreading debugging method of an ATE (automatic test equipment) tester program, which is used for solving the problem of breakpoints caused by multithreading in the debugging process of the tester program, and can be suitable for debugging the tester program in mainstream operating environments such as Windows environment. The breakpoint debugging of the tester program is realized by constructing a debugging thread independent of other threads, and the breakpoint debugging is not limited by multiple threads in the tester program and is not limited by the number of debugging functions. When the debugging thread is in a breakpoint state, other threads can normally run, the debugging thread can randomly acquire the information of other threads without being influenced by breakpoints, the requirements of a developer on testing such as single step debugging, breakpoint information query and function call in a multi-thread testing machine program are met, and the limitation of multi-thread is avoided.
Example 2
The embodiment 2 of the invention discloses a multithreading debugging system of an ATE (automatic test equipment) tester program, the multithreading debugging method of the ATE tester program of the embodiment 1 is systematized, the specific structure of the system is shown as the attached figure 7 of the specification, and the specific scheme is as follows:
a multithreading debugging system of an ATE tester program comprises a breakpoint setting unit 1, an address translation unit 2, a function execution unit 3, a breakpoint execution unit 4 and a breakpoint skipping unit 5. The specific scheme is as follows:
breakpoint setting unit 1: the device comprises a host computer, a function to be executed, a function name sending module, a function execution module and a test machine program, wherein the host computer is used for setting a breakpoint of the test machine program, taking a function to be executed before the current breakpoint as a function to be executed, and sending the function name of the function to be executed to the test machine program; preferably, the breakpoint setting unit 1 transfers the function name of the function to be executed to the test machine program through Socket, so as to simplify the data transmission flow and improve the transmission efficiency.
Address translation unit 2: the testing machine program is provided with a debugging thread which is used for continuously receiving the function name sent by the upper computer through the debugging thread, translating the function name into an actual function address through a preset address translator and filling a relevant variable value into the actual function address to obtain a process internal address; the debugging thread is independent of other threads in the test machine program;
the function execution unit 3: the function execution module is used for executing the function to be executed in the process of the preset test machine according to the address in the process and feeding back an execution result to the upper computer;
breakpoint execution unit 4: and the debugging thread executes the current breakpoint and waits for receiving a new function name when the upper computer completely sends all the function names of all the functions to be executed before the current breakpoint and the functions to be executed are completely executed.
Breakpoint skipping unit 5: the debugging thread is used for stopping executing the current breakpoint when the current breakpoint is selected to be skipped; and the upper computer continuously sends the function name of the function to be executed in the test machine program to the test machine program, and the debugging thread receives the new function name.
It should be noted that the multithread debugging system provided in this embodiment is not limited to the Windows environment, and can achieve the same effect in the Linux environment. Under the Windows environment, the existing debugging tool can not realize non stop debugging, and all threads of the whole process stop when a breakpoint is reached. This problem also exists in the Linux environment.
The multithreading debugging system also sets all functions and global variables involved in the debugging process as dynamic link libraries; if the function to be executed is recorded in the test machine program, the test machine program translates the function name of the function to be executed into an actual function address through the dynamic link library, and fills in a relevant variable value to obtain an address in the process.
This embodiment discloses a multi-thread debugging system for ATE tester programs, which makes the acceleration method of embodiment 1 systematic and more practical.
Example 3
This embodiment provides a test machine applied to ATE equipment, in which the multi-thread debugging system of the ATE tester program provided in embodiment 2 is disposed. The specific scheme is as follows:
the embodiment provides a test machine, which is applied to ATE equipment. The software module of the test machine is configured with the multi-thread debugging system of embodiment 2, and the multi-thread debugging system includes a breakpoint setting unit 1, an address translation unit 2, a function execution unit 3, a breakpoint execution unit 4, and a breakpoint skipping unit 5.
Breakpoint setting unit 1: the device comprises a host computer, a function to be executed, a function name sending module, a function execution module and a test machine program, wherein the host computer is used for setting a breakpoint of the test machine program, taking a function to be executed before the current breakpoint as a function to be executed, and sending the function name of the function to be executed to the test machine program; preferably, the breakpoint setting unit 1 transfers the function name of the function to be executed to the test machine program through Socket, so as to simplify the data transmission flow and improve the transmission efficiency.
Address translation unit 2: the testing machine program is provided with a debugging thread which is used for continuously receiving the function name sent by the upper computer through the debugging thread, translating the function name into an actual function address through a preset address translator and filling a relevant variable value into the actual function address to obtain a process internal address; the debugging thread is independent of other threads in the test machine program;
the function execution unit 3: the function execution module is used for executing the function to be executed in the process of the preset test machine according to the address in the process and feeding back an execution result to the upper computer;
breakpoint execution unit 4: and the debugging thread executes the current breakpoint and waits for receiving a new function name when the upper computer completely sends all the function names of all the functions to be executed before the current breakpoint and the functions to be executed are completely executed.
Breakpoint skipping unit 5: the debugging thread is used for stopping executing the current breakpoint when the current breakpoint is selected to be skipped; and the upper computer continuously sends the function name of the function to be executed in the test machine program to the test machine program, and the debugging thread receives the new function name.
The embodiment provides a test machine, which can realize a debugging function and help a developer to debug by graphically displaying data information of the machine.
The invention provides a multithreading debugging method and system of an ATE (automatic test equipment) tester program and a tester table, which solve the problem of breakpoints caused by multithreading in the debugging process of the tester program. The scheme of the invention can be suitable for debugging the test machine program in mainstream operation environments such as Windows environment. The breakpoint debugging of the tester program is realized by constructing a debugging thread independent of other threads, and the breakpoint debugging is not limited by multiple threads in the tester program and is not limited by the number of debugging functions. When the debugging thread is in a breakpoint state, other threads can normally run, the debugging thread can randomly acquire the information of other threads without being influenced by breakpoints, the requirements of a developer on testing such as single step debugging, breakpoint information query and function call in a multi-thread testing machine program are met, and the limitation of multi-thread is avoided.
Those skilled in the art will appreciate that the figures are merely schematic representations of one preferred implementation scenario and that the blocks or flow diagrams in the figures are not necessarily required to practice the present invention. Those skilled in the art will appreciate that the modules in the devices in the implementation scenario may be distributed in the devices in the implementation scenario according to the description of the implementation scenario, or may be located in one or more devices different from the present implementation scenario with corresponding changes. The modules of the implementation scenario may be combined into one module, or may be further split into a plurality of sub-modules. The above-mentioned invention numbers are merely for description and do not represent the merits of the implementation scenarios. The above disclosure is only a few specific implementation scenarios of the present invention, however, the present invention is not limited thereto, and any variations that can be made by those skilled in the art are intended to fall within the scope of the present invention.
Claims (10)
1. A multithreading debugging method of an ATE tester program is characterized by comprising the following steps:
setting a current breakpoint of a test machine program through an upper computer, taking a function to be executed before the current breakpoint as a function to be executed, and sending a function name of the function to be executed to the test machine program through the upper computer;
a debugging thread is configured in the test machine program, the debugging thread continuously receives the function name sent by the upper computer, the function name is translated into an actual function address through a preset address translator, and a relevant variable value is filled in the actual function address to obtain an in-process address; wherein the debugging thread is independent of other threads in the tester program;
executing the function to be executed in the process of a preset test machine according to the in-process address, and feeding back an execution result to the upper computer;
and when the upper computer sends all the function names of all the functions to be executed before the current breakpoint and all the functions to be executed are completely executed, the debugging thread executes the current breakpoint and waits for receiving a new function name.
2. The multi-threaded debugging method of claim 1, wherein when a current breakpoint is selected to be skipped, the debugging thread stops executing the current breakpoint;
and the upper computer continuously sends the function name of the function to be executed in the test machine program to the test machine program, and the debugging thread receives the new function name.
3. The multi-thread debugging method of claim 2, further comprising:
setting all functions and global variables related in the debugging process as a dynamic link library;
if the function to be executed is recorded in the test machine program, the debugging thread translates the function name of the function to be executed into an actual function address through the dynamic link library, and fills in a relevant variable value to obtain an address in a process.
4. The multi-threaded debugging method of claim 2, wherein, when the debugging thread executes a current breakpoint,
in the test machine program, other threads except the debugging thread run normally;
the debugging thread may call functions of other threads or obtain information of other threads.
5. The multi-thread debugging method of claim 2, further comprising:
modifying variable values of internal functions located inside the tester process;
and a process function translator is preset in the debugging thread, the address translation is carried out on the internal function through the process function translator, the modified variable value is filled in, and a process address is obtained and executed so as to realize the debugging of the internal function.
6. The multi-thread debugging method of claim 2, further comprising:
and after the in-process address is obtained, adding the in-process address into a preset execution queue, and sequentially executing the functions in the execution queue, thereby realizing multi-user debugging.
7. A multi-threaded debugging system for an ATE tester program, the multi-threaded debugging system comprising:
breakpoint setting unit: the device comprises an upper computer, a function module and a test machine program, wherein the upper computer is used for setting a breakpoint of the test machine program, taking a function which needs to be executed before the current breakpoint as a function to be executed, and sending a function name of the function to be executed to the test machine program through the upper computer;
an address translation unit: the testing machine program is provided with a debugging thread which is used for continuously receiving the function name sent by the upper computer through the debugging thread, translating the function name into an actual function address through a preset address translator and filling a relevant variable value into the actual function address to obtain an address in a process; wherein the debugging thread is independent of other threads in the tester program;
a function execution unit: the function to be executed is executed in the process of a preset test machine according to the in-process address, and an execution result is fed back to the upper computer;
a breakpoint execution unit: and the debugging thread is used for executing the current breakpoint and waiting for receiving a new function name when the upper computer sends all the function names of all the functions to be executed before the current breakpoint and the functions to be executed are all executed.
8. The multi-threaded debugging system of claim 7, further comprising,
a breakpoint skipping unit: the debugging thread is used for stopping executing the current breakpoint when the current breakpoint is selected to be skipped; and the upper computer continuously sends the function name of the function to be executed in the test machine program to the test machine program, and the debugging thread receives the new function name.
9. The multi-threaded debugging system of claim 7, further comprising:
setting all functions and global variables related in the debugging process as a dynamic link library;
if the function to be executed is recorded in the test machine program, the debugging thread translates the function name of the function to be executed into an actual function address through the dynamic link library, and fills in a relevant variable value to obtain an address in a process.
10. A tester table applied to ATE equipment, wherein a software module of the tester table is configured with the multi-thread debugging system of any one of claims 7-9.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111387510.5A CN114253837B (en) | 2021-11-22 | 2021-11-22 | Multithreading debugging method and system for ATE (automatic test equipment) tester program and tester table |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111387510.5A CN114253837B (en) | 2021-11-22 | 2021-11-22 | Multithreading debugging method and system for ATE (automatic test equipment) tester program and tester table |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN114253837A true CN114253837A (en) | 2022-03-29 |
| CN114253837B CN114253837B (en) | 2023-03-24 |
Family
ID=80791023
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202111387510.5A Active CN114253837B (en) | 2021-11-22 | 2021-11-22 | Multithreading debugging method and system for ATE (automatic test equipment) tester program and tester table |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN114253837B (en) |
Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101504626A (en) * | 2009-03-06 | 2009-08-12 | 中兴通讯股份有限公司 | Debugging control implementing method and system |
| US20100242026A1 (en) * | 2009-03-18 | 2010-09-23 | International Business Machines, Corporation | Enhanced thread stepping |
| CN102346708A (en) * | 2010-08-03 | 2012-02-08 | 中兴通讯股份有限公司 | Debugger and debugging method thereof |
| CN103218294A (en) * | 2013-04-16 | 2013-07-24 | 华为技术有限公司 | Debugging method for embedded system, debugging conversion device and system |
| CN103365707A (en) * | 2012-03-30 | 2013-10-23 | 国际商业机器公司 | Method and device for controlling returning of asynchronous calls |
| CN106201896A (en) * | 2016-07-26 | 2016-12-07 | 华中科技大学 | Adjustment method based on checkpoint, system and device under a kind of embedded environment |
| CN108319555A (en) * | 2018-03-17 | 2018-07-24 | 成都大学 | A kind of real-time adjustment method based on embedded real time system |
| CN113189479A (en) * | 2021-06-28 | 2021-07-30 | 杭州加速科技有限公司 | Method, device and test system for improving test speed of ATE chip |
-
2021
- 2021-11-22 CN CN202111387510.5A patent/CN114253837B/en active Active
Patent Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101504626A (en) * | 2009-03-06 | 2009-08-12 | 中兴通讯股份有限公司 | Debugging control implementing method and system |
| US20100242026A1 (en) * | 2009-03-18 | 2010-09-23 | International Business Machines, Corporation | Enhanced thread stepping |
| CN102346708A (en) * | 2010-08-03 | 2012-02-08 | 中兴通讯股份有限公司 | Debugger and debugging method thereof |
| CN103365707A (en) * | 2012-03-30 | 2013-10-23 | 国际商业机器公司 | Method and device for controlling returning of asynchronous calls |
| CN103218294A (en) * | 2013-04-16 | 2013-07-24 | 华为技术有限公司 | Debugging method for embedded system, debugging conversion device and system |
| CN106201896A (en) * | 2016-07-26 | 2016-12-07 | 华中科技大学 | Adjustment method based on checkpoint, system and device under a kind of embedded environment |
| CN108319555A (en) * | 2018-03-17 | 2018-07-24 | 成都大学 | A kind of real-time adjustment method based on embedded real time system |
| CN113189479A (en) * | 2021-06-28 | 2021-07-30 | 杭州加速科技有限公司 | Method, device and test system for improving test speed of ATE chip |
Also Published As
| Publication number | Publication date |
|---|---|
| CN114253837B (en) | 2023-03-24 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| JP7295954B2 (en) | Automated test equipment with on-chip system test controller | |
| CN109302522B (en) | Test method, test device, computer system, and computer medium | |
| US6668339B1 (en) | Microprocessor having a debug interruption function | |
| CN111651366A (en) | SDK test method, device, equipment and storage medium | |
| JP2014532914A (en) | Programmable test equipment | |
| CN109189663A (en) | A kind of plug-in unit adjustment method, test method and microkernel architecture system | |
| US20130254750A1 (en) | Method of debugging software and corresponding computer program product | |
| US7319947B1 (en) | Method and apparatus for performing distributed simulation utilizing a simulation backplane | |
| US7149943B2 (en) | System for flexible embedded Boundary Scan testing | |
| CN114253837B (en) | Multithreading debugging method and system for ATE (automatic test equipment) tester program and tester table | |
| CN111159023A (en) | Test method, test device, electronic equipment and computer readable storage medium | |
| CN113127329B (en) | Script debugging method and device and computer storage medium | |
| CN112231210A (en) | Test method, equipment and storage medium under network function virtualization environment | |
| US20040177344A1 (en) | Debugging method for the keyboard controller code | |
| CN109144850A (en) | The test method interactively communicated and system of mobile terminal | |
| CN114020618A (en) | High-availability test method and system based on FPGA and DPDK | |
| US20060161422A1 (en) | Virtual emulation modules, virtual development systems and methods for system-on-chip development | |
| EP2722761A1 (en) | Arithmetic processing device and control method for arithmetic processing device | |
| JP2001318805A (en) | Test method for built-in system and test system | |
| CN111966582B (en) | Cluster debugging system with multiple debugging objects and management method and debugging method thereof | |
| CN108415839A (en) | The development frame of multinuclear SoC chip and the development approach of multinuclear SoC chip | |
| CN112015650B (en) | Event testing method and device based on computer vision | |
| AU2023201696B2 (en) | Method and device for determining coverage in HIL testing, and storage medium | |
| JPH0397040A (en) | Inspecting system for test program | |
| US11719749B1 (en) | Method and system for saving and restoring of initialization actions on dut and corresponding test environment |
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 | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |