JPH02116935A - Program analyzing system - Google Patents

Abstract

PURPOSE:To perform to count the number of dynamic steps of every subsystem by giving a ruled name to every prescribed classification with respect to plural functions used for a program, and monitoring it. CONSTITUTION:Plural functions 3 used for a program 1 are classified into every subsystem SE, OS and SF and a specific name is given to them, and thereafter, by using a monitor 11, a function name, a process name, the number of dynamic steps of every function, an address, displacement between the functions, etc., are collected. When the dynamic step is generated, the monitor 11 draws out the name of the function 3 and the subsystem 2 to which the function 3 belongs from a table 14 in accordance with a head address of the function 3 to be brought to access first, and displacement between the functions which is generated is listed up together with related information, and also, the number of dynamic steps is counted at every subsystem 2, and data collected by the monitor 11 is edited in an output format 13 by an editing part 12.

Description

Detailed Description of the Invention (Industrial Application Field) The present invention relates to a program analysis method (prior art) that is performed for the purpose of improving the performance of an operating system, etc. As basic software for operating computer hardware, An operating system (O8) is used. In addition to assembly language, operating systems are generally written in C language in consideration of CPU (central processing unit) portability. When operating such an operating system, multiple subsystems are prepared to support the operating system.

FIG. 2 shows the relationship between such an operating system and subsystems, and particularly shows an explanatory diagram of how dynamic steps occur.

In the figure, when an operating system 1 is executed, various functions 3 making up a subsystem 2 are called at any time. This function 3 is a part also called a module of the subsystem 2 created in C language, and performs a subroutine-like function. During execution of the operating system 1, the process of calling the function 3 as described above is called a dynamic step, and the number of dynamic steps is a parameter for evaluating the performance of the operating system. Furthermore, the displacement between each function during operation of the operating system also serves as a parameter for performance evaluation.

FIG. 3 shows a list of examples of displacements between functions.

Five types of displacement examples are displayed here.
is a command to call a function, "return" is a function call, a command to return to the source, "trap"
is a command that represents a trap exception, "int" is a command that represents another interrupt 7 exception, and "rte" is a command that represents a return from an interrupt 7 exception.

Conventionally, a means called a hardware monitor or a software monitor has been used to measure the number of dynamic steps during execution of such an operating system.

FIG. 4 shows a block diagram of the hardware monitor.

In the figure, a CPU 5 executes the above operating system. Here, the CPU 5 accesses a memory space including subsystems and the like via an address translation cache memory 6 and an external cache memory 7. The address translation cache memory 6 is a memory that stores table data for converting logical addresses output by the CPU 5 into physical addresses. Further, the external cache memory 7 is a memory that extracts and temporarily stores a data group that is actually an access target from the memory empty volume 8.

When performing hardware monitoring, the output of the CPU 5 and the output of the address translation cache memory 6 are captured by the bus cycle collection monitor 9, and the access signals are restored to grasp the program execution status in detail.

Further, FIG. 5 is an explanatory diagram of the operation of the software monitor.

The software monitor does not require a specific measuring device such as the bus cycle collection monitor described above. As an alternative, prepare a program for the system (IIIG) monitor.Then, for each step of the program to be measured, the address signal to be accessed is taken into the system side, and the program is operated again on the device to be measured. Collect the execution status using methods such as reverting the operating system.By printing out the results, you can get a detailed understanding of the operating system's execution status.

(Problem to be Solved by the Invention) By the way, in the conventional analysis using the hardware monitor or software monitor, it is necessary to check the number of appearances of each function shown in Figure 2, or It was common to measure the number of dynamic steps that appeared in the process.

However, for example, clearly understanding the number of dynamic steps for each subsystem and how to move between subsystems makes the analysis results more effective. Conventional systems have not always been satisfactory for performing such analysis.

The present invention has been made with attention to the above points, and an object of the present invention is to provide a program analysis method that allows the number of dynamic steps for each subsystem to be easily recognized.

(Means for Solving the Problems) The program analysis method of the present invention is used for a program when the number of dynamic steps occurring during program execution is counted by monitoring memory addresses accessed by the program. A plurality of functions are given regular names for each predetermined classification, and the start address of the function that is accessed when a dynamic step occurs in the program is recognized, and the name of the function and
The present invention is characterized in that the classification to which the function belongs is identified, the classification is classified according to the classification, and the number of occurrences of the dynamic step is counted.

(Operation) In the method of the present invention, for each function, at the stage of creating a program such as an operating system,
For each predetermined classification such as a subsystem, a function is set with a regularized name having a specific initial letter. Then, when a dynamic step occurs in a program, the name of the function is recognized from the start address of the function to be accessed using a hardware monitor, software monitor, or the like. Thereafter, by classifying and classifying functions based on the characteristics of the names given above, it is possible to count the number of dynamic step occurrences for each classification.

