JP4132504B2 - Semiconductor test system - Google Patents

Description

[0001]
BACKGROUND OF THE INVENTION
The present invention relates to a semiconductor test system for testing the operation of a semiconductor device.
[0002]
[Prior art]
In order to test the operation of a semiconductor device, it is necessary to create a program (hereinafter referred to as “test program”) that determines the signals used for testing the semiconductor device and the input / output order of the signals. A test program creation language (hereinafter referred to as “TP language”) suitable for creating a test program is used for the description of the test program. This is common to the use of a hardware description language (HDL), which is a design language, for designing hardware such as LSI. The TP language has a structure, a grammar, an instruction, and a function (hereinafter referred to as “TP function”) that facilitate the creation of a test program. However, it does not necessarily include a general-purpose function (hereinafter referred to as “general-purpose function”) included in another general programming language, for example, C language or C ++ language (hereinafter referred to as “general-purpose language”). When using a function that is not provided in the TP language but is provided in the general-purpose language, the test program needs to call the function from the general-purpose language.
[0003]
In calling such a function, it is mainly necessary to specify a general-purpose function and an argument necessary for executing the general-purpose function (hereinafter referred to as “general-purpose argument”). More specifically, the TP language processing system collects general functions and general arguments to be called into one package, that is, after packaging (encapsulation), and then delivers the package to the general language processing system. When the package is received, the general-purpose language processing system executes the specified general-purpose function using the specified general-purpose argument, and then executes the execution result (hereinafter referred to as “return value”). Return to. The processing system of the TP language performs subsequent processing using the returned return value. As described above, between the processing system of the TP language and the processing system of the general language, a package including the general function and the general argument, and a return value as a result of executing the general function using the general argument are exchanged. The
[0004]
[Problems to be solved by the invention]
The above-described package needs to be configured in accordance with general-purpose language rules. For example, if the general-purpose arguments of a general-purpose function Gp are g ₁ , g ₂ , and g ₃ , and the designation order is determined as g ₃ , g ₂ , and g ₁ , the package is a general-purpose argument g _3. , G ₂ , and g ₁ in this order.
[0005]
However, the TP language processing system and the general-purpose language processing system function independently of each other. Therefore, it is not guaranteed that the general-purpose arguments g ₁ , g ₂ , and g ₃ are handled in the order of g ₃ , g ₂ , and g _{1 in} the TP language processing system. Generic arguments g _1, g _2, g _3, for example, g _2, g _3, or handled in the order of g _1, which may or handled in the order of g _1, g _3, g _2. Furthermore, when the order of arguments (hereinafter referred to as “TP arguments”) of a certain TP function is defined as g ₁ , g ₃ , and g ₂ , the processing system of the TP language can use arguments g ₁ and g the _2, g _3, also guarantees that handled the order g _1, g _3, g ₂ of the TP argument, never guarantee that handled the order g _3, g _2, g ₁ of the general-purpose parameter. As a result, in order to execute the general function Gp, the order of g ₁ , g ₃ , and g ₂ had to be changed to the order of g ₃ , g ₂ , and g ₁ . Since this rearrangement, that is, transshipment, must be performed every time the general-purpose function Gp is executed, there is a problem that the program becomes complicated and redundant, and as a result, processing is delayed.
[0006]
The present invention was created in view of this point, and its purpose is to specially prepare a general-purpose function included in a test program created using a test program creation language for the general-purpose arguments of the general-purpose function. It is to provide a semiconductor test system that can be called without any problems.
[0007]
[Means for Solving the Problems]
In order to solve the above-described problems, a semiconductor test system according to the present invention is written in a test program creation language used to create a test program for testing a semiconductor device, and is a test program creation language. The semiconductor device is tested in accordance with a test program that executes the first function included in the program and calls the second function included in a language other than the test program creation language. Part and a control part. The argument storage unit stores first data used as an argument of the first function and second data used as an argument of the second function, and the temporary storage unit executes a test program. When the second function is called, the second data is temporarily stored in order to transfer the second data from the test program creation language processing system to the other language processing system. The control unit stores the duplicate data used as the first data and also used as the second data in a predetermined address of the argument storage unit according to a rule to be observed in order to execute the second function, and performs a test. When executing the program and calling the second function, the duplicate data stored in the predetermined address of the argument storage unit is read according to the above-described rules and temporarily stored in the temporary storage unit. According to the present invention, when the second function used as an argument of the second function is stored in the temporary storage unit when the test program is executed and the second function is called, the second function is Since it is not necessary to rearrange according to the rules to be observed in order to execute, the structure of the test program can be simplified, thereby reducing the time required for calling the second function.
[0008]
It further includes a table unit that stores information indicating the correspondence between the duplicate data described above and the address of the argument storage unit in which the duplicate data is stored, and the control unit stores the duplicate data in the argument storage unit. It is desirable to do it based on information. This makes it possible to clarify the address of the argument storage unit that stores duplicate data.
[0009]
The argument storage unit described above preferably stores information indicating the correspondence between the second function and the address of the argument storage unit in which duplicate data is stored. Thus, when common data is used as an argument of a plurality of functions, it is not necessary to store the data separately at a plurality of addresses corresponding to each of the plurality of functions, and the data is stored only at one address. Since storing is sufficient, the number of times of accessing the argument storage unit can be reduced, and as a result, the entire processing time can be shortened.
[0010]
It is desirable that the order of the arguments of the second function is defined according to the rules described above, and that the duplicate data is stored in the argument storage unit according to this order by the control unit. For the second function, it is often required that a predetermined number of arguments are arranged in a predetermined order. Therefore, by storing data in the argument storage unit corresponding to such an order, The second function call process can be quickly performed.
[0011]
DETAILED DESCRIPTION OF THE INVENTION
A semiconductor test system according to an embodiment of the present invention will be described with reference to the drawings.
[0012]
FIG. 1 is a diagram illustrating a configuration of a semiconductor test system according to an embodiment. The semiconductor test system tests the semiconductor device DUT based on a test program for testing the operation of the semiconductor device DUT. For this purpose, the semiconductor test system includes a test / program processing apparatus 1 and a semiconductor test apparatus 2. The test program processing apparatus 1 is used for editing, compiling, debugging, and the like of a test program. The semiconductor test apparatus 2 inputs various signals for testing to the semiconductor device DUT according to the test program created by using the test program processing apparatus 1, or the semiconductor device DUT responds to these input signals. Check the output signal. In order to perform such a function, the semiconductor test apparatus 2 includes hardware, an operating system, and software for executing a test program, a socket for setting the semiconductor device DUT, and the semiconductor device DUT. And a probe (not shown) for inputting / outputting various signals.
[0013]
The test program processing apparatus 1 includes a CPU (Central Processing Unit) 10, a program storage unit 20, an address table unit 30, an argument storage unit 40, a stack unit 50, and a general-purpose function processing unit for performing processing related to the test program. 60. The CPU 10 executes a test program and calls a general-purpose function as necessary in the course of execution. The program storage unit 20 stores a test program. The address table unit 30 stores a relationship between at least data used as a TP argument and general-purpose arguments and an address of the argument storage unit 40 in which the data is stored. The argument storage unit 40 stores information indicating the correspondence between the TP function and the data used as the TP argument, and information indicating the correspondence between the general function and the data used as the general argument. The stack unit 50 is used to temporarily store and save a general-purpose function and a general-purpose argument corresponding to the general-purpose function when a general-purpose function is called during execution of a test program. That is, it is used to package (encapsulate) general functions and general arguments. The general-purpose function processing unit 60 executes the specified general-purpose function using the package contents, that is, the saved general-purpose arguments, and then returns a return value as a result to the processing system of the TP language.
[0014]
The above test program is described using instructions and TP functions provided in the TP language, and is also described using general functions provided in the general language as necessary. This general-purpose language includes a general-purpose function library including a plurality of general-purpose functions. The processing system of the test program executes the test program by calling a general function in such a general function library as appropriate, thereby simplifying the configuration of the test program.
[0015]
FIG. 2 is a diagram conceptually illustrating the configuration of the test program. The test program includes a TP function F _{1 and the} like, a general-purpose function Gs and the like, and a TP function H ₁ that calculates an argument of these functions. In the figure, an instruction “EXE” indicates that a TP function or a general-purpose function is executed.
[0016]
FIG. 3 is a diagram illustrating an execution result of the TP function H ₁ . For example, by executing H ₃ (x ₃₀ ), data to be used as the arguments b ₃ and d ₃ can be obtained.
[0017]
Returning to FIG. 2, the instruction “STR” indicates that the result of the execution is stored. For example, “STR H ₁ (x ₁₀ )” means that data obtained as a result of executing H ₁ (x ₁₀ ) is stored in the argument storage unit 40. Which address in the argument storage unit 40 is stored is determined by referring to the address table unit 30.
[0018]
FIG. 4 is a diagram showing the relationship between the data used as an argument stored in the address table unit 30 and the address where the data is to be stored. For example, it is indicated that the data used as the argument b ₃ should be stored at the addresses 1012h and 2020h of the argument storage unit 40, and the data used as the argument d ₃ is the address of the argument storage unit 40. It is shown that it should be stored in 1032h. Therefore, by executing the instruction “STR H ₁ (x ₁₀ )”, the data used as the argument b ₃ is stored in 1012h and 2020h, and the data used as the argument d ₃ is stored in 1032h. .
[0019]
When calling a general-purpose function in a test program, that is, when the general-purpose function is executed by the general-purpose function processing unit 60, it is necessary to specify a general-purpose function and a general-purpose argument as the contents of a package passed to the general-purpose language processing system. It is. For example, for the general-purpose function Gu, it is necessary to specify not only the general-purpose function Gu but also general-purpose arguments a ₁ , b ₁ , c ₁ , and d ₁ . In particular, it is necessary to specify the general-purpose arguments by specifying them in a predetermined order according to a rule (second rule) to be observed in order to execute the general-purpose function.
[0020]
For example, since the order of a ₁ , d ₁ , b ₁ , and c ₁ is determined for the general-purpose function Gu, the general-purpose arguments a ₁ , b ₁ , c ₁ , and d ₁ are changed to the order a ₁ , d _1. , B ₁ and c ₁ need to be rearranged. In other words, even if all of the general-purpose arguments a ₁ , b ₁ , c ₁ , d ₁ are specified, if the order is different from the predetermined order, the general-purpose function cannot be executed, or the desired operation Will perform different operations.
[0021]
FIG. 5 is a diagram illustrating the relationship between the TP function and data used as the TP argument and the relationship between the general function and data used as the general argument stored in the argument storage unit 40. As illustrated, for example, the TP function F ₁ includes data used as the TP argument a ₁ stored at the address 1000h of the argument storage unit 40 and data used as the TP argument a ₂ stored at the address 1001h. It is executed using. Similarly, general-purpose functions Gu and Gw are used as data used as general-purpose argument a ₁ stored at address 2030h, data used as general-purpose argument d ₁ stored at address 2031, and general-purpose argument b ₁ stored at address 2032h. It is executed using the data and data used as the general-purpose argument c ₁ stored in the address 2033h.
[0022]
FIG. 6 is a diagram illustrating general functions and general arguments saved in the stack unit 50. When calling the general-purpose function Gu, the processing system of the TP language designates the general-purpose function Gu and saves the general-purpose arguments a ₁ , d ₁ , b ₁ , and c ₁ in this order. For example, the CPU 10 serving as a processing system of the TP language specifies a general function Gu to be called by storing a predetermined code corresponding to the general function Gu in the top area of the stack unit 50, and in this top area Data used as each of the general-purpose arguments a ₁ , d ₁ , b ₁ , and c ₁ are sequentially stored in each of a plurality of subsequent areas. As a result, the general function processing unit 60 can execute the operation Gu (a ₁ , d ₁ , b ₁ , c ₁ ) using the general function Gu and the general arguments a ₁ , d ₁ , b ₁ , c _1. The return value as the execution result is returned to the processing system of the TP language.
[0023]
Regarding the relationship between the embodiment and the claims, the CPU 10 corresponds to the control unit, the address table unit 30 corresponds to the table unit, the argument storage unit 40 corresponds to the argument storage unit, and the stack unit. 50 corresponds to a temporary storage unit. The TP function corresponds to the first function, and the general-purpose function corresponds to the second function.
[0024]
The operation of the test / program processing apparatus 1 will be described below. By sequentially executing the TP functions H _{1 to} H ₄ using the data x ₁₀ , x ₂₀ , x ₃₀ , and x ₄₀ , arguments a ₁ , b ₁ , c ₁ , d ₁ , a ₂ , b ₂ , Refer to FIG. 2 for operations for calculating data used as c ₂ , b ₃ , d ₃ , and b ₄ and executing the TP functions F _{1 to} F ₄ and general-purpose functions Gs to Gw using these data. However, it will be explained.
[0025]
Step 100: The CPU 10 executes the instruction “EXE H ₁ (x ₁₀ )”. Accordingly, as described above, data used as the arguments a ₁ , b ₁ , c ₁ , and d ₁ are obtained as a result of the calculation of the TP function H ₁ (x ₁₀ ).
[0026]
Step 110: The CPU 10 executes the instruction “STR H ₁ (x ₁₀ )”. Specifically, the CPU 10 refers to the address table unit 30 to confirm the address where the data used as the arguments a ₁ , b ₁ , c ₁ , and d ₁ should be stored, and then stores the data used as the argument a ₁ as an argument. Stored at addresses 1000h, 2030h, and 2041h in the unit 40. Similarly, the CPU 10 stores data used as the argument b ₁ at addresses 1010h, 2032h, and 2042h, stores data used as the argument c ₁ in 1020h and 2033h, and stores data used as the argument d ₁ in 1030h and 2031h. To do.
[0027]
Similarly, the CPU 10 executes the instruction “EXE H ₂ (x ₂₀ )” to calculate data to be used as the arguments a ₂ , b ₂ , and c ₂ , and then uses those data as the address table unit 30. Are stored in the corresponding addresses of the argument storage unit 40, respectively. Similarly for the other TP function H ₃ (x ₃₀ ) and TP function H ₄ (x ₄₀ ), the CPU 10 refers to the address table unit 30 for data used as the argument b ₃ , d ₃ , or b ₄ . As a result, the corresponding address in the argument storage unit 40 is stored. In this way, the instructions “EXE H ₁ (x ₁₀ )”, “STR H ₂ (x ₂₀ )”,..., “EXE H ₄ (x ₄₀ )”, “STR H ₄ (x ₄₀ )” Complete all executions.
[0028]
Step 120: The CPU 10 executes an instruction “EXE F ₁ (a ₁ , a ₂ )” following the instruction “STR H ₄ (x ₄₀ )” (not shown). Specifically, the TP function F ₁ is executed by using the data stored at the addresses 1000 h and 1001 of the argument storage unit 40 as the arguments a ₁ and a ₂ .
[0029]
Step 130: Similarly, the CPU 10 executes the next instruction “EXE F ₂ (b ₁ , b ₂ , b ₃ , b ₄ )”. That is, the TP function F ₂ is executed by using the data stored at the addresses 1010h, 1011h, 1012h, and 1013h as the arguments b ₁ , b ₂ , b ₃ , and b ₄ . Similarly, other TP functions F ₃ (c ₁ ) and F ₄ (d ₁ , d ₂ , d ₃ ) are executed.
[0030]
Step 140: The CPU 10 prepares to execute the instruction “EXE Gs (a ₂ , b ₂ )” following the instruction “EXE F ₄ (d ₁ , d ₂ , d ₃ )” (not shown). More specifically, the CPU 10 saves the data stored in the addresses 2000h and 2001h necessary for executing the general-purpose function Gs (a ₂ , b ₂ ) as general-purpose arguments a ₂ and b ₂ in the stack unit 50. After saving the data, the CPU 10 designates the general-purpose function Gs in the same manner as the general-purpose function Gu in FIG. In this way, packaging is completed. When the package is prepared in the stack unit 50, the execution of the test program shifts from the TP language processing system to the general-purpose language processing system. In other words, the execution of the general function Gs is left to the general function processing unit 60. The general-purpose function processing unit 60 executes the general-purpose function Gs using data saved in the stack unit 50 to be used as the general-purpose arguments a ₂ and b ₂ . When the execution of the general-purpose function Gs (a ₂ , b ₂ ) is finished, the general-purpose function processing unit 60 sends the return value, which is the execution result, from the general-purpose language processing system to the TP language processing system via the stack unit 50. Return to.
[0031]
Step 150: Similar to the preparation for executing the general-purpose function Gs, the CPU 10 prepares for executing the general-purpose function Gu (a ₁ , d ₁ , b ₁ , c ₁ ). That is, the data stored in the addresses 2030h, 2031h, 2032h, and 2033h are saved in the stack unit 50 as general-purpose arguments a ₁ , d ₁ , b ₁ , and c ₁ and the general-purpose function Gu is designated. When the package is completed in this way, the general-purpose function processing unit 60 executes the general-purpose function Gu (a ₁ , d ₁ , b ₁ , c ₁ ).
[0032]
Steps 160 to 170: The CPU 10 performs other general-purpose functions in the same manner as the preparation for executing the general-purpose functions Gs (a ₂ , b ₂ ) and Gu (a ₁ , d ₁ , b ₁ , c ₁ ). A package for Gw (a ₁ , d ₁ , b ₁ , c ₁ ), Gt (b ₃ ) is prepared, and the general-purpose function processing unit 60 performs general-purpose function Gw (a ₁ , d ₁ , b ₁ , c ₁ ), Gt (b ₃ ).
[0033]
The semiconductor test system of the above-described embodiment, used as TP argument TP function F ₁ to F _4, and the data which is also used as a general argument of generic functions Gs~Gw is a TP function F ₁ to F ₄ In addition to storing in the argument storage unit 40 in the order according to the first rule to be observed for execution, separately from this, the second rule to be observed for executing the general-purpose functions Gs to Gw. The order is also stored in the argument storage unit 40. Thus, unlike the conventional semiconductor test system in which those data are stored only in a predetermined order corresponding to the TP functions F _{1 to} F ₄ , when the general functions Gs to Gw are called, the general functions Gs to Gw Since it is not necessary to rearrange the data required for execution according to the second rule corresponding to the general functions Gs to Gw, the structure of the test program can be simplified. As a result, the processing time for calling the general-purpose functions Gs to Gw can be shortened.
[0034]
In the example described above, the stack unit 50 stores data used as a general-purpose argument. Instead of saving the data itself, the address where the data is stored may be saved. For example, instead of saving the data used as the general-purpose argument b ₃ of the general-purpose function Gt, the address 2020h of the argument storage unit 40 in which the data is stored may be saved. In this case, the general-purpose language processing system may read data to be used as the argument b ₃ from the address 2020h of the argument storage unit 40 when executing the general-purpose function Gs.
[0035]
In the above-described example, the same data (for example, data used as a ₂ ) used in different TP functions or general functions is stored redundantly at a plurality of addresses in the argument storage unit 40. In order to avoid such duplication, data may be stored in one of a plurality of addresses, and an address in which this data is stored may be stored in other addresses.
[0036]
FIG. 7 is a diagram illustrating a correspondence relationship between general-purpose functions and addresses at which data used as general-purpose arguments are stored. In the figure, “fm” indicates an address where data used as an argument is stored. For example, for the general function Gs, it indicates that data used as the general argument a ₂ is stored at the address 1001h of the argument storage unit 40, and that data used as the general argument b ₂ is stored at the address 1011h. Thus, when the general-purpose function Gs is called from the processing system of the TP language, the data used as the argument a ₂ stored in the address 1001h and the data used as the argument b ₂ stored in the address 1011h are used for the stack unit 50. It is possible to perform a save operation.
[0037]
In the correspondence shown in FIG. 5, for example, the data used as the argument a ₁ must be stored at three locations of addresses 1001h, 2030h, and 2041h. On the other hand, by using the correspondence shown in FIG. 7, it is sufficient to store data used as the argument a ₁ only at the address 1000h. Therefore, it is possible to avoid an increase in the time required for storing data used as an argument in the argument storage unit 40.
[0038]
【The invention's effect】
As described above, according to the present invention, a test program created in a test program creation language uses data used as an argument necessary for executing a function provided in another language as a rule for the function. Remember according to. Therefore, it is not necessary to arrange these arguments so as to conform to the rules before calling a general-purpose function, so that a function in another language can be easily called by a test program.
[Brief description of the drawings]
FIG. 1 is a diagram showing a configuration of a semiconductor test system according to an embodiment.
FIG. 2 is a diagram conceptually illustrating the configuration of a test program.
FIG. 3 is a diagram illustrating an execution result of a TP function H ₁ .
FIG. 4 is a diagram illustrating a relationship between data used as an argument stored in an address table unit and an address where the data is to be stored.
FIG. 5 is a diagram illustrating a relationship between a TP function and data used as a TP argument and a relationship between a general function and data used as a general argument stored in an argument storage unit;
FIG. 6 is a diagram illustrating general-purpose functions and general-purpose arguments saved in a stack unit.
FIG. 7 is a diagram illustrating a correspondence relationship between general-purpose functions and addresses at which the same data as data used as general-purpose arguments is stored.
[Explanation of symbols]
DESCRIPTION OF SYMBOLS 1 Test program processing apparatus 2 Semiconductor test apparatus 10 CPU
20 Program storage unit 30 Address table unit 40 Argument storage unit 50 Stack unit 60 General-purpose function processing unit

