JP2003030007A - Program development support system, program development support method, computer-readable recording medium storing program development support program, and program development support program - Google Patents

Abstract

(57) [Problem] To design a program that performs a conventional state transition operation, it is difficult to handle design information related to the state transition and design information related to the execution time limit in a cooperative manner. There was a problem of forgetting or overlooking the description of the design information regarding the time limit. SOLUTION: The program development support system according to the present invention is configured such that a state transition editor 1 designates event information, action information, and time limit information indicating an action execution time limit as state transition information in correspondence with the action information. Specify element information. The program automatic generation means 3 selects a program component from the program component storage unit 9 based on the component information and generates a program according to the state transition information and the component information using the selected program component. At this time, the generated program includes a process of measuring the actual execution time of the action, comparing the actual execution time measured and the execution time limit, and presenting the result.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a system for supporting development work related to state transition in program development, and more particularly to a program development support system for supporting development work related to processing time of a program required for state transition. The present invention also relates to a program development support method, a computer-readable recording medium recording the program development support program, and a program development support program.

[0002]

2. Description of the Related Art With the rapid development of information processing technology and the expansion of application fields, the scale and functions of programs to be developed are generally expanding rapidly. In response to this situation, various technologies are currently being developed to improve program development efficiency and quality. For example, in a control system, communication system, or embedded system program, in general, the operating specifications of a program are often defined as a plurality of states and transitions between the states. Therefore, in software development in these fields, the state transition specifications are specified. A method has been developed to support program development by describing it formally.

FIG. 20 is a description example of the state transition shown in Japanese Patent Laid-Open No. 7-78076 "Automatic Program Generator". This method is a description method widely known as a state transition diagram.
It contains four elements called actions. An event is an event that occurs in the system, and an action is a process that is performed when transitioning from one state to another state due to the occurrence of the event. In this description method, states are circles, transitions between states are arrows, and events and actions are described in the form of "event / action" on both sides of "/" accompanying the transitions. SN1 and SN2 represent different states, an arrow from SN1 to SN2 represents a transition from state SN1 to state SN2, and en1 represents an event that triggers the transition.
an1 represents an action performed at the time of the transition.

