JP2014154039A - Sequence monitoring automatic programming device and automatic programming method - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a sequence monitoring automatic programming device capable of monitoring execution sequence between modules ranging over multiple task levels.SOLUTION: The sequence monitoring automatic programming device comprises: a source code input unit 1; an object module detection unit 2 for detecting modules to be monitored from the source code; a monitoring table reference unit 3 for referring to a sequence monitoring table in order to acquire information defining the modules to be monitored, and acquiring information necessary for the processing; a monitoring code creation unit 4 for creating monitoring code for monitoring execution sequence between modules ranging over multiple task levels, for the detected modules to be monitored, according to information of task levels where the respective modules are executed; a monitoring code insertion and source code output unit 5 for inserting the created monitoring code into source code of each module (performing edit) and outputting the source code; and a monitoring implementation table output unit 6 for outputting a sequence monitoring implementation table to refer to when the source code is executed.

Description

  The present invention relates to a sequence monitoring automatic programming apparatus and an automatic programming method for monitoring a program execution state in an embedded device using a microprocessor.

  In the past, some proposals have been made regarding techniques for monitoring the program execution status of embedded devices. However, most of the techniques for incorporating monitoring functions into execution programs are for each module to be monitored. At present, the monitoring function is individually incorporated into the source code.

  Further, in Patent Document 1 below, when the function of the program read from the storage unit is a function to be monitored, a monitoring code is inserted into the program so that the monitoring process is performed on the function to be monitored. A technique is disclosed in which a program execution unit monitors a program execution state by executing a function in which a monitoring code is inserted.

Under these circumstances, the conventional technique in which the worker individually incorporates the monitoring function has the following problems because it is necessary for the worker to incorporate the monitoring function for each module. That is,
Programming errors may occur due to manual work by workers. Moreover, since the description content to be incorporated differs for each module, a programming error may occur. In the case of a simple execution sequence, the monitoring function to be incorporated is also simple, but if the number of modules to be monitored increases and the configuration becomes complicated, there is a high possibility that errors or omissions in the monitoring function to be incorporated will occur. Become. As a result, it is necessary to check whether the required monitoring sequence matches the monitoring function that is actually built into each module. As the module configuration and monitoring sequence become more complicated, omissions and errors occur. Is more likely to do. In addition, when the monitoring contents are changed, it is necessary to correct each module body, which further increases the amount of work by workers.

  In the prior art disclosed in Patent Document 1, when the function of the program read from the storage unit is a function to be monitored, the monitoring code is added to the program so that the monitoring process is performed on the function to be monitored. Has been proposed, and the program execution section executes the function with the monitoring code inserted to monitor the execution state of the program and embed the monitoring code at the time of program execution. This is not applicable to simple embedded device products that operate on a ROM basis.

  In order to solve the above-described problems of the prior art, the sequence monitoring automatic programming device described in Patent Document 2 below automatically monitors the source code of each module from the module that is the target of sequence monitoring and the description of the execution order relationship. Proposes to provide a mechanism to incorporate functionality.

JP 2004-287869 A JP 2011-159115 A

  However, the sequence monitoring automatic programming device described in Patent Document 2 has a mechanism that automatically incorporates a monitoring function into the source code of each module from the modules that are subject to sequence monitoring and the descriptions of their execution order relationships. There is a problem that the execution order between modules across multiple task levels cannot be monitored.

  Accordingly, an object of the present invention is to provide a sequence monitoring automatic programming device and an automatic programming method capable of monitoring the execution order between modules across a plurality of task levels in order to solve the above-described problems.

  In order to solve the above problems, a sequence monitoring automatic programming apparatus according to the present invention includes a means for inputting a source code of a program, a means for detecting a module to be monitored from the input source code, and the module to be monitored. And the identification code, task level, presence / absence of initialization of the sequence stack, and means for referring to the sequence monitoring table to obtain information defined for the preceding module identification code, and for each module in the referenced sequence monitoring table Means for generating a monitoring code for monitoring an execution order between modules across a plurality of task levels for the detected monitoring target module according to information on a task level to be executed; and the generated plurality of task levels Supervises the execution order between modules It means for monitoring code is inserted into the source code of each module output that is characterized by comprising a means for outputting a sequence monitoring implementation tables for reference runtime code generation.

