JP2595718B2 - In-circuit emulator - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION <Industrial Application Field> The present invention relates to an in-circuit emulator, and more particularly to an improvement in a software performance evaluation function.

<Prior Art> A microprocessor in-circuit emulator is used when developing and debugging a microprocessor application device. This in-circuit emulator has a function of executing a target microprocessor while stopping it for each instruction and debugging the target program. With the spread of high-level languages (for example, C language) in recent years, there have appeared functions that can be executed while being stopped for each source line in the high-level language to perform high-level language level debugging.

The processing speed of a program written in a high-level language is lower than that of a program written in an assembler language. Therefore, a function of software performance evaluation that can measure which function requires processing time after completion of logical debugging and find an improvement point is desired for an in-circuit emulator.

<Problems to be Solved by the Invention> However, the performance evaluation function attached to the conventional in-circuit emulator has a small number of functions that can be measured, or samples the execution address of the processor at regular time intervals to determine the relative required time. Most can only grasp the tendency of.

In particular, when a certain function calls another function in multiple stages as shown in FIG. 6, it is impossible to accurately measure the time required for each function. FIG. 6 shows the function A
Call the function B from further example in which the function B calls function C, a, b, c, a ', b', respectively the time in terms of _{c 't a, t b,} t c, t _a ', t _b', is set to t _c '. In this case, the time required for the function A T ^- _A is t _a 'is obtained by -t _a, the time required for this function B and _{^{C T - B (= tb'-}} tb), T - C
(= Tc'-tc). Pure duration is T _A = T functions _A ^- A -T ^- _B -T ^- must seek _C.

Some of the objectives that have partially achieved this purpose include, for example, the setting of up to two measurement exclusion sections (corresponding to T _B and T _C in FIG. 6), or the measurement that can be performed only within the range of the section T _A. is there.

However, as a desirable function of performance measurement, in the example of FIG. 6, it is necessary that T _A , T _B , and T _C can be simultaneously and accurately measured. Also, the call depth is not limited to three steps, but it is necessary to be able to collectively measure the number of steps, but no such function has been realized so far. .

The object of the present invention has been made in view of such a point, it is possible to individually and accurately measure the required time only in each function called in multiple stages, and it is necessary to check the mutual calling relationship in advance. It is an object of the present invention to provide an in-circuit emulator capable of correctly tracking the call state at execution time and measuring the time required for a corresponding function.

<Means for Solving the Problems> The present invention for achieving the above object is an in-circuit emulator that can download a target program from a host computer and measure the execution time of a function. Break function block (1) that can set a breakpoint at the beginning of the target CP
A timer function block (2) that can measure only the time during operation of U, a stack memory read function block (3) that reads the contents of the stack memory of the target system during a break, and a host address of all functions Processing means (10) consisting of a start address download function block (4) downloaded from the computer; a break RAM (5) for storing a target program and setting breakpoints; a start address of each function, a measurement mode A function table (6) for holding information on required time, and a pointer stack table (7) for holding a pointer to a table of a corresponding function in the form of a stack every time a break occurs at the beginning of a function. .

<Operation> In the present invention, the calling relation of a function is dynamically represented by a pointer stack format data table at the time of execution. As a result, it is possible to correctly track any calling relationship without checking in advance.

In addition, a return address of a function is read from the stack, and a break is made at a point where the function returns. Thereby, even if the program has a plurality of exits logically, it is possible to detect the end of the function.

Then, it is possible to specify whether each function is included in the required time of the caller.

As a result, the time required for all functions can be measured individually.

<Example> Hereinafter, the present invention will be described in detail with reference to the drawings. FIG. 1 is a main part configuration diagram showing an embodiment of an in-circuit emulator according to the present invention. In the figure, reference numeral 10 denotes a processing means, which comprises various functional blocks. Processing means
In 10, 1 is a multi-point break function block that can set a breakpoint at the beginning of each function, and 2 can measure only the time during which a target central processing unit (hereinafter referred to as a target CPU) is operating. A timer function block 3 is a stack memory read function block for reading the contents of the stack memory of the target system during a break, and 4 is a start address download function block for downloading the start addresses of all functions from the host computer.

5 is a break RAM for storing a target program and setting breakpoints (RAM is a random access memory)
ry), 6 is a function table that holds information on the start address, measurement mode, and required time of each function, and 7 is a pointer stack table that holds a pointer to a table of the corresponding function in a stack every time a break occurs at the start of a function. It is.

FIG. 2 is a configuration diagram showing details of a timer function block.
An AND gate 21 outputs a basic clock CLK (for example,
To 1MH _z), run the target becomes the only running HIGH (R
UN) Gates on signals. The clock (gated clock) output from the AND gate is counted by the counter 22, and the count value is controlled by the emulator control CP.
Read by U23.