For formal description of state transition, description methods such as a state transition diagram and a state chart and a state transition table are widely used. The statechart is UML (Un
This is a description method of state transitions defined by "iform Modeling Language", and is characterized in that state hierarchies and parallel state transitions can be easily described as compared with state transition diagrams. However, basically, a description method using a graphic similar to the state transition diagram is adopted,
States are described as rectangles, transitions are indicated by arrows between states, and events and actions are described as annotations for transitions. on the other hand,
The state transition table is a tabular description method. States are listed in columns (horizontal direction) and events are listed in rows (vertical direction). Each cell in the table that is an intersection of rows and columns has a corresponding column. The state and action of the transition destination at that time are described in each of these cells as a transition that occurs in the state shown by the event indicated by the corresponding row. FIG. 21 shows an example of the state transition description based on the state transition table. In this example, the state SN1
Indicates that the action an1 is performed in the transition triggered by the event en1 to transit to the state SN2. This description content is equivalent to the description example using the state transition diagram shown in FIG.

As described above, in a control system, a communication system, or an embedded system program, its operation can often be described by state transitions. Therefore, in software development in these fields, the state transitions described above are performed at the design stage. It is widely practiced to use formal description of state transitions using diagrams, state charts, state transition tables, or other methods with equivalent description capabilities. By adopting these formal description methods, it becomes possible to clearly describe the operation specification of the program and to verify its accuracy easily, and it is possible to improve the development efficiency and quality of the program. Such a formal description method of state transition is used not only in the above field but also in designing a program that realizes a user interface of a device, for example. The operation of the user interface can be expressed as a state transition by using the user's operation on the device as an event, and by using the formal description method of the state transition, the development efficiency and quality of the program can be improved. This is because.

[0006]

By the way, in a control system, a communication system, or an embedded system, there is usually a limitation on the time required for the processing, that is, a real-time operation is usually required. Regarding the user interface of the device, in order to realize a comfortable operability for the user, there are often restrictions on the time required from the operation to the response in designing the program.

However, in general, the restrictions on the program operation time are rarely described formally at the program design stage, and usually in the form of comments attached to the program design information in addition to the design information on the program logic. Often written in natural language. For example, in any of the formal description methods regarding the state transition described above, the description regarding the execution time (execution time limit) allowed for the processing of the action is not formalized. Therefore, it is usually difficult to handle the design information related to the state transition operation and the design information related to the execution time limit, and the design information related to the execution time limit is easily forgotten or overlooked. There is also a problem in that the test concerning is likely to be overlooked at the time of its design.

In order for the developed system to operate while satisfying the time constraint, generally, the program is first run to measure whether or not the design time constraint is satisfied, and there is a problem. If you analyze its internal operation,
Repeat the work to shorten the processing time by removing the defect that causes the time excess or improving the operation logic, and finally satisfy the time constraint in design, or Follow the procedure such that it fits within the limit. This work is carried out in the downstream process of program development where the program can operate, but at this stage the delay in the development process is often a problem, and this work requires repeated measurement work and takes a lot of man-hours. Therefore, there is a problem that it is difficult to carry out the operation without omission.

The present invention has been made to solve the above-mentioned problems of the prior art. At the time of designing a state transition, the time limit (execution time limit) allowed for the processing of the action is described at the same time. In addition, by making it easy to measure the time required for action processing (actual measurement time) and analyze the execution time limit and the actual measurement time, omission of the specification regarding the execution time limit and test design and The purpose is to prevent omission of implementation, to enable sufficient verification and improvement regarding execution time limit, and to improve development efficiency and quality of programs.

[0010]

A program for developing a program which executes an action designated by an event that occurs according to the present invention to transition one state among a plurality of states to another state and which operates on a computer The development support system includes a program component storage unit that stores a plurality of program components of the program, state information indicating each of a plurality of states transitioned by the program, event information indicating the event, and the action. And the time limit information indicating the time limit of the process for executing the action for each of the actions is specified as the state transition information, and is used to execute the action in association with the action information. State transitions that specify program components as component information An editor and a program for selecting an appropriate program component from the program component storage unit based on component information specified by the state transition editor, and executing an action including the selected program component, A program for executing the process of measuring the actually measured execution time when the action is executed, and the process of presenting the result of comparison between the measured actually measured time and the time limit specified by the state transition editor. And a program generation unit for generating

Further, in the program development support system according to the present invention, the program development support system further executes the program generated by the program generation unit, and executes an action measured by executing the program. A program execution unit that notifies the actual measurement time for each action, an execution actual measurement time collection unit that receives the actual execution time measurement for each action notified by the program execution unit, and collects the actual execution time measurement for each action, and the above execution The actual measurement time for each action collected by the actual time collection unit is acquired, and the time limit information for each action specified by the state transition editor is acquired, and the time limit information and the actual measurement time for execution are acquired. It is equipped with an execution time analysis unit that compares and presents the comparison results. To.

Also, in the program development support system according to the present invention, the program execution unit executes one action a plurality of times according to an event that occurs, and the execution measurement time collection unit collects the execution measurement for each collected action. Based on the time, at least one of the average execution measurement time for each action and the maximum execution measurement time for each action is obtained, and the execution time analysis unit calculates the average measurement for each action obtained by the execution measurement time collection unit. At least one of the time and the maximum actual measurement time for each action is compared with the time limit information for each action designated by the state transition editor, and the comparison result is presented.

Further, in the program development support system according to the present invention, the execution measurement time collection unit obtains a statistical execution measurement time which is a statistical value for each action based on the collected execution measurement time for each action, The execution time analysis unit compares the statistical execution measurement time for each action obtained by the execution measurement time collection unit with time limit information for each action specified by the state transition editor,
The feature is that the result of the comparison is presented.

Further, in the program development support system according to the present invention, the program constituent element is either a function for performing a predetermined process or a case including one or more functions for performing a predetermined process. The program generation unit generates a program that executes a process of measuring the function execution actual measurement time when the function is executed, and the program execution unit executes the program generated by the program generation unit. The process for measuring the function execution actual measurement time is executed, and the program development support system is activated by the process for measuring the function execution time executed by the program execution unit to measure the function execution actual measurement time for each function. The function execution time measurement unit collects the function execution time measurement unit, and the execution time analysis unit collects the function execution time measurement unit. Characterized in that it presents to obtain the function execution measured time for each function.

Also, in the program development support system according to the present invention, the state transition editor indicates the time limit of the processing when the state transition editor executes the program component indicated by the component information in association with the component information. Designating the component time limit information, the program generation unit, a process of measuring the component execution actual measurement time when executing the program component for each of the program components, and the measured component execution actual measurement time It is characterized by generating a program for executing a process of comparing the constituent element time limit information designated by the state transition editor and presenting a result of the comparison.

Further, in the program development support system according to the present invention, the program execution unit executes the program generated by the program generation unit, and the component execution actual measurement time for each program component is measured. The execution measurement time collection unit is notified, the execution measurement time collection unit collects the component execution measurement time for each program component notified by the program execution unit, and the execution time analysis unit calculates the execution measurement time. By comparing the component execution actual measurement time for each program component collected by the collection unit with the component time limit information for each program component specified by the state transition editor,
The feature is that the result of the comparison is presented.

Further, in the program development support system according to the present invention, the program constituent element is either a function for performing a predetermined process or a function including one or more functions for performing a predetermined process, The component time limit information specified by the state transition editor is the function time limit information of the process when the function is executed, and the program generation unit measures the function execution actually measured time when the function is executed. A program for executing a process is generated, and the program execution unit executes a process of measuring the function execution measurement time by executing the program generated by the program generation unit. The function execution for each function is started by the process of measuring the function execution actual measurement time, which is executed by the program execution unit. A function execution time measurement unit that measures and collects the actual measurement time is provided, and the execution time analysis unit acquires the function execution actual measurement time for each function collected from the function execution time measurement unit and uses the state transition editor. It is characterized in that the function time limit information for each designated function is acquired, the function execution actual measurement time is compared with the function time limit information, and the comparison result is presented.

Further, in the program development support system according to the present invention, the execution time analysis unit presents the function execution actually measured time in the order of the function having the longest function execution actually measured time and the function execution actually measured time. It is characterized in that either of the above-mentioned actions is presented in descending order of influence on the actually measured execution time.

Further, in the program development support system according to the present invention, the function execution time measuring unit calculates the statistical function execution actually measured time which is a statistical value for each function based on the collected function execution actually measured time for each function. Then, the execution time analysis unit
It is characterized in that it is presented in descending order of variation based on the statistical function execution actual measurement time obtained by the function execution time measurement unit.

Also, in the program development support system according to the present invention, the execution measurement time collection unit obtains a statistical execution measurement time which is a statistical value for each action based on the collected execution measurement time for each action, The function execution time measurement unit obtains a statistical function execution measurement time, which is a statistical value for each function, based on the collected function execution measurement time for each function, and the execution time analysis unit calculates the execution measurement time collection unit. Based on the statistical execution actual measurement time obtained by the above and the statistical function execution actual measurement time obtained by the above function execution time measuring unit, the above-mentioned function execution actual measurement time is presented in the order of increasing influence on the statistical execution actual measurement time of the above action. It is characterized by doing.

Further, in the program development support system according to the present invention, the program constituent element is either a function for performing a predetermined process or a case including one or more functions for performing a predetermined process. The component time limit information specified by the state transition editor is the function time limit information of the process when the function is executed, and the program generation unit measures the function execution measured time when the function is executed. The program development support system further executes the program generated by the program generation unit, and executes the program to measure the function execution measurement time. Program execution unit to be executed, and processing for measuring the function execution actual measurement time executed by the program execution unit The function execution time measurement unit that is activated by measuring the function execution actual measurement time for each function and the function execution actual measurement time for each function collected by the function execution time measurement unit are acquired, and the state transition is performed. The function time limit information for each function designated by the editor is acquired, and the function time measurement time and the function time limit information are compared, and an execution time analysis unit that presents the comparison result is provided. Characterize.

According to the present invention, there is provided a program development support method for developing a program operating on a computer, which executes a transition between designated states of a plurality of states according to an event that occurs, and which is one of the above actions. Program components for performing the predetermined processing included above are stored in the program component storage unit, and status information indicating each of a plurality of transition states of the program, event information indicating the event, and the action And the time limit information indicating the time limit of the process when executing the above action for each of the above actions is specified as the state transition information,
A program component included in the action is designated as component information in association with the action information, and a corresponding program component is selected from the program component storage unit based on the designated component information and selected. In addition to executing the action including the program component described above, the process of measuring the actually measured execution time when executing the above action and the comparison of the measured actually measured time with the specified time limit are presented and the result of comparison is presented. It is characterized by generating a program for executing the processing.

Further, in the program development support method according to the present invention, the program development support method further executes the generated program, and sets an action execution measurement time measured by executing the program. Each time it is notified, the execution measurement time for each action is notified, the execution measurement time for each action is collected, the execution measurement time for each action is acquired, and the specified action is specified. Each time limit information is acquired, the time limit information is compared with the execution actual measurement time, and the comparison result is presented.

Further, in the program development support method according to the present invention, the time limit for processing when the program development support method further executes the program component indicated by the component information in association with the component information. Specifying the component element time limit information, and processing for measuring the component execution actual measurement time when the program component is executed for each program component, and the measured component execution actual measurement time and the specified It is characterized by generating a program that executes a process of comparing the constituent element time limit information and presenting a result of the comparison.

Further, in the program development support method according to the present invention, the program development support method further notifies the component execution actual measurement time for each program component measured by executing the generated program,
The component execution actual measurement time of each notified program component is collected, and the collected component execution actual measurement time of each program component is compared with the component time limit information of each designated program component. Then, the result of the comparison is presented.

Further, in the program development support method according to the present invention, the program component is either a function for performing a predetermined process or a case including one or more functions for performing a predetermined process. The specified time limit information is the function time limit information of the process when the function is executed, and when the program is generated, the process of measuring the function execution measured time when the function is executed is executed. The program development support method further includes executing the generated program, executing the process of measuring the function execution actual measurement time by executing the program, and executing the function execution actual measurement. It is started by the process of measuring the time, and the measured function execution time for each function is measured and collected, and the measured function execution time for each function is acquired. Together, it acquires the function time limit information for each function that is the specified, by comparing the function execution measured time and the function restriction time information, characterized in that it presents the results of a comparison.

According to the present invention, a computer readable recording program development support program for developing a program operating on a computer that executes a specified action to transit between predetermined states of a plurality of states according to an event that occurs In the recording medium, a program component for storing a program component, which is stored in the computer-readable recording medium, for performing a predetermined process included in one or more of the actions in the program component storage unit. Storing step, status information indicating each of a plurality of transition states of the program, event information indicating the event, action information indicating the action, and processing for executing the action for each action System that indicates the time limit of The time transition information is designated as the state transition information, and the state transition information designating step of designating the program component included in the action as the component information in association with the action information, and the state transition information designating step. Based on the component information, the corresponding program component is selected from the program component storage unit, the action including the selected program component is executed, and the actual measurement time for executing the action is measured. And a program generation step of generating a program for executing the processing and the processing of presenting the result of comparison by comparing the measured actual measured time with the time limit specified by the state transition information specifying step. Characterize.

Further, in a computer-readable recording medium recording the program development supporting program according to the present invention, the program development supporting program recorded in the computer-readable recording medium is further generated by the program generating step. By executing the program, the program execution process for notifying the action execution measurement time measured by executing the program for each action, and the execution measurement time for each action notified by the program execution process are received. , The actual measurement time collecting step for collecting the actual execution time for each action, and the actual execution time for each action collected by the actual execution time collecting step, and for each action specified by the state transition information designating step Get time limit information and Te, and comparing the limit time information and the execution measured time, and having an execution time analysis step of presenting the results of a comparison.

Further, in a computer-readable recording medium recording the program development supporting program according to the present invention, the state transition information designating step of the program development supporting program recorded in the computer-readable recording medium has the above structure. Corresponding to the element information, the constituent element time limit information indicating the time limit of the process when the program constituent element indicated by the constituent element information is executed is designated, and the program generation step includes the program for each program constituent element. The result of comparing and comparing the process of measuring the component execution actual measurement time when executing the component and the measured component execution actual measurement time and the component time limit information designated by the state transition information designating step Is generated, and a program for executing the processing is presented.

Further, in a computer-readable recording medium recording the program development supporting program according to the present invention, the program executing step of the program developing supporting program recorded in the computer readable recording medium is the program generating step. The component actual measurement time for each program component measured by executing the program generated by is notified, and the execution actual time collection step is performed by the program execution element notified by the program execution step. The actual measurement time is collected, and the execution time analysis step is performed by the component actual measurement time for each program constituent element collected by the actual execution time collection step Compare with the component time limit information, Characterized in that it presented the results of the compare.

In the computer-readable recording medium in which the program development support program according to the present invention is recorded, the above-mentioned program constituent elements are a function for performing a predetermined process, and one or more functions for performing a predetermined process. And the time limit information specified by the state transition information specifying step is function time limit information of processing when executing a function, and the program generation step executes the function. A computer-readable recording medium that generates a program for performing the process of measuring the function execution actual measurement time in the case of storing the program development support program further executes the program generated by the program generating step. , By executing the above program, execute the process to measure the function execution actual measurement time. A program execution step, a function execution time measurement step that is started by the processing for measuring the function execution actual measurement time executed by the program execution step, and measures and collects the function execution actual measurement time for each function, and the function execution The function execution actual measurement time for each function collected in the time measuring step is acquired, and the function time limit information for each function specified in the state transition information specifying step is acquired to obtain the function execution actual measurement time and the function restriction. And an execution time analysis step of presenting a result of the comparison.

In the program development support program for developing a program operating on a computer, which executes a designated action between a plurality of predetermined states according to the present invention, the program development support program is developed. But in the above action 1
A program component storing step of storing, in the program component storage unit, a program component that performs one or more predetermined processes, state information indicating each of a plurality of transition states of the program, and the event The event information indicated, the action information indicating the action, and the time limit information indicating the time limit of the process for executing the action for each of the actions are specified as the state transition information and are associated with the action information. State transition information specifying step of specifying the program constituent elements included in the above action as constituent element information,
A corresponding program component is selected from the program component storage unit based on the component information designated by the state transition information designating step, an action including the selected program component is executed, and the action is executed. And the process of measuring the actual measurement time
A program generation step of generating a program that compares the measured actual measurement time with the time limit specified by the state transition information specification step, and presents a result of the comparison. To do.

In the program development support program according to the present invention, the program development support program further executes the program generated in the program generation step, and executes an action measured by executing the program. A program execution process for notifying the actual measurement time for each action, an execution actual measurement time collecting process for receiving the actual execution time for each action notified by the program execution process, and collecting the actual execution time for each action, and the above execution The actual measurement time for each action collected by the actual measurement time collection step is acquired, and the time limit information for each action specified by the state transition information specification step is acquired, and the time limit information and the actual measurement time for execution are acquired. Execution time analysis engine that compares with and presents the comparison result Characterized in that it has and.

Further, in the program development support program according to the present invention, the time limit for processing when the state transition information designating step executes the program component indicated by the component information in association with the component information. Specifying the component time limit information, the program generation step, the process of measuring the component execution actual measurement time when executing the program component for each program component, and the measured component execution actual measurement It is characterized by generating a program for executing a process of comparing the time and the component element time limit information designated by the state transition information designation step and presenting the result of the comparison.

In the program development support program according to the present invention, the program execution step notifies the component element actual measurement time of each program component element measured by executing the program generated by the program generation step. Then, the execution measurement time collection step collects the component execution measurement time of each program component notified by the program execution step, and the execution time analysis step collects the program collected by the execution measurement time collection step. It is characterized in that the actual measurement time of component execution for each component is compared with the component time limit information for each program component designated by the state transition information designating step, and the comparison result is presented.

Further, in the program development support program according to the present invention, the program constituent element is either a function for performing a predetermined process or a case including one or more functions for performing a predetermined process. The time limit information specified by the state transition information specifying step is function time limit information of the process when executing the function, and the program generating step measures the function execution actually measured time when executing the function. Generating a program for executing the processing, the program development support program further executes the program generated by the program generation step, and executes the program to measure the function execution measurement time. Measure the program execution process to be executed and the function execution measurement time executed by the program execution process The function execution time measurement step that is started by the processing to measure and collect the function execution measurement time for each function, and the function execution measurement time for each function collected by the function execution time measurement step are acquired. A function time limit information for each function designated by the state transition information designation step is acquired, the function execution measured time is compared with the function time limit information, and an execution time analysis step of presenting the comparison result is performed. It is characterized by having.

[0037]

BEST MODE FOR CARRYING OUT THE INVENTION In the embodiments described below,
The program generation unit is a program automatic generation unit, the program execution unit is a program execution unit, the execution measurement time collection unit is the execution measurement time collection unit, the execution time analysis unit is the execution time analysis unit, and the function execution time measurement unit is the function execution time measurement unit. Called.

The program component is a collection of source codes written in a predetermined programming language for causing a computer to execute the four arithmetic operations, the branch processing, the control processing, the function, and the like. Is. The case where the collection of source codes is a function is particularly called a "program part", but in each of the following embodiments, the collection of source codes is not a function and is not a function (four arithmetic operations processing, branching processing, control Processing for performing) is referred to as a “program component” without distinguishing it from the case. Further, component information is part information, program component is a program component, component time limit information is part time limit information, component execution actual measurement time is part execution actual measurement time, and program component storage step is program part storage step. Call. Also, it is not a function (four arithmetic operations,
It is assumed that the branch process, the process for performing control, and the program components that are functions are both stored in the program component storage unit.

Embodiment 1. 1 is a system configuration diagram of a program development support system according to a first embodiment of the present invention. As shown in FIG. 1, this embodiment includes a state transition editor 1, a state transition information holding unit 2, a program automatic generation unit 3, a program source code 4, and a program component storage unit 9.

In the present embodiment, the program developer uses the state transition editor 1 as the information regarding the state transition in the operation specifications of the program, the state information indicating each state of the plurality of states and the plurality of events. The event information indicating each event, the transition between the states caused by the occurrence of the event in each state, and the action information indicating the action executed in each transition are described as the state transition information. In the description of an action, part information such as which program part is called in what procedure in correspondence with the action information, for example, the program flow is described, and the time limit (the time limit allowed for the process) is added as necessary. Describe the time limit information indicating the execution time limit.

State transition editor 1 in the present embodiment
2 and 3 show examples of the state transition information described in. Figure 2
Is an example of description of state transition information by the state transition editor 1 in the present embodiment. In the present embodiment, in the state transition information, the state 11 is represented by a circle and the transition 12 between states is represented by an arrow in accordance with the format of the state transition diagram. In addition, the event that triggers the transition 12, the action executed in the transition 12, and the execution time limit of the action are displayed in the transition 12 in the format of “event / action / execution time limit” that is connected using “/”. Described in accompanying. If it is not necessary to define the execution time limit, describe it as "event / action /-" or "event / action". In the description example shown in FIG. 2, SN
There are three states 11, 1, SN2, SN3, and state S
The transition 12 from N1 to state SN2 is "enA / an12.
/ T12 ”, that is, the transition triggered by the event enA, the action an12 is performed, and the execution time limit at that time is t12.

FIG. 3 is a description example of a program flow (parts information) of an action by the state transition editor 1 in this embodiment. In the description example shown in FIG. 3, the process S10 of the action an12 is described, and the process S10 is described.
First executes the program component p1 (S11), then inspects the execution result of p1 (S12), and if the result is true (YES in S12), executes the program component p2 (S13). To finish. If the execution result of p1 is not true (NO in S12), the process is immediately terminated.
The program components p1 and p2 are program components stored in the program component storage unit 9. Registration of the program component in the program component storage unit 9 is performed by the program component storage step. The description of the state transition information and the description of the component information are performed in the state transition information specifying step.

The state transition information and the component information described by the state transition editor 1 are stored in the state transition information holding means 2. Further, the contents held by the state transition information holding means 2 can be revised again by the program developer using the state transition editor 1 and saved again. The program automatic generation unit 3 refers to the program component storage unit 9 based on the component information held in the state transition information holding unit 2, selects a program component to be used, and holds the selected program component and state transition information. The program source code 4 for realizing the state transition processing is automatically generated based on the content of the state transition information stored in the means 2. The program source code 4 generated at this time may include a process of verifying the execution time limit for any action, or may not include such a verification process at all. When the execution time limit is described in association with the action information, a process for verifying the execution time limit for the action is included. If the execution time limit is not described in association with the action information, the process of verifying the execution time limit for the action is not included.
The generation of the program source code 4 is performed by the program generation step.

An example of a flow chart of the program source code 4 generated by the program automatic generation means 3 in the present embodiment is shown in FIGS. FIG. 4 is a flowchart of a basic state transition process S20 in which the verification process for the execution time limit is not performed for any action in the program source code that realizes the state transition process that operates in the event-driven type. is there. The program automatic generation means 3 automatically generates a program that operates according to the flowchart shown in FIG. At this time, the program component used in the action is selected and used from the program component storage unit 9 based on the component information designated by the state transition editor 1.

In the process S20 shown in FIG. 4, the initialization process necessary for the operation of the program is first performed (S21), and then the state SN1 is set to the present state as the initial state at the start of the program (S22). After that, the occurrence of an event that triggers the state transition is waited (S23), and when the event occurs, the action execution and the process transition to the next state S24 are performed according to the current state and the occurred event, and then the event The occurrence waiting (S23) is repeated.

In the step S24 of executing an action and transitioning to the next state, the current state is first checked (S25), and if the state is SN1, the corresponding step S26 is performed again.
If it is N2, the corresponding process S27 is performed, and then the state SN3
If so, the corresponding process S28 is executed. In the process S26 corresponding to the state SN1, the generated event is checked (S
261), if the event is enA, action a
n12 is executed (S262), the current state is set to the post-transition state SN2 (S263), and the process S26 is ended. If it is other than the event enA, the process S26 is ended as it is. In the process S27 corresponding to the state SN2,
Examine the event that occurred (S271), if event e
If it is nB, the action an23 is executed (S27
2), the current state is set to the state SN3 after transition (S27
3) After that, the process S27 ends, and if the event enD
If so, the action an21 is executed (S274),
The current state is set to the post-transition state SN1 (S275), and then the process S27 is ended. Otherwise, the process S27 is ended. In the process S28 corresponding to the state SN3, the generated event is checked (S281). If the event is enC, the action an32 is executed (S282), and the current state is set to the state SN2 after transition (S283). After that, the process S28 ends, and if the event is enD, the action an31 is executed (S
284), the current state is set to the state SN1 after the transition (S
285) and then the process S28 ends, and otherwise, the process S28 ends.

On the other hand, FIG. 5 performs a verification process for the execution time limit for the action an12 executed in the transition from the state SN1 to the state SN2 in the program source code that realizes the state transition process operating in the event driven type. 7 is a flowchart of a state transition process S30 thus performed.

The process S30 shown in FIG. 5 is basically the same logic as the process S20 shown in FIG. 4, except that the process S32 for measuring the execution time is added and the state SN1 is added. It is only that the corresponding process S26 is changed to the process S33 including the verification process regarding the execution time limit. That is, like the process S20, the process S30 first performs an initialization process required for the operation of the program (S21),
Next, the state SN1 is set to the current state as the initial state at the start of the program (S22). After that, the occurrence of an event that triggers the state transition is waited for (S23), and when the event occurs, the execution of the action including the verification processing of the execution time limit for the event an12 and the next state are performed according to the present state and the event that occurred. Processing of the transition of S31 is performed, and then the waiting for the occurrence of an event is repeated (S2
3).

In step S31 of executing the action and transiting to the next state, the current time is obtained and stored in the variable t (S3
2) Then, check the current state (S25), and if the state S
If N1, the corresponding process S33 is performed, if the state is SN2, the corresponding process S27 is performed, and if the state is SN3, the corresponding process S28 is performed. Note that the process S27 corresponding to the state SN2 and the process S28 corresponding to the state SN3
Is the same as the processing S27 and S28 shown in FIG. 4, and therefore its explanation is omitted, and hereinafter, the processing S3 corresponding to the state SN1 is performed.
3 is shown.

In the process S33 corresponding to the state SN1, the generated event is checked (S261), and if the event en
If it is A, the action an12 is executed (S26
2), the current state is set to the state SN2 after the transition (S
263). Then, the difference between the current time and the time saved in the variable t, that is, the time required to execute the action an12 (actual measurement time) is obtained (S34). If the difference is larger than the execution time limit t12 of the action an12, (YES in S35), a warning indicating that the actual measurement time of the action an12 cannot satisfy the execution time limit is output (S36), and the process S33 ends. On the other hand, when the difference is less than the execution time limit t12 (N in S35)
O) ends the process S33 without outputting a warning. If the generated event is other than the event enA, the process S33 corresponding to the state SN1 is finished as it is.

In FIG. 5, in addition to the basic state transition process S20 shown in FIG. 4, only the verification process for the execution time limit is added to the action an12 executed in the transition from the state SN1 to the state SN2. Processing S
Although 30 is shown, the verification processing regarding other actions may be added to the processing S20 in the same manner, and the program automatic generation means 3 in the present embodiment has a form as shown in FIG. It operates to add a verification process for the execution time limit to an arbitrary action.
In the processes of S32, S34 to S36 of FIG. 5, the model of the program source code for measurement is incorporated in the automatic program generation means 3, and the automatic program generation means 3 performs the action anX for measuring the execution time. Depending on,
The template is appropriately modified and then added to an appropriate place in the program source code. Further, the automatic program generation means 3 generates a program according to the program flow shown in FIG. 3 when generating a program for processing an action. The program component described in the program flow is selected from the program component storage unit 9 and incorporated when the program is generated.

In this embodiment, since the program development support system operates as described above, when designing the state transition, it is possible to simultaneously describe the time limit allowed for processing the action together with the state transition. The process of measuring the time required to process an action and comparing it with the execution time limit can be automatically embedded in the generated program source code. As a result, it is possible to prevent the design information about the execution time limit from being forgotten or overlooked, and to avoid forgetting to design or execute the test regarding the execution time limit, which simplifies the verification work.
This makes it easier to sufficiently carry out verification and improvement work related to time constraints in the downstream process of software development, and the effect of improving program development efficiency and quality can be obtained.

In the present embodiment, the execution time limit for an action is described as an accompanying notation such as "event / action / execution time limit" for a transition. In contrast, if only the "event / action" is described and the execution time limit is described together with the program flow for the action, the execution time limit is separately described as attribute information for the entire program flow. good. Further, in the present embodiment, the description of the state transition is performed according to the format of the state transition diagram. The same effect can be obtained. Similarly, in this embodiment, the processing of actions is described as a program flow, but this is
AD (problem analysis diagr
am) and HCP (hierarchical and
compact description char
Similar effects can be obtained by adopting another graphic description method such as t) or a text description method such as the source code of a program.

When comparing the execution time limit and the actual measurement time, a warning is not displayed when the actual measurement time exceeds the execution time limit, but a value obtained by multiplying the execution time limit by a certain ratio, For example, a warning may be presented when the execution time exceeds 80%, and a warning is issued when the execution time exceeds 80% and a warning is issued when the execution time is exceeded. By making a difference in the way of presentation as described above, the priority of measures can be suggested to the program developer, and the work efficiency of the improvement work is improved. Further, even if the difference or ratio between the execution time limit and the actual measurement time is obtained and the value is written together and presented to the program developer, the priority of the countermeasure can be suggested, and the effect can be enhanced.

Further, in the present embodiment, when the execution actually measured time for the action is obtained, the measurement is performed based on the current time.
X (“UNIX” is the name of the operating system developed by AT & T Bell Laboratories) and Windows N
T (“Windows NT” is “Windows Ne
Abbreviation of "w Technology". Microsof
When operating on a multi-tasking operating system such as the T company's trademark, the CPU consumed for the processing since the program was started, not the current time
(Central processing unit)
The time may be replaced by time, and in this case, the influence of other tasks on the measurement of the actual measurement time can be reduced, and the measurement accuracy of the actual measurement time can be improved. Alternatively, the execution time limit for an action is set assuming that the program runs on a specific embedded device, while the environment in which the program actually runs is on another device (for example, a general-purpose personal computer or workstation). If the actual measurement time is found, the actual measurement time on the device where the program originally operates is estimated by converting the difference in the hardware performance between the current time and the CPU time from the value of the difference between the current time and the CPU time. You may ask for it in this way. In this case, the accuracy of comparison between the actual measurement time and the execution time limit can be improved.

Further, since the warning output process performed when the actual measurement time exceeds the execution time limit takes the form of, for example, log output to a file on the hard disk, a relatively large time is required for the processing time of the program. Therefore, if the problem is that the time behavior of the program changes when the execution time limit verification process is added and when it is not added, the time action of the program should not be changed during the warning output process. By temporarily stopping the operation of the specified timekeeping function and peripheral devices (or its simulation), the difference in the time operation of the program between when the execution time limit verification process is performed and when it is not performed is reduced. Can be dealt with.

The execution time limit verification process is added to the state transition process in addition to the event driven type state transition process as shown in FIGS. It is possible as well. In the following, FIG.
A method of adding the execution time limit verification process to the event polling type state transition process will be described with reference to FIG. 7, and an event driven type state transition process using a state transition table will be described with reference to FIGS. The respective embodiments will be described with respect to the method of adding the execution time limit verification process to the above.

As a flow chart of the program source code 4 generated by the automatic program generation means 3 in the present embodiment, an example of event polling type state transition processing is shown in FIGS. 6 and 7. FIG. 6 is a flowchart of a basic state transition process S40 in which, of the program source code that realizes the state transition process that operates in the event polling type, the verification process for the execution time limit is not performed for any action. is there. FIG. 7 shows a state in which the verification process for the execution time limit is performed for the action an12 executed in the transition from the state SN1 to the state SN2 in the program source code that realizes the state transition process that operates in the event polling type. It is a flowchart of a transition process S50.

The process S40 shown in FIG. 6 is basically the same as the process S20 shown in FIG. 4 except for the event acquisition process part. That is, in the process S40, the initialization process required for the operation of the program is first performed (S21), and then the state SN1 is set to the current state as the initial state at the start of the program (S22). After that, the elapse of a certain time corresponding to the polling interval is waited (S41), and then it is checked whether an event that triggers the state transition has occurred (S42). If no event has occurred (NO in S42), wait for the passage of time again (S4).
Return to 1). On the other hand, if an event has occurred (YES in S42), the time for performing the action S24 of executing the action and transitioning to the next state according to the current state and the event that has occurred, and then waiting for the event to occur again. The waiting for the progress (S41) is repeated. Since the process S24 of executing the action and transitioning to the next state is the same as the process S24 shown in FIG. 4, description thereof will be omitted.

On the other hand, the process S50 shown in FIG. 7 has basically the same logic as the process S40 shown in FIG. 6, and the difference is that the process S24 of executing the action and transition to the next state in FIG. However, it is only changed to the processing S31 of executing the action including the verification processing of the execution time limit for the event an12 and transiting to the next state. That is, in the process S50, similarly to the process S40, the initialization process necessary for the operation of the program is first performed (S21), and then the state SN1 is set to the current state as the initial state at the start of the program (S22). After that, the elapse of a certain time corresponding to the polling interval is waited (S41), and then it is checked whether an event that triggers the state transition has occurred (S42). If no event has occurred (NO in S42), wait for the passage of time again (S41).
Return to. On the other hand, if an event has occurred (Y in S42)
S), according to the current state and the event that has occurred, for executing the action including the verification process of the execution time limit for the event an12 and the process S31 for transition to the next state, and then waiting for the event to occur again. The waiting for the passage of time (S41) is repeated. Here, the process S31 of executing the action and transitioning to the next state is the process S3 shown in FIG.
The description is omitted because it is the same as 1.

