JP2022083141A - Control device and processing method - Google Patents

Abstract

To provide a control device which can normally restart interrupted processing, when executing a coroutine function.SOLUTION: In a control device 100, a program 4 includes steps of: securing a retraction area 3e for retracting information on a coroutine function to a global area 3b of a memory 3, after the coroutine function is called; retracting an automatic variable included in the information on the coroutine function which is saved in a stack area 3d of the memory 3, to the retraction area 3e, before processing of the coroutine function is interrupted, after the coroutine function is called; and restoring the automatic variable retracted to the retraction area 3e, in the stack area 3d of the memory 3, before restarting the interrupted processing.SELECTED DRAWING: Figure 9

Description

The present invention relates to a control device and a processing method, and more particularly to a control device and a processing method for executing a coroutine function.

Conventionally, a processing method for executing a coroutine function is known (see, for example, Patent Document 1).

The above-mentioned Patent Document 1 discloses a process of a coroutine function. In a normal function (referred to as function B such as a subroutine function), when function B is called from the calling function (referred to as function A), the processing is performed after the processing of the called function B is completed. Return to the function A of. On the other hand, in the coroutine function, when the coroutine function (referred to as coroutine function C) is called from the calling function A, the coroutine function C interrupts the processing after executing the processing. As a result, the process returns to the calling function A. Then, when the calling function A calls the coroutine function C again, the called coroutine function C resumes the processing from the time when the processing is interrupted.

Here, conventionally, there is a language such as C language in which a coroutine function is not provided as a standard library. In this case, for example, in C language, a method of implementing a coroutine function in a pseudo manner using a switch-case statement is known. In this method, a plurality of processes in a coroutine function are divided into units of case clauses. Then, the processing in one case clause is executed, the label of the case clause to be processed next time is saved in the memory, and then the coroutine function is terminated. As a result, the processing of the coroutine function is interrupted in a pseudo manner. The automatic variables of the coroutine function are stored in the stack area of the memory. Then, when the process is restarted, the process is executed from the beginning of the coroutine function. Then, the process of the case clause of the label saved before the interruption of the process is executed by the conditional determination of the switch-case statement.

Japanese Patent No. 5421914

However, when a pseudo coroutine function is implemented using the C language switch-case statement, the memory in which the automatic variables of the coroutine function are stored when the coroutine function is called to resume the interrupted processing. The stack area of is initialized, or an indefinite value is saved in the stack area. Therefore, when the interrupted processing is restarted, the value of the automatic variable of the coroutine function is different from the value before the processing is interrupted, and there is a problem that the interrupted processing may not be restarted normally.

The present invention has been made to solve the above-mentioned problems, and one object of the present invention is a control device capable of normally resuming interrupted processing when executing a coroutine function. And to provide a processing method.

In order to achieve the above object, the control device according to the first aspect of the present invention is a control device that executes a coroutine function that suspends processing and then resumes processing from the continuation of the interrupted processing, and is a coroutine. A memory containing a program containing a function and a control unit for executing the program are provided, and the program secures a save area for saving the information of the coroutine function in the global area of the memory after the coroutine function is called. A step and a step to save the automatic variables contained in the information of the coroutine function stored in the stack area of the memory to the save area after the coroutine function is called and before the processing of the coroutine function is interrupted. Includes a step of restoring the coroutines saved in the save area to the memory stack area before resuming the interrupted processing. The "coroutine function" is a concept including a pseudo coroutine function implemented by using a switch-case statement in C language in addition to the coroutine function provided as a standard library.

In the control device according to the first aspect of the present invention, as described above, the program is a coroutine function stored in a stack area of memory after the coroutine function is called and before the processing of the coroutine function is interrupted. It includes a step of saving the automatic variables included in the information of the above to the save area and a step of restoring the automatic variables saved in the save area to the stack area of the memory before restarting the interrupted processing. As a result, the automatic variables saved in the stack area of the memory are saved in the save area of the global area of the memory. Therefore, when the collout function is called to restart the interrupted processing, the stack area of the memory is initially set. Even if the variable value is changed or an indefinite value is stored in the stack area, the automatic variable saved in the save area of the global area of the memory is restored to the stack area of the memory. As a result, when the interrupted processing of the coroutine function is resumed, the processing can be resumed based on the exact automatic variable. As a result, when the coroutine function is executed, the interrupted processing can be resumed normally.

In the control device according to the first aspect, preferably, the information of the coroutine function further includes the pointer information of the coroutine function, the interruption position of the coroutine function, the argument, and the return value. With this configuration, the pointer information of the coroutine function required to restart the interrupted processing, the interruption position of the coroutine function, the automatic variable, the argument, and the return value are saved in the save area of the global area of the memory. , The interrupted processing can be resumed normally and surely.