(Example) FIG. 1 is an explanatory diagram for explaining the present invention in detail.

In the method of the present invention, the operating system (
When the program 1 such as O8) is executed, and the function 3 constituting each subsystem 2 is called by a dynamic step, it is monitored by the monitor 11. In the figure, subsystem 2 is SE, OS , SF are shown.

Here, the functions 3 constituting each subsystem are given names as shown in FIG. 6 for each subsystem. This is determined at the stage of building the operating system.

FIG. 6 shows a list showing the relationship between such subsystems and function names.

In the figure, the subsystems are AP, SE, O3゜SF,...
・Nine items are shown, such as DRIVE.

It is assumed that each subsystem includes several functions.

Here, first, the subsystem AP consists of functions whose main storage address is less than "0X4000000", and refers to a subsystem for the user. The functions included in this subsystem are not used by the operating system, so there are no restrictions on their names. Subsystem SE is an execution management system, and each function has the initial letter "e".
Add. Further, subsystem O8 is for system calls, and the first three characters of each function are "O8".

Next, subsystem SF is for file management,
Let the initial letter of each function be "f". Also, subsystem S
C is for communication control, and the initial letter of each function is "c" or "C". The subsystem SU is for system control, and the first character of each function is "u". Furthermore, the subsystem SS is for system control, and the first character of the function is "S."The subsystem SO is for operation management, and the first two characters of the function are "0."

Finally, for DRIVE, in systems other than those mentioned above, give a function name such that the first three characters are the driver name.

As described above, after classifying the functions into subsystems and giving them specific names, as shown in FIG. number of dynamic steps per
Collect addresses, displacements between functions, etc.

This collection method uses the hardware monitor or software monitor described above.
Proceed as explained in the diagram. Therefore, duplicate explanations will be omitted.

Returning to FIG. 1 again, the data collected by the monitor 11 is edited by the editing section 12.

The editing unit 12 edits the data collected by the monitor 11 in an output format 13 as shown in the figure.

That is, the monitor 11 uses Table 1 for the start address of the function that is first accessed when a dynamic step occurs in the operating system 1.
See 4. According to this table 14, it is possible to extract the name of a function and the subsystem to which the function belongs, corresponding to the start address. Also, the displacement between functions is
Subject to editing along with necessary related information. As a result, as shown in output format 13 in the figure, the displacements that have occurred are restored together with related information, and the number of dynamic steps for each subsystem is counted and printed out.

The processing itself such as table reference and classification editing, etc.
Conventionally, commonly used software such as U
5tep, dsa command and e on NIX machine
This can be executed using the mi command or the like.

As described above, as can be seen from the output format 13 shown in FIG. It is easy to find the number of variables, and it is very useful for program analysis.

The present invention is not limited to the above embodiments.

In the above embodiment, an example was shown in which the number of steps for each subsystem is output, but it is also possible to count the number of dynamic steps for each function in parallel using a conventional method.

Furthermore, the method of the present invention is applicable not only to operating systems but also to various cases where the number of dynamic steps occurring during the execution of various programs is monitored and counted.

(Effects of the Invention) According to the program analysis method of the present invention described above, regularized names are given to a plurality of functions used in a program for each predetermined classification, and these are monitored. , the number of dynamic steps can be counted by dividing the data obtained as a result of monitoring into categories.

Therefore, program analysis work can be performed in more detail and more efficiently than in the past.

[Brief explanation of the drawing]

Fig. 1 is an explanatory diagram showing a specific example of the method of the present invention, Fig. 2 is an explanatory diagram of the occurrence situation of dynamic steps, Fig. 3 is a list showing examples of displacement between functions, and Fig. 4 is a hardware diagram. FIG. 5 is a block diagram of the monitor, FIG. 5 is an explanatory diagram of the operation of the software monitor, and FIG. 6 is a list showing the relationship between the names of subsystems and functions in the present invention. 1...Program (OS), 2...Subsystem,
3...Function, 11...Monitor, 12...Editorial department,
13...Output format, 14...Table. Patent applicant Oki Electric Industry Co., Ltd.

Claims (1)

[Claims] In the case where the number of dynamic steps that occur during program execution is counted by monitoring memory addresses accessed by the program, a plurality of functions used in the program are classified according to predetermined classifications. It gives a regularized name, recognizes the start address of the function that is accessed when a dynamic step occurs in the program, identifies the name of the function and the classification to which the function belongs, and classifies it according to the classification. and counting the number of occurrences of the dynamic step.