In addition, in FIG. 7, in addition to the basic state transition process S40 shown in FIG. 6, for the action an12 executed in the transition from the state SN1 to the state SN2, only the state transition in which the verification process for the execution time limit is added is added. Processing S
Although 50 is shown, the verification processing regarding other actions may be added to the processing S40 in the same manner, and the program automatic generation means 3 in the present embodiment is required as shown in FIG. Depending on the desired action,
It operates so that verification processing for the execution time limit can be added.

Next, as the program source code 4 generated by the automatic program generation means 3 in the present embodiment, an example of event-driven state transition processing using a state transition table will be described with reference to FIGS. 8, 9 and 10. It demonstrates using. FIG. 8 is a diagram showing the structure of the state transition table 21 used in the state transition processing shown in FIGS. 9 and 10 in the program source code 4 generated by the automatic program generation means 3. FIG. 9 is a flowchart of a basic state transition process S60 in which the verification process for the execution time limit is not performed for any action in the program source code for realizing the state transition process. Figure 1
0 is a flowchart of a state transition process S70 of performing a verification process for the execution time limit for each action in the program source code that realizes the state transition process.

The content of the state transition table 21 shown in FIG. 8 is similar to that of the state transition table shown in FIG. 21, but the present invention shown in FIG. 2 for the state transition diagram of the prior art shown in FIG. Similar to the state transition diagram in (1), the execution time limit can also be held. That is, for example, the transition triggered by the event enA in the state SN1 is held as a cell where the state SN1 and the event enA intersect in FIG. 8, and the action an12 (middle stage in the cell).
The state is changed to the state SN2 (upper stage in the cell), and the effective time limit at that time is t12 (lower stage in the cell). If it is not necessary to define the execution time limit, a negative value (for example, a negative value) is held as the execution time limit to distinguish it from the case where the execution time limit is defined. As a result, the state transition table 21 shown in FIG. 8 can hold contents equivalent to the description using the state transition diagram shown in FIG.

By using the state transition table 21, the process S60 shown in FIG. 9 first performs an initialization process necessary for the operation of the program (S21), and then sets the state SN1 as the initial state at the start of the program. Set to state (S
22). After that, the occurrence of an event that triggers the state transition is waited for (S23), and when the event occurs, the information of the corresponding transition destination state and the action to be executed is retrieved from the state transition table 21 based on the current state and the occurred event. (S61). Next, execute the obtained action (S6
2) Set the transition destination state to the new current state (S6
3) After that, the operation of repeating the operation of waiting for the occurrence of an event (S23) is repeated to perform the state transition process.

On the other hand, the process S70 shown in FIG. 10 has basically the same logic as the process S60 shown in FIG. 9, and the difference is that the process S32 for measuring time is added and the execution time limit. It is only that the verification processes S72 to S75 are added. That is, the process S70 is the process S
Similar to 60, first, initialization processing necessary for the operation of the program is performed (S21), and then the state SN1 is set to the current state as the initial state at the start of the program (S22). After that, wait for the occurrence of an event that triggers the state transition (S2
3) When an event occurs, first obtain the current time and save it in a variable t (S32), then, based on the current state and the event that occurred, the state of the corresponding transition destination from the state transition table 21, execution Information on the action to be performed and the execution time limit for the action is extracted (S71). Then, the obtained action process is executed (S62). Next, if the execution time limit is not an invalid value (for example, a negative value) (S
No of 72), the difference between the current time and the time saved in the variable t, that is, the time required to process the action (execution actual measurement time) is obtained (S73), and if the execution actual measurement time is larger than the execution time limit for the action (YES in S74), a warning indicating that the actual measurement time of the action cannot satisfy the execution time limit is output (S7).
5) After that, the state of the transition destination is set to the new current state (S63), and the waiting for the occurrence of the event (S23) is repeated. If the execution time limit is an incorrect value (S7
2) or if the execution time limit for the action as a result of comparison is satisfied (NO in S74), the transition destination state is set to the new current state without outputting a warning (S63), and the event The occurrence waiting (S23) is repeated.

When the program automatic generation means 3 generates the program source code 4, the portion corresponding to the action to be verified is the state transition information as the execution time limit held in each cell of the state transition table 21. By setting a design definition value (correct value as the execution time limit) to be defined, and setting an invalid value (for example, a negative value) as the execution time limit for the other actions, the process S70 is performed. Whether or not to execute the verification processing of the execution time limit for the action can be arbitrarily determined for each action. In the present embodiment, when the program automatic generation means 3 generates the program source code corresponding to the state transition table 21, by appropriately setting the value of the execution time limit held in the state transition table 21 in this way, For the action of, the operation is performed to control whether or not the verification process is performed for the execution time limit.

Thus, the program automatic generation means 3
Can generate the program source code 4 to which the verification process of the execution time limit corresponding to various state transition processes is added, and thereby the applicability of the generated program source code 4 can be enhanced. The application target of the form can be spread.

In the first embodiment, the program development support system having the following features has been described. As the program specifications, multiple states, multiple events, transitions between states caused by the occurrence of an event in each state, actions executed in each transition,
State transition information describing state transition information, state transition information holding means for storing the state transition information described by the state transition editor, and source code of a program for realizing state transition processing based on the state transition information It consists of the program automatic generation means to automatically generate, in the state transition editor, in the description of action processing,
It is possible to describe the program flow such as what program part is called by what procedure, and the time limit (execution time limit) allowed for the processing of any action can be described. The means can automatically generate the program source code including a process of measuring a processing time (actually measured time) of the arbitrary action, comparing the time with the execution time limit, and presenting the result.

Embodiment 2. 11 is a system configuration diagram showing a program development support system according to a second embodiment of the present invention. As shown in FIG. 11, in the present embodiment, the state transition editor 1, the state transition information holding means 2, the program automatic generation means 3, the program source code 4, the program execution means 5, the execution measurement time collection means 6, the execution time are provided. The analysis unit 7 and the program component storage unit 9 are included.

The operations of the state transition editor 1 and the state transition information holding means 2 in the present embodiment are the same as the operations of the state transition editor 1 and the state transition information holding means 2 shown in the first embodiment, and therefore their explanations are given. Is omitted. Similarly, an example of the state transition information described in the state transition editor 1 is the same as that shown in FIGS. The program component storage unit 9 is also used as described in the first embodiment.

The program automatic generation means 3 in the present embodiment automatically generates the program source code 4 for realizing the state transition processing based on the contents of the state transition information held in the state transition information holding means 2. To do. The program source code 4 generated at this time should include a process of measuring the time required for execution of any action (execution actual measurement time), or not include such measurement process at all. It is also possible to do so. Whether to include it or not to include it is determined depending on whether or not the time limit information is specified by the state transition editor 1 as described in the first embodiment.

In the program source code 4 generated by the program automatic generation means 3 in the present embodiment, the measurement processing of the time required for the processing (execution measurement time) is not performed for any action. The example of the flowchart of the state transition process is the same as the process S20 of FIG. 4 described in the first embodiment, and therefore the description thereof is omitted. Next, the program automatic generation means 3 generates a program source code which realizes a state transition process which operates in an event driven type. In the generated program source code, the action actual measurement time is measured for the action an12 executed in the transition from the state SN1 to the state SN2. An example of a flowchart of this state transition process will be described with reference to FIG.

FIG. 12 shows a program source code 4 generated by the automatic program generation means 3 in this embodiment.
11 is a flowchart of a state transition process S80 which operates in an event-driven manner, in which an execution actual measurement time is measured for an action an12 executed in a transition from the state SN1 to the state SN2.

The process S80 shown in FIG. 12 is basically
It has almost the same logic as the process S20 shown in FIG.
The difference is that processing S32 for time measurement is added,
The only difference is that the process S26 corresponding to the state SN1 is changed to the process S82 including the process of measuring the actually measured execution time. That is, like the process S20, the process S80 first performs an initialization process necessary for the operation of the program (S21), and then sets the state SN1 to the current state as the initial state at the start of the program (S22). After that, the occurrence of an event that triggers the state transition is waited for (S23), and when the event occurs, the event an according to the current state and the occurred event an
The action including the measurement process of the actual measurement time for 12 and the process of transition to the next state S81 are performed, and then the occurrence of an event is repeated waiting (S23).

In the process S81 of executing the action and transitioning to the next state, the current time is obtained and stored in the variable t (S3
2) Then, check the current state (S25), and if the state S
If N1, the corresponding process S82 is performed, if the state is SN2, the corresponding process S27 is performed, and if the state is SN3, the corresponding process S28 is performed. Note that the process S27 corresponding to the state SN2 and the process S28 corresponding to the state SN3
Is the same as the processing S27 and S28 shown in FIG. 4, and therefore its explanation is omitted, and hereinafter, the processing S8 corresponding to the state SN1 is performed.
2 is shown.

In the process S82 corresponding to the state SN1, the generated event is checked (S261), and if the event en
If it is A, the action an12 is executed (S26
2), the current state is set to the state SN2 after the transition (S
263). Then, the difference between the current time and the time stored in the variable t, that is, the time required to execute the action an12 (execution actual measurement time) is obtained (S34), and the measured value is set as the execution actual measurement time for the action an12, and the execution actual measurement time collection means 6 To (S83), and the process S82 ends. If the generated event is other than the event enA, the process 82 corresponding to the state SN1 is ended.

In addition, in FIG. 12, in addition to the basic state transition processing S20 shown in FIG. 4, only the measurement processing of the actual measurement time for the action an12 executed in the transition from the state SN1 to the state SN2 is added. Although the process S80 is shown, similarly, the process of measuring the actually measured execution time relating to another action may be added to the process S20, and the program automatic generation means 3 in the present embodiment has the form shown in FIG. , It operates so as to add a process of measuring the execution actual measurement time to an arbitrary action as needed. The program automatic generation means 3 is a state transition editor 1
A program for executing the processing procedure of the flowchart shown in FIG. 12 is automatically generated based on the state transition information and the component information designated by. As with the first embodiment, the state transition editor 1 is used for the processing of the action an12.
Based on the component information designated by, the corresponding program component is selected from the program component storage unit 9 and the selected program component is used when the program is generated. The process of automatically generating this program is referred to as a program automatic generation process, and the process of designating state transition information and component information is referred to as a state transition information designating process. Further, the state transition information and the component information are held by the state transition information holding means 2 as in the first embodiment.

Further, in FIG. 12, the measured value is notified to the execution measured time collecting means in the process S83, but the notification is performed and the measured actual time and the execution time limit of the processes S35 and S36 in FIG. 5 are compared. Then, the program automatic generation means 3 can also generate the program source code so as to perform the processing of presenting the comparison result.

In the program execution means 5, based on the program source code 4 automatically generated by the program automatic generation means 3, compile or link processing is performed as needed to generate an executable executable module, and a state transition is made. The program that operates as defined by the state transition information held by the information holding means 2 is executed. If the program source code 4 used at this time is a logic that includes a process of measuring the actually measured execution time for an action as in step S80, the actually measured execution time measured each time the action is executed as the program is executed. Is passed to the actually-measured execution time collecting means 6 together with information on the corresponding action. The actually measured execution time collecting means 6 operates so as to obtain and hold the average value of the actually measured execution time for each action based on the information of the passed action and the actually measured execution time, and can provide it to the execution time analysis means 7 later. So save that value. The actual measurement time collecting means 6 is shown in FIG.
Then, until the processing of the process S80 is completed, the actually measured execution time notified for each action is accumulated, and the average value of the actually measured execution time is obtained based on the actually measured execution time for each action accumulated at the end of the process S80. Even if it is the same action, the actual measurement time is different depending on the system environment when the program is being executed, so the average value of the actual measurement time is calculated for each action. Further, for example, the process S80 of FIG. 12 may be executed a plurality of times, and the actually measured execution time for each action when the processing S80 is executed a plurality of times may be accumulated to obtain the average value.

The execution time analysis means 7 checks the contents of the state transition information held by the state transition information holding means 2 and does not measure the actually measured execution time for each action for which the execution time limit is defined. Or, if the actual measurement time stored in the actual measurement time collection means 6 is checked, the actual measurement time (measured average value) for the action is stored, and the value exceeds the execution time limit. Outputs a warning to that effect.

The fact that the actual measurement time for the action is not measured or the content of the actual measurement time held by the actual measurement time collection means 6 is checked means that all the actions included in the program by the execution of the program must be executed. It is not always executed, so I am investigating.

The program executing means 5 executes the program generated by the program automatic generating means 3 in the program executing step. At this time, the program generated by the automatic program generation means 3 is added to the process S3 of FIG.
If the process of S5 and S36 is included, the processes S35 and S36 are executed each time the action is executed.
Further, the actual measurement time collection means 6 receives the notification of the actual measurement time for each action, accumulates the same, and obtains the average value of the actual measurement time by the actual measurement time collection step.
Further, the process of comparing the average value of the actually measured execution time of each action executed by the execution time analysis unit 7 with the execution time limit and presenting the comparison result is performed by the execution time analysis step.