In this case, preferably, the information of each of the automatic variable, the argument, and the return value is the area information or the pointer information in the memory. Here, since the global area of the memory can be freely written unlike the stack area of the memory, each information of the automatic variable, the argument, and the return value can be either the area information or the pointer information on the memory. Can be written.

In the control device according to the first aspect, preferably, the step of securing the save area includes a step of securing the save area according to the size of the information of the coroutine function. Here, when the information of the coroutine function is stored in the stack area of the calling function that calls the coroutine function, the area for the information of the coroutine function may be secured in a fixed size. In this case, depending on the configuration of the coroutine function (the number of each of the arguments, automatic variables, and return values), it may not be possible to properly secure an area (excess or deficiency) for the information of the coroutine function. Therefore, by configuring as described above, the save area can be secured by the variable length in the global area of the memory (the size of the area can be easily specified in the global area as compared with the stack area). The evacuation area can be secured appropriately.

In the control device according to the first aspect, preferably, the program further includes a step of restoring the automatic variable to the stack area of the memory and then releasing the area where the automatic variable is stored. With this configuration, the area where the automatic variables in the memory are stored is released after the automatic variables are restored to the stack area of the memory. Therefore, when multiple coroutine functions are provided, the global area of the memory after release is released. Can be used as an area for storing automatic variables of other coroutine functions. That is, even if the number of coroutine functions is relatively large, the coroutine functions can be executed appropriately.

In the control device according to the first aspect, preferably, the program further includes a step of creating an address list of automatic variables in the stack area of memory in the global area of memory after calling the coroutary function, and saves the automatic variables. The step to save to the area includes the step to save the automatic variable to the save area based on the created address list, and the step to restore the automatic variable to the stack area is based on the created address list. Includes a step to restore to the stack area of memory. With this configuration, the automatic variables are saved and restored based on the address list, so that the automatic variables can be saved in the save area and restored in the stack area without making a mistake.

In this case, preferably, the program further includes a step of saving the automatic variable in the save area and then releasing the area in which the address list of the automatic variable is stored. With this configuration, after the automatic variables are saved in the save area, the area where the address list of the automatic variables is saved is released. Therefore, when multiple coroutine functions are provided, the global memory after release is released. The area can be used as an area for storing the address list of other coroutine functions. That is, even if the number of coroutine functions is relatively large, the coroutine functions can be executed appropriately.

The processing method according to the second aspect of the present invention is a processing method for executing a coroutine function that suspends the processing and then resumes the processing from the continuation of the interrupted processing, the step of calling the coroutine function and the coroutine function. After the coroutine function is called, the step to secure a save area to save the information of the coroutine function in the global area of the memory, and after the coroutine function is called, before the processing of the coroutine function is interrupted, the stack area of the memory A step to save the automatic variables included in the saved coroutine function information to the save area, and restore the automatic variables saved in the save area to the stack area of the memory before restarting the interrupted processing. Including steps.

In the processing method according to the second aspect of the present invention, as described above, after the coroutine function is called and before the processing of the coroutine function is interrupted, the information of the coroutine function stored in the stack area of the memory is used. It includes a step of saving the included automatic variables in the save area and a step of restoring the saved automatic variables in the save area to the stack area of the memory before restarting the interrupted processing. As a result, the automatic variables saved in the stack area of the memory are saved in the save area of the global area of the memory. Therefore, when the collout function is called to restart the interrupted processing, the stack area of the memory is initially set. Even if the variable value is changed or an indefinite value is stored in the stack area, the automatic variable saved in the save area of the global area of the memory is restored to the stack area of the memory. As a result, when the interrupted processing of the coroutine function is resumed, the processing can be resumed based on the exact automatic variable. This makes it possible to provide a processing method capable of normally resuming the interrupted processing when the coroutine function is executed.

According to the present invention, as described above, when the coroutine function is executed, the interrupted processing can be resumed normally.

