JP4327416B2 - Trace data processing apparatus, trace data processing method, and program for executing the method - Google Patents

Description

[0001]
BACKGROUND OF THE INVENTION
The present invention relates to a trace data processing apparatus, a trace data processing method, and a program for executing the method, which can trace a subroutine call path of a program mounted on a controller and a subroutine call timing when an abnormality occurs. is there.
[0002]
[Prior art]
In recent factories, production activities utilizing the FA system (factory automation system) are often performed. This FA system refers to a control system that combines automation and computerization that comprehensively controls equipment such as production equipment and transport equipment, and production activities such as production planning and production management. I call it this way.
[0003]
FIG. 8 is a diagram illustrating an example of a system configuration in the FA system. In the figure, a controller 81 controls an intelligent unit 82 and a non-intelligent unit 83 connected via a system bus. Various control devices such as an I / O device 84, a servo motor 85, a sensor 86, a lamp, and an actuator 87 are connected to the intelligent unit 82, and a switch, an output device, a light pipe, and the like 88 are connected to the non-intelligent unit 83. It is connected. These control devices perform physical input / output, communication, data conversion, and the like with the outside. The controller 81 includes a microprocessor (MPU) therein, and executes a user control program mounted on the MPU to control the operation of the entire system.
[0004]
By the way, when debugging a control program of a controller, there are cases where it is desired to trace as a history what route a certain executed subroutine was called. Furthermore, when an abnormality occurs in a subroutine, it is the psychology of the developer of the control program that wants to debug following the path when the abnormality occurs based on the trace data.
[0005]
FIG. 9 is a block diagram showing an internal configuration of a conventional controller. An MPU 91 executes a user control program and controls the operation of the entire system. 92 is a work RAM and 93 is a system ROM. The system ROM 93 describes a system program for controlling the operation of the controller, and the system program executes the user's control program, whereby the entire system is controlled. The work RAM 92 is a memory used for work (work) used when the MPU 91 executes a system program stored in the system ROM 93. That is, it is used to save data that needs to be temporarily saved, or to store data generated during input / output with the outside of the controller.
[0006]
In FIG. 9, 94 is a user RAM, 95 is a parameter, 96 is a user program, and 97 is a device memory. The user control program is stored in the user program 96. At that time, the device memory 97 is used as a work area when the user's control program is executed. The parameter 95 is given a condition when the control program is executed. Reference numeral 98 is an address bus, and 99 is a data bus. The address bus 98 is used by the MPU 91 to access the work RAM 92, the system ROM 93, the user RAM 94, and the device memory 97, and the data bus 99 is used to read / write data from / to each memory. The system ROM 93 is a read-only memory.
[0007]
FIG. 10 is a diagram illustrating an example of the operation of a control program of a conventional controller. Steps S10201 to S10205 are descriptions of the main program. First, the execution condition a is read in step S10201. When the execution condition is satisfied, a subroutine starting from the pointer Pa is called in step S10202. The execution condition b is read in step S10203. When the execution condition is satisfied, the pointer Pb is read in step S10204. Call a subroutine starting with. Step S10205 shows an instruction (FEND instruction) indicating the end of the main program.
[0008]
Next, Pa is a pointer indicating the head of the subroutine called in step S10202. The execution condition Paa is read in step S10206. When the execution condition is satisfied, the subroutine starting from the pointer Pcom is called in step S10207. After the actual processing of this subroutine is completed, the instructions in steps S10208 to S10209 are executed, and the instruction for returning from the subroutine (RET instruction) is executed in step S10210. Similarly, Pb is a pointer indicating the head of the subroutine called in step S10211. The execution condition Pbb is read in step S10211. When the execution condition is satisfied, the subroutine starting from the pointer Pcom is called in step S10212. After the actual processing of this subroutine is completed, the instructions of steps S10213 to S10214 are executed, and the instruction for returning from the subroutine (RET instruction) is executed in step S10215.
[0009]
Pcom is a pointer indicating the head of the subroutine called in step S10207 or S10212. The execution condition Pcc is read in step S10216. When the execution condition is satisfied, the actual processing of the subroutine is started in step S10217. The instruction of S10219 is executed, and an instruction to return from the subroutine (RET instruction) is executed in step S10220. Step S10221 indicates an instruction (END instruction) that means the end of all programs.
[0010]
FIG. 11 is a diagram showing processing of a subroutine program of the controller in the prior art. As shown in the figure, the normal controller executes the program by repeating external input processing, program execution, and external output processing as one cycle. This period of time is called a scan time. When a subroutine call occurs during program execution, the execution of the main program is temporarily interrupted, the program corresponding to the subroutine call pointer is executed, and when execution of the subroutine program ends, the next instruction when the subroutine call occurs After returning, the processing of the suspended program is resumed.
[0011]
Subroutines are a very important concept in programming techniques, and are an essential concept for developing programs efficiently and creating easy-to-read programs. Among them, in particular, one of the reasons for requiring a subroutine is that it can “do the same thing over and over”. When creating a program, it is necessary to perform exactly the same processing in different scenes in the flow of the program, or the processing is almost the same, but slightly different processing often appears. If possible, describe one process that can be shared, and then use that description. Therefore, a method has been devised in which only one process that appears many times is created in a different location from the main program (main routine), and that process is called when it becomes necessary.
[0012]
FIG. 12 is an explanatory diagram showing a processing concept of a subroutine. In the example shown in the figure, the process A is called three times by the main routine (timing 121, 123, 125 shown in the figure), and the process B is called once by the main routine (timing 127 shown in the figure). ). A program that is described in a place different from the main routine and performs a certain process to be called from the program body is called a subroutine. Even if the same subroutine is called from different locations, when returning, the same subroutine is returned to different locations each time (timing 122, 124, 126, 128 shown in the figure).
[0013]
FIG. 13 is an explanatory diagram showing the concept of a CALL instruction, a RET instruction, and a stack. The stack is an operation of “retrieving the last stored data first”. Stacking is similar to stacking books. As books are stacked, the first one that can be taken out is the last one. That is, if some data is loaded on the stack, the first data that can be taken out is the last loaded data. A stack pointer (SP) is prepared for realizing this stack. As can be seen from what is called a pointer, the stack pointer has a role of pointing to the memory in the stack area, and always points to the top of the stack (the top of the stacked stack).
[0014]
How the stack state changes in response to the subroutine call will be described with reference to FIG. First, it is assumed that the stack state before the CALL instruction is executed is “(1) stack state before the CALL instruction is executed”. When the CALL instruction is executed in step S10401, “bbb” indicating the address of the instruction to be executed next is stacked on the stack. At this time, the stack pointer is updated for the next stack processing. That is, the stack pointer moves to the place where this “bbb” is stacked. At the same time, the stack state becomes “(2) Stack state after execution of CALL instruction”. When the CALL instruction is executed in step S 10402, “ccc” indicating the address of the instruction to be executed next is stacked on the stack, the stack pointer is updated for the next stack processing, and the stack state is “ (3) Stack state after execution of CALL instruction ". In this state, when “(4) Subroutine actual process execution” is performed, the RET instruction corresponding to step S10402 is executed in step S10404, and the address “ccc” of the instruction to be executed next is taken out of the stack. The pointer is updated for the stack processing, and the stack state becomes “(5) Stack state after execution of RET instruction”.
[0015]
Similarly, in step S10405, the RET instruction corresponding to step S10401 is executed, the address “bbb” of the instruction to be executed next is fetched from the stack, the pointer is updated for the next stack processing, and the state of the stack is , “(6) Stack state after execution of RET instruction”. In this way, when a series of subroutine call processing is completed, the state finally returns to the state before the call, that is, “(1) stack state before execution of CALL instruction”.
[0016]
In this way, even when jumping to the subroutine from the middle of the main routine, the address of the instruction to be executed next can be taken out from the stack when executing the RET instruction. Therefore, the main pointer can be managed only by managing the stack pointer. By dividing the routine into subroutines, the readability of the program can be improved.
[0017]
FIG. 14 is a diagram illustrating an example of the operation of the CALL instruction and the RET instruction in the prior art. FIG. 10 specifically shows how the program of FIG. 10 is stored in the user program 96 of FIG.
[0018]
In FIG. 14, “LD execution condition a” (reading instruction for execution condition a) is included in step S10601, “CALL Pa” (subroutine call instruction starting from pointer Pa) is included in step S10602, and “LD execution condition b is included in step S10603. "(Reading instruction of execution condition b)", "CALL Pb" (subroutine call instruction starting from pointer Pb) is stored in step S10604, and "FEND" (instruction indicating the end of the main program) is stored in step S10605. Yes.
[0019]
Next, in step S10606, “LD execution condition Paa” (reading instruction for execution condition Paa), “CALL Pcom” (subroutine call instruction starting from pointer Pcom) in step S10607, and instructions AA to AZ in steps S10608 to S10609. In step S10610, “RET” (an instruction for returning from the subroutine Pa) is stored.
[0020]
Also, “LD execution condition Pbb” (reading instruction for execution condition Pbb) is included in step S10611, “CALL Pcom” (subroutine call instruction starting from pointer Pcom) is included in step S10612, and instructions BA to BZ are included in steps S10613 to S10614. In step S10615, “RET” (an instruction for returning from the subroutine P) is stored.
[0021]
Finally, "LD execution condition Pcc" (reading instruction for execution condition Pcc) is included in step S10616, instructions CA to CZ are included in steps S10617 to S10619, "RET" (an instruction for returning from subroutine Pcom) is included in step S10620, In S10621, “END” (an instruction indicating the end of all programs) is stored.
[0022]
Next, the concept of the CALL instruction and the RET instruction will be described with reference to FIG. As shown in FIG. 10, the process starts when it is determined whether “LD execution condition a” is satisfied. If it is determined in step S10601 that the “LD execution condition a” is satisfied, “CALL Pa” is executed in step S10602. At this time, the step number (step S10603) of the instruction to be executed next to “CALL Pa” is stacked on the stack, and the process jumps to step S10606 as indicated by process 141.
[0023]
If it is determined in step S10606 that the “LD execution condition Paa” is satisfied, “CALL Pcom” is executed in step S10607. At this time, the step number (step S10608) of the instruction to be executed next to “CALL Pcom” is stacked on the stack, and the process jumps to step S10616 as indicated by process 142.
[0024]
If it is determined in step S10616 that the “LD execution condition Pcc” is satisfied, “command CA” is executed in step S10617, “instruction CB” is executed in step S10618, and the instructions are executed sequentially. In step S10619, “instruction CZ” is executed. Finally, in step S10621, the RET instruction is executed. At this time, the “step number of the instruction to be executed next (in this case, step S10608)” loaded on the stack is read, and the process jumps to step S10608 as indicated by processing 143.
[0025]
In step S10608, “instruction AA” is executed, and thereafter the instructions are sequentially executed. In step S10609, “instruction AZ” is executed. Finally, in step S10610, the RET instruction is executed. At this time, the “step number of the next instruction to be executed (here, step S10603)” further loaded on the stack is read, and the process jumps to step S10603 as indicated by process 144. Since the same processing is repeated for processing 145 to processing 148, the description thereof is omitted.
[0026]
[Problems to be solved by the invention]
In recent years, computer programs have become object-oriented, and there is a strong tendency to use standardized programs regardless of target fields such as OA and FA. In particular, under the influence of IEC 61131-3 which is the only international standard in the FA field, there is a movement to shift from programming by ladder and list to programming by function block (FB) or function block diagram (FBD). According to the IEC61131-3 standard, a frequently used program can be made into a component (FB), and the FB can be used in the main program. Therefore, the prospect of the whole program is improved, and development efficiency seems to have improved at first glance. Illusion.
[0027]
The FB is converted to the FB because it is a frequently used program part, and it is highly possible that the FB is used multiple times at several locations in the main program. Let's consider what happens when an abnormality occurs in the FB. For example, when a subroutine is called in the FB and an abnormality occurs in the subroutine. In this case, debugging cannot be performed unless it is known where the main program was called from and at what timing.
[0028]
However, the above-described prior art has a drawback that the order of subroutine calls cannot be traced. Further, the prior art disclosed in JP-A-7-141222, JP-A-4-336663, JP-A-2-294845, JP-A-64-48133, JP-A-59-221753, etc. traces the timing of occurrence of an abnormality. I couldn't do it, or even if I could, I had to use special means.
[0029]
The present invention has been made in view of the above, and performs trace data processing apparatus, trace data processing method and method capable of recording trace information related to a subroutine with little overhead and tracing the timing of the subroutine CALL when an abnormality occurs. The purpose is to obtain a program for.
[0030]
[Means for Solving the Problems]
  In order to achieve the above object, a trace data processing apparatus according to the present invention comprises:Loaded with this programExecution information of subroutines called hierarchically from the programToStores execution information of subroutines called hierarchically from a program in a trace data processing device to be racedIs a storage areaStack area andCallCall source subroutine call step number, callee subroutine pointer value, and callee subroutine execution resultExecution information includingPayStorage area, A data table different from the stack areaAnd the first address location called from the program or subroutineTrace points that serve as indicators for instructing storage in the data tableExistWhen you are,In the data tableExecution informationIndicates the storage location ofFirstPointerIn the position indicated byCalling step number of the calling subroutine and pointer value of the calling subroutineThe caseAnd return processing from the called subroutineWhenIn the data tableIndicates the storage location of execution information, which is different from the first pointerSecond pointerAt the position indicated byProcessing result of called subroutineThe caseIt is characterized by paying.