Since the present embodiment operates as described above, when designing the state transition, as in the first embodiment,
It is possible to describe the time limit allowed for the processing of the action together with the state transition, and automatically embed the processing for measuring the time required for processing the action (actual measurement time) in the generated program source code. Further, it is possible to automatically compare the measured actual measurement time with the execution time limit. This will prevent you from forgetting or overlooking the design information about the execution time limit,
In addition, it is possible to prevent forgetting the design and forgetting to execute the test related to the execution time limit, and simplifying the verification work, which makes it easy to perform verification and improvement work related to time constraints in the downstream process of software development. It is possible to obtain effects such as improvement of program development efficiency and quality.

In the above description, in the process S83 of FIG. 12, as the method of passing the actually measured time to the actually measured time collecting means 6, for example, a method of outputting it as a log to a file, a message mechanism or a shared memory mechanism is used. In general, it can be realized by using any method such as a method of transferring information between a plurality of programs.

As in the first embodiment, when comparing the execution time limit and the execution time limit, a warning is not given when the execution time limit exceeds the execution time limit, but the execution time limit is fixed. A warning may be displayed when the value exceeds the execution time limit, for example, when the execution time limit exceeds 80%. If the execution time limit exceeds 80%, warning is issued and the execution time limit is exceeded. In this case, by giving a difference such as giving a warning, the priority of the measure can be suggested to the program developer, and the work efficiency of the improvement work is improved. Further, even if the difference or ratio between the execution time limit and the actual measurement time is obtained and the value is written together and presented to the program developer, the priority of the countermeasure can be suggested, and the effect can be enhanced.

In the above embodiment, the actually-measured execution time collecting means 6 operates so as to hold the average value of the actually-measured execution time for each action based on the information of the passed action and the actually-measured execution time thereof. , Which may operate to find the maximum value. In this case, the execution time limit and the actual measurement time can be compared under more severe conditions.
Further, both the average value and the maximum value of the actually measured execution time are used together, and the actually measured time collection means 6 operates so as to obtain both the average value and the maximum value. You may make it present the comparison result with. In this case, the degree of achievement of the execution time limit for each action can be roughly classified, the priority of the countermeasure can be suggested, and the work efficiency of the improvement work is also improved. Alternatively, only the maximum value of the actually measured execution time may be obtained for each action, and the maximum value and the execution time limit may be compared.

Alternatively, the actually-measured-time collecting means 6 operates so as to generate and hold a statistical value such as a histogram or a probability distribution of actually measured times, instead of a specific single numerical value such as an average value or a maximum value. In this case, the execution time analysis means 7 has a probability of exceeding the execution time limit,
Alternatively, when the probability of exceeding the value obtained by multiplying the execution time limit by a certain ratio is more than a certain value, the warning effect is presented to obtain the same effect. Further, similar to the case of using the average value or the maximum value, a warning is displayed when the probability of exceeding 80% of the execution time limit is a certain value or more, and a warning is displayed when there is a value exceeding the execution time limit. By giving different methods and presenting the distribution status of the actual measurement time, it is possible to suggest the priority of the measures for each action to the program developer, and the work efficiency of the improvement work is also improved.

In the present embodiment, the execution time limit for an action is described as an accompanying notation such as "event / action / execution time limit" for a transition, but this is the same as in the first embodiment. "Event / action" for other methods, eg transitions
It is also possible to adopt a method of describing only the execution time and describing the execution time limit together with the program flow for the action. Further, in the present embodiment, the description of the state transition is performed according to the format of the state transition diagram. The same effect can be obtained. Similarly, in the present embodiment, the action processing is described as a program flow. However, this employs other graphic description methods such as PAD and HCP, and a text description method such as the source code of the program. Also has the same effect.

Further, in the present embodiment, when the actually measured execution time for the action is obtained, the measurement is performed based on the current time. However, similarly to the first embodiment, for example, the program is UNIX or Windows. When operating on a multitasking operating system such as NT, instead of the current time, the CPU time consumed for the processing after the program is started may be replaced. In this case, another task may be used to measure the actually measured execution time. Can be reduced, and the measurement accuracy of the actual measurement time can be improved. Alternatively, the execution time limit for an action is set assuming that the program runs on a specific embedded device, while the environment in which the program actually runs is on another device (for example, a general-purpose personal computer or workstation). If the actual measurement time is found, the actual measurement time on the device where the program originally operates is estimated by converting the difference in the hardware performance between the current time and the CPU time from the value of the difference between the current time and the CPU time. It may be determined in this way, and in this case, the accuracy of comparison between the actual measurement time and the execution time limit can be improved.

Further, since the process S83 of passing the measured actually measured time to the actually measured time collecting means 6 takes the form of, for example, log output to a file on the hard disk, a relatively large time is required for the processing time of the program. However, if there is a problem that the time behavior of the program changes depending on whether the measurement process of the actual measurement time is added or not, the time action of the program may be interrupted during the process of passing the measurement information. By temporarily stopping the operation of the specified timekeeping function and peripheral equipment (or its simulation), the difference in the time operation of the program between when the actual measurement time is measured and when it is not is reduced. Can be dealt with.

Further, as in the first embodiment, the program source code 4 generated by the automatic program generation means 3 is not limited to the event driven type state transition processing shown in FIG. 4 or 12, but also the event polling type state. It may be a transition process or an event-driven state transition process using the state transition table 21. Since the program source code 4 corresponding to various methods can be generated, the applicability of the program source code 4 can be enhanced,
The target of application of the present embodiment can be widened.

In the second embodiment, the program development support system having the following features has been described. As the program specifications, multiple states, multiple events, transitions between states caused by the occurrence of an event in each state, actions executed in each transition,
A state transition editor that describes state transition information, including state transition information holding means that stores the state transition information described by the state transition editor, and a source code of a program that implements state transition processing based on the state transition information A program automatic generation unit that automatically generates a program, a program execution unit that executes a program based on the source code of the automatically generated program, and a measurement value (execution time) of the time required for processing an action that is passed along with the execution of the program. (Actual measurement time), the actual measurement time collection means for collecting the actual measurement time and the execution time analysis means for analyzing the collected actual measurement time. In the state transition editor, in the description of the action processing,
You can describe the program flow such as which program part is called by what procedure, and the time limit (execution time limit) allowed for the processing of any action can be described. The means can automatically generate the program source code including the process of measuring the time required for execution of any action (actual measurement time) and passing it to the actually-measured time collection means. For the action, the execution time limit described as the state transition information and the actual measurement time collected in the actual execution time collection means can be compared and presented.

As another feature, the actually measured time collecting means operates so as to find and hold the average value and / or the maximum value for each action based on the passed actually measured time, and the execution time analyzing means. , The actual execution time of the action is compared with the execution time limit of the action based on the average value or the maximum value of the actual execution time held by the execution actual time collection means, and when the value is exceeded,
Alternatively, the program development support system having the feature of presenting a warning when it is close is explained.

As another characteristic, the actually-measured-time collection means uses the actually-measured execution time passed as a statistical value such as a histogram or a probability distribution instead of a specific fixed value, and actually-measured execution time for each action. When the execution time analysis means determines the probability that the execution time limit of the action exceeds or is close to the actual measurement time that the actual measurement time collection means holds, and the probability exceeds a certain value. Explained a program development support system with the feature of presenting warnings.

Embodiment 3. FIG. 13 is a system configuration diagram of the program development support system according to the third embodiment of the present invention. As shown in FIG. 13, in the present embodiment, the state transition editor 1, the state transition information holding means 2, the program automatic generation means 3, the program source code 4, the program execution means 5, the execution measurement time collection means 6, the execution time are executed. The analysis unit 7, the function execution time measurement unit 8, and the program component storage unit 9 are included.

The operations of the state transition editor 1 and the state transition information holding means 2 in the present embodiment are the same as the operations of the state transition editor 1 and the state transition information holding means 2 shown in the first embodiment, and therefore their explanations are given. Is omitted. Similarly, the examples of the state transition information and the component information described in the state transition editor 1 are the same as those in FIGS.

The automatic program generation means 3 in the present embodiment uses the program source code 4 for realizing the state transition processing based on the contents of the state transition information and the component information held in the state transition information holding means 2. Generate automatically.
The program source code 4 generated at this time may also include a process of measuring the time required for execution of any action (actual measurement time) and the execution time of the function executed in the process of the action. It is also possible not to include such measurement processing at all. When the execution time limit is specified in the state transition information specified by the state transition editor 1, the program is generated so as to include the process of measuring the execution time of the function. When the execution time limit is not specified in the state transition information, the program is generated so as not to include the process of measuring the execution time of the function.

In the program source code 4 generated by the program automatic generation means 3 in the present embodiment, the measurement processing of the time required for the processing (execution measurement time) is not performed for any action. The example of the flowchart of the state transition process is the same as the process S20 of FIG. 4 described in the first embodiment, and therefore the description thereof is omitted. Next, of the program source code that realizes the processing of the state transition that operates in the event-driven type, the action an12 to be executed at the transition from the state SN1 to the state SN2 is executed within the execution measurement time and the processing of the action. An example of a flow chart of a state transition process in which the function execution time measurement process is performed will be described with reference to FIG. In the program generation step, the program automatic generation means 3 selects the program component specified in the component information from the program component storage unit 9 based on the component information specified by the state transition editor 1 and selects the selected program. A program for executing the processing procedure of the flowchart of FIG. 14 is generated based on the components and the state transition information specified by the state transition editor 1.

FIG. 14 is a program source code 4 generated by the automatic program generation means 3 in this embodiment.
Among them, the action an12 executed in the transition from the state SN1 to the state SN2 operates as an event-driven type in which the actual measurement time of the action and the execution time of the function executed in the process of the action are measured. It is a flow chart of processing S90 of state transition.

Basically, the process S90 shown in FIG.
It has almost the same logic as the process S20 shown in FIG.
The difference is that processing S32 for time measurement is added,
The only difference is that the process S26 corresponding to the state SN1 is changed to the process S92 including the process of measuring the actually measured execution time. That is, in the process S90, similarly to the process S20, first, the initialization process necessary for the operation of the program is performed (S21), and then the state SN1 is set to the current state as the initial state at the start of the program (S22). After that, the occurrence of an event that triggers the state transition is waited for (S23), and when the event occurs, the event an according to the current state and the occurred event an
The action including the process of measuring the actually measured time for 12 and the process of transition to the next state S91 are performed, and then the occurrence of an event is repeated waiting (S23).

In the process S91 of executing an action and transiting to the next state, the current time is obtained and stored in the variable t (S3
2) Then, check the current state (S25), and if the state S
If N1, the corresponding process S92 is performed, if the state is SN2, the corresponding process S27 is performed, and if the state is SN3, the corresponding process S28 is performed. Note that the process S27 corresponding to the state SN2 and the process S28 corresponding to the state SN3
Is the same as the processes S27 and S28 shown in FIG. 4, and therefore the description thereof is omitted, and hereinafter, the process S9 corresponding to the state SN1.
2 is shown. In addition, the measurement of the actual measurement time of the function is
This is performed by the function execution time measuring means 8. Therefore, when generating a program, the automatic program generation means 3 generates a program source code that activates the function execution time measurement means 8 immediately before executing an action, and measures the function execution time immediately after execution of the action. A program source code for stopping the means 8 is generated. Further, the function execution time measuring means 8 operates so as to measure the actually measured execution time of a function that is called by the operation of a certain function or a function that is called from the called function. The function execution time measuring means 8 does not operate unless the function actually operates.

In the processing S92 corresponding to the state SN1, the generated event is checked (S261), and if the event en
If it is A, the function execution time measuring means 8 is instructed to start measuring the execution time of the function (S93), then the action an12 is executed (S262), and the function execution time measuring means 8 is executed. To stop the measurement of (S94), and then change the current state to the state SN after transition.
It is set to 2 (S263). Then, the difference between the current time and the time stored in the variable t, that is, the time required to execute the action an12 (execution actual measurement time) is obtained (S34), and the measured value is set as the execution actual measurement time for the action an12, and the execution actual measurement time collection means 6 To (S83), processing S92
To finish. If the generated event is other than the event enA, the process 92 corresponding to the state SN1 is finished as it is. When the program automatic generation means 3 generates a program, it checks whether the action includes a function or whether the action itself is a function, and when the function is included or is a function, The program is generated so that the program source code includes the processing of steps S93 and S94 of FIG. 14, and the function is not included.
Alternatively, if it is not a function, the processes S93 and S in FIG.
The program may be generated so that the processing of 94 is not included in the program source code. The program automatic generation means 3 generates a program for executing the processing procedure of the flowchart shown in FIG. 14 by the program generation step.

In addition, in FIG. 14, in contrast to the basic state transition process S20 shown in FIG. 4, the actually measured execution time for the action an12 executed in the transition from the state SN1 to the state SN2 and the function executed in the action process. Although the state transition process S90 in which only the execution time measurement process is added is shown, the process measurement process of the execution time of the function executed in the action measurement process and the action of another action is similarly performed to the process S20. The program automatic generation means 3 in the present embodiment may be added in the form as shown in FIG. 14, and is executed within the processing of the actually measured execution time and the action for an arbitrary action as needed. It operates so as to add the measurement processing of the execution time of the function.

In the program execution means 5, based on the program source code 4 automatically generated by the program automatic generation means 3, compile or link processing is performed as necessary to generate an executable executable module, and the state transition is performed. The program that operates according to the state transition information held by the information holding unit 2 is executed. The program is executed in the program execution step. If the program source code 4 used at this time is a logic that includes the measurement process of the actual measurement time of the action and the execution time of the function executed in the action process as in step S90, the measurement is performed as the program is executed. The actually-measured execution time of the action thus taken is passed to the actually-executed time collection means 6 together with information on the corresponding action. The actually measured execution time collecting means 6 operates so as to obtain and hold the average value of the actually measured execution time for each action based on the information of the passed action and the actually measured execution time, and can provide it to the execution time analysis means 7 later. So save that value.

Further, the function execution time measurement processing is carried out by instructing the function execution time measurement means 8 to start and stop the measurement of the function execution time. The function execution time measuring means 8 processes the function of the program function operating inside the program executed by the program executing means 5 while receiving the instruction to start the measurement of the execution time of the function and then the instruction to stop the measurement. It measures to measure the time from the start to the end and calculates and holds the average value, and saves the value so that it can be provided to the execution time analysis means 7 later. As a form of executing a function, an action to be executed may be one function, a plurality of functions may be called in one action, or another function may be called in one function. . The function execution time measuring means 8 measures the function execution time for each function in all the cases described above. In FIG. 14, between the function execution time measurement start process S93 and the function execution time measurement end process S94, that is, the action an12.
The execution time of the function is measured behind the operation of the execution processing S262 of. The function execution time measuring means 8 will be described in detail in order to explain the measurement of the execution time of the function on the back side. For example, the function execution time measuring unit 8 notifies the function execution time recording unit that records the function execution time, the function execution time data file that stores the function execution time, and the function execution time to the execution time analysis unit 7. And a function execution time notifying means for performing. For each "call / return" of the function called in the action an12, the function execution time recording means operates to measure the execution time of the function that has been called and executed, and associates it with the function information indicating the function. The measured execution time of the function is recorded in the function execution time data file. After that, when the execution time analysis unit 7 checks the execution time of each function held by the function execution time measurement unit, the execution of each function recorded in the function execution time data file is executed by the function execution time notification unit. Get the execution time for each function by instructing to notify the time. Since there is a commercially available tool described below as an example of means for measuring the execution time of a function, it is used. Alternatively, the function execution time measuring means can be realized by using a program development tool called a debugger. As an example of commercially available tools,
There are al Quantify (tools sold by Rational) and TrueTime (tools sold by NuMega). The program generated by the program automatic generation means 3 is executed by the program execution means 5 in the program execution step.
Further, the measured actual measurement time is notified to the actual measurement time collection means 6 by the actual measurement time collection step. Also,
The execution time of the function is measured by the function execution time measuring means 8 in the function execution time measuring step. In addition, comparison of actual measurement time and execution time limit, and presentation of comparison result,
The process of presenting the function execution time is performed by the execution time analysis means 7 in the execution time analysis step.

The execution time analysis means 7 checks the contents of the state transition information held by the state transition information holding means 2 and, for each of the actions for which the execution time limit is defined, does not measure the actually measured execution time for the action. Or, if the actual measurement time stored in the actual measurement time collection means 6 is checked, the actual measurement time (measured average value) for the action is stored, and the value exceeds the execution time limit. Outputs a warning to that effect. At the same time, the execution time analysis means 7 analyzes the program flow of the target action to check what function the action calls, and the function execution time measurement means 8 for each called function. By checking the contents of the execution time of each function held by, and obtaining the measured value (function execution time) and the function information, the function executed in the processing of the action whose actual execution time exceeds the execution time limit, A list of the function names and function execution times is output.