It is a block diagram of the control device by this embodiment. It is a figure which shows the structure of the memory of the control device by this embodiment. It is a sequence diagram for demonstrating the processing of a general subroutine function. It is a sequence diagram for demonstrating the processing of a general coroutine function. It is a figure for demonstrating the relationship between the processing of a coroutine function and a memory by this embodiment. It is a figure for demonstrating the block of the memory of the control device by this embodiment. It is a figure which illustrated the processing of the coroutine function by this embodiment. It is a figure for demonstrating the address list (stack frame definition) of an automatic variable by this embodiment. It is a flow diagram for demonstrating the processing of the coroutine function by this embodiment. It is a figure for demonstrating the description example of the coroutine function and the actual code example by this Embodiment. It is a sequence diagram for demonstrating the processing of a coroutine function by this embodiment. It is a memory transition diagram for demonstrating the processing of a coroutine function by this embodiment. It is a sequence diagram for demonstrating the processing of two coroutine functions by this embodiment. It is a memory transition diagram for demonstrating the processing of two coroutine functions by this embodiment. It is a sequence diagram for demonstrating the processing of the coroutine function and the sub-coroutine function by this embodiment. It is a memory transition diagram for demonstrating the processing of a coroutine function and a sub-coroutine function by this embodiment.

Hereinafter, embodiments embodying the present invention will be described with reference to the drawings.

The configuration of the control device 100 according to the present embodiment will be described with reference to FIGS. 1 to 16. The control device 100 is, for example, a control device 100 used for an embedded device.

As shown in FIG. 1, the control device 100 includes a microcomputer 2 provided on the printed circuit board 1 and a memory 3. The memory 3 is composed of a ROM (Read Only Memory), a RAM (Random Access Memory), and the like. Further, the program 4 including the coroutine function is stored in the memory 3. The microcomputer 2 executes the program 4 stored in the memory 3. Program 4 is written in C language. The microcomputer 2 is an example of a "control unit" within the scope of claims.

As shown in FIG. 2, the memory 3 handled by the C language includes a text area 3a, a global area 3b (static area), a heap area 3c, and a stack area 3d. Then, the program 4 translated into the machine language is stored in the text area 3a. Static variables such as global variables are stored in the global area 3b. The heap area 3c is used for managing the memory 3. C language automatic variables (local variables, etc.) are stored in the stack area 3d. Further, the sizes of the heap area 3c and the stack area 3d change during the program 4.

In the present embodiment, the control device 100 is configured to execute a pseudo coroutine function implemented in C language, which suspends the processing and then resumes the processing from the continuation of the interrupted processing.

The difference between the subroutine function and the coroutine function will be described with reference to FIGS. 3 and 4.

As shown in FIG. 3, when the subroutine function calls the func2 function which is a subroutine function from the func1 function (call), the func2 function executes the processing up to the return statement included in the func2 function. On the other hand, as shown in FIG. 4, in the coroutine function, when the coroutine function func2 function is called from the func1 function (resume), the process is executed halfway through the func2 function and is interrupted (yeld). Then, when the func2 function is called again from the func1 function (resume), the processing is restarted from the continuation of the portion interrupted in the previous processing.

In C language, coroutine functions are not provided as a standard library. Therefore, in this embodiment, a pseudo coroutine function is implemented by using a C language Switch-case statement (see FIG. 10). Specifically, in the pseudo coroutine function implemented by the Switch-case statement, the processing of the coroutine function is divided into case clause units. Then, after the processing of one case clause is executed and the label (interruption position) of the case clause to be processed next time is saved in the memory 3, the processing returns (leaves) from the coroutine function. As a result, a pseudo coroutine function is implemented using a C language Switch-case statement. When the processing of the coroutine function is restarted, the coroutine function is called and the processing is started from the beginning of the coroutine function. Then, based on the condition determination of the Switch statement, the process is executed from the case clause corresponding to the label (interruption position) of the case clause saved at the time of the interruption of the previous process.

(Program structure)
Next, the configuration (configuration of the program 4) of the coroutine function pseudo-implemented in the C language according to the present embodiment will be described.

In the present embodiment, as shown in FIG. 5, in the processing of the coroutine function (program 4) pseudo-implemented in C language, the information of the coroutine function is stored in the global area 3b of the memory 3 after the coroutine function is called. Includes a step of securing a save area 3e to save. The save area 3e is managed in units of variable length blocks. Further, as shown in FIG. 6, block information including a usage information flag and a block size is stored at the head of the block. The usage information flag indicates unused or in use. The block size includes block information and information on the size of the allocated memory area.

In the process of securing the save area 3e, the block information is referred from the beginning of the save area 3e, and the block in which the usage status flag is not used is searched. Then, when a block whose usage status flag is unused is found, the usage status flag of this block is set to be in use, and the start address of the allocated memory 3 area (block) is returned. If a block whose usage status flag is unused is not found, the block whose usage status flag is not used is searched again (sequential search) in the block information.