The sequence monitoring automatic programming method of the present invention includes a process of inputting a source code of a program, a process of detecting a module to be monitored from the input source code,
The module to be monitored and its identification code, task level, presence / absence of sequence stack initialization, and a process of referring to a sequence monitoring table to acquire information defined for a preceding module identification code, the sequence monitoring referred to The process of generating monitoring code for monitoring the execution order between modules across a plurality of task levels for the detected module to be monitored according to information on the task level executed by each module in the table, the generated plurality The process of outputting the monitoring code for monitoring the execution order between modules across the task level of each module and outputting it to the source code of each module, and the process of outputting the sequence monitoring implementation table for reference when generating the execution code, It is characterized by including

  According to the present invention, the task level to be executed of the module to be monitored is defined in the sequence monitoring table, and the source code in which the monitoring code for monitoring the execution order between the modules across the plurality of task levels is inserted based on the defined task level. Is automatically output, and the function for monitoring the execution order between modules across multiple task levels can be implemented without error and with less man-hours.

It is a block diagram which shows the structure outline | summary of the sequence monitoring automatic programming apparatus which concerns on embodiment of this invention. It is a figure which shows the Example of the sequence monitoring automatic programming apparatus which concerns on embodiment of this invention. It is a figure which shows the execution order of each module in an embedded device. It is a figure which shows the processing flow of the Example of the sequence monitoring automatic programming apparatus which concerns on embodiment of this invention. FIG. 5 is a diagram showing the contents of the initialization process “initial” shown in FIG. 4. It is a figure which shows the content of the sequence monitoring process "check" shown in FIG.