Since the present embodiment operates as described above, when designing the state transition, the time limit allowed for the processing of the action together with the state transition is described at the same time as in the first and second embodiments. Further, as in the second embodiment, the process for measuring the time required for processing an action (execution actual measurement time) can be automatically embedded in the generated program source code. Execution time limits can be automatically compared. As a result, it is possible to prevent the design information related to the execution time limit from being forgotten or overlooked, and to prevent the test design related to the execution time limit from being forgotten or forgotten, and the verification work can be simplified. Furthermore, regarding the processing of actions that have exceeded the execution time limit, by outputting a list of the names and execution times of the functions executed inside the processing, it is possible to suggest the target of improvement of the processing time. This makes it easier to carry out verification and improvement work related to time constraints in the downstream process, and obtains effects such as improvement in program development efficiency and quality.

Generally, in order to improve the processing time of a program, it is effective to take measures in the order of the processing that occupies the main time in the internal processing. For this reason, when outputting a list of function names and function execution times for functions executed within the processing of an action whose actual measured time exceeds the execution time limit, it is possible to present them in descending order of execution time. , It is possible to suggest the priority of measures for improving the processing time to the program developer, and the work efficiency of the improvement work is improved. Further, when the execution time analysis unit 7 analyzes the program flow of an action for which a warning is to be output, the number of executions of each function is obtained, and the list of the names of functions to be internally called and the function execution time is output. By presenting in order of the product of the execution time and the effective number, the priority of the countermeasure can be more effectively suggested and the effect can be enhanced.

As in the first and second embodiments, when the execution time limit is compared with the actual measurement time, a warning is not presented when the actual measurement time exceeds the execution time limit, but the execution time limit is not displayed. A warning may be given when a value obtained by multiplying by a certain ratio, for example, exceeding 80% of the execution time limit, and when exceeding 80% of the execution time limit, be warned and set the execution time limit. By giving different warnings, such as showing a warning when the number exceeds, it is possible to suggest the priority of measures to the program developer.
Work efficiency of improvement work is improved. Further, even if the difference or ratio between the execution time limit and the actual measurement time is obtained and the value is written together and presented to the program developer, the priority of the countermeasure can be suggested, and the effect can be enhanced.

Further, in the above embodiment, the actually-measured execution time collecting means 6 operates so as to obtain and hold the average value of the actually-measured execution time for each action based on the information of the passed action and the actually-measured execution time thereof. However, this may operate so as to obtain the maximum value as in the second embodiment. In this case, the execution time limit and the actual measurement time can be compared under more severe conditions. Further, both the average value and the maximum value of the actual measurement time are used together, and the actual measurement time collection means 6 is used.
May operate to obtain both the average value and the maximum value, and the execution time analysis means 7 may present the comparison result of each of the average value and the maximum value and the execution time limit. In this case, the degree of achievement of the execution time limit for each action can be roughly classified, and the priority of the countermeasure can be suggested. Alternatively, the actual measurement time collecting means 6
May operate to generate and hold a statistical value (statistical execution actual measurement time) such as a histogram of execution actual measurement times or a probability distribution, instead of a specific single numerical value such as an average value or a maximum value. In the case, the execution time analysis means 7 operates to present a warning when the probability of exceeding the execution time limit or the probability of exceeding the value obtained by multiplying the execution time limit by a certain ratio is a certain value or more, The same effect can be obtained. Further, as in the case of using the average value or the maximum value, a warning is given when the probability that 80% of the execution time limit is exceeded is a certain value or more, and a warning is given when there is a value that exceeds the execution time limit. By making a difference in the way and by presenting the distribution status of the actual measurement time,
It is possible to suggest the priority of the measures for each action to the program developer, and the work efficiency of the improvement work is improved.

Similarly, in the above embodiment, the function execution time measuring means 8 operates so as to hold the average value as the execution time of the function, but it may operate so as to obtain the maximum value. In this case, a function whose processing time is to be improved can be suggested under more severe conditions. Generally, regarding the program processing time, it can be estimated that there is a lot of room for improvement in the processing time when the difference between the maximum execution time and the average execution time is large. Therefore, both the average value and the maximum value are used together to measure the function execution time. The means 8 operates so as to obtain both the average value and the maximum value, and the execution time analysis means 7 presents the values of the both and the information indicating the variation in the function execution time such as the difference or ratio thereof. Thus, it is possible to suggest the priority of measures for improving the processing time, and improve the work efficiency of the improvement work. In this case, the order of presenting each function is not limited to the order of the average value or the maximum value, but the priority of the measures can be further improved by making it possible to present the values in the descending order of the difference in the function execution time such as the difference or ratio between the two. Can be effectively suggested,
The effect can be enhanced.

Further, in the function execution time measuring means 8, the function execution time is not a specific single numerical value such as an average value or a maximum value but a statistical value (statistical function) such as a histogram or a probability distribution of the function execution time. Actual measurement time)
May be generated and held. In this case, when the execution time analysis means 7 outputs the name of the function and the list of the function execution times, in addition to the average value or the maximum value of the execution times of the functions, for example, the upper limit value (90% of the execution time is satisfied. By presenting in order based on a scale such that 90% of the execution time is less than or equal to that value, it is possible to indicate to the program developer the priority of measures for improving the processing time, and the work of improvement work. Efficiency is improved. Furthermore, by presenting the distribution status of the execution time of the function together, it is possible to more effectively suggest the priority of measures,
The effect can be enhanced. Moreover, in general, it can be estimated that there is a lot of room for improvement in the processing time when there is a large variation in the processing time of the program. Therefore, when outputting the list of functions, even if the distribution of the execution time of the functions has a large variation, By presenting them, or by presenting them in an appropriate order in consideration of both other scales and variations, it is possible to more effectively suggest the priority of measures and improve work efficiency. The effect can be enhanced.

In general, if the statistical distribution of the actual measurement time of the action and the statistical distribution of the execution time of the function operating in the action can be measured, the statistical distribution of the actual measurement time of the action is used. If there is a function that has a similar distribution of execution times, it can be considered that the function has a strong influence on the distribution of the execution times of actions. It can be inferred that the modification of the corresponding function is effective for improving the action execution time. From this fact, the actually measured execution time collecting means 6 operates so as to generate and hold a statistical value such as a histogram or a probability distribution of the actually measured execution time of the action, and the function execution time measuring means 8 executes the function. It operates so as to generate and hold a statistical value such as its histogram or probability distribution as time, and the execution time analysis means 7 measures the execution of an action when outputting a list of function names and function execution times for the action. Compare the statistical distribution of time and the statistical distribution of execution time of each function called in the action, find the similarity between them, and present the functions in descending order of similarity. You may As a result, it is possible to suggest to the program developer the priority of measures for improving the processing time, and the work efficiency of the improvement work is improved. In addition, as a method of obtaining the similarity of the probability distribution,
For example, the method of obtaining the ratio of each average value and the maximum value and making the similarity high when the values are close, the method of obtaining the variance of each and making the similarity high when the values are close, and further the cross correlation It is possible to use various methods based on statistical knowledge, such as a method of obtaining a value and using the value. It is only necessary to select and use an appropriate method from the viewpoints of both the appropriateness of similarity and the calculation load required for derivation from these methods, and any method can achieve the desired effect.

Further, in the above embodiment, when the program automatic generation means 3 instructs the start of measurement of the execution time of a function, the program source code 4 also passes information on which action is the measurement. Is generated. When the program execution means 5 passes to the function execution time measurement means 8 instructions for starting and stopping the measurement of the function execution time in accordance with the execution of the program based on the program source code 4, which action is the measurement concerned? Operates to pass information as well. When measuring the execution time of a function, the function execution time measurement means 8 determines which action is related to the measurement of the execution time of the function, and determines the average value or the maximum value of the execution time of each function.
Alternatively, when a statistical value such as a histogram or a probability distribution is obtained and held, the function execution time is distinguished and obtained and held for each related action. When the execution time analysis unit 7 checks the contents of the execution time of each function held by the function execution time measurement unit 8 for the function called by the target action, the execution time of the function measured in relation to the corresponding action. May be checked. In this case, since the information about the execution time of the function is handled separately for each corresponding action, it is possible to improve the accuracy in comparing the execution time of the function with the actual measurement time of the action, and to improve the processing time. The priority of measures can be more appropriately suggested.

In the third embodiment, the program development support system having the following features has been described. As the program specifications, multiple states, multiple events, transitions between states caused by the occurrence of an event in each state, actions executed in each transition,
State transition information describing state transition information, state transition information holding means for storing the state transition information described by the state transition editor, and source code of a program for realizing state transition processing based on the state transition information A program automatic generation means for automatically generating a program, a program execution means for executing a program based on the source code of the automatically generated program, and a measurement value (execution time of the time required for processing an action passed along with the execution of the program Actual measurement time) collecting means, function execution time measuring means for measuring the time required to execute a function accompanying program execution, and execution time analyzing means for analyzing the collected actual measurement time. In the transition editor, which program part is called in what procedure in the description of the action processing. Can describe a program flow such or out, and for any action,
The time limit (execution time limit) allowed for the processing can be described, and the program automatic generation means measures the time required for the execution (actual measurement time) for any action, and the execution time measurement means collects it. The program source code can be automatically generated, including control of the passing process and the measurement process of the execution time of the function executed in the process of the action. The execution time limit described as is compared with the actual measurement time collected in the actual measurement time collection means and presented, and the function execution time measurement means measures the function executed in the action process incidentally. The list can be presented together with the executed time.

As another feature, when the execution time analysis means presents a list of the functions executed in the processing of the action, the execution time analysis means, in order of the execution time of the function,
Also, the program development support system having the characteristics listed in descending order of influence on the actually measured execution time of the action inferred from the measured execution time of the function has been described.

As another feature, in the function execution time measuring means, the measured execution time of the function is not a single numerical value, but both an average value and a maximum value, or a statistical value such as a histogram or a probability distribution. The program development support system has a characteristic that, when the execution time analysis means presents a list of the functions executed in the processing of the action, .

As another feature, the execution measurement time collection means obtains and holds not a single numerical value but a statistical value such as a histogram or a probability distribution as the execution measurement time of the action, and the function execution time measurement means. Then, instead of a single numerical value, a statistical value such as a histogram or probability distribution is obtained and held as the measured execution time of the function, and the execution time analysis means presents a list of the functions executed in the processing of the action. When performing the action, the degree of influence of the function on the execution time of the action is estimated from the similarity between the distribution of the actually measured execution time of the action and the distribution of the execution time of the function, and the features are listed in descending order. The program development support system was explained.

Fourth Embodiment An example of the program development support system according to the fourth embodiment of the present invention will be described with reference to FIGS. An example of the state transition information described in the configuration and the state transition editor 1 of this embodiment, and an example of the program source code 4 corresponding to the state transition information generated by the automatic program generation means 3 are shown in the first embodiment. Since it is the same as FIG. 1, FIG. 2, FIG. 4, and FIG. 5, its explanation is omitted. The operation of the state transition information holding means 2 of this embodiment is the same as that of the state transition information holding means 2 shown in the first embodiment.
Since the operation is the same as the above, the description thereof will be omitted. FIG. 15 is a description example of component information (program flow) of an action described in the state transition editor 1 in this embodiment. FIG. 16 is an example of a flowchart of the program source code 4 corresponding to the action generated by the program automatic generation means 3 in the present embodiment.

State transition editor 1 in the present embodiment
Is allowed for partial processing in the program flow when describing the component information (program flow) such as which program component is called by what procedure as a description of the action processing. The time limit (execution time limit) can be described as the component time limit information. Further, the program automatic generation means 3 in the present embodiment measures the value of not only the entire processing of the action but also the execution time (execution actual measurement time) of a partial processing of the action for an arbitrary action, and responds. It is possible to automatically generate the program source code including the processing to be presented in comparison with the execution time limit. Generation of the program source by the automatic program generation means 3 is performed in the program generation step. Further, the designation of the component time limit information by the state transition editor 1 is performed in the state transition information designating step.

Regarding the operation of the program flow description of the action in the state transition editor 1 of this embodiment,
This will be described with reference to FIG. FIG. 15 is a description example of the program flow of the action described in the state transition editor 1 in this embodiment, and the process S of the action an12.
10 shows the description of 10. In this figure, the description of the action program flow itself is the same as in FIG. 3 of the first embodiment. That is, the processing S of the action an12
10 first executes the program component p1 (S11),
Next, the execution result of p1 is inspected (S12). If the result is true (YES in S12), the program part p2 is checked.
Is executed (S13), and the process ends. If the execution result of p1 is not true, the process is immediately terminated (N in S12).
O). Furthermore, in the state transition editor 1 of this embodiment,
Time limit (execution time limit) allowed for the partial process in process S10 of action an12
For, it is possible to describe the part time limit information. That is, the execution time limit for the process S11 is t12_a, the execution time limit from the process S12 to the end of an12 is t12_b, and the execution time limit for the process S13 is defined as t12_bp2. The execution time limit t12 of the entire process S10 is automatically set based on the information designated by the state transition information shown in FIG.

The state transition editor 1 also automatically analyzes the program flow for an action to automatically extract the constraint conditions that should be satisfied for the execution time limit for these partial processes. It operates to automatically adjust the value of the execution time limit for various processes. That is, according to the state transition information shown in FIG. 2, the execution time limit for the entire action an12 is t
12 and t12_a ≤ t12, t1 by considering the execution order of each process S11, S12, S13.
2_b ≤ t12, t12_a + t12_b ≤
When the constraint conditions such as t12, t12_bp2 ≤ t12_b are extracted and the program developer tries to set a value that does not satisfy these constraint conditions, a warning is issued and an erroneous value cannot be defined. In addition, if you can automatically obtain other values by defining some values, those values are automatically set as reference values and the program developers are encouraged to adopt or modify them. To do. For example, when t12 is 0.5 seconds, t12
If _a is defined as 0.1 seconds, t12_b is 0.4
Seconds (t12_b = t12-t12_a), t
12_bp2 is also 0.4 seconds (t12_bp2 = t12_
It operates so that b) and a temporary value are automatically set. The component time limit information is designated in the state transition information designation step.

Next, the operation of the program source code automatic generation corresponding to the action in the program automatic generation means 3 of the present embodiment will be described with reference to FIG. FIG. 16 is a process in which the actual measurement time verification process is performed for a partial process inside the program source code 4 corresponding to the action an12 generated by the program automatic generation means 3 in the present embodiment. S
10 is a flowchart of 100. Note that the flow chart of the processing in which the verification processing of the actual measurement time for the internal partial processing is not performed is the same as the flow chart of the processing S10 shown in FIG.

The process S100 shown in FIG. 16 has basically the same logic as the process S10 shown in FIG. 15, and the difference is that each process of preparation, measurement, comparison, and result presentation for verification of the actual measurement time of execution. S101 to S106, S110
It is only that S116 is added. That is, process S1
00 first initializes the variable t2 to an invalid value as time (S101), then saves the current time in the variable t0 (S102), and then executes the program component p1 (S1).
1) and then save the current time in the variable t1 (S10
3) Next, the execution result of p1 is checked (S12), and if the result is true (YES in S12), the current time is stored in the variable t2 (S104), and then the program component p2 is stored.
Is executed (S13), the current time is then stored in the variable t3 (S105), and then the current time is stored in the variable t4 (S106). If the execution result of p1 is not true (NO in S12), processes S104, S13, and S105.
S10 for saving the current time in the variable t4 without executing
Do 6.