Further, in the present embodiment, the information of the coroutine function further includes the pointer information of the coroutine function, the interruption position of the coroutine function, the argument, and the return value in addition to the automatic variable. Further, each information of the automatic variable, the argument, and the return value is the area information or the pointer information on the memory 3. The size of the area information of the automatic variable, the area information of the argument, and the area information of the return value can be changed within the range of the save area 3e. Further, the reference destination of the pointer information of the automatic variable, the pointer information of the argument, and the pointer information of the return value is an area secured in the save area 3e and having a size required for each.

Further, in the present embodiment, as shown in FIG. 5, the step of securing the save area 3e includes a step of securing the save area 3e in the global area 3b of the memory 3 according to the size of the information of the coroutine function. .. Here, when the information of the coroutine function is secured in the stack area 3d of the calling function that calls the coroutine function, the size (maximum value) of the stack area 3d is determined at the time of compiling the program 4. Therefore, the size of the stack area 3d for storing the information of the coroutine function is smaller than the maximum value of the stack area 3d determined at compile time, so that the number of coroutine functions that can be executed at the same time is limited. On the other hand, in the present embodiment, the information of the coroutine function is stored in the save area 3e of the global area 3b. Since it is easier to specify the size of the global area 3b as compared with the stack area 3d, in the present embodiment, it is possible to suppress the limitation on the number of coroutine functions that can be executed at the same time.

Further, in the present embodiment, the program 4 is an automatic variable included in the information of the coroutine function stored in the stack area 3d of the memory 3 after the coroutine function is called and before the processing of the coroutine function is interrupted. Is included in the evacuation area 3e. The automatic variable may be saved in the automatic variable area inside the coroutine function information (hereinafter, may be referred to as Co information), or may be saved in the area reserved separately from the Co information. good.

Further, in the present embodiment, the program 4 includes a step of restoring the automatic variables saved in the save area 3e to the stack area 3d of the memory 3 before restarting the interrupted process.

In the example shown in FIG. 7, the coroutine function 1 and the coroutine function 2 are executed. When the coroutine function 1 is executed, the automatic variables 1-1 and 1-2 of the coroutine function 1 are stored in the stack area 3d of the memory 3. Before the processing of the coroutine function 1 is interrupted, the automatic variables 1-1 and the automatic variables 1-2 stored in the stack area 3d are saved in the save area 3e. In the example of FIG. 7, the automatic variable 1-1 and the automatic variable 1-2 have Co information 1 (pointer information, interruption position of the coroutine function, argument, return value, etc.) which is information of the coroutine function 1. It is saved in an area different from the saved area.

Next, when the coroutine function 2 is executed, the automatic variable 2-1 and the automatic variable 2-2 of the coroutine function 2 are stored in the stack area 3d of the memory 3. Before the processing of the coroutine function 2 is interrupted, the automatic variables 2-1 and the automatic variables 2-2 stored in the stack area 3d are saved in the save area 3e.

When the coroutine function 1 is restarted, the automatic variables 1-1 and 1-2 stored in the stack area 3d are restored to the stack area 3d of the memory 3. The same applies when the coroutine function 2 is restarted.

Further, in the present embodiment, the program 4 further includes a step of restoring the area (save area 3e) in which the automatic variable is stored after restoring the automatic variable to the stack area 3d of the memory 3. Specifically, as shown in FIG. 6, the usage status flag of this block is unused by referring to the block information of the block including the area to be released from the start address of the save area 3e.

Further, in the present embodiment, as shown in FIG. 8, the program 4 further includes a step of creating an address list AL (stack frame definition) of automatic variables in the stack area 3d of the memory 3 after calling the coroutine function. .. Specifically, the definition area 3f necessary for storing the information of the address list AL is secured in the global area 3b of the memory 3. Then, the address value (pointer) on the stack area 3d of the automatic variable to be saved is stored in the global area 3b as the address list AL (stack frame definition).

For example, in the example shown in FIG. 8A, the automatic variable A, the automatic variable B, and the automatic variable C (referred to as A, B, and C, respectively in FIG. 8) are stored in the stack area 3d. Then, in the global area 3b, the pointer of the automatic variable A, the pointer of the automatic variable B, and the pointer of the automatic variable C are stored as the address list AL. The pointer of the automatic variable A, the pointer of the automatic variable B, and the pointer of the automatic variable C are not limited to the order shown in FIG. 8, and are stored in any order.

Then, in the present embodiment, as shown in FIG. 8C, the step of saving the automatic variable to the global area 3b is a step of saving the automatic variable to the save area 3e based on the created address list AL. include. Specifically, a save area 3e for saving coroutine function information (automatic variable) is secured in the global area 3b of the memory 3. Then, the values of the automatic variables referenced by the pointer are stored in the save area 3e in the order defined in the address list AL.