[0031]
  According to the present invention, execution information of subroutines called hierarchically from a program is stored.Is a storage areaStack areaWhen,Calling step number of calling subroutine, pointer value of calling subroutine, and execution result of calling subroutineIs a storage area for storing execution information includingData table different from stack areaAnd are provided. The trace data processing unit is located at the first address location called from the program or subroutine.Trace points that serve as indicators for instructing storage in the data tableExistWhen you areThe call step number of the call source subroutine and the pointer value of the call destination subroutine are stored at the position indicated by the first pointer indicating the storage position of the execution information in the data table. The execution information storage position is stored, and the processing result of the called subroutine is stored at the position indicated by the second pointer different from the first pointer.
[0032]
  A trace data processing apparatus according to a next invention is the above-described invention, wherein a first counter that holds the number of calls of the subroutine stored in the data table and a number of times of return after execution of the subroutine are stored. 2 counter, and the trace point is added to the callee subroutine.GThe trace counter is increased by increasing the value of the first counter at a certain time.TheIn the return processing from the called subroutine having, the value of the first counter is increased and the value of the second counter is decreased.
[0033]
  According to the present invention, a first counter that holds the number of subroutine calls stored in the data table, a second counter that holds the number of times the subroutine is returned after execution processing,Is providedTrace point in the called subroutineGIncrease the value of the first counter at a certain time, trace pointsTheAt the time of the return processing from the called subroutine, the value of the first counter is increased and the value of the second counter is decreased.