Hereinafter, embodiments of the present invention will be described in detail.
FIG. 1 is a block diagram showing an outline of the configuration of a sequence monitoring automatic programming apparatus according to an embodiment of the present invention. 1, a sequence monitoring automatic programming device (hereinafter abbreviated as “automatic programming device”) according to an embodiment of the present invention includes a source code input unit 1 for inputting a source code of a program, and a monitoring target from the input source code. A target module detection unit 2 for detecting a module to be detected, and a sequence monitor to acquire information defined about the module to be monitored and its identification code, task level, sequence stack initialization, and preceding module identification code A monitoring table reference unit 3 that acquires information necessary for processing from the defined information with reference to the table (see FIG. 2), and information on the task level executed by each module in the referenced sequence monitoring table According to the detected module to be monitored A monitoring code generation unit 4 that generates a monitoring code that monitors the execution order between modules across multiple task levels, and outputs the source code by inserting (editing) the generated monitoring code into the source code of each module A monitoring code insertion / source code output unit 5 and a monitoring implementation table output unit 6 that outputs a sequence monitoring implementation table (see FIG. 2) to be referred to when the output source code is executed.

  The hardware configuration for realizing the functional blocks of the automatic programming device described above is configured by a personal computer level computer well known to those skilled in the art, and has an input having a keyboard, a mouse, a pointing device, and the like. Outside of the device, the device for outputting the processing result, the output device capable of displaying on the display for confirming the contents being input or being processed, the central processing device for executing the processing according to the program stored in the memory (CPU (Central Processing Unit)), memory for storing programs and data (ROM (read only memory), RAM (random access memory), HDD (Hard Disk Device), USB (universal serial bus) memory, etc.)) , A recording medium driving device for driving a storage medium such as an HDD, and an interface to an input / output device And various external devices and interfaces for exchanging data (IF), and a like. The computer may have a function of connecting to a network such as the Internet.

  In the above, the source code input unit 1 accesses a storage medium storing external source code via a CPU and an interface (IF) that execute processing based on a program under the instruction of the input device of the computer. This can be realized by fetching the source code from the storage medium into the memory in the computer. The target module detection unit 2, the monitoring table reference unit 3, and the monitoring code generation unit 4 perform processing based on a program while referring to a sequence monitoring table (see FIG. 2) prepared in advance by the CPU of the computer. And the above-described functions can be realized by storing the processing result in the memory in the computer. Details will be described later. The monitoring code insertion / source code output unit 5 and the monitoring implementation table output unit 6 can be realized by the CPU of the computer outputting the processing result stored in the memory to the output device. When outputting to the output device, an interface (IF) can be used as necessary.

  FIG. 2 is a diagram showing an example of the sequence monitoring automatic programming apparatus according to the embodiment of the present invention. In the embodiment shown in FIG. 2, the sequence monitoring automatic programming apparatus 100 first reads the contents of the input modules 210 to 250 including the source code for each module from the input file 200 in which the source code is described.

  Next, the sequence monitoring automatic programming apparatus 100 refers to the sequence monitoring table 300, edits the source code included in the read input modules 210 to 250 according to the contents thereof, and adds a sequence monitoring function, for example, initial to each source code for each module. The output modules 410 to 450 into which software processing functions such as processing and check processing are inserted are output as the output file 400. In addition, a sequence monitoring implementation table 500 is output for reference when generating an execution code from the source code of the output modules 410 to 450 that is output and inserted into the source code by the sequence monitoring function.

  The operation processing of the sequence monitoring automatic programming device 100 is thus completed, but the user (user) thereafter compiles and builds the source code output to the output file 400 in the software development environment in the same way as normal software development. As a result, an execution code is generated, and the generated execution code is mounted on an embedded device (not shown) with a built-in microprocessor.

  The sequence monitoring table 300 holds, for each module, a task level 310, a module name 320, whether or not a sequence stack is initialized 330, a module identification code 340, and a preceding module identification code 350. The sequence monitoring table 300 is generally created as a text file, but the creation method and physical format are arbitrary. Similarly to the sequence monitoring table 300, the sequence monitoring implementation table 500 describes data in each column of the identification code 510, the task level 520, and the preceding module identification code 530.

  The sequence monitoring implementation table 500 shown in FIG. 2 defines the execution status of the modules shown in FIG. FIG. 3 shows the execution order of modules in an embedded device (not shown). When module_A, module_B, and module_C are executed in this order in one execution cycle of the same task level x, FIG. An example in which a normal sequence is considered to have been executed is shown, and whether such an execution state is normally performed is automatically monitored by sequence monitoring described later.

  That is, module_A is the module that is executed first in the execution cycle at the task level x, and initializes a monitoring sequence stack (not shown) in the process (in the sequence monitoring table 300 of FIG. 2). The identifier “A” indicating that module_A has been implemented is stored in the sequence stack after initialization. The contents are described in the module_A portion of the sequence monitoring table 300. The identifier “A” indicates the character code A here. This is an example, and any numerical value or other code system can be used as long as module_A can be uniquely identified.

  Module_B is to be executed next to module_A. As a monitoring function inserted into module_B, it is monitored whether module_A is executed before execution. This content is described in the preceding module identification code 350 of module_B of the sequence monitoring table 300.

  In module_C, module_A, B and module_D, module_E executed at task level y must be executed in this order before execution, and this content is described in the preceding module identification code 350 of module_C in the sequence monitoring table 300 Is done.

  The module_D executed at the task level y is a module executed first in the execution cycle at the task level y, and a monitoring sequence stack (not shown) is initialized in the processing (FIG. 2). The identifier “D” indicating that the module_D has been implemented is stored in the sequence stack after the initialization. The contents are described in the module_D portion of the sequence monitoring table 300.

  The module_E executed at the task level y is to be executed next to the module_D, and the monitoring function inserted into the module_E is to monitor whether the module_D is executed before execution. This content is similarly described in the preceding module identification code 350 of module_E of the sequence monitoring table 300.

  FIG. 4 is a diagram showing a processing flow of an example of the sequence monitoring automatic programming apparatus according to the embodiment of the present invention. In FIG. 4, first, an environment for referring to the sequence monitoring table 300 is initialized (step S41). Thereafter, the processing can be performed while referring to the sequence monitoring table 300 in order.

  Next, the sequence monitoring automatic programming device 100 searches the source code file 200 including the module name described in the sequence monitoring table 300 (step S42). Then, the initialization presence / absence 330 of the sequence monitoring table 300 is referred to (step S43). If initialization is present (step S43: Yes), an initialization process (call initial (argument)) is inserted into the source code (step S43: Yes) Step S44). As an example, the name of the initialization process is “initial”. The argument passed to the process is the identification code 340 described in the sequence monitoring table 300.

  On the other hand, if there is no initialization (step S43: No), a monitoring process (call check (argument)) is inserted into the source code (step S45). In this example, the name of the monitoring process is “check”. The argument passed to the process is the identification code 340 in the sequence monitoring table 300, as in the case of initialization described above. When any of these processes is completed, the source code that has been edited, that is, the monitoring function is inserted, is output (step S46).

  This completes the process for one module described in the sequence monitoring table 300, so that this process is repeated for the modules described in the sequence monitoring table 300 (step S47). When the repetitive processing is finished, the sequence monitoring mounting table 500 is output (step S48), and the processing of the sequence monitoring automatic programming device 100 is finished.

  As a result, the sequence monitoring sequence and the modules to be monitored are defined in the sequence monitoring table as the task level to be executed by the modules to be monitored, and the source code in which the monitoring process is inserted is automatically output based on this Therefore, the function for monitoring the execution order between modules across a plurality of task levels can be implemented without error and with less man-hours.

  FIG. 5 is a diagram showing the contents of the sequence monitoring initialization process (initial (“”)) shown in FIG. In FIG. 5, a sequence stack (not shown) for monitoring the task level corresponding to the module indicated by the argument (here, the identification code) is initialized (step S51). Thereafter, the identification code 340 passed as an argument is stored in the sequence stack (step S52). Thus, the sequence monitoring initialization process (initial (“”)) is completed.

  FIG. 6 is a diagram showing the contents of the sequence monitoring process (check (“”)) shown in FIG. In FIG. 6, first, the preceding module identification code 530 of the module corresponding to the argument identification code 510 is extracted from the sequence monitoring implementation table 500 (step S61).

  Next, it is confirmed whether the identification codes stored in the sequence stack (not shown) are stored in the same order as the contents of the preceding module identification code 530 described in the sequence monitoring implementation table 500 (step S62). If stored in order (step S62: Yes), the sequence is normal, and the identification code 510 passed as an argument is stored in the corresponding task level sequence stack (step S63).

  On the other hand, if they are not stored in order (step S62: No), an abnormal process (subroutine) is called (step S64). The contents of the abnormality process include the contents that are specific to the embedded device, and the abnormality process (subroutine) is executed accordingly.

  In general, the contents of abnormality processing are to display the occurrence of abnormality or issue a warning to the outside, notify the appropriate department that abnormality has occurred, or stop or stop the processing. Transition is performed as appropriate.

  In this example, when the abnormal process (subroutine) is completed, the process returns to the normal process route, and the identification code passed as an argument is stored in the sequence stack (step S63). Thus, the sequence monitoring process (check (“”)) is terminated.

  As described above, the sequence monitoring automatic programming device according to the embodiment of the present invention defines the task level to be executed by the module to be monitored in the sequence monitoring table, and automatically inputs the source code into which the monitoring process is inserted based on the defined task level. By outputting, the function of monitoring the execution order between modules across multiple task levels can be implemented without error and with fewer man-hours.