For example, in the example shown in FIG. 8C, the automatic variable A, the automatic variable B, and the automatic variable C are stored in the stack area 3d. Then, the value of the automatic variable A referenced by the pointer is stored in the save area 3e. As a result, the value of the automatic variable A is saved in the global area 3b. The same applies to the automatic variable B and the automatic variable C.

Then, in the present embodiment, the program 4 further includes a step of releasing the area in which the address list AL is stored after the step of saving the automatic variable (value) in the save area 3e.

Further, in the present embodiment, as shown in FIG. 8B, in the step of restoring the automatic variable to the stack area 3d, the automatic variable is transferred to the stack area 3d of the memory 3 based on the created address list AL. Includes steps to restore. Specifically, the value of the automatic variable saved before the processing is interrupted is acquired from the save area 3e. Then, the automatic variables are stored in the stack area 3d indicated by the pointer in the order defined in the address list AL.

For example, in the example shown in FIG. 8B, the value of the automatic variable A, the value of the automatic variable B, and the value of the automatic variable C before the interruption are stored in the save area 3e. Then, the value of the automatic variable A is stored in the stack area 3d indicated by the pointer of the automatic variable A in the address list AL. As a result, the value of the automatic variable A is restored to the stack area 3d. The same applies to the automatic variable B and the automatic variable C. After the automatic variables A to C are restored to the stack area 3d of the memory 3, the area where the automatic variables A to C are stored (the part of the global area 3b) is released.

Next, a processing method of the coroutine function of the present embodiment will be described. The following processing is performed by the microcomputer 2.

First, as shown in FIGS. 9, 11 and 12, the coroutine function is called in step S1 (co_begin in FIG. 10).

Next, in step S2 (define_frame in FIG. 10), after the coroutine function is called, an area for storing the address list AL of the automatic variable in the stack area 3d of the memory 3 is secured in the global area 3b of the memory 3. do. Then, after calling the coroutine function, the address list AL is created in this area.

Next, in step S3 (Switch in FIG. 10), the switch statement determines the interruption position of the processing of the coroutine function.

When it is determined in step S3 that the coroutine function is executed for the first time (case 0 in FIG. 10), the process in the case () clause in FIG. 10 is executed in step S4. That is, "hello world !!" is displayed on a display (not shown).

Next, as shown in FIG. 10 (a description example of the coroutine function), "co_yeld ()" commands the interruption of the processing of the coroutine function. Specifically, in step S5 (save_value in FIG. 10), the automatic variables stored in the stack area 3d for the coroutine function are saved in the save area 3e of the global area 3b. Specifically, after securing the save area 3e for saving the coroutine function information (automatic variable, coroutine function pointer information, coroutine function interruption position, argument, and return value) in the global area 3b of the memory 3, the stack. The automatic variables in the area 3d are saved in the save area 3e in the global area 3b.

Next, in step S6 (_state = _LINE_ in FIG. 10), the interruption position (the position where the coroutine function is interrupted) is saved (saved) in the save area 3e of the memory 3.

Next, in step S7 (return in FIG. 10), the coroutine function is interrupted (finished).

When it is determined in step S3 that the coroutine function has been restarted (first restart) (case_LINE_ in FIG. 10), in step S8, the automatic variable saved in the global area 3b of the memory 3 is moved to the stack area 3d. It is restored (load_varie () in FIG. 10). After that, in the global area 3b of the memory 3, the area where the automatic variable is stored is released.

Next, in step S9, the process of the case_LINE_ clause of FIG. 10 is executed. That is, "hi world!" Is displayed on a display (not shown).

Next, as shown in FIG. 10, "co_yield ()" commands the interruption of the processing of the coroutine function. Specifically, in step S10 (save_value in FIG. 10), the automatic variables stored in the stack area 3d for the coroutine function are saved in the save area 3e of the global area 3b. Specifically, after securing the save area 3e for saving the coroutine function information (automatic variable, coroutine function pointer information, coroutine function interruption position, argument, and return value) in the global area 3b of the memory 3, the stack. The automatic variables in the area 3d are saved in the save area 3e in the global area 3b.

Next, in step S11 (_state = _LINE_ in FIG. 10), the interruption position (the position where the coroutine function is interrupted) is saved in the save area 3e of the memory 3.

Next, in step S12 (return in FIG. 10), the coroutine function is interrupted (finished).

When it is determined in step S3 that the coroutine function has been restarted (second restart) (case_LINE_ in FIG. 10), in step S13, the automatic variable saved in the global area 3b of the memory 3 is moved to the stack area 3d. It is restored (load_varie () in FIG. 10). After that, in the global area 3b of the memory 3, the area where the automatic variable is stored is released.