[0034]
In the trace data processing apparatus according to the next invention, in the above invention, when the value of the first pointer is n and the value of the second counter is m, the value p of the second pointer is set. ,
p = n − ((m−1) × 3 + 1)
It is calculated by the following formula.
[0035]
According to the present invention, when the value of the first pointer is n and the value of the second counter is m, the value p of the second pointer is
p = n − ((m−1) × 3 + 1)
It can be calculated by the following formula.
[0036]
  The trace data processing method according to the next invention is a subroutine execution information called hierarchically from a program.ToStores execution information of subroutines that are called hierarchically from a program in the trace data processing method to be raced.Is a storage areaStack area andCallCall source subroutine call step number, callee subroutine pointer value, and callee subroutine execution resultExecution information includingPayStorage area, A data table different from the stack areaAnd the first address location called from the program or subroutineTrace points that serve as indicators for instructing storage in the data tableExistWhether it exists, and the trace pointExistWhen present in the data tableExecution informationIndicates the storage location ofFirstPointerIn the position indicated byCalling step number of the calling subroutine and pointer value of the calling subroutineThe caseAnd return processing from the called subroutineWhenIn the data tableIndicates the storage location of execution information, which is different from the first pointerSecond pointerAt the position indicated byProcessing result of called subroutineThe caseIt is characterized by paying.