After the processing S106, the verification processing of the execution actual measurement time is subsequently performed. That is, first, as a verification of the actually measured time for the process S11, it is checked whether the difference between the time stored in the variable t1 and the time stored in the variable t0, that is, the actually measured time for the process S11 exceeds the corresponding execution time limit t12_a (S110. ), If it exceeds (YES in S110), a warning indicating that the actual measurement time of the process S11 cannot satisfy the execution time limit is output (S111). If it does not exceed, the warning output S111 is not performed. Then, similarly, the variable t
The difference between the time stored in 4 and the time stored in the variable t1, that is, whether the actually measured time for the processes S12 and S13 exceeds the corresponding execution time limit t12_b (S1
12) If it exceeds (Y in S112)
S), a warning indicating that the actual measurement time of the processes S12 and S13 does not satisfy the execution time limit is output (S113). If not exceeded, a warning output S
113 is not performed. Further, if the correct time is set in the variable t2 (YES in S114), it is determined that the process S13 is executed, and similarly, the difference between the time saved in the variable t3 and the time saved in the variable t2, that is, the process S13 is executed. Execution time limit t12_bp2 corresponding to the measured time
Is checked (S115), and if it is exceeded (YES in S115), a warning is output indicating that the actual measurement time of the process S13 cannot satisfy the execution time limit (S116). . If it does not exceed, the warning output S116 is not performed. If a correct value is not set for the variable t2 (N in S114)
O), assuming that the process S13 has not been executed, the verification processes S115 and S116 related to the process S13 are not executed. The program automatic generation means 3 uses S100 of FIG.
A program for executing the processing procedure according to the flowchart of is generated by the program generation step using the component time limit information and the component information.

In this embodiment, since the operation is as described above, when describing the program flow of the action,
For a partial process in the program flow, the time limit allowed for that process can be described at the same time as part time limit information, and the time required for the partial process inside the action can be measured and executed. The process of comparing with the time limit can be automatically embedded in the generated program source code. This will prevent you from forgetting or overlooking the design information about the execution time limit,
In addition, it is possible to prevent forgetting the design and forgetting to execute the test related to the execution time limit, and simplifying the verification work, which makes it easy to perform verification and improvement work related to time constraints in the downstream process of software development. It is possible to obtain effects such as improvement of program development efficiency and quality.

When comparing the execution time limit and the actual measurement time, a warning is not displayed when the actual measurement time exceeds the execution time limit, but a value obtained by multiplying the execution time limit by a certain ratio, For example, a warning may be presented when the execution time limit exceeds 80%, and a warning is issued when the execution time limit is exceeded, and a warning is displayed when the execution time limit is exceeded. Make a difference in how to present. As a result, the priority of the measures can be suggested to the program developer, and the work efficiency of the improvement work is improved. Further, even if the difference or ratio between the execution time limit and the actual measurement time is obtained and the value is written together and presented to the program developer, the priority of the countermeasure can be suggested, and the effect can be enhanced.

In the fourth embodiment, the program development support system having the following features has been described. In the state transition editor, as a description of action processing,
When describing a program flow such as which program part is called by what procedure, the time limit (execution time limit) allowed for the partial process in the program flow can be described. , The program automatic generation means, for any action,
Not only the entire process of the action, but also the execution time (actual measurement time) for the partial process inside the action source code including the process of measuring the value and comparing it with the corresponding execution time limit It can be automatically generated.

Embodiment 5. An example of the program development support system according to the fifth embodiment of the present invention will be described with reference to FIG. Since the configuration of the present embodiment is the same as that of FIG. 11 shown in the second embodiment, the description thereof will be omitted. Further, since the example of the state transition information described in the state transition editor 1 of the present embodiment is the same as that of FIG. 2 shown in the first embodiment, the program flow of the action described in the state transition editor 1 (part information and Since a description example of (parts time limit information) is the same as that of FIG. 15 shown in the fourth embodiment, the description thereof will be omitted. Further, the operation of the state transition information holding means 2 of the present embodiment is the same as the operation of the state transition information holding means 2 shown in the first embodiment, and therefore its explanation is omitted. An example of the program source code 4 corresponding to the state transition information generated by the automatic program generation means 3 is shown in FIG. 4 shown in the first embodiment and FIG. 12 shown in the second embodiment.
Since it is the same as the above, the description thereof will be omitted. FIG. 17 is an example of a flowchart of the program source code 4 corresponding to the action generated by the program automatic generation means 3 in the present embodiment.

State transition editor 1 in the present embodiment
As in the case of the fourth embodiment, when describing a program flow (component information) such as which program component is called in what procedure as a description of action processing, a partial process in the program flow is described. The time limit (execution time limit) allowed for the processing can be described as the component time limit information. Further, the automatic program generation means 3 in the present embodiment measures and executes not only the entire process of an action but also the execution time (actual measurement time) for a partial process inside the action for an arbitrary action. The program source code can be automatically generated including the process of passing it to the measured time collection means 6. The state transition information is designated by the state transition editor 1, and the component information and the component time limit information are designated in the state transition information designating step. Further, the program generation by the program automatic generation means 3 is performed in the program generation step.

Automatic program generation means 3 of the present embodiment
The operation of automatically generating the program source code corresponding to the action in (1) will be described with reference to FIG. FIG. 17 shows the automatic program generation means 3 in this embodiment.
Of the program source code 4 corresponding to the action an12 generated by the process S120 in which the actual measurement time measurement process is performed for a partial process inside thereof.
It is a flowchart of. Note that the flow chart of the processing in which the measurement processing of the actual measurement time is not performed for the internal partial processing is the same as the flow chart of the processing S10 shown in FIG.

The process S120 shown in FIG. 17 is basically the same as the process S10 shown in FIG. 15, except that the processes S101 to S101 for preparing, measuring, and presenting results for verification of the actually measured time of execution. S106, S114, S12
It is only the addition of 1 to S123. That is, the process S120 first initializes the variable t2 as an invalid value as the time (S101), then saves the current time in the variable t0 (S102), and then executes the program component p1 (S1).
1) and then save the current time in the variable t1 (S10
3) Next, the execution result of p1 is checked (S12), and if the result is true (YES in S12), the current time is stored in the variable t2 (S104), and then the program component p2 is stored.
Is executed (S13), the current time is then stored in the variable t3 (S105), and then the current time is stored in the variable t4 (S106). If the execution result of p1 is not true (NO in S12), processes S104, S13, and S105.
S10 for saving the current time in the variable t4 without executing
Do 6.

After the processing S106, the measurement processing of the execution actual measurement time is subsequently performed. That is, for example, by outputting to a file as a log, the time saved in the variable t1 and the variable t0
The difference in time stored in step S11 is passed to the actual measurement time collection means 6 as the actual measurement time for step S11 (S121), and then the difference between the time saved in the variable t4 and the time saved in the variable t1 is processed in steps S12 and S13. The actual measurement time is passed to the actual measurement time collection means 6 (S122). Furthermore, if the correct time is set in the variable t2 (S11
4), and assuming that the process S13 is being executed, similarly, the difference between the time saved in the variable t3 and the time saved in the variable t2 is passed to the execution measured time collection means 6 as the execution measured time for the process S13 (S123). . If the correct value is not set for the variable t2 (NO in S114),
Assuming that the process S13 has not been executed, the process S13
The output process S123 of the actual measurement time regarding is not executed. The program automatic generation means 3 generates the source code of the program that operates according to the processing procedure shown in the flowchart of FIG. 17 in the program generation step.

In the program execution means 5, the second embodiment is adopted.
Similarly to the above, based on the program source code 4 automatically generated by the program automatic generation means 3, compile and link processing are performed as necessary to generate an executable executable module, and the state transition information holding means 2 Executes a program that operates as defined in the retained state transition information. The program source code 4 executed at this time is
If the logic includes the measurement process of the measured actual execution time for the partial process inside the action like the process S120, the actually measured execution time measured along with the execution of the program indicates the partial process inside the corresponding action. It is passed to the execution measurement time collection means 6 together with the information. Based on the information indicating the partial processing inside the passed action and the actually measured execution time, the actually measured execution time collecting means 6 operates so as to obtain and hold the average value of the actually measured execution time for each processing, and then executes the latter. The value is saved so that it can be provided to the time analysis means 7. The program executing means 5 executes the program in the program executing step. The actual measurement time collection means 6 calculates and holds the average value of the actual measurement times by the actual measurement time collection step.

The execution time analysis means 7 checks the contents of the component time limit information and the state transition information held by the state transition information holding means 2, and checks each of the partial processes inside the action for which the time limit is defined. Regarding the measured actual execution time, the contents of the actual measured time held by the actual measured time collection means 6 are checked, and the corresponding actual measured time (measured average value) is held. If the value exceeds the component time limit or the execution time limit, a warning indicating that fact is output. The execution time analysis means 7 performs a process of comparing the designated execution time limit or the component time limit with the actual measurement time and presenting a comparison result in the execution time analysis step.

In this embodiment, since the program development support system operates as described above, when describing the program flow (part information) of an action, a partial process of the program flow is The allowable time limit (component time limit) can be described at the same time, and the process of measuring the time required for partial processing inside an action (component actual measurement time) is automatically included in the generated program source code. Can be embedded in the target. As a result, it is possible to automatically compare the measured component execution actual measurement time with the component time limit. As a result, it is possible to prevent the design information related to the execution time limit from being forgotten or overlooked, and to prevent the test design related to the execution time limit from being forgotten or forgotten, and the verification work can be simplified. As a result, it becomes easy to sufficiently carry out verification and improvement work related to time constraints in the downstream process of software development, and it is possible to obtain effects such as improvement in program development efficiency and quality.

When comparing the component time limit and the component actual measurement time, as in the second embodiment, instead of presenting a warning when the component actual measurement time exceeds the component time limit, the component time limit is displayed. A warning may be given when a value obtained by multiplying by a certain ratio, for example, exceeds 80% of the part time limit, and when 80% of the part time limit is exceeded, be warned and It may be possible to make a difference in the manner of presenting it, such as presenting a warning when it exceeds. Further, a difference or a ratio between the component time limit and the component execution actual measurement time may be obtained, and the value may be additionally written and presented. Further, in the above-mentioned embodiment, the actual measurement time collection means 6
Operates so as to obtain and hold the average value of the component execution actual measurement time, but it may operate so as to obtain the maximum value as in the second embodiment, or it may operate to obtain the average value or the maximum value of the component execution actual measurement time. Both may be used together, and the actually measured time collection means 6 may operate to obtain both the average value and the maximum value, and the execution time analysis means 7 may present the comparison result of each and the component time limit. . Further, the actually measured execution time collecting means 6 operates so as to generate and hold a statistical value such as a histogram or a probability distribution of the actually measured time of parts, and the execution time analysis means 7 causes the probability of exceeding the time limit of parts, Alternatively, when the probability of exceeding the value obtained by multiplying the component time limit by a certain ratio is a certain amount or more, a warning may be presented. Alternatively, when the probability that 80% of the component time limit exceeds 80% or more, a warning is issued, and when there is a value that exceeds the component time limit, a warning is issued. Further, the distribution status of the component execution actual measurement time is presented. May work like. All of these processes can suggest the priority of measures to the program developer, and improve the work efficiency of the improvement work.