Next, in step S14, the process of the case_LINE_ clause of FIG. 10 is executed. That is, ":)" is displayed on a display (not shown).

Next, as shown in FIG. 10, "co_end" commands the end of the processing of the coroutine function. Specifically, in step S15 (_state = _LINE_ in FIG. 10), the interruption position (the position where the coroutine function ends) is saved in the save area 3e of the memory 3.

Next, in step S16 (return in FIG. 10), the coroutine function is terminated. In addition, the area where the automatic variables are stored (the part of the global area 3b) is released.

If it is determined in step S3 that the coroutine function has been restarted after the end of the coroutine function in step S16, the position where the coroutine function has ended is saved in the save area 3e of the memory 3 in step S16. The coroutine function ends without executing the processing of the coroutine function.

(Multiple coroutine functions)
Next, the operation when a plurality of coroutine functions are executed will be described with reference to FIGS. 13 and 14. The case where the coroutine function 1 and the coroutine function 2 are executed will be described below.

First, the coroutine function 1 is called (step S21). Then, after the coroutine function 1 is called, an area for storing the address list AL is secured in the global area 3b of the memory 3, and the address list AL (Co information 1) is created in this area.

Next, the process of the coroutine function 1 is executed (step S22). During the execution of the processing of the coroutine function 1, the automatic variable 1-1 is stored in the stack area 3d. Although FIG. 14 shows a diagram in which the automatic variable 1-1 is stored in the global area 3b (save area 3e) and the automatic variable 1-1 is restored in the stack area 3d, the first coroutine function 1 is shown. At the time of executing the process of, it is not necessary to restore the automatic variable 1-1 and release the area in which the automatic variable 1-1 is stored.

Next, the processing of the coroutine function 1 is interrupted (step S23). As a result, the automatic variable 1-1 stored in the stack area 3d is saved in the save area 3e of the global area 3b. Further, the interrupted position (the position where the coroutine function is interrupted) is saved in the save area 3e (Co information 1) of the memory 3.

Next, the coroutine function 2 is called (step S24). Then, after the coroutine function 2 is called, an area for storing the address list AL is secured in the global area 3b of the memory 3, and the address list AL (Co information 2) is created in this area.

Next, the process of the coroutine function 2 is executed (step S25). During the execution of the processing of the coroutine function 2, the automatic variable 2-1 is stored in the stack area 3d. Although FIG. 14 shows a diagram in which the automatic variable 2-1 is stored in the global area 3b (save area 3e) and the automatic variable 2-1 is restored in the stack area 3d, the first coroutine function 2 is shown. At the time of executing the process of, it is not necessary to restore the automatic variable 2-1 and release the area in which the automatic variable 2-1 is stored.

Next, the processing of the coroutine function 2 is interrupted (step S26). As a result, the automatic variable 2-1 stored in the stack area 3d is saved in the save area 3e of the global area 3b. Further, the interrupted position (the position where the coroutine function is interrupted) is saved in the save area 3e (Co information 2) of the memory 3.

Next, the coroutine function 1 is called again, and the processing of the coroutine function 1 is restarted (step S27). As a result, the automatic variable 1-1 saved in the global area 3b of the memory 3 is restored to the stack area 3d. After that, in the global area 3b of the memory 3, the area in which the automatic variable 1-1 is stored is released. The subsequent processing of interruption of the coroutine function 1 is the same as described above.

Next, the coroutine function 2 is called again, and the processing of the coroutine function 2 is restarted (step S28). As a result, the automatic variable 2-1 saved in the global area 3b of the memory 3 is restored to the stack area 3d. After that, in the global area 3b of the memory 3, the area in which the automatic variable 2-1 is stored is released. The subsequent processing of interruption of the coroutine function 2 is the same as described above.

(Subcoroutine function)
Next, the operation when the subcoroutine function is called from the coroutine function will be described with reference to FIGS. 15 and 16. Hereinafter, a case where the coroutine function 1 and the coroutine function 1-1, which is a subcoroutine function, is executed will be described.

First, the coroutine function 1 is called (step S31). Then, after the coroutine function 1 is called, an area for storing the address list AL is secured in the global area 3b of the memory 3, and the address list AL (Co information 1) is created in this area.

Next, the coroutine function 1-1 is called (step S32).

Next, the coroutine function 1-1 is activated (step S33), an area for storing the address list AL is secured in the global area 3b of the memory 3, and the address list AL (Co information 1-1) is stored. Create in the area.