[0037]
  According to the present invention, execution information of subroutines called hierarchically from a program is stored.Is a storage areaStack area andCallCall source subroutine call step number, callee subroutine pointer value, and callee subroutine execution resultExecution information includingPayStorage area, Data table different from stack areaAnd are provided. At the first address location called from a program or subroutine,Trace points that serve as indicators for instructing storage in the data tableExistWhether it exists or not,thisTrace pointExistIn the data tableExecution informationIndicates the storage location ofFirstPointerIn the position indicated byThe calling step number of the calling subroutine and the pointer value of the called subroutine areCaseReturn processing from the called subroutineWhenIn the data tableIndicates the storage location of execution information, different from the first pointerSecond pointerIn the position indicated byStores the processing result of the called subroutine.
[0038]
  In the trace data processing method according to the next invention, in the above invention, a first counter that holds the number of calls of the subroutine stored in the data table and a number of times of return after execution of the subroutine are stored. 2 counter, and the trace point is added to the callee subroutine.GOne time, the value of the first counter stored in the data table is increased, and the trace point is increased.TheIn the return processing from the called subroutine having, the value of the first counter is increased and the value of the second counter is decreased.
[0039]
  According to the present invention, the trace point is set in the called subroutine.GAt some point, the value of the first counter holding the number of subroutine calls stored in the data table is increased, and the trace point is increased.TheAt the time of return processing from the called subroutine, the value of the first counter is increased, and the value of the second counter that holds the number of times of return after execution processing of the subroutine is decreased.
