JPH0318939A - In-circuit emulator - Google Patents

Abstract

PURPOSE:To dynamically and correctly grasp an actual call function without checking it previously and to accurately measure the necessary time of each function by expressing a call function as a stack of a pointer. CONSTITUTION:A target program is down-loaded into a break RAM 5 from a host computer via a head address down-load function block 4. Then a function address is down-loaded and a function table 6 is produced. A head address is obtained out of the table 6 via a multi-point break function block 1, and a break point is set at the head of each function. Under such conditions, the call relation of functions is dynamically expressed into a pointer stack table 7 of pointer stack type in the form of a data table at execution. Then a time function block 2 measures only the working time of a target CPU. Thus any type of call relation can be correctly tracked without checking it previously, and the time necessary for all functions can be individually and accurately measured.

Description

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

<Conventional technology> In-circuit emulators for microprocessors are
Used when developing and debugging microprocessor application equipment. This in-circuit emulator has a function of debugging a target program by causing the target microprocessor to execute each instruction while stopping the instruction. In recent years, due to the inconvenience of high-level languages (for example, C language), some systems have appeared that have a function that allows debugging at a high-level language level by stopping and executing each source line in a high-level language.

A program written in a high-level language has a lower processing speed than a program written in an assembler language.

Therefore, it is desirable for in-circuit emulators to have a software performance evaluation function that can measure whether functions require processing time after logical debugging and find areas for improvement.

<Problems to be Solved by the Invention> However, the performance evaluation function attached to conventional in-circuit emulators is limited in the number of functions that can be measured, or measures the relative time required by sampling the execution addresses of the processor at regular intervals. In most cases, it is only possible to grasp trends.

In particular, when a function calls other functions in multiple stages as shown in FIG. 6, it is impossible to accurately measure the time required for each function. FIG. 6 is an example in which function A calls function B, and function B calls function C, and the times at points a, bc, a', b', and c' are set to 1. 1. 1. 1. ．． 1. 1. It is said that

a b c a b' cIn this case, the required time for function A''-0 is obtained by 1a+-1a, but this is the required time for functions B and C 'T'-(=t
b'-tb) and Tc (=tc'-tc). The pure time required for function A is T = 'I'
−'T” −T−c must be found ^
AB No.

Examples of methods that partially achieve this purpose include, for example, setting up to two measurement exclusion zones (corresponding to 'I' s and T c in Figure 6), or measuring execution only within the range of zone TA. There is.

However, as a desirable function of performance measurement,
In the example shown in the figure, it is necessary to be able to accurately measure T, T゛, and Tc at the same time. Also, the depth of calling is not limited to 3 steps, but it is necessary to be able to measure all the steps at once, but there has never been anything that has achieved this ability. Ta.

The purpose of the present invention has been made in view of the above points, and is capable of individually and accurately measuring the time required only within each function that is called in multiple stages, and further eliminates the need to check mutual calling relationships in advance. The object of the present invention is to provide an in-circuit emulator that can accurately track the call state at runtime and measure the time required for the corresponding function.

Means for Solving the Problems> In order to achieve such objects, the present invention downloads a target program from a host computer,
An in-circuit emulator that can measure the execution time of functions, and a multi-point break function block (that allows you to set breakpoints at the beginning of each function).
1), a timer function block (2) that can only measure the operating time of the target CPU, and a stack memory read function block (3) that reads the contents of the target system's stack memory during a break. Start address download function block (4) that downloads the start address of a function from the host computer
A processing means (10) consisting of a break RAM (5) that stores the target program and can set breakpoints, and a function table (6) that holds information on the start address, measurement mode, and required time of each function. ) and a pointer stack table (7) that holds a pointer to the table of the corresponding function in a stack every time there is a break at the beginning of the function. is dynamically expressed in a pointer stack format data table at runtime. With this, it is possible to accurately trace any calling relationship without having to check it in advance.

Also, read the return address of the function from the stack and break at the point where it returns. This makes it possible to detect the end of all functions even if the program has multiple logical exits.

Additionally, it is now possible to specify whether or not each function should be included in the required time for the caller.

As a result of doing the above, it is possible to measure the time required for all functions individually.

<Example> The present invention will be described in detail below with reference to the drawings.

FIG. 1 is a block diagram of essential parts of an embodiment of an in-circuit emulator according to the present invention. In FIG. 0, numeral 10 denotes a processing means, which is composed of various functional blocks. In the processing unit PiIO, 1 is a multi-point break function block that can set breakpoints at the beginning of each function, and 2 is a target central processing unit (hereinafter referred to as target CP).
3 is a stack memory read function block that reads the contents of the target system's stack memory during a break, and 4 is a host for the start address of all functions. This is the start address download function block that is downloaded from the computer.