1 Source code input unit 2 Target module detection unit 3 Monitoring table reference unit 4 Monitoring code generation unit 5 Monitoring code insertion / source code output unit 6 Monitoring implementation table output unit
100 Sequence monitoring automatic programming device
200 input source code file
210 Input module with source code content 1
220 Input module with source code contents 2
230 Input module with source code contents 3
240 Input module with source code contents 4
250 Input module with source code contents 5
300 Sequence monitoring table
310 task level
320 Module name
330 Initialization
340 identification code
350 Predecessor identification code
400 Output source code file with monitoring function inserted
410 Output module with monitoring function 1 inserted in source code
420 Output module with monitoring function 2 inserted in source code
430 Output module with monitoring function 3 inserted in source code
440 Output module with monitoring function 4 inserted in source code
450 Output module with monitoring function 5 inserted in source code
500 Sequence monitoring implementation table
510 ID code
520 task level
530 Predecessor module identification code

Claims (3)

Means for inputting the source code of the program;
Means for detecting the module to be monitored from the input source code;
Means for referring to a sequence monitoring table in order to obtain information defining the module to be monitored and its identification code, task level, presence / absence of sequence stack initialization, and preceding module identification code;
Means for generating monitoring code for monitoring the execution order between modules across a plurality of task levels for the detected module to be monitored in accordance with the information on the task level executed by each module in the referenced sequence monitoring table When,
Means for inserting and outputting monitoring code for monitoring the execution order between modules across the plurality of generated task levels into the source code of each module;
Means for outputting a sequence monitoring implementation table for reference during execution code generation;
A sequence monitoring automatic programming apparatus comprising: The process of entering the source code of the program,
The process of detecting the module to be monitored from the input source code,
The process of referring to the sequence monitoring table to obtain information defining the module to be monitored and its identification code, task level, presence / absence of sequence stack initialization, and preceding module identification code,
A process of generating monitoring code for monitoring an execution order between modules across a plurality of task levels for the detected monitoring target module according to information on a task level executed by each module in the referenced sequence monitoring table ,
A process of inserting and outputting monitoring code for monitoring the execution order between modules across the plurality of generated task levels into the source code of each module, and
The process of outputting the sequence monitoring implementation table for reference during execution code generation,
A sequence monitoring automatic programming method comprising: A program for automatically generating and outputting a source code in which a monitoring code is inserted in an information processing apparatus having means for referring to a sequence monitoring table defining a sequence monitoring process,
On the computer,
The ability to enter program source code,
A function to detect the module to be monitored from the input source code,
A function to refer to the sequence monitoring table to obtain information defining the module to be monitored and its identification code, task level, presence / absence of sequence stack initialization, and preceding module identification code;
Monitoring code monitoring code for monitoring the execution order between modules across a plurality of task levels with respect to the detected module to be monitored according to the information of the task level executed by each module in the referenced sequence monitoring table Function to generate,
A function for inserting and outputting the generated monitoring code into the source code of each module; and
A function to output a sequence monitoring implementation table for reference during execution code generation,
A program to realize