[0040]
In the trace data processing method according to the next invention, in the above invention, when the value of the first pointer is n and the value of the second counter is m, the value p of the second pointer is ,
p = n − ((m−1) × 3 + 1)
It is calculated by the following formula.
[0041]
According to the present invention, when the value of the first pointer is n and the value of the second counter is m, the value p of the second pointer is
p = n − ((m−1) × 3 + 1)
It can be calculated by the following formula.
[0042]
A program according to the next invention is a program for causing a computer to execute the method described in any one of the above inventions, and the program can be read by a computer, whereby the operation according to any one of the above inventions is performed. Can be executed by a computer.
[0043]
DETAILED DESCRIPTION OF THE INVENTION
Exemplary embodiments of a trace data processing device, a trace data processing method, and a program for executing the method will be described below in detail with reference to the accompanying drawings.
[0044]
FIG. 1 is a diagram showing an example of the operation of the control program of the controller according to the present invention. Steps S101 to S105 are descriptions of the main program. First, the execution condition a is read in step S101. When the execution condition is satisfied, a subroutine starting from the pointer Pa is called in step S102. The execution condition b is read in step S103. When the execution condition is satisfied, the pointer Pb is read in step S104. Call a subroutine starting with. Step S105 represents an instruction (FEND instruction) indicating the end of the main program.
[0045]
Next, Pa is a pointer indicating the head of the subroutine called in step S102. The execution condition Paa is read in step S106. When the execution condition is satisfied, a subroutine starting from the pointer Pcom is called in step S107. After the actual processing of this subroutine is completed, the instructions in steps S108 to S109 are executed, and the instruction for returning from the subroutine (RET instruction) is executed in step S110. Similarly, Pb is a pointer indicating the head of the subroutine called in step S104. The execution condition Pbb is read in step S111. When the execution condition is satisfied, the subroutine starting from the pointer Pcom is called in step S112. After the actual processing of this subroutine is completed, the instructions in steps S113 to S114 are executed, and the instruction for returning from the subroutine (RET instruction) is executed in step S115.
[0046]
By the way, Pcom is a pointer indicating the head of the subroutine called in step S107 or S112, but this Pcom is characterized by being modified by “tp (trace point)”, and is different from the prior art. is there. This tp will be described in detail later.
[0047]
In the subsequent processing, the execution condition Pcc is read in step S116, and when the execution condition is satisfied, the actual processing of the subroutine is started in step S117 and the instructions in steps S118 to S119 are executed in the same manner as described in the prior art. In step S120, an instruction for returning from the subroutine (RET instruction) is executed. Step S121 is an instruction (END instruction) that means the end of all programs.
[0048]
FIG. 2 is an explanatory diagram showing the concept of implementation of the hierarchical structure program according to the present invention. In the figure, 21 is a CALL counter, 22 is a RET counter, 23 is a data table, 24 is a CALL pointer, and 25 is a RET pointer.
[0049]
The CALL pointer 24 and the RET pointer 25 are a data table in which three pieces of information: (1) the calling step number of the calling subroutine, (2) the pointer number of the calling subroutine, and (3) the execution result of the calling subroutine are stored as one block. 23 is a pointer to be stored in 23. The CALL counter 21 and the RET counter 22 are work areas for storing the number of CALL processing and RET processing used for calculating the CALL pointer 24 and the RET pointer 25.
[0050]
FIG. 3 is a diagram showing an example of operations of the CALL instruction and the RET instruction according to the present invention. This figure is a diagram specifically showing how the program of FIG. 1 is stored in the user program 96 shown in FIG. Compared with the prior art shown in FIG. 14, “tp” in step S322 is stored between “RET” in step S315 and “LD execution condition Pcc” in step S316. In addition, the position where the instruction is stored and the call operation are the same as those described in the related art, and thus the description thereof is omitted.
[0051]
FIG. 4 is a flowchart showing a processing procedure of CALL processing according to the present invention. A normal CALL process and a CALL process in the case of calling a pointer with tp will be described with reference to FIG.
[0052]
First, the stack pointer is read in step S401, the step number to be executed is stored in the position next to the position pointed to by the stack pointer in step S402, the stack pointer is updated in step S403, and the subroutine pointer number of the call destination is determined in step S404. read out. Up to this point, the process is not different from the normal CALL process.
[0053]
Next, it is determined whether or not the pointer to be CALLed in step S405 is a pointer with tp. If the pointer to be CALLed in step S405 is a pointer with tp, the process proceeds to step S407, where the CALL pointer 24 in the data table 23 shown in FIG. 2 is read, and in step S408, the caller step number is displayed at the position indicated by the CALL pointer 24. In step S409, the CALL pointer 24 is updated. In step S410, the pointer number of the call destination subroutine is read. In step S411, the pointer number of the call destination subroutine is stored at the position indicated by the CALL pointer 24. In step S412. The CALL pointer 24 is updated. In step S413, the CALL counter 21 shown in FIG. 2 is updated. In step S414, the CALL pointer 24 is copied to the RET pointer 25 shown in FIG. In step S415, a pointer call flag with tp is set in the work RAM 92 shown in FIG. 9, and the process of the step number indicated by the pointer number called in step S416 is executed. In addition, the flow which transfers to the process of step S416 from the process of said step S401-S404 is a flow of a normal process.
[0054]
On the other hand, if the CALL pointer is not a pointer with tp in the process of step S405, it is further determined whether or not the pointer call flag with tp stored in the work RAM 92 is set in step S406. If the pointer call flag with tp is set, the process from step S407 is executed. If the pointer call flag with tp is not set, the process of step S416 is executed.
[0055]
FIG. 5 is a flowchart showing the processing procedure of the RET process corresponding to the CALL process of FIG. The flow of RET processing will be described with reference to FIG.
[0056]
First, in step S502, it is determined whether or not the CALL counter 21 shown in FIG. 2 is “0”. When the CALL counter 21 is “0”, since the subroutine CALL processing with tp has not been performed, the routine proceeds to step S510 to perform normal RET processing, and the stack pointer is read out at step S510. In step S511, the step number to be executed next is read from the stack, and the instruction of the step number read in step S512 is executed.
[0057]
On the other hand, if the CALL counter 21 is not “0” in step S502, it means that the subroutine CALL processing with tp has been performed. In step S503, the RET counter 22 shown in FIG. 2 is read, and in step S504 the RET counter is read. 22 is updated, and the RET pointer 25 is calculated using the value (m) of the RET counter 22 in step S505. The calculation contents of the RET pointer 25 are calculated by the following formula: RET pointer 25 = CALL pointer 24-{(m−1) × 3 + 1}. Further, in step S506, the RET processing result is stored at the position indicated by the calculation result of the RET pointer 25. In step S507, the CALL counter 21 is updated to indicate the end of the RET processing.
[0058]
Next, in step S508, the value of the CALL counter 21 is checked again. If this value is 0, all the pointer call processing with tp has been completed, the pointer call flag with tp is cleared in step S509, and step S510. The normal RET process is performed. If the value of the CALL counter 21 is not 0 in step S508, the pointer call process with tp has not been completed. Therefore, the pointer call flag with tp is not cleared, and the routine proceeds to step S510 to perform normal RET processing. .
[0059]
FIG. 6 is an explanatory diagram showing the movement of the data table and the like when the CALL process for the call with tp is performed. This figure shows how the data table 23, CALL pointer (CP) 24, RET pointer (RP) 25, CALL counter 21, and RET counter 22 shown in FIG. 2 change from the initial state with the execution of the CALL instruction. . Note that the CALL nest (depth) is “5”, and it is assumed that the CALL processing for all calls with tp has been executed.
[0060]
In FIG. 6, in the initial state, the CALL counter and the RET counter are both “0”, and CP and RP are set at predetermined positions (not shown). When the first CALL instruction is executed, the CALL counter is incremented (+1), that is, set to “1” (corresponding to the process of step S413 in FIG. 4), and CP is incremented (+3) (in FIG. 4). The RP is also set to the same pointer value as the CP (corresponding to the processing in step S414 in FIG. 4). Therefore, the pointer at position 61 in FIG. 6 is set for CP and RP.
[0061]
Similarly, when the second CALL instruction is executed, the CALL counter is incremented (+1), that is, set to “2”, CP is incremented (+3), and RP is also set to the same pointer value as CP. . Therefore, the pointer at position 62 is set in CP and RP. Thereafter, when the fifth CALL instruction is executed, the CALL counter is finally set to “5”, and pointers at position 65 are set in CP and RP.
[0062]
FIG. 7 is an explanatory diagram showing the movement of the data table and the like when the RET instruction is executed after the CALL process of FIG. 6 is performed. This figure shows how the data table 23, CALL pointer (CP) 24, RET pointer (RP) 25, CALL counter 21, and RET counter 22 shown in FIG. 2 change from the state of FIG. 6 with the execution of the RET instruction. ing.
[0063]
In FIG. 7, the state where the RET instruction is not executed is the same as the state where the fifth CALL instruction is executed in FIG. That is, the CALL counter 25 is set to “5”, the RET counter is set to “0”, and pointers at position 65 are set in CP and RP. When the first RET instruction is executed, the RET counter is incremented (+1), that is, set to “1” (corresponding to the process of step S504 in FIG. 5), the CALL counter is decremented (−1), That is, it is set to “4” (corresponding to the process of step S507 in FIG. 5), the value of CP remains unchanged, RP is decremented (−1), and the pointer at position 66 is set (step in FIG. 5). Corresponding to the arithmetic processing in S505).
[0064]
Similarly, when the second RET instruction is executed, the RET counter is incremented (+1), that is, set to “2”, and the CALL counter is decremented (−1), that is, set to “3”. The value of CP remains unchanged, RP is decremented (-3), and the pointer at position 67 is set. Thereafter, when the fifth RET instruction is executed, the CALL counter is finally set to “0”, the RET counter is set to “5”, and the CP remains as a pointer at the position 65. The pointer at position 70 is set.
[0065]
For example, in FIG. 7, assuming that an error has occurred before the third RET instruction is executed and the fourth RET instruction is executed, RP is not updated to the pointer at position 69, but the pointer at position 68. Remains. At this time, it is possible to determine in which calling process an error has occurred from information on the CALL counter value, the RET counter value, and the RP value. If the pointer at the position where the error occurred (position 68 in this example) is X, the pointer number of the callee is set in X-1, and the step number of the caller is set in X-2. Therefore, it is possible to obtain program execution information for searching for the cause of the error occurrence from these pieces of information.
[0066]
This trace processing is composed of only three pieces of information: (1) the calling step number of the calling subroutine, (2) the pointer number of the calling subroutine, and (3) the execution result of the calling subroutine. Execution information related to the structure program can be obtained. Further, since not only the trace information but also the information on the execution result of the subroutine is included, the validity of the processing result itself can be evaluated even in a normally completed process, so that efficient debugging can be performed.
[0067]
As described above in detail, according to the trace data processing device, the trace data processing method, and the program for executing the method according to the present invention, the hierarchical structure relates to the program execution of the information processing device for processing the structured program. The execution timing of a hierarchical program can be traced in the execution of a structured program with, and if an error occurs during execution, the cause of the error and the execution timing of the program can be grasped, and the overhead is low The execution information related to the hierarchical structure program can be obtained.
[0068]
【The invention's effect】
  As described above, according to the present invention, execution information of subroutines called hierarchically from a program is stored.A stack area that is a storage area; andCalling step number of calling subroutine, pointer value of calling subroutine, and execution result of calling subroutineIs a storage area for storing execution information includingData table different from stack areaWhen a trace point that functions as an index for instructing storage in the data table exists at the first address position called from the program or subroutine, the storage position of execution information in the data table is indicated. The calling step number of the caller subroutine and the pointer value of the callee subroutine are stored at the position indicated by the first pointer. The return position from the callee subroutine indicates the storage position of the execution information in the data table. Since the processing result of the called subroutine is stored at the position indicated by the second pointer different from the pointer ofEven if an error occurs in a deep subroutine nesting stage, the movement of the CALL instruction can be traced in order, and the CALL processing stage in which the error has occurred can be traced. There is an effect that improvement in debugging efficiency can be expected. The information required for one CALL process is only (1) the calling step number of the calling subroutine, (2) the pointer number of the calling subroutine, and (3) the execution result of the calling subroutine. There is a further effect that the above effect can be obtained. Further, since the normal CALL process and the present CALL process can be used properly, if necessary, a pointer with tp is used where FB or FBD is used, thereby improving debugging efficiency, improving processing efficiency, and memory resources. For example, it is possible to provide an optimal debugging means for the user, such as enabling efficient use of the device.