Next, the process of the coroutine function 1-1 is executed (step S34). During the execution of the processing of the coroutine function 1-1, the automatic variable 1-1-1 is stored in the stack area 3d. Although FIG. 16 shows a diagram in which the automatic variable 1-1-1 is stored in the save area 3e and the automatic variable 1-1-1 is restored in the stack area 3d, the first coroutine function 1- When executing the process 1-1, it is not necessary to restore the automatic variable 1-1-1 and release the area in which the automatic variable 1-1-1 is stored.

Next, the processing of the coroutine function 1-1 is interrupted (step S35). As a result, the automatic variable 1-1 stored in the stack area 3d is saved in the save area 3e of the global area 3b. Further, the interrupted position (the position where the coroutine function is interrupted) is saved in the save area 3e (Co information 1-1) of the memory 3.

Next, the processing of the coroutine function 1 is restarted (step S36). Specifically, the automatic variable 1-1 stored in the save area 3e of the global area 3b is restored (saved) in the stack area 3d, and the automatic variable 1-1 stored in the stack area 3d is used. Execute the process. In addition, the save area 3e in which the automatic variable 1-1 is stored is released. Then, when the processing of the coroutine function 1 is interrupted, the automatic variable 1-1 stored in the stack area 3d is saved in the save area 3e of the global area 3b. Further, the interrupted position (the position where the coroutine function is interrupted) is saved in the save area 3e (Co information 1) of the memory 3.

[Effect of this embodiment]
In this embodiment, the following effects can be obtained.

In the present embodiment, as described above, the program 4 is included in the information of the coroutine function stored in the stack area 3d of the memory 3 after the coroutine function is called and before the processing of the coroutine function is interrupted. It includes a step of saving the automatic variables saved in the save area 3e and a step of restoring the automatic variables saved in the save area 3e to the stack area 3d of the memory 3 before restarting the interrupted processing. As a result, the automatic variables stored in the stack area 3d of the memory 3 are saved in the save area 3e of the global area 3b of the memory 3. Therefore, when the collout function is called to restart the interrupted processing, the memory Even if the stack area 3d of 3 is initialized or an indefinite value is stored in the stack area 3d, the automatic variables saved in the save area 3e of the global area 3b of the memory 3 are restored to the stack area 3d of the memory 3. Will be done. As a result, when the interrupted processing of the coroutine function is resumed, the processing can be resumed based on the exact automatic variable. As a result, when the coroutine function is executed, the interrupted processing can be resumed normally.

Further, in the present embodiment, as described above, the information of the coroutine function further includes the pointer information of the coroutine function, the interruption position of the coroutine function, the argument, and the return value. As a result, the pointer information of the coroutine function required for resuming the interrupted processing, the interruption position of the coroutine function, the automatic variable, the argument, and the return value are saved in the save area 3e of the global area 3b of the memory 3. The interrupted processing can be resumed normally and reliably.

Further, in the present embodiment, as described above, the information of each of the automatic variable, the argument, and the return value is the area information or the pointer information on the memory 3. Here, since the global area 3b of the memory 3 can be freely written unlike the stack area 3d of the memory 3, each information of the automatic variable, the argument, and the return value can be used as the area information on the memory 3 or the area information on the memory 3. Any of the pointer information can be written.