Claims (3)

It is described in a test program creation language used to create a test program for testing a semiconductor device, executes a first function provided in the test program creation language, and for creating the test program In a semiconductor test system for testing a semiconductor device according to a test program that calls a second function provided in a language other than a language,
An argument storage unit for storing first data used as an argument of the first function and second data used as an argument of the second function;
In order to transfer the second data from the test program creation language processing system to the other language processing system when the test program is executed and the second function is called, A temporary storage unit for temporarily storing data,
The duplicate data used as the first data and also used as the second data is stored at a predetermined address of the argument storage unit corresponding to the order specified when the first function is executed. , Another area of the argument storage unit, which is stored in a predetermined address of the argument storage unit corresponding to the order specified when executing the second function, and the test program is executed to execute the test program A control unit that reads out the duplicate data stored in the predetermined address of the argument storage unit corresponding to the second function and temporarily stores the duplicate data in the temporary storage unit when the function of 2 is called;
A semiconductor test system comprising: In claim 1,
A table unit for storing information indicating a correspondence relationship between the duplicate data and the address of the argument storage unit in which the duplicate data is stored;
The said control part stores the said duplication data in the said predetermined address based on the information which shows the said correspondence memorize | stored in the said table part, The semiconductor test system characterized by the above-mentioned. In claim 1,
The argument storage unit stores information indicating a correspondence relationship between the second function and an address of the argument storage unit in which the duplicate data is stored.

Images