[0069]
  According to the next invention, a first counter that holds the number of subroutine calls stored in the data table, a second counter that holds the number of times the subroutine has been returned, andIs providedTrace point in the called subroutineGIncrease the value of the first counter at a certain time, trace pointsTheSince the value of the first counter is increased and the value of the second counter is decreased at the time of return processing from the called subroutine that has an error, even if an error occurs in a deeply nested subroutine The movement of the CALL instruction can be traced in order, and it can be traced at which CALL processing stage an error has occurred, so that it is possible to expect an improvement in debugging efficiency of a standardized program using many subroutines. In addition, since the normal CALL process and the present CALL process can be used properly, if necessary, a pointer with tp is used where FB or FBD is used, thereby improving debugging efficiency, improving processing efficiency, and memory resources. For example, it is possible to provide an optimal debugging means for the user, such as enabling efficient use of the device.
[0070]
According to the next invention, when the value of the first pointer is n and the value of the second counter is m, the value p of the second pointer is
p = n − ((m−1) × 3 + 1)
Therefore, even if an error occurs when the subroutine is deeply nested, the movement of the CALL instruction can be traced in order, and the error occurs at any CALL processing stage. Therefore, the debugging efficiency of a standardized program using many subroutines can be expected to be improved.
[0071]
  According to the next invention, execution information of subroutines called hierarchically from a program is stored.Is a storage areaStack area andCallCall source subroutine call step number, callee subroutine pointer value, and callee subroutine execution resultExecution information includingPayStorage area, Data table different from stack areaAnd provided,Trace points that serve as indicators for instructing storage in the data tableGIt is determined whether it exists on the called subroutine, and the trace pointGIn the data table when it exists on the called subroutineExecution informationIndicates the storage location ofFirstPointerIn the position indicated byThe calling step number of the calling subroutine and the pointer value of the called subroutine areCaseReturn processing from the called subroutineWhenIn the data tableIndicates the storage location of execution information, different from the first pointerSecond pointerIn the position indicated bySince the processing result of the called subroutine is stored, even if an error occurs when the subroutine is deeply nested, the movement of the CALL instruction can be traced in order, and the error occurs at any CALL processing stage. Therefore, the debugging efficiency of a standardized program using many subroutines can be expected to be improved. The information required for one CALL process is only (1) the calling step number of the calling subroutine, (2) the pointer number of the calling subroutine, and (3) the execution result of the calling subroutine. There is a further effect that the above effect can be obtained. Further, since the normal CALL process and the present CALL process can be used properly, if necessary, a pointer with tp is used where FB or FBD is used, thereby improving debugging efficiency, improving processing efficiency, and memory resources. For example, it is possible to provide an optimal debugging method for the user, such as enabling efficient use.