It should be noted that it is possible to easily add the same processing as that of the present embodiment to the third embodiment, and the same effect can be obtained. That is, when describing a program flow (component information) such as which program component is called in what procedure as a description of action processing in the state transition editor 1, regarding a partial process in the program flow. It is possible to describe the time limit (part time limit) allowed for the processing, and to the program automatic generation means 3 not only the entire processing of the action but also a partial internal part of the action. Execution time for various processes (measurement time of component execution)
As for the above, the program source code can be automatically generated including the processing of measuring the value and passing it to the actually measured time collection means 6. Further, each of the program execution means 5, the execution measurement time collection means 6, and the execution time analysis means 7 is added with processing so as to handle the component execution measurement time for the partial processing inside the action, as in the present embodiment. As a result, similarly to the present embodiment, for a partial process in the program flow of an action, the time limit allowed for the process is simultaneously described as the part time limit information, and the time required for the process (part execution The process of measuring (measured time) is automatically embedded in the generated program source code, and it becomes possible to automatically compare the measured part execution measured time with the part time limit. It is possible to prevent information from being forgotten or overlooked. Furthermore, it is possible to prevent forgetting to design or forget to implement the test regarding the time limit.
As a result, since the verification work can be simplified, it becomes easy to sufficiently carry out the verification and improvement work regarding the time constraint in the downstream process of software development, and the effect of improving the development efficiency and quality of the program can be obtained.

In the fifth embodiment, the program development support system having the following features has been described. In the state transition editor, as a description of action processing,
When describing a program flow such as which program part is called by what procedure, the time limit (execution time limit) allowed for the partial process in the program flow can be described. , The program automatic generation means, for any action,
Automatic generation of program source code including not only the entire processing of the action but also the execution time (actual measurement time) for the internal partial processing, including the process of measuring the value and passing it to the actual measurement time collection means. You can

Sixth Embodiment FIG. 18 is a system configuration diagram showing an example of the program development support system according to the sixth embodiment of the present invention. As shown in FIG. 18, in the present embodiment, the state transition editor 1, the state transition information holding means 2, the program automatic generation means 3, the program source code 4,
The program execution unit 5, the function execution time measurement unit 8, the execution time analysis unit 7, and the program component storage unit 9 are included.

The operations of the state transition editor 1 and the state transition information holding means 2 in the present embodiment are the same as the operations of the state transition editor 1 and the state transition information holding means 2 shown in the first embodiment, and therefore their explanations are given. Is omitted. Similarly, the examples of the state transition information and the component information described in the state transition editor 1 are the same as those in FIGS.

The program automatic generation means 3 in the present embodiment automatically executes the program source code 4 for realizing the state transition processing based on the contents of the state transition information and the component information held in the state transition information holding means 2. To generate. At this time, in the program source code 4, the process for each action is generated as one function, and the name of the function is set to a name uniquely associated with the action. Various methods can be adopted for associating the action and the function name, but one of the simplest methods is a method in which the name of each action itself is used as the function name. In this method, for example, the name of the function that realizes the processing of the action an12 is “an12”.

Automatic program generation means 3 according to this method
FIG. 19 shows an example of a flowchart of the program source code 4 generated by. The process S140 of FIG. 19 is similar to the flowchart of the state transition process S20 of FIG. The difference between FIG. 4 and FIG. 19 is that a process S93 for starting the function execution time measuring means 8 is added before the process S262 for executing the action an12, and the process S2 for executing the action an12.
The point is that after S62, a process S94 for stopping the operation of the function execution time measuring means 8 is added. Since the other processing is described in the first embodiment, the description is omitted here. In the program source code 4 generated by the automatic program generation means 3 of the present embodiment and corresponding to the flowchart of the process S20 shown in FIG. 4, for example, the process S262 for executing the action an12 is specifically a function "
The state transition information and the component information designated by the state transition editor 1 are designated by the state transition information designating step. Further, the program source code is generated by the automatic program generation means 3. The program generation process is performed.

On the basis of the program source code 4 automatically generated by the program automatic generation means 3, the program execution means 5 compiles and links as needed to generate an executable module which can be executed, and makes a state transition. The program that operates as defined in the state transition information held by the information holding means 2 is executed. The function execution time measuring means 8 is executed by the program executing means 5 at S9.
The process is started by executing the process of step S3, and the operation is stopped by executing the process of step S94. The function execution time measuring means 8 is
For a program function that operates inside the program executed by the program executing means 5, the time from the start to the end of the function processing (function execution time) is measured, and the average value is calculated and held. . The value is saved so that it can be provided to the execution time analysis means 7 later. The execution of the program generated by the program automatic generation means 3 by the program execution means 5 is performed in the program execution step. Further, the function execution time measurement process by the function execution time measurement means 8 is performed in the function execution time measurement step.

The execution time analysis means 7 checks the contents of the state transition information and the component information held by the state transition information holding means 2 and, for each action for which the execution time limit is defined, a function corresponding to the processing of the action. Function execution time is not measured, or the function execution time measurement means 8 is used based on the name of the function uniquely determined corresponding to the action.
Check the contents of the function execution time held by, and if the function execution time (measured average value) is held for the function corresponding to the action and the value exceeds the execution time limit for the action , And outputs a warning to that effect. At the same time, the execution time analysis unit 7 analyzes the program flow of the target action to check what function the action calls, and the function execution time measurement unit 8 for each called function. By checking the contents of the execution time of each function held by, and obtaining the measured value (function execution time),
For a function executed in the processing of an action whose execution time exceeds the execution time limit, a list of the function name and function execution time is output.

In this embodiment, since the program development support system operates as described above, when designing the state transition, the state transition and its action (in this embodiment, the action is one function) are processed. It is possible to simultaneously describe the time limit allowed for the time limit information. Further, it is possible to measure the time required to process the action and automatically compare it with the corresponding execution time limit. As a result, it is possible to prevent the design information related to the execution time limit from being forgotten or overlooked, and to prevent the test design related to the execution time limit from being forgotten or forgotten, and the verification work can be simplified. Further, similarly to the third embodiment, regarding the processing of the action that exceeds the execution time limit, by outputting the list of the names and the execution times of the functions executed inside the processing, the improvement target of the processing time is suggested. As a result, it becomes easy to sufficiently carry out verification and improvement work regarding time constraints in the downstream process of software development, and it is possible to obtain effects such as improvement in program development efficiency and quality.

In the above-described embodiment, the function execution time measuring means 8 allows different function execution times to be treated as different function execution times even when the callers are different even if the measured values are for the same function. The means 7 is
For the action to be warned, for each function called from the action, when the content of the execution time of each function held by the function execution time measuring means 8 is checked and the measured value (function execution time) is obtained, The function execution time when called from the function corresponding to the action may be obtained. Specifically, for example, when the function "p1" is called from each of the function "an12" and the function "an21", the function execution time measuring unit 8 calls the function "p1" from the function "an12". The measured value at this time is treated as the function execution time in "an12⇒p1", and the function "an21" to function "p"
When "1" is called, the measured value is "an21⇒p1"
The function execution time is treated as a function execution time, and both can be provided to the execution time analysis means 7 separately. The execution time analysis means 7 is a function called from the action an12 "
When checking the function execution time for p1 ", the function" an1 "that executes the process corresponding to the action an12
The function execution time in "an12⇒p1" when called from "2" is calculated. In this case, since the information regarding the function execution time is handled separately for each corresponding action, the function execution time is It is possible to improve the accuracy in comparison with the actually measured execution time of the action, and it is possible to more appropriately suggest the priority of the measure for improving the processing time.

Further, generally, in order to improve the processing time of a program, it is effective to take measures in the order of the processing that occupies the main time in the internal processing. Therefore, when outputting the list of function names and function execution times for the functions executed in the processing of the action whose execution time exceeds the execution time limit, the function execution time can be presented in the descending order. , It is possible to suggest the priority of measures for improving the processing time to the program developer, and the work efficiency of the improvement work is improved. Further, when the execution time analysis unit 7 analyzes the program flow of an action for which a warning is to be output, the number of executions of each function is obtained, and the name of the function called internally and the list of the function execution time are output. By calculating the product of the execution time and the number of executions and presenting them in descending order of the calculated answer, the priority of the countermeasure can be more effectively suggested and the effect can be enhanced.

When comparing the execution time of the function corresponding to the action and the execution time limit, a warning is not displayed when the execution time of the corresponding function exceeds the execution time limit, but the execution time limit is displayed. A warning may be presented when a value multiplied by a certain ratio, for example, exceeding 80% of the execution time limit. Furthermore, by giving a warning when the execution time exceeds 80% and displaying a warning when the execution time exceeds the time limit,
The priority of measures can be suggested to the program developer, and the work efficiency of improvement work is improved. Further, even if the difference or ratio between the execution time limit and the actual measurement time is obtained and the value is written together and presented to the program developer, the priority of the countermeasure can be suggested, and the effect can be enhanced.

Further, in the above-mentioned embodiment, the function execution time measuring means 8 operates so as to obtain and hold the average value of the execution times of the passed functions, but this is the same as in the third embodiment. It may operate so as to obtain the maximum value. In this case, the execution time limit and the actual measurement time can be compared under more severe conditions, and the function whose processing time is to be improved can be suggested under more severe conditions.

Further, the function execution time measuring means 8 may operate so as to obtain both the average value and the maximum value, and the execution time analyzing means 7 may present the result of comparison between each of them and the execution time limit. In this case, the degree of achievement of the execution time limit for each action can be roughly classified, and the priority of the countermeasure can be suggested. Further, generally, regarding the processing time of a program, it can be estimated that there is a lot of room for improvement in the processing time when the difference between the maximum execution time and the average execution time is large. Therefore, when the execution time analysis unit 7 outputs the list of the function names and the function execution times of the functions executed in the processing of the action whose execution time exceeds the execution time limit, the function execution is executed. Both the maximum value and the average value of the time, and the information indicating the variation in the function execution time such as the difference or the ratio between them are presented. As a result, it is possible to suggest the priority of measures for improving the processing time, and the work efficiency of the improvement work is improved. In this case, the order of presentation of the respective functions is not limited to the order of the average value or the maximum value, but the order of presenting the value representing the variation in the function execution time such as the difference or ratio between the two may be presented. This makes it possible to more effectively suggest the priority of the countermeasure and enhance the effect.

Alternatively, the function execution time measuring means 8 may operate to generate and hold a statistical value such as a histogram or a probability distribution instead of a specific single numerical value such as an average value or a maximum value. In this case, the execution time analysis means 7 operates so as to present a warning when the probability of exceeding the execution time limit or the probability of exceeding the value obtained by multiplying the execution time limit by a certain ratio is a certain value or more. , The same effect can be obtained. Further, as in the case of using the average value or the maximum value, a warning is given when the probability that 80% of the execution time limit is exceeded is a certain value or more, and a warning is given when there is a value that exceeds the execution time limit. By showing the distribution of the execution time of the function corresponding to the action by making a difference in the way, it is possible to suggest the priority of the measure for each action to the program developer, and the work efficiency of the improvement work. Is improved. Similarly, when the execution time analysis unit 7 outputs a list of function names and function execution times for functions executed in the processing of an action whose execution time exceeds the execution time limit, the execution time of the function is In addition to the average value or maximum value of, the processing is presented to the program developer in order based on a scale such as an upper limit value that 90% of the execution time satisfies (a value that 90% of the execution time is less than that value) The priority of measures for improving time can be suggested, and the work efficiency of improvement work is improved. Furthermore, by presenting the distribution status of the execution time of the function together, the priority of the countermeasure can be more effectively suggested, and the effect can be enhanced. Further, in general, it can be estimated that there is a lot of room for improvement in the processing time of the program when the variation in the processing time is large. Therefore, when outputting a list of functions, make it possible to present them even in the order in which the variations in the distribution of the execution time of the functions are large, or to present them in an appropriate order in consideration of both other scales and variations. To As a result, the priority of measures can be more effectively suggested, and the effect of improving work efficiency can be enhanced.

Generally, if there is a similarity between the statistical distribution of the execution time of an action and the statistical distribution of the execution time of a function operating in the action, the function has a strong distribution of the execution time of the action. It can be considered that there is a high possibility that it has an effect, and it can be inferred that modification of the corresponding function is effective for improving the execution time of the action. Therefore, when the execution time analysis unit 7 outputs a list of functions, the statistical distribution of the execution time of the functions corresponding to the action and the statistics of the execution time of each function called in the action are collected. Comparing the shapes of the various distributions, obtaining the similarity between the two,
The functions may be presented in descending order of similarity. As a result, it is possible to suggest to the program developer the priority of measures for improving the processing time, and the work efficiency of the improvement work is improved. As a method of obtaining the similarity of the probability distribution, for example, the method of determining the ratio of the average value and the maximum value to have a high similarity when the values are close to each other, and the method of determining the variance of each to be similar when the values are close How to be high,
Furthermore, it is possible to use various methods based on statistical knowledge, such as the method of obtaining the cross-correlation value and using that value. It is an appropriate method from the viewpoint of both the degree of similarity and the calculation load required for derivation. May be selected and used, and the desired effect can be obtained by any method.

In FIG. 19, the operation of the function execution time measuring means 8 is activated (S93) before the action an12 is executed (S262), and the operation of the function execution time measuring means 8 is stopped after the action an12 is executed. (S94) was performed. However, the function execution time measuring means 8 is shown in FIG.
The execution time of the function is ready to be measured at any time when the function is started at the start of the operation S140, and the function execution time measuring means 8 itself determines the end of the execution of the function by receiving some information from the function. If possible, S93,
The process of S94 may be omitted. Also, the action an12 is one function, but the action an23
Is a general process, not a function, and time limit information is specified in the state transition information. In this case, the program automatic generation means 3 generates the source code of the program including the process for measuring the actually measured execution time of the action an23. In addition, the source code of the program is generated so as to notify the actually measured execution time collecting unit 6 of the measured actually measured time. Therefore, although the actually measured time collection means 6 is not shown in FIG. 18, it is possible to add the actually measured time collection means 6 to configure a program development support system.

In the sixth embodiment, the program development support system having the following features has been described. As the program specifications, multiple states, multiple events, transitions between states caused by the occurrence of an event in each state, actions executed in each transition,
A state transition editor that describes state transition information, including state transition information holding means that stores the state transition information described by the state transition editor, and a source code of a program that implements state transition processing based on the state transition information A program automatic generating means for automatically generating a program, a program executing means for executing a program based on the source code of the automatically generated program, and a function for measuring a time (function execution time) required to execute a function accompanying the execution of the program Consists of execution time measurement means and execution time analysis means for analyzing the collected function execution times. In the state transition editor, in describing the processing of actions, describe the program flow such as which program component is called in what procedure. You can also, for any action,
The time limit (execution time limit) allowed for the process can be described, and the automatic program generation unit generates the process for any action as a function with a name that can be uniquely identified, and the execution time analysis unit. Then, for an arbitrary action, the execution time limit described as the state transition information and the execution time of the function corresponding to the action collected by the function execution time measuring means are compared and presented. A list of the functions executed in the process can be presented together with the execution time.

Further, as another feature, when the execution time analysis means presents a list of the functions executed in the processing of the action, in order of the execution time of the function,
Also, the program development support system having the characteristics listed in descending order of influence on the actually measured execution time of the action inferred from the measured execution time of the function has been described.

As another feature, in the function execution time measuring means, the measured execution time of the function is not a single numerical value, but both an average value and a maximum value, or a statistical value such as a histogram or a probability distribution. The program development support system has a characteristic that, when the execution time analysis means presents a list of functions executed in the processing of an action, the execution time analysis means enumerates them in descending order of variation in function execution time. .

As another feature, the function execution time measuring means finds and holds not a single numerical value but a statistical value such as a histogram or a probability distribution as the measured execution time of the function, and the execution time analyzing means. When presenting a list of functions executed in the processing of an action, the internal distribution of the execution time of the function corresponding to the action and the distribution of the execution time of the functions executed inside the I explained the program development support system which has the feature that the degree of the influence that the function executed in the paragraph gives to the execution time of the action is estimated and listed in descending order of the degree.

The processing steps described in the first to sixth embodiments are the processing steps included in the program development support method and the processing steps included in the program development support program. The program development support program is recorded in a computer-readable recording medium (for example, ROM (Read Only Memory) or FXD (Flexible Disk)). The program development support program is a program that runs on a computer included in the program development support system.

[0160]

As described above, according to the present invention, when designing a program for performing state transition, the state information and the event are set to the time limit allowed for the action execution time by the state transition editor or the state transition information designating step. It can be described at the same time as information and action information. Further, it is possible to embed in the generated program source code a process of measuring the time required to execute the action and comparing it with the time limit by the program generation unit or the program generation step. As a result, it is possible to prevent the design information related to the time limit from being forgotten or overlooked, and to avoid forgetting the design or execution of the test related to the time limit, which simplifies the verification work. This makes it easier to carry out verification and improvement work related to time constraints, with the effect of improving program development efficiency and quality.

Further, the execution time analysis section or the execution time analysis step can automatically compare the measured actual measurement time with the time limit. As a result, it is possible to prevent the design information related to the time limit from being forgotten or overlooked, and to avoid forgetting the design or execution of the test related to the time limit, which simplifies the verification work. This makes it easier to carry out verification and improvement work related to time constraints, with the effect of improving program development efficiency and quality.

Further, by comparing the actual measurement time of at least one of the average actual measurement time and the maximum execution actual measurement time for each action with the time limit, it is possible to compare the time limit and the actual time under more severe conditions. As a result, the degree to which the time limit can be achieved for each action can be presented to the user, and the work efficiency of the work for improving the program can be improved.

Further, by obtaining the statistical execution actual measurement time and comparing the statistical execution actual measurement time with the time limit, the distribution status of the actual execution actual measurement time can be presented to the user. This has the effect of being able to suggest to the user the priority of measures against actions.

Further, the program is generated by including the process of measuring the function execution actual measurement time when the function is executed in the generated program. As a result, when the action includes the function, or when the action is the function, the actual measurement time of the function is measured together with the actual measurement time of the action, and the actual measurement time of the action is compared with the time limit. , Regarding the processing of the action that exceeds the time limit, by outputting the list of the name and actual measurement time of the function executed inside the processing, there is an effect that it is possible to suggest the target of improvement of the processing time. . In addition, it becomes easier to sufficiently carry out verification and improvement work related to time constraints in the downstream process of software development.
It is possible to obtain effects such as improvement in program development efficiency and quality.

Further, the process of designating the constituent element time limit information, measuring the time required for the partial processing inside the action, and comparing with each time limit,
It can be embedded in the generated program source code. As a result, it is possible to prevent forgetting or overlooking the description of the design information regarding the time limit even for the partial processing inside the action, and it is possible to prevent forgetting to forget the design of the test regarding the time limit or forgetting to implement it, and simplify the verification work. Is effective. As a result, it becomes easy to sufficiently carry out verification and improvement work regarding time constraints in the downstream process of software development, and it is possible to obtain effects such as improvement in program development efficiency and quality.

Further, for a partial process inside an action, the time limit (component time limit) allowed for the process can be described together with the component information and the state transition information. Further, the process of measuring the time required for the partial process inside the action (the component element actual measurement time) can be automatically embedded in the generated program source code. As a result, it is possible to automatically compare the measured actual execution time of the component with the time limit of the component, and prevent forgetting or missing the design information about the execution time limit. It is possible to prevent forgetting to carry out, and to simplify the verification work. As a result, it becomes easy to sufficiently carry out verification and improvement work related to time constraints in the downstream process of software development, and it is possible to obtain effects such as improvement in program development efficiency and quality.

Further, regarding the processing of the action that has exceeded the time limit, the list of the names and the execution times of the functions executed inside the processing is output. As a result, it is possible to suggest the target of improvement of the processing time, it becomes easy to sufficiently carry out verification and improvement work regarding time constraints in the downstream process of software development, and it is possible to obtain the effect of improving the development efficiency and quality of the program. To be

Further, when outputting the list of the function name and the function execution actual measurement time, by presenting the function execution time in the descending order, the priority of the measure for improving the processing time is given to the program developer. Can be suggested, which has the effect of improving the work efficiency of the improvement work. In addition, by presenting the actions in the descending order of the influence on the actual measurement time of execution, it is possible to more effectively suggest the priority of the measures.

Information indicating the variation in the statistical function execution actual measurement time is presented. As a result, it is possible to suggest the priority of measures for improving the processing time, and there is an effect that the work efficiency of the improvement work is improved. In this case, they are presented in descending order of the value representing the variation. This has the effect of more effectively suggesting the priority of measures.

When presenting the function execution actually measured time, it is presented in descending order of the effect on the statistical execution actually measured time of the action. As a result, there is an effect that the priority of measures for improving the processing time can be suggested to the user. As a result, it becomes easy to sufficiently carry out verification and improvement work concerning time constraints in the downstream process of software development, and it is possible to obtain the effects of improving the development efficiency and quality of programs.

In designing the state transition, the time limit allowed for processing the action including one function or one or more functions together with the state transition is described as time limit information (function time limit information) at the same time. The time required for processing an action (function execution actual measurement time) is measured, and the function execution actual measurement time is compared with the function time limit. As a result, it is possible to prevent forgetting or forgetting to forget the description of the design information related to the function time limit, and to prevent forgetting to design or perform the test related to the function time limit, which simplifies the verification work.

[Brief description of drawings]

FIG. 1 is a system configuration diagram of a program development support system according to a first embodiment.

FIG. 2 is a diagram showing an example of state transition information described in a state transition editor according to the first embodiment.

FIG. 3 is a diagram showing an example of component information described in the state transition editor according to the first embodiment.

FIG. 4 is a diagram showing an example of a flowchart of program source code according to the first embodiment.

FIG. 5 is a diagram showing an example of a flowchart of a program source code according to the first embodiment.

FIG. 6 is a diagram showing an example of a flowchart showing a method of adding the execution time limit verification process to the event polling type state transition process according to the first embodiment.

FIG. 7 is a diagram showing an example of a flowchart showing a method of adding the execution time limit verification process to the event polling type state transition process in the first embodiment.

FIG. 8 is a diagram showing an example of a state transition table according to the first embodiment.

FIG. 9 is a diagram showing an example of a flowchart showing a method of adding the execution time limit verification process to the event-driven state transition process using the state transition table according to the first embodiment.

FIG. 10 is a diagram showing an example of a flowchart showing a method of adding the execution time limit verification process to the event-driven state transition process using the state transition table according to the first embodiment.

FIG. 11 is a system configuration diagram of a program development support system according to the second embodiment.

FIG. 12 is a diagram showing an example of a flowchart of program source code according to the second embodiment.

FIG. 13 is a system configuration diagram of a program development support system according to the third embodiment.

FIG. 14 is a diagram showing an example of a flowchart of program source code according to the third embodiment.

FIG. 15 is a diagram showing an example of component information described in the state transition editor in the fourth embodiment.

FIG. 16 is a diagram showing an example of a flowchart of program source code according to the fourth embodiment.

FIG. 17 is a diagram showing an example of a flowchart of program source code according to the fifth embodiment.

FIG. 18 is a system configuration diagram of a program development support system according to the sixth embodiment.

FIG. 19 is a diagram showing an example of a flowchart of program source code according to the sixth embodiment.

FIG. 20 is a diagram showing a description example of state transition in the conventional example.

FIG. 21 is a diagram showing an example of a state transition description in a conventional state transition table.

[Explanation of Codes] 1 state transition editor, 2 state transition information holding means, 3
Automatic program generation means, 4 program source code, 5 program execution means, 6 execution measured time collection means, 7 execution time analysis means, 8 function execution time measurement means, 9 program component storage section, 11 states, 12
Transition, 21 State transition table.

Claims (27)

[Claims] 1. A program development support system for developing a program that runs on a computer by executing an action designated by an event that occurs to transition one state among a plurality of states to another state, the program comprising: A program component storage unit that stores a plurality of program components for causing a computer to perform a predetermined process to configure, status information indicating each of a plurality of states transitioned by the program, and event information indicating the event And action information indicating the action, and time limit information indicating the time limit of the process for executing the action for each action, as state transition information, and the action corresponding to the action information. The program components used to execute Based on the state transition editor specified as information and the component information specified by the state transition editor, select the corresponding program component from the program component storage section and execute the action including the selected program component. Which is a program for measuring the actual measured time of execution when executing the above action, compares the measured actual measured time with the time limit specified by the state transition editor, and presents the comparison result. And a program generation unit that generates a program for executing the processing. 2. The program development support system further executes a program generated by the program generation unit to notify an action execution measurement time measured by executing the program for each action. The execution unit, the execution measurement time collection unit that receives the execution measurement time for each action notified by the program execution unit, and collects the execution measurement time for each action, and the action collected by the execution measurement time collection unit The actual measurement time for each is acquired, the time limit information for each action specified by the state transition editor is acquired, and the result of comparing and comparing the time limit information and the actual measurement time is presented. The program development support system according to claim 1, further comprising an execution time analysis unit. . 3. The program execution unit executes one action a plurality of times depending on an event that occurs, and the execution measurement time collection unit calculates an average execution measurement for each action based on the collected execution measurement time for each action. At least one of the time and the maximum execution measurement time for each action is obtained, and the execution time analysis unit calculates the average measurement time for each action and the maximum execution measurement time for each action obtained by the execution measurement time collection unit. 3. The program development support system according to claim 2, wherein at least one of the above and the time limit information for each action designated by the state transition editor are compared and the comparison result is presented. 4. The execution measurement time collection unit obtains a statistical execution measurement time that is a statistical value for each action based on the collected execution measurement time for each action, and the execution time analysis unit calculates the execution measurement time. The statistical execution actual measurement time for each action obtained by the time collection unit is compared with the time limit information for each action specified by the state transition editor, and the comparison result is presented. Program development support system. 5. The program component is either a function that performs a predetermined process or a case that includes one or more functions that perform a predetermined process, and the program generation unit executes the function. A program for executing the process of measuring the function execution actual measurement time when executing is generated, and the program execution unit executes the process of measuring the function execution actual measurement time by executing the program generated by the program generation unit. The program development support system is activated by a process for measuring the function execution time executed by the program execution unit, and a function execution time measurement unit for measuring and collecting the function execution actual measurement time for each function. The execution time analysis unit may acquire and present the function execution measurement time for each function collected by the function execution time measurement unit. Program development support system according to claim 2, wherein. 6. The state transition editor specifies constituent element time limit information indicating a time limit of processing when executing a program constituent element indicated by the constituent element information in association with the constituent element information, The program generation unit measures the component execution actual measurement time when the program component is executed for each program component, the measured component execution actual measurement time, and the component specified by the state transition editor. The program development support system according to claim 1 or 2, wherein a program that executes a process of presenting a result of the comparison by comparing the time limit information with the time limit information is generated. 7. The program execution unit notifies the execution measurement time collection unit of the component execution measurement time for each program component measured by executing the program generated by the program generation unit, and The execution measurement time collection unit collects the component execution measurement time for each program component notified by the program execution unit, and the execution time analysis unit collects each program component collected by the execution measurement time collection unit. 7. The program development support according to claim 6, wherein the actual measurement time of component execution is compared with the component time limit information for each program component specified by the state transition editor, and the comparison result is presented. system. 8. The program component is either a function for performing a predetermined process or includes one or more functions for performing a predetermined process, and the component specified by the state transition editor. The time limit information is the function time limit information of the process when the function is executed, and the program generation unit generates a program that executes the process of measuring the function execution actually measured time when the function is executed, The program execution unit executes a process of measuring the function execution actual measurement time by executing the program generated by the program generation unit, and the program development support system executes the function execution performed by the program execution unit. Function execution time measurement unit that is started by the process of measuring the actual measurement time and measures and collects the actual measurement time of function execution for each function The execution time analysis unit acquires the function execution measurement time for each function collected from the function execution time measurement unit, and also acquires the function time limit information for each function specified by the state transition editor. 8. The program development support system according to claim 7, wherein the measured function execution time is compared with the function time limit information, and the comparison result is presented. 9. The execution time analysis unit presents the function execution actually measured time in the order of the function having the longest function execution actually measured time, and the influence of the function execution actually measured time on the action actually measured time. The method of presenting in any one of the following order:
Described program development support system. 10. The function execution time measurement unit obtains a statistical function execution measurement time, which is a statistical value for each function, based on the collected function execution measurement time for each function, and the execution time analysis unit 9. The program development support system according to claim 5, wherein the program development support system presents the statistical function execution measurement time obtained by the function execution time measurement unit in descending order of variation. 11. The actually measured execution time collecting unit obtains a statistically actually measured time, which is a statistical value for each action, based on the collected actually measured execution time for each action, and the function execution time measuring unit collects it. The statistical function execution actual measurement time, which is a statistical value for each function, is calculated based on the function execution actual measurement time for each function, and the execution time analysis unit calculates the statistical execution actual time and the statistical execution actual time acquired by the execution actual time collection unit. Based on the statistical function execution actual measurement time obtained by the function execution time measurement unit,
9. The program development support system according to claim 5, wherein the function execution actually measured time is presented in descending order of influence on the statistical execution actually measured time of the action. 12. The configuration specified by the state transition editor, wherein the program component is either a function for performing a predetermined process or a function including one or more functions for performing a predetermined process. The element time limit information is the function time limit information of the process when the function is executed, and the program generation unit generates a program that executes the process of measuring the function execution measured time when the function is executed, The program development support system further executes a program generated by the program generation unit to execute a process of measuring the function execution measurement time by executing the program, and the program execution unit. The function execution actual measurement time for each function is The function execution time measurement unit that collects by setting the function execution time measurement unit for each function collected by the function execution time measurement unit is acquired, and the function time limit information for each function specified by the state transition editor is acquired. 2. The program development support system according to claim 1, further comprising: an execution time analysis unit that acquires and compares the measured function execution time with the function time limit information and presents the comparison result. 13. A program development support method for developing a program operating on a computer, which executes a specified action between a plurality of predetermined states depending on an event to be generated and transitions, wherein at least one of the actions is included. A program component for performing a predetermined process is stored in the program component storage unit, and state information indicating each state of a plurality of transition states of the program, event information indicating the event, and the action are indicated. Action information and time limit information indicating a time limit for processing when executing the action for each action are specified as state transition information, and program components included in the action in association with the action information are specified. It is specified as component information, and the component information specified above is specified. A process of selecting a corresponding program component from the program component storage unit based on a report, executing an action including the selected program component, and measuring an actual measurement time for executing the action; A program development support method comprising: comparing the measured actual measurement time with the specified time limit, and generating a program for executing a process of presenting the comparison result. 14. The program development support method executes the generated program, and notifies, for each action, an actually measured execution time of an action measured by executing the program, and for each of the notified actions. The actual measurement time for each action is received, the actual measurement time for each action is collected, and the actual measurement time for each action is collected and the time limit information for each specified action is acquired. 14. The program development support method according to claim 13, wherein the time limit information is compared with the execution actual measurement time, and the comparison result is presented. 15. The program development support method specifies constituent element time limit information indicating a time limit of processing when executing a program constituent element indicated by the constituent element information, in association with the constituent element information, The process of measuring the component execution actual measurement time when the program component is executed for each program component, and the measured component execution actual measurement time and the specified component time limit information are compared and compared. 15. The program development support method according to claim 13 or 14, wherein a program that executes the processing of presenting the result is generated. 16. The program component is either a function for performing a predetermined process or a function including one or more functions for performing a predetermined process, and the designated time limit information is: This is the function time limit information of the process when executing the function. When the above program is generated, a program that executes the process of measuring the function execution actual measurement time when executing the above function is generated, and the above program development support is performed. The method further includes executing the generated program, executing the process of measuring the function execution actual measurement time by executing the program, and being activated by the process of measuring the function execution actual measurement time. The measured function execution time for each function is measured and collected, and the collected function execution measured time for each function is acquired and the function control for each specified function is acquired. 14. The program development support system according to claim 13, wherein the time limit information is acquired, the function execution actual measurement time is compared with the function time limit information, and the comparison result is presented. 17. The program development support method notifies a component execution actual measurement time for each program component measured by executing the generated program, and the notified component for each program component. Collecting the actual measurement time of execution, comparing the collected actual time of execution of the constituent element of each program constituent element with the time limit information of the constituent element of each designated program constituent element, and presenting the result of the comparison. 16. The program development support method according to claim 15, which is characterized in that. 18. A computer-readable recording medium recording a program development support program for developing a program operating on a computer, which executes a specified action between a plurality of predetermined states according to an event to be generated and transits. In the program component storage step of storing in the program component storage unit a program component for performing a predetermined process included in one or more of the above actions, and a state indicating each of a plurality of transition states of the program. Information, event information indicating the event, action information indicating the action, and time limit information indicating the time limit of processing when the action is executed for each of the actions, as well as specifying as state transition information, Corresponding to the above action information, the above action State transition information designating step of designating the program constituent elements included in the program as constituent element information, and selecting the corresponding program constituent element from the program constituent element storage unit based on the constituent element information designated by the state transition information specifying step. Then, while performing the action including the selected program component, the process of measuring the actual measurement time when executing the action,
And a program generation step for generating a program for executing a process of presenting the result of comparison by comparing the measured execution measurement time with the time limit specified by the state transition information specifying step. A computer-readable recording medium recording a program development support program. 19. A computer-readable recording medium recording the program development support program, further executing the program generated by the program generating step, and executing an action measured by executing the program. A program execution step for notifying the actual measurement time for each action, an execution actual measurement time collection step for receiving the actual execution time for each action notified by the program execution step, and collecting the actual execution time for each action, and the above execution The actual measurement time for each action collected by the actual measurement time collection step is acquired, and the time limit information for each action specified by the state transition information specification step is acquired, and the time limit information and the actual measurement time for execution are acquired. And an execution time analysis step that presents the results of comparison A computer-readable recording medium having the program development support program according to claim 18 recorded thereon. 20. The state transition information designating step designates constituent element time limit information indicating a time limit of processing when executing a program constituent element indicated by the constituent element information, in association with the constituent element information. The program generation step is a process of measuring a component execution actual measurement time when the program component is executed for each of the program components, and the measured component execution actual measurement time and the state transition information designation step. 20. A computer program recording a program development support program according to claim 18, wherein the program is executed to compare the generated component element time limit information and present a result of comparison. Possible recording medium. 21. The program execution step notifies a component element actual measurement time measured for each program component by executing the program generated by the program generation step, and the execution actual measurement time collection step comprises: The component execution actual measurement time for each program component notified by the program execution step is collected, and the execution time analysis step is performed by the component execution actual measurement time for each program component collected by the execution actual time collection step. 3. The comparison result is presented by comparing with the constituent element time limit information for each program constituent element designated by the state transition information designating step.
A computer-readable recording medium in which the program development support program described in 0 is recorded. 22. The program component is either a function for performing a predetermined process or a function including one or more functions for performing a predetermined process, and is designated by the state transition information designating step. The time limit information is the function time limit information of the process when the function is executed, and the program generation step generates a program that executes the process of measuring the function execution measured time when the function is executed, A computer-readable recording medium recording the program development support program further executes the program generated by the program generation step, and executes the process of measuring the function execution measurement time by executing the program. To measure the program execution process and the function execution measurement time executed by the program execution process. The function execution time measurement step that is started by the process and measures and collects the function execution measurement time for each function, and the function execution measurement time for each function collected by the function execution time measurement step is acquired and And a function execution time analysis step of acquiring the function time limit information for each function specified by the transition information specification step, comparing the function execution actual measurement time with the function time limit information, and presenting the comparison result. 19. A computer-readable recording medium having the program development support program according to claim 18 recorded therein. 23. A program development support program for developing a program operating on a computer, which executes a specified action between a plurality of predetermined states according to an event to be generated and transitions, one or more of the actions being included. Program component storing step of storing a program component for performing a predetermined process in a program component storage unit, state information indicating each of a plurality of transition states of the program, and event information indicating the event And action information indicating the action, and time limit information indicating the time limit of the process for executing the action for each action, as state transition information, and the action corresponding to the action information. The program components included in A state transition information designating step to be designated by the user, and a corresponding program component is selected from the program component storage unit on the basis of the component information designated by the state transition information designating step to include the selected program component. Along with executing the action, the process of measuring the actual measurement time when executing the above action,
And a program generation step for generating a program for executing a process of presenting the result of comparison by comparing the measured execution measurement time with the time limit specified by the state transition information specifying step. Program development support program. 24. The program development support program further executes the program generated in the program generating step, and notifies each action of an actually measured execution time of an action measured by executing the program. Execution process, an actual measurement time collection process that receives the actual measurement time for each action notified by the program execution process, and collects the actual measurement time for each action, and the action collected by the actual measurement time collection process While acquiring the actual measurement time for each, also obtain the time limit information for each action designated by the state transition information designating step, and compare the time limit information and the actual measurement time to the result of comparison. 24. The professional program according to claim 23, further comprising a step of analyzing the execution time. Gram development support program. 25. The state transition information designating step designates, in association with the constituent element information, constituent element time limit information indicating a processing time limit when executing a program constituent element indicated by the constituent element information. The program generation step is a process of measuring a component execution actual measurement time when the program component is executed for each of the program components, and the measured component execution actual measurement time and the state transition information designation step. 25. The program development support program according to claim 23, further comprising: a program for executing a process of comparing the generated component element time limit information and presenting a result of the comparison. 26. The program execution step notifies a component element actual measurement time for each program component measured by executing the program generated by the program generation step, and the execution actual measurement time collection step comprises: The component execution actual measurement time for each program component notified by the program execution step is collected, and the execution time analysis step is performed by the component execution actual measurement time for each program component collected by the execution actual time collection step. 3. The comparison result is presented by comparing with the constituent element time limit information for each program constituent element designated by the state transition information designating step.
The program development support program described in 5. 27. The program component is either a function for performing a predetermined process or a function including one or more functions for performing a predetermined process, and is designated by the state transition information designating step. The time limit information is the function time limit information of the process when the function is executed, and the program generation step generates a program that executes the process of measuring the function execution measured time when the function is executed, The program development support program further executes the program generated in the program generation step, and executes the program to execute a process of measuring the function execution measurement time, and the program execution step. It is started by the process of measuring the above-mentioned function execution actual measurement executed by the process, and the function execution actual measurement for each function The function execution time measurement step of measuring and collecting the interval, and the function execution actual measurement time of each function collected by the function execution time measurement step, and the function of each function specified by the state transition information specifying step 24. The program development according to claim 23, further comprising: an execution time analysis step of acquiring time limit information, comparing the function execution actual measurement time with the function time limit information, and presenting a result of the comparison. Support program.