5 Break RAM that can store target programs and set breakpoints (RAM is 11 and
IAccess Memory), 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 that holds a pointer to the table of the corresponding function in a stack every time there is a break at the beginning of the function. It's a table.

FIG. 2 is a configuration diagram that does not show details of the timer function block.
The gate is applied with the RUN signal. AN
The tarock (gated clock) output from the D gate is counted by a counter 22, and the count value is read by the emulator control CPU 23.

This allows the target execution time to be measured.

The operation in such a configuration will be explained step by step. FIG. 3 is a diagram showing the memory and various tables, and the explanation will be made with reference to this.

(1) First, a target program as shown in FIG. 3 is downloaded from a post computer (not shown) using the head address download function block 4.

■After downloading the function address, function table 5
Create.

■Next, the multi-point break function block 1 obtains the start address from the function table 5 and breaks the break point 1.
, 2.3 respectively as the number func-A.

Set at the beginning of func-8 and func-C.

Assume that the execution as shown in FIG. 4 can be carried out in this state. The processing is divided into the following (a) or (b) depending on the position of the breakpoint.

(a) When a break occurs at breakpoint n (here, n is either 1.2°3), processing is performed according to the following algorithm.

(1) Find out the stop address and the start address of the function table to determine which function is entered.

(2) Point the pointer to the address of the found function table Pointer stack Table 6 pointer stack■
Pile it on.

(3) Set time t to the entry time of the function table for the table pointed to by the pointer.

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

(5) Obtain the return address from the stack, set breakpoints (O1■, ■), and store them at the return address.

(6) Start execution.

(b) Breakpoint set at the return address (4th
The following processing is performed in (■) and (O) in the figure.

(1) Entry time t (or 1.1)a from the table pointed to by the top pointer on the pointer stack
Get bc.

(2) Read current time 1, (or 1, 1.) a
b' c including, 1'=t, -ta are calculated and added to the required time of the function table.

(3) If the time measurement mode of the function table is "not included", subtract T from the required time of the tables pointed to by all pointers stacked below the function table.

This allows you to calculate the pure required time, which does not include the time required for the called function.

(4) Release the breakpoint set at the return address and remove the stack top pointer (3rd
■ Pointer stack table in figure.

■).

(5) Obtain the 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 number of spaces table in FIG. 3).

(6) Resume execution.

As a result of the above, when we finally return to the function func-A
, func-B, and funcJ, only the required time of each function is stored in the required time shelf of the function table.

FIG. 5 shows how the values of the required time for each function change. It can be seen that at the last point O, the desired values are obtained for each function.

<Effects of the Invention> As described above in detail, 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 output even if the function has multiple exits, and the user can manage these exit addresses. You can measure the time required for a function without any problems.

■Since calling functions are represented as a stack of pointers, it is possible to dynamically and accurately grasp the actual calling relationships without checking in advance, and the time required for each function can be accurately measured regardless of the calling function.

These things made it possible to improve the performance evaluation function as a whole.

[Brief explanation of drawings]

FIG. 1 is a block diagram showing the main parts of 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, FIG. 3 is a diagram showing memory and various tables, and FIG. The figure is an explanatory diagram showing the flow of 10 grams,
FIG. 5 is a diagram that does not show changes in the time required for each function, and FIG. 6 is an explanatory diagram when a certain function calls other functions in multiple stages. 1...Multi-point 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
...Top diagram

Claims (1)

[Claims] An in-circuit emulator that can download a target program from a host computer and measure the execution time of a function, and a multi-point break function block that can set a breakpoint at the beginning of each function. (1), a timer function block (2) that can only measure the operating time of the target CPU, and a stack memory read function block (2) that reads the contents of the stack memory of the target system during a break.
3), a processing means (10) consisting of a start address download function block (4) that downloads the start addresses of all functions from the host computer, and a break RAM (5) that stores the target program and can set breakpoints. , a function table (6) that holds information on the start address, measurement mode, and required time of each function, and a pointer stack table (7) that holds a pointer to the table of the corresponding function in a stack every time a break occurs at the beginning of a function. ), the function call relationship is dynamically expressed as a data table in the pointer stack table (7) in pointer stack format during execution, and the logic is Even in programs with multiple exits, it is possible to detect the end of all functions, and to specify whether or not to include each function in the caller's required time. An in-circuit emulator characterized by being able to measure time individually.