[0072]
  According to the following invention,When there is a tracepoint at the first address called from a program or subroutine that serves as an indicator for directing storage to the data table,Increase the value of the first counter that holds the number of subroutine calls stored in the data table,TheSince the value of the first counter is increased and the value of the second counter that holds the number of times of return after execution of the subroutine is decreased during the return processing from the called subroutine that has the subroutine, Even if an error occurs at a deep nesting stage, the movement of the CALL instruction can be traced in order, and the CALL processing stage at which the error has occurred can be traced, so debugging of a standardized program using many subroutines There is an effect that an improvement in efficiency can be expected. In addition, since the normal CALL process and the present CALL process can be used properly, if necessary, the pointer with tp is used where FB or FBD is used, thereby improving debugging efficiency, improving processing efficiency, and memory resources. For example, it is possible to provide an optimal debugging method for the user, such as enabling efficient use.
[0073]
According to the next invention, when the value of the first pointer is n and the value of the second counter is m, the value p of the second pointer is
p = n − ((m−1) × 3 + 1)
Therefore, even if an error occurs when the subroutine is deeply nested, the movement of the CALL instruction can be traced in order, and the error occurs at any CALL processing stage. Therefore, the debugging efficiency of a standardized program using many subroutines can be expected to be improved.
[0074]
According to the program of the next invention, since the method described in any one of the above inventions is caused to be executed by a computer, the program can be read by a computer. There is an effect that one operation can be executed by a computer.
[Brief description of the drawings]
FIG. 1 is a diagram showing an example of the operation of a control program of a controller according to the present invention.
FIG. 2 is an explanatory diagram showing a concept of implementing a hierarchical structure program according to the present invention.
FIG. 3 is a diagram showing an example of operations of a CALL instruction and a RET instruction according to the present invention.
FIG. 4 is a flowchart showing a processing procedure of CALL processing according to the present invention.
5 is a flowchart showing a processing procedure of RET processing corresponding to the CALL processing of FIG. 4;
FIG. 6 is an explanatory diagram showing movement of a data table or the like when CALL processing for a call with tp is performed.
7 is an explanatory diagram showing movement of a data table or the like when a RET instruction is executed after the CALL process of FIG. 6 is performed.
FIG. 8 is a diagram illustrating an example of a system configuration in an FA system.
FIG. 9 is a block diagram showing an internal configuration of a conventional controller.
FIG. 10 is a diagram illustrating an example of an operation of a control program of a controller of a conventional technique.
FIG. 11 is a diagram showing processing of a subroutine program of a controller in the prior art.
FIG. 12 is an explanatory diagram showing a processing concept of a subroutine.
FIG. 13 is an explanatory diagram showing a concept of a CALL instruction, a RET instruction, and a stack.
FIG. 14 is a diagram illustrating an example of operations of a CALL instruction and a RET instruction in the prior art.
[Explanation of symbols]
21 CALL counter, 22 RET counter, 23 data table, 24 CALL pointer, 25 RET pointer, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70 position, 81 controller, 82 intelligent unit, 83 non Intelligent unit, 84 I / O device, 85 servo motor, 86 sensor, 87 actuator, 88 switch, output device, lightning tube, etc. 91 MPU, 92 work RAM, 93 system ROM, 94 user RAM, 95 parameters, 96 user program 97 device memory, 98 address bus, 99 data bus, 121, 122, 123, 124, 125, 126, 127, 128 timing, 141, 142, 143, 144, 145, 146, 14 , 148 processing.