Thereby, the execution time of the target can be measured.

The operation in such a configuration will be described step by step.
FIG. 3 shows a memory and various tables, which will be described with reference to FIG.

First, the head address download function block 4 downloads a target program as shown in FIG. 3 from a host computer (not shown).

After downloading the function address, the function table 6
Create

Next, the start address is obtained from the function table 6 by the multipoint break function block 1 and the breakpoints 1 and 2 are obtained.
2, 3 are set at the head of the functions func-A, func-B, and func-C, respectively.

It is assumed that the execution as shown in FIG. 4 is performed in such a state. Depending on the position of the breakpoint, processing is as follows (a)
Or (b).

(A) When a break is caused by a break point n (here, n is one of 1, 2, and 3), processing according to the following algorithm is performed.

(1) The stop address is compared with the head address of the function table to determine which function has been entered.

(2) The pointer pointing to the address of the found function table is placed on the pointer stack of the pointer stack table 7.

(3) sets the time t _a the entrance time of the function table for the table pointed to by the pointer.

(4) Release the breakpoint currently set at the return address.

(5) Get return address from stack and breakpoint Is set and stored in the return address.

(6) Start execution.

(B) Breakpoint set at return address Then, the following processing is performed.

(1) The entry time t _a (or t _b , t _c ) is obtained from the table indicated by the pointer at the top of the pointer stack.

(2) the current time t _a '(or t _b', t _c ') reads, T = t _a' calculate the -t _a, is added to the time required for the function table.

(3) If the timing mode of the function table is “not included”, T is subtracted from the required time of the table pointed to by all the pointers stacked below the stack.

As a result, a pure required time that does not include the required time of the called function can be calculated.

(4) Release the breakpoint set at the return address and remove the pointer at the top of the stack (third
In the pointer stack table in the figure,).

(5) Obtain a return address from the table pointed to by the new stack top pointer, and set a breakpoint there (see the return address column of the function table in FIG. 3).

(6) Resume execution.

Finally, At the time of returning to the above, only the required time of each function is stored in the required time column of the function table of the functions func-A, func-B, and func-C. FIG. 5 shows how the value of the required time of each function changes. Last It can be seen that at each point, the desired value is obtained for each function.

<Effects of the Invention> As described in detail above, the present invention has the following effects.

Since the function exit is obtained from the return address on the stack, there is no need to set a timing point for each exit even if the function has multiple exits, and the function does not need to be managed by the user. The required time can be measured.

Since the calling function is represented as a stack of pointers, it is possible to dynamically and correctly grasp the actual calling relationship without checking in advance, and it is possible to correctly measure the time required for each function regardless of the calling function.

As a result, it has become possible to improve the performance evaluation function as a whole.

BRIEF DESCRIPTION OF THE DRAWINGS FIG. 1 is a block diagram showing an embodiment of an in-circuit emulator according to the present invention, FIG. 2 is a block diagram showing details of a timer function block, and FIG. FIG. 4 is a diagram showing a table, FIG. 4 is an explanatory diagram showing a program flow,
FIG. 5 is a diagram showing the transition of the required time of each function, and FIG. 6 is an explanatory diagram in the case where one function calls another function in multiple stages. 1 ... multipoint break function block, 2 ... timer function block, 3 ... stack memory read function block,
4 ... Start address download function block, 5 ...
Break RAM, 6: Function table, 7: Pointer stack table, 10: Processing means, 21: AND gate, 22: Counter, 23: Emulator control CPU.

Claims (1)

(57) [Claims] 1. An in-circuit emulator that can download a target program from a host computer and measure the execution time of a function, and a multipoint break function block that can set a breakpoint at the beginning of each function. 1) and target CPU
A timer function block (2) that can measure only the time during the operation of the stack, a stack memory read function block (3) that reads the contents of the stack memory of the target system during a break, and a host computer Processing means (10) consisting of a top address download function block (4) downloaded from
And a break RAM (5) for storing the target program and setting breakpoints; a function table (6) for storing information on the start address of each function, measurement mode, and required time; And a pointer stack table (7) for holding a pointer to a table of a function corresponding to the above in a stack form, and dynamically expressing a calling relation of the function in a pointer stack table (7) in a pointer stack format at the time of execution. By reading the return address of a function from the stack and breaking at the point where it returns, even if it is logically a program with multiple exits, it detects the end of the function and calls the individual functions as required by the caller. The time required for all functions can be measured individually by specifying whether to include them in the time. In-circuit emulator characterized in that it can be set.