Further, in the present embodiment, as described above, the step of securing the save area 3e includes a step of securing the save area 3e according to the size of the information of the coroutine function. Here, when the information of the coroutine function is stored in the stack area 3d of the calling function that calls the coroutine function, the area for the information of the coroutine function may be secured in a fixed size. In this case, depending on the configuration of the coroutine function (the number of each of the arguments, automatic variables, and return values), it may not be possible to properly secure an area (excess or deficiency) for the information of the coroutine function. Therefore, by configuring as described above, the save area 3e can be secured by the variable length in the global area 3b of the memory 3 (in the global area 3b, it is easier to specify the size of the area as compared with the stack area 3d. Therefore, the evacuation area 3e can be appropriately secured.

Further, in the present embodiment, as described above, the program 4 further includes a step of restoring the area in which the automatic variable is stored after restoring the automatic variable in the stack area 3d of the memory 3. As a result, the area where the automatic variables of the memory 3 are stored is released after the automatic variables are restored to the stack area 3d of the memory 3. Therefore, when a plurality of coroutine functions are provided, the global area of the memory 3 after the release is released. 3b can be used as an area for storing automatic variables of other coroutine functions. That is, even if the number of coroutine functions is relatively large, the coroutine functions can be executed appropriately.

Further, in the present embodiment, as described above, the program 4 further includes a step of creating an address list AL of automatic variables in the stack area 3d of the memory 3 in the global area 3b of the memory 3 after calling the coroutine function. .. The step of saving the automatic variable to the save area 3e includes a step of saving the automatic variable to the save area 3e based on the created address list AL. Further, the step of restoring the automatic variable to the stack area 3d includes a step of restoring the automatic variable to the stack area 3d of the memory 3 based on the created address list AL. As a result, the automatic variables are saved and restored based on the address list AL, so that the automatic variables can be saved in the save area 3e and restored in the stack area 3d without making a mistake.

Further, in the present embodiment, as described above, the program 4 further includes a step of saving the automatic variable in the save area 3e and then releasing the area in which the address list AL of the automatic variable is stored. As a result, after the automatic variable is saved in the save area 3e, the area in which the address list AL of the automatic variable is saved is released. Therefore, when a plurality of coroutine functions are provided, the global area of the memory 3 after release is released. 3b can be used as an area for storing the address list AL of other coroutine functions. That is, even if the number of coroutine functions is relatively large, the coroutine functions can be executed appropriately.

[Modification example]
It should be noted that the embodiments disclosed this time are exemplary in all respects and are not considered to be restrictive. The scope of the present invention is shown by the scope of claims rather than the description of the above-described embodiment, and further includes all modifications (modifications) within the meaning and scope equivalent to the scope of claims.

For example, in the above embodiment, an example in which a coroutine function is pseudo-implemented by the C language is shown, but the present invention is not limited to this. For example, the coroutine function may be implemented in a language other than C language.

Further, in the above embodiment, an example in which the coroutine function is pseudo-implemented by the Switch-case statement in C language is shown, but the present invention is not limited to this. For example, the coroutine function may be implemented by using a statement (instruction statement) other than the Switch-case statement in C language.

Further, in the above embodiment, an example is shown in which the information of the coroutine function includes an automatic variable, pointer information of the coroutine function, a break position of the coroutine function, an argument, and a return value, but the present invention is not limited to this. .. In the present invention, the information of the coroutine function may include information other than the above information.

Further, in FIG. 12 and the like of the above embodiment, an example is shown in which the automatic variable is stored in an area other than the area in which the Co information is stored on the global area 3b of the memory 3, but the present invention is limited to this. I can't. For example, the automatic variable may be stored in the area for the automatic variable in the Co information.

2 Microcomputer (control unit)
3 Memory 3b Global area 3d Stack area 3e Evacuation area 4 Program 100 Controller AL address list

Claims (8)

A control device that executes a coroutine function that suspends processing and then resumes processing from the continuation of the interrupted processing.
The memory in which the program containing the coroutine function is stored, and
It is equipped with a control unit that executes the program.
The program
After the coroutine function is called, a step of securing a save area for saving the information of the coroutine function in the global area of the memory, and a step of securing the save area.
A step of saving an automatic variable included in the information of the coroutine function stored in the stack area of the memory to the save area after the coroutine function is called and before the processing of the coroutine function is interrupted. When,
A control device including a step of restoring the automatic variable saved in the save area to the stack area of the memory before restarting the interrupted process. The control device according to claim 1, wherein the information of the coroutine function further includes pointer information of the coroutine function, an interruption position of the coroutine function, an argument, and a return value. The control device according to claim 2, wherein the information of each of the automatic variable, the argument, and the return value is area information or pointer information on the memory. The control device according to any one of claims 1 to 3, wherein the step of securing the save area includes a step of securing the save area according to the magnitude of information of the coroutine function. The control according to any one of claims 1 to 4, further comprising a step of restoring the automatic variable to the stack area of the memory and then releasing the area in which the automatic variable is stored. Device. The program further comprises, after calling the coroutine function, creating an address list of the automatic variables in the stack area of the memory in the global area of the memory.
The step of saving the automatic variable to the save area includes a step of saving the automatic variable to the save area based on the created address list.
One of claims 1 to 5, wherein the step of restoring the automatic variable to the stack area includes a step of restoring the automatic variable to the stack area of the memory based on the created address list. The control device described in the section. The control device according to claim 6, wherein the program further includes a step of saving the automatic variable in the save area and then releasing the area in which the address list of the automatic variable is stored. It is a processing method that executes a coroutine function that resumes processing from the continuation of the interrupted processing after suspending the processing.
The step of calling the coroutine function and
After the coroutine function is called, a step of securing a save area for saving the information of the coroutine function in the global area of the memory, and
A step of saving an automatic variable included in the information of the coroutine function stored in the stack area of the memory to the save area after the coroutine function is called and before the processing of the coroutine function is interrupted. When,
A processing method comprising a step of restoring the automatic variable saved in the save area to the stack area of the memory before restarting the interrupted process.

Images