Claims (7)

Equipped with a program, the trace data processing apparatus for trace execution information of subroutine hierarchically called from the program,
A stack area that is a storage area for storing execution information of subroutines called hierarchically from a program ;
Call out the original subroutine call step numbers, and the pointer value and executing information including an execution result of the called subroutine call destination subroutine storage area you store a different data tables and the stack area,
Is provided,
When the first address location to be called from a program or subroutine, before Symbol trace point that acts as an indicator for indicating the storage in the data table exists,
The position indicated by the first pointer indicating the storage location of the execution information in the data table, the pointer value of the call step number and the call destination subroutine of the calling subroutine to store,
During the process of returning from the call destination subroutine said indicate the storage location of the execution information in the data table, the position indicated by the different second pointer from the first pointer, store the processing result of the call destination subroutine A trace data processing apparatus characterized by: A first counter that holds the number of calls of the subroutine stored in the data table;
A second counter for holding the number of return times after execution of the subroutine;
Is provided,
Increasing the value of the first counter when there is the trace points in the call destination subroutine,
When returning process from the callee subroutine with said trace points, the increase the value of the first counter, and, according to claim 1, characterized in that reducing the value of the second counter Trace data processing device. When the value of the first pointer is n and the value of the second counter is m, the value p of the second pointer is
p = n − ((m−1) × 3 + 1)
The trace data processing device according to claim 2, wherein the trace data processing device is calculated by the following formula. In the trace data processing method for trace execution information of subroutine hierarchically called from a program,
A stack area that is a storage area for storing execution information of subroutines called hierarchically from a program ;
Call out the original subroutine call step numbers, and the pointer value and executing information including an execution result of the called subroutine call destination subroutine storage area you store a different data tables and the stack area,
Is provided,
The first address location to be called from a program or subroutine, it is determined whether the trace points Togason standing functioning as an indicator for indicating the storage of previous SL data table,
When the trace point exists at a position indicated by the first pointer indicating the storage location of the execution information in the data table, the pointer value of the call step number and the call destination subroutine of the calling subroutine to store ,
During the process of returning from the call destination subroutine said indicate the storage location of the execution information in the data table, the position indicated by the different second pointer from the first pointer, store the processing result of the call destination subroutine A trace data processing method characterized by: A first counter for holding the number of calls of the subroutine stored in the data table, and a second counter for holding the number of return after execution of the subroutine are provided,
Wherein when there is a trace point to the called subroutine, increasing the value of the said first counter stored in the data table,
When returning process from the callee subroutine with said trace points, the increase the value of the first counter, and, according to claim 4, characterized in that to reduce the value of the second counter Trace data processing method. When the value of the first pointer is n and the value of the second counter is m, the value p of the second pointer is
p = n − ((m−1) × 3 + 1)
The trace data processing method according to claim 5, wherein the trace data processing method is calculated by the following formula.   The program which makes a computer perform the method as described in any one of Claims 4-6.

Images