JP5598375B2 - Allocation method for allocating code included in program to memory area and memory system for executing the method - Google Patents

Description

  The present invention relates to a method for assigning a code included in a program code to a memory area and a memory system for executing the method.

  In a system comprising a CPU and a memory, a method has been proposed in which the CPU controls the operation of the memory so as to reduce the power consumption of the memory in accordance with the contents of the source program supplied to the CPU (Patent Document 1). 2). In particular, in an SOC (System On Chip) in which a system including a CPU and a memory is mounted on a single semiconductor chip, the above-described memory operation control method for reducing power consumption is drawing attention.

  According to Patent Document 1, each phase in units of a loop in a source program and reference data to be referred to in each phase are extracted to perform phase division processing for dividing the source program. There is described a method for reducing power by optimally allocating a memory area necessary for storage to a cache memory of a CPU and an on-chip memory outside the CPU.

  According to the documents of Patent Documents 1 and 2, when the time for the memory to transition to or return from the power control state is longer than the clock period supplied to the CPU, the performance does not deteriorate. Describes a method for reducing the power consumption by optimally controlling the power control state of the memory area in which the instruction code is stored.

  However, depending on the structure of the source program, the memory area that stores the instruction code that can be in the power control state is limited, and depending on the control of the power control state, the effect of reducing power consumption may be reduced.

JP 2008-102733 A JP 2010-257437 A

  It is an object of the present invention to provide a method for realizing an allocation state of program codes to a storage area, which can reduce power consumption by controlling the power state of the storage area, and a memory system for executing the method.

  In order to solve the above, according to one aspect of the present invention, a call relationship between functions in a program read by a processor is extracted into a function call chain based on a process in which the processor extracts and a call relationship between functions. The call relationship is traced, and when a function that has been called once is called again, recursive call extraction is performed with the function group passed between the first call and the second call as the recursive call part. A code allocation step in which a processor assigns a code included in a program representing a process and a recursive calling unit to a memory bank in which a supplied voltage state can be switched independently; A method for allocating assigned codes to memory areas is provided.

According to the present invention, a method for allocating a code included in a program to a storage area, and controlling a power state of a device constituting the storage area according to a code allocation state in the storage area realized by the method. In this case, it is possible to provide a method capable of realizing power consumption reduction and a memory system that executes the method.

FIG. 1 is a diagram illustrating a memory system 50 according to the first embodiment. FIG. 2 is a diagram showing an example of a source program and an example of allocation of memory areas to instruction codes of the source program. FIG. 3 shows an allocation method for allocating storage areas to codes included in a program. FIG. 4 shows a flowchart, a static call graph, and an output data table after the call relationship is extracted regarding the call relationship extraction step S31. FIG. 5 shows a main flowchart for explaining the recursive call extraction step S32A and a subroutine flowchart for explaining the subroutine S321. FIG. 6 is a flowchart showing the relationship between the subroutine S322 and the subroutine S322 and the recursive degeneration step S33. FIG. 7 is a diagram for explaining the detection of the recursive reading unit in the recursive call extraction step S32A. FIG. 8 is a diagram for explaining the recursive degeneration step S33. FIG. 9 shows an example of a specific processing operation in the recursive degeneration step S33. FIG. 10 is a flowchart for explaining the memory allocation step S34. FIG. 11 is a diagram showing an assignment state of program source codes related to functions. FIG. 12 is a flowchart for a memory system 110 that is a modification of the first embodiment and a method for generating an execution program with power supply control generated in the memory system 110. FIG. 13 is a diagram illustrating an allocation method for allocating storage areas to codes included in a program according to the second embodiment. FIG. 14 shows a flowchart, a static call graph, and an output data table after the call extraction related to the call relationship extraction step S35. FIG. 15 is a diagram for explaining the recursive degeneration step S36. FIG. 16 shows an example of a specific processing operation in the recursive degeneration step S36. FIG. 17 is a flowchart illustrating the memory allocation step S37 according to the embodiment. FIG. 18A shows a memory allocation step S4005 according to the third embodiment. FIG. 18B shows a memory area allocation routine S400507 according to the third embodiment. FIG. 19A shows a specific example in which a function is allocated to each memory bank in the memory allocation step S4005 according to the third embodiment. FIG. 19B shows a specific example in which a function is allocated to each memory bank in the memory allocation step S4005 according to the third embodiment. FIG. 19C shows a specific example in which a function is allocated to each memory bank in the memory allocation step S4005 according to the third embodiment. FIG. 19D shows the result of performing memory allocation step S4005 with power control. FIG. 20 shows an example in which the power consumption reduction effect decreases when the program shown in the third embodiment is executed. FIG. 21A shows a memory allocation step S4105 according to the fourth embodiment. FIG. 21B is a diagram for explaining a routine S410524 for assigning a function group F_Max to a memory bank. FIG. 22 shows a specific example in which a function is allocated to each memory bank in the memory allocation step S4105 according to the fourth embodiment.

  The present invention includes the embodiments described below that have been modified by the design that can be conceived by those skilled in the art, and those in which the components shown in the embodiments have been recombined. Further, the present invention includes those in which the constituent elements are replaced with other constituent elements having the same operational effects, and are not limited to the following embodiments.

FIG. 1 is a diagram illustrating a memory system 50 according to the first embodiment. The memory system 50 includes a memory unit 10, a processor 20, a control register group 30, a bus 40, a power supply line 45, and a power supply control device 46. (See Japanese Patent Application Nos. 2009-9065, 2009-266575, and 2010-9269)
The processor 20 includes a memory controller, and controls writing or reading of data or instruction codes to or from the memory banks 11, 12, 13, 14, 15 included in the memory unit 10. Further, a power control signal for performing power control of the memory banks 11, 12, 13, 14, 15 is output to the control register group 30.
The control register group 30 is a register group that stores the power control states of the memory banks 11, 12, 13, 14, and 15 in accordance with a power control signal from the CPU. Therefore, for example, the control register group 30 is composed of eight registers. When “00000101” is set as a digit, the power to the memory bank 11 and the memory bank 13 is turned on.

  The power supply control device 46 is disposed between the power supply line 45 and each of the memory banks 11, 12, 13, 14, 15. The power supply state of each of the memory banks 11, 12, 13, 14, 15 is changed from the control register group 30. Control according to the signal. The power supply state is a power-off state in which the connection from the power supply line 45 to each of the memory banks 11, 12, 13, 14, and 15 is cut off, and the power supply from the power supply line 45 is reduced in voltage to each memory. A power saving supply state for supplying to the banks 11, 12, 13, 14, 15 and a normal power supply state for supplying the power from the power supply line 45 to each of the memory banks 11, 12, 13, 14, 15 while maintaining the voltage. Including.

The memory unit 10 includes an instruction code memory 16 and a data memory 17. The instruction code memory 16 includes memory banks 11, 12, 13, and 14. The data memory 17 includes a plurality of memory banks 15. It goes without saying that the power supply state of each memory bank 11, 12, 13, 14, 15 is controlled by the power supply control device 46.
In the power-off state, the memory banks 11, 12, 13, 14, and 15 cannot hold data, and cannot read and write. In the power saving supply state, each of the memory banks 11, 12, 13, 14, and 15 can hold data, but cannot read and write normally. In the normal power supply state, each of the memory banks 11, 12, 13, 14, and 15 can hold data and can normally perform reading and writing. The memory bank 11 occupies an area from the address 0x0000 to the address 0x0fff in the memory unit 10. The memory bank 12 occupies an area from the address 0x1000 to the address 0x1fff in the memory unit 10. The memory bank 13 occupies an area from the address 0x2000 to the address 0x2fff in the memory unit 10. The memory bank 14 occupies an area from the address 0x3000 to the address 0x3fff in the memory unit 10. The memory bank 15 occupies the memory area after the address 0x4000 in the data memory 17.

  Therefore, each memory bank 11, 12, 13, 14, 15 can be brought into a power saving supply state when no read and write operations occur. Then, the power of the entire memory system 50 can be greatly reduced as reading and writing are concentrated in a small number of memory banks.

FIG. 2 is a diagram showing an example of a source program and an example of allocation of memory areas to instruction codes of the source program. According to FIG. 2, the main program is assigned to the memory bank 11, the program specifying the function func_A1 is assigned to the memory bank 12, and the program specifying the function func_A2 is assigned to the memory bank 13.
The “memory bank 12 sleep cancellation code fragment” in the main program is an instruction code fragment that shifts the memory bank 12 from the power saving supply state to the normal power supply state. Next, “call Func_A1” is an instruction code for calling a function called Func_A1 assigned to the memory bank. Next, the “memory bank 12 Sleep code fragment” is an instruction code fragment that shifts the memory bank 12 from the normal power supply state to the power saving supply state.

The “memory bank 13 sleep cancellation code fragment” in the main program is an instruction code fragment that shifts the memory bank 13 from the power saving supply state to the normal power supply state. Next, “call Func_A2” is an instruction code for calling a function called Func_A2 assigned to the memory bank. Next, the “memory bank 13 Sleep code piece” is an instruction code piece for shifting the memory bank 13 from the normal power supply state to the power saving supply state.
As described above, when there is an instruction code for calling a function in the main program, the memory bank to which the instruction code representing the function is assigned is shifted from the power saving supply state to the normal power supply state, and the function result is transferred to the main program. Then, the memory bank is returned from the normal power supply state to the power saving supply state.

FIG. 3 shows an allocation method for allocating storage areas to codes included in a program. By executing the allocation method, it is possible to realize a storage area allocation state that can reduce power consumption by controlling the power state of the storage area.
The allocation method for allocating codes to storage areas is executed by the processor 20 of FIG. 1 and includes a call relation extraction step S31, a recursive call extraction step S32A, a recursive call processed static call graph creation step S32B, a recursive degeneration step S33, and A memory allocation step S34 is included.
The call relationship extraction step S31 is a step of scanning the source code, assembly or object of the program 62 and creating a static call graph. A static call graph expresses a call relationship between a parent function or functions on source code, assembly code, or object code. Therefore, prior to creating the static call graph, the processor 20 extracts the “call relationship between functions” in the read program. The static call graph will be further described with reference to FIG.

The recursive call extraction step S32A is a step of extracting a parent function or a recursive call portion between functions based on the call relationship of the call relationship extraction step S31. When the recursive call part is extracted, the process proceeds to the recursive degeneration step S33 in order to degenerate the recursive call part. On the other hand, when returning from the recursive degeneration step S33, if no recursive call part is extracted, the process proceeds to the recursive read processed static call graph creation step S32B.
Here, the recursive call means that a function in a call chain including a function corresponding to the call or a function further called from the function calls a function that is a source of the call relation.
Further, extracting the recursive call part means that the call relationship is traced along the function call chain based on the “call relationship between functions”, and when a function that has been called once is called again, A function group passed between the first call and the second call is assumed to be a recursive call unit. The extraction of the recursive call part will be further described with reference to FIGS.
Recursive call processed static call graph creation step S32B: The recursive call extraction step S32A and the recursive degeneration step S33 are repeated, and the extraction of the recursive call portion and the recursive degeneration for the recursive call portion are completed for all source codes. Sometimes, in the recursive call processed static call graph creation step S32B, recursive call processed static call graph 63, recursive call completed function size information 64, and function degeneration information 65 are created for all source codes.

In the recursive degeneration step S33, when a recursive call portion is extracted in the recursive call extraction step S32A, a recursive degeneracy for recursive call portions is performed. As a result of the recursive reduction, the recursive call part that is grouped is regarded as one function. The storage size of the function regarded as one is obtained by calculation according to the original function size obtained from the function size information 61. The recursive degeneration will be further described with reference to FIG. 8, FIG. 9, and FIG.
In the recursive read processed static call graph creation step S32B, when all the recursive read units are detected and the recursive degeneration is completed, the static call graph and recursive call after the recursive read processing are applied to the entire given source code. Create function size information and function degeneration information after processing.

  The memory allocation step S34 is a step of allocating codes in a program representing a function assumed to be one to the same memory bank in the memory area. That is, a function that is regarded as one is stored in the same memory bank. Here, a memory bank to which a function assumed to be one is allocated is a memory bank whose power supply state can be switched, such as memory banks 11, 12, 13, 14, and 15 shown in FIG.

FIG. 4 shows a flowchart, a static call graph, and an output data table after the call relationship is extracted regarding the call relationship extraction step S31.
The static call graph of FIG. 4 represents a function calling relationship on the source code given as an example. That is, in the static call graph of FIG. 4, a path for calling the child function f_B2 from the main function f_MAIN via the child function f_A2, a path for calling the child function f_B2 from the main function f_MAIN via the child function f_A3, A path for calling the child function f_B3 from the main function f_MAIN via the child function f_A3, a path for calling the child function f_B3 from the child function f_B2, and a path for calling the child function f_A3 from the child function f_B2 are described.
The output data table in the call relationship extraction step S31 in FIG. 4 is an output data table corresponding to the static call graph in FIG. The first column of the output data table in FIG. 4 describes the call source function, and the second column describes the call destination function. According to the output data table of FIG. 4, the main function f_MAIN calls the child function f_A2 and the child function f_A3. The child function f_A2 and the child function f_A3 call the child function f_B2. The child function f_A3 and the child function f_B2 call the child function f_B3. The child function f_B2 calls the child function f_A3.

According to the flowchart of FIG. 4, the call relationship extraction step S31 includes a function start description extraction step S311 and a step of performing a function call description detection and addition step S312 to the output data table.
The function start description extraction step S311 is a step of extracting a description at the start of the function from the given source code and obtaining the function name of the call source. The function call description detection and output table addition step S312 is a step of detecting a function call description in a given source code and adding the call source function and the call destination function in a table format. For example, the data shown in the output data table of FIG. 4 is created.

FIG. 5 shows a main flowchart for explaining the recursive call extraction step S32A and a subroutine flowchart for explaining the subroutine S321. The main flowchart for explaining the recursive call extraction step S32A includes an initialization step S3201, a subroutine execution step S3202, and a flag determination step S3203.
Initialization step S3201: All variables visited used in the recursive call extraction step S32A are set to false. Also, the data PATH is emptied. Further, the variable flag is set to false.
Subroutine execution step S3202: This is a step of setting the main function f_MAIN to the variable f indicating the target function in the subroutine S321 and executing the subroutine S321.
Flag determination step S3203: Checks whether the variable flag is true or false. If true, the process returns to the initialization step S3201. If it is false, the recursive call extraction S32A is terminated. Here, when the variable flag is true, it means that the recursive calling unit is found by performing the subroutine S321. In addition, it means that the recursive call unit found here is regarded as one function by performing the recursive degeneration step S33.

The subroutine flowchart for explaining the subroutine S321 includes a PATH addition step S32101, a subroutine execution step S32102, and a PATH deletion step S32103.
The PATH addition step S32101 is a step of setting all the child functions called from the main function as PATH variables following the main function. When there are a plurality of child functions called from the parent function, there are a plurality of PATHs composed of function call chains.
Therefore, the process proceeds to the subroutine execution step S32102, and in each of the PATHs, the subroutine S322 is performed to detect the recursive calling unit, and the recursive calling unit is regarded as one function. Thereafter, the process proceeds to the PATH deletion step S32103.
The PATH deletion step S32103 is a step of deleting the last function from the PATH variable. After the PATH deletion step S32103 is completed, the process returns to the main flowchart.

  FIG. 6 is a flowchart showing the relationship between the subroutine S322 and the subroutine S322 and the recursive degeneration step S33. The flowchart of the subroutine S322 includes a step S3221 for checking whether a variable flag is true or false, a step S32202 for checking whether a function added to the PATH has been called or not, and a variable verified setting step. S32203, subroutine execution step S32204, variable visited setting step S32205, recursive call part setting step S32206, recursive degeneration step S33, step 32207, and variable flag setting step S32208 are included.

Step S3221 for checking whether the variable flag is true or not: When the variable flag is true, the process proceeds to the end stage of the subroutine S322. When the variable flag is false, the process proceeds to step S32202 for checking the truth of the variable visited indicating whether or not the call has been made.
Step S32202 of checking whether the variable visited is true or not: When the variable visited is true, the process proceeds to the recursive call unit setting step S32206. When the variable visited is false, the process proceeds to a variable visited setting step S32203.
Variable visited setting step S32203: The variable visited of the called function is set to true.
Subroutine execution step S32204: The called function is set to the variable f indicating the target function in the subroutine S321, and the subroutine S321 is executed.
Variable visited setting step S32205: This is a step in which the variable visited for the called function is set to false.

Recursive call section setting step S32206: This is a process in which a function in which the variable “visited” is true and a function thereafter are used as a recursive call section among the functions added to the PATH variable when executing the subroutine S322.
Step 32207 for performing the recursive degeneration step S33: This is a step for performing the recursive degeneration step S33 for the function chain that has been made a recursive call unit in the recursive call unit setting step S32206.
Variable flag setting step S32208: This is a step of setting the variable visited of the called function to be true.

FIG. 7 is a diagram for explaining the detection of the recursive reading unit in the recursive call extraction step S32A. According to FIG. 7, there are stages 1 to 5 for detecting the recursive readout section.
Stage 1: Stage 1 is a stage representing the first start time of the subroutine execution step S32102 in the flowcharts shown in FIGS. Until this state is reached, the initialization step S3201, the subroutine execution step S3202, and the PATH addition step S32101 are executed. In the PATH addition step S32101, the function added to the end of the PATH is the parent function f_MAIN set to the function f in the subroutine execution step S3202, and therefore, the PATH function is composed of only the parent function f_MAIN.
From here, first, the subroutine S322 is started for the functions f_A2 and f_A3 that are the call destinations of the function f_MAIN. Hereinafter, a case where the subroutine S322 is started for the function f_A2 will be described.
Here, the variable flag and the variable visited for the function f_A2 are false. This is because, since the initialization step S3201 is performed, the current call is a call to the first child function f_A2 and a visit. Then, a variable visited setting step S32203 is performed via a step S32201 for checking the authenticity of the variable flag and a step S3222 for checking the trueness of the variable visited. As a result, after the variable visited of the child function f_A2 is set to true, the process proceeds to the subroutine execution step S32204.
Subroutine execution step S32204 starts execution of subroutine S321 with function f set as child function f_A2. In the PATH addition step S32101, the child function f_A2 set in the function f in the subroutine execution step S32204 is added to the end of the PATH. As a result, the PATH function is composed of a parent function f_MAIN and a child function f_A2. Note that this child function f_A2 is a function to be processed in stage 1.
Stage 2: Stage 2 is a stage representing the second start time of the subroutine execution step S32102 in the flowcharts shown in FIGS. From this state, the subroutine S322 is started for the callee function f_B2 of the function f_A2.
Here, the variable flag and the variable visited for the function f_B2 are false. This is because, since the initialization step S3201 is performed, the current call is a call to the first child function f_B2 and a visit. Then, a variable visited setting step S32203 is performed via a step S32201 for checking the authenticity of the variable flag and a step S3222 for checking the trueness of the variable visited. As a result, after the variable visited of the child function f_B2 is set to true, the process proceeds to the subroutine execution step S32204.
In subroutine execution step S32204, execution of subroutine S321 is further started with function f set as child function f_B2.
In the PATH addition step S3210, the child function f_B2 set in the function f by the subroutine execution step S32204 is added to the end of the PATH, and the PATH is called from the parent function f_MAIN, the child function f_A2 called from the parent function f_MAIN, and the child function f_A2. Child function f_B2.

Stage 3: Stage 3 is a stage representing the third start time of the subroutine execution step S32102 in the flowcharts shown in FIGS. From here, the subroutine S322 is started for the child function f_A3 and the child function f_B3, which are the call destination functions of the child function f_B2. Here, the case where the subroutine S322 is started for the child function f_A3 is shown.
Here, the variable flag and the variable visited for the function f_A3 are false. This is because, since the initialization step S3201 is performed, the current call is a call to the first child function f_A3 and a visit. Then, a variable visited setting step S32203 is performed via a step S32201 for checking the authenticity of the variable flag and a step S3222 for checking the trueness of the variable visited. As a result, after the variable visited of the child function f_A3 is set to true, the process proceeds to the subroutine execution step S32204.
In the subroutine execution step S32204, the execution of the subroutine S321 is further started with the function f set as the child function f_A3.
In the PATH addition step S3210, the child function f_A3 set in the function f in the subroutine execution step S32204 is added to the end of the PATH. That is, PATH is a parent function f_MAIN, a child function f_A2 called from the parent function f_MAIN, a child function f_B2 called from the child function f_A2, and a child function f_A3 called from the child function f_B2.
Stage 4: Stage 4 is a stage representing the fourth start time of the subroutine execution step S32102 in the flowcharts shown in FIGS. From this state, the subroutine S322 is started for the child function f_B2 and the child function f_B3 that are the call destination functions of the function f_A3. Here, the case where the subroutine S322 is started for the child function f_B2 first is shown.

Stage 5: Stage 5 is a stage that represents the start time immediately after stage 4 of step S32202 for checking the truth of the variable visited indicating whether or not the call in the flowcharts shown in FIGS. Here, the variable visited for the child function f_B2 is true, and the variable flag is false. This is because the variable visited setting step S32203 is performed on the child function f_B2 in the previous stage of the stage 5, and the variable visited of the child function f_B2 is set to true. As a result, the process proceeds to the recursive call unit setting step S32206, where the child function f_B2 and the child function f_A3 are extracted as recursive call units, and CYCLE = (f_B2, f_A3) is obtained. Next, the process proceeds to step 32207 where the recursive reduction process S33 is performed, and the recursive reduction process S33 is performed with CYCLE = (f_B2, f_A3) as an argument, so that the child function f_B2 and the child function f_A3 are regarded as one function. Get the call graph.
Next, the process proceeds to a variable flag setting step S32208, and the variable flag is set to true. Then, the subroutine S322 for the child function f_B2 as a call destination of the child function f_A3 is ended. Then, it returns to the place where the subroutine S322 of stage 4 is started.
Subsequently, the subroutine S322 is started for the child function f_B3 as a call destination function of the child function f_A3. Since the variable flag is set to true in the variable flag setting step S32208, the process checks the truth of the variable flag S32201. Then, the subroutine S322 is terminated. Thereafter, unless the initialization step S3201 is executed again and the variable flag is returned to false, the subroutine S322 is newly executed as a subroutine that does nothing. Subsequently, the process proceeds to the PATH deletion step S32103.

In the PATH deletion step S32103, the PATH so far is the parent function f_MAIN, the child function f_A2 called from the parent function f_MAIN, the child function f_B2 called from the child function f_A2, and the child function f_A3 called from the child function f_B2. However, the child function f_A3 at the end of the PATH is deleted, and the PATH becomes a parent function f_MAIN, a child function f_A2 called from the parent function f_MAIN, and a child function f_B2 called from the child function f_A2.
Then, when the subroutine S321 in the stage 4 is finished, the variable visited setting step S32205 returns the variable visited regarding the child function f_A3 to false, and the subroutine S322 is finished. Then, it returns to the subroutine execution process S32102 which started the subroutine S322 in the stage 3.
In the subroutine execution step S32102, the subroutine S322 is newly executed with respect to another child function f_B2 called from the child function f_A3. However, since the variable flag is true, the subroutine ends without doing anything.
Subsequently, in the PATH deletion step S32103, the PATH so far is the parent function f_MAIN, the child function f_A2 called from the parent function f_MAIN, and the child function f_B2 called from the child function f_A2. The function f_B2 is deleted and the PATH is changed to a parent function f_MAIN and a child function f_A2 called from the parent function f_MAIN, and the subroutine S321 in the stage 3 is ended.
When the subroutine S321 in the stage 3 is finished, the variable visited for the child function f_B2 is returned to false by the variable visited setting step S32205, and the subroutine S322 is finished. Then, it returns to the subroutine execution process S32102 which started the subroutine S322 in the stage 2.
In the subroutine execution step S32102, since there is no child function called from the child function f_A2 other than the child function f_B2, the process proceeds to the PATH deletion step S32103. In the PATH deletion step S32103, the previous PATH is the parent function f_MAIN and the child function f_A2 called from the parent function f_MAIN. The child function f_A2 at the end of the PATH is deleted, and the PATH becomes the parent function f_MAIN. The subroutine S321 in 2 is finished.
When the subroutine S321 in stage 2 ends, the variable visited setting step S32205 returns the variable visited regarding the child function f_A2 to false, the subroutine S322 ends, and the subroutine returns to the subroutine execution step S32102 that started the subroutine S322 in stage 2. Come.
In the subroutine execution step S32102, the subroutine S322 is newly executed for another child function f_A3 called from the child function f_MAIN. However, since the variable flag is true, the subroutine ends without doing anything. In the PATH deletion step S32103, the previous PATH is the parent function f_MAIN, the child function f_MAIN at the end of the PATH is deleted, the PATH is emptied, and the subroutine S321 in the stage 1 is ended. Then, when the subroutine S321 in the stage 1 is finished, the process proceeds to the flag determination step S3203.
In the flag determination step S3203, since the variable flag is set to true in the variable flag setting step S32208, the process returns to the initialization step S3201.
Thereafter, in order to detect other recursive calling units, the subroutine execution step S3202 and subsequent steps are executed again on the static call graph obtained in step 32207 in which the recursive degeneration step S33 is performed. However, since there is no recursive calling part in this call graph, all of the child functions are checked in the variable verified setting step S32203 for checking whether the variable visited indicating whether or not the call has been made. Then, the recursive calling step S32A for detecting the recursive reading unit is completed.

  FIG. 8 is a diagram for explaining the recursive degeneration step S33. The recursive degeneration step S33 is a routine that receives the output from the call relationship extraction step S31, the output from the recursive call unit setting step S32206, and the function size information 3304, and executes steps S3301, S3302, and S3303. As a result, the recursive degeneration step S33 outputs a recursive call processed static call graph 3305, function degenerate information 3306, and recursive call processed function size information 3307.

The output from the call relationship extraction S31 and the output from the recursive call unit setting step S32206 have been described in the explanatory texts for FIGS.
The function size information 3304 is the data size of the source code that defines the parent function (f_MAIN) and the child functions (f_A2, f_A3, etc.).

Step S3301 performs a replacement operation for replacing each function related to the detected recursive call with the same function name in the static call graph as the output from the call function extracting step S31. The replacement rule at this time is stored as function degeneration information 3306. The replacement rule includes information on the same function name used in the replacement operation. And after completion | finish of process S3301, said function degeneracy information 3306 is output for process S3302 and process S3303. A specific example of the replacement process in step S3301 is shown in FIG.
Step S3302 is a step of deleting and integrating function call relationships (entries) using the function degeneration information 3306. That is, as a result of the replacement operation in step S3301, if a function call relationship (entry) in which the call source function and the call destination function are the same is generated, the function call relationship is deleted from the static call graph. In addition, when the call source function and the call destination function are the same in a plurality of function call relationships (entries) and a duplicate function call relationship occurs, a plurality of function call relationships (entries) are expressed in the static call graph. Integrated into one. As a result, the function related to the recursive call is described as a function regarded as one on the static call graph. When step S3302 ends, a static call graph 3305 that has been subjected to recursive call processing is output from the static call graph after the function call relationship (entry) is deleted and integrated. A specific example of the deletion and integration of the function call relationship (entry) is also shown in FIG.
Step S3303 is a step of creating recursive call processed function size information using the function degeneration information 3306. That is, based on the function size information 3304, the function size of the function assumed to be one is estimated. In step S3303, the function size information 3307 is created by adding the function size of the function that is assumed to be one to the function size information 3304. A specific example of the process in step S3303 is shown in FIG.

FIG. 9 shows an example of a specific processing operation in the recursive degeneration step S33. FIG. 9 illustrates the output of the call-related output S31, the output of the recursive call unit setting step S32206, the output of the step S3301, the function size information 3304, and the output of the recursive degeneration step S33.
In the output of the call relationship output step S31, the parent function (f_MAIN) has a relationship of calling the child function f_A2 and the child function f_A3, the child function f_A2 has a relationship of calling the child function f_B2, and the child function f_A3 has the relationship of calling the child function f_B2, child It is described that the function f_B3 is called and the child function f_B2 is called to call the child function f_A3 and the child function f_B3.
The output of the recursive call unit setting step S32203 describes that the child function f_B2 and the child function f_A3 are in a recursive call relationship. Therefore, in step S3301, the child function f_A2 and the child function f_B2 are replaced with a function f_B2 * f_A3 in which the child function f_B2 and the child function f_A3 are regarded as one with respect to the output of the call relation output step S31. Then, the function degeneration information 3306 stores that the function f_B2 * f_A3 regarded as one is {f_B2, f_A3}.

The output of the recursive degeneration step S33 includes the output of the step S3302, a part of the output of the step S3301, and the output of the step S3303. Here, part of the output of step S3301 is function degeneration information 3306.
In step S3302, there are a plurality of relations for calling the function f_B2 * f_A3 assumed to be one from the function f_B2 * f_A3 assumed to be one of the outputs of the step S3301, so that one of them is left. delete. In step S3302, since there are a plurality of functions that call the child function f_B3 from the function f_B2 * f_A3 that is regarded as one, they are integrated into one. As a result, a recursive call processed static call graph 3305 is formed.
In step S3303, based on the function size information 3304, the parent function, the child function, and the function f_B2 * f_A3 regarded as one existing in the recursive call processed static call graph 3305 are estimated. As a result, recursive call processed function size information 3307 is formed.

FIG. 10 is a flowchart for explaining the memory allocation step 34. The memory allocation step 34 includes a parent function placement step S3401, a total code size calculation step S3402, a memory allocation step S3403 with power control, and an address calculation step S3404.
In order to execute the memory allocation process 34, the recursive static call graph displayed as b output from the recursive degeneration process S33, the recursive function size information displayed as c, and the function degeneration displayed as d. Information 3407 including information is used. Further, in order to execute the memory allocation step 34, the memory structure information 3408 labeled a is used. Further, in order to execute the memory allocation step 34, information 3409 including a static call graph labeled e and function size information labeled f is used. Information 3407 and information 3409 are information obtained from the source code, the object, or the assembly 3411.
In the parent function selection step S3401, a memory area is allocated to the code related to the parent function. In allocating the memory area, the memory structure information indicated as a, the recursive static call graph indicated as b, and the recursive function size information indicated as c are used.
In the total code size calculation step S3402, code sizes are calculated for all functions in order to secure a memory area. In calculating the code size, the recursively called function size information indicated as c is used. Furthermore, it grasps the code size for a function that is regarded as one function. In recognizing the code size, the recursively called function size information indicated as c is used.
In the allocation step S3403 to the memory with power control, a function regarded as one function is allocated to a single memory bank from the code size of the function regarded as one function and the memory structure information indicated as a. As described above, a function that assumes a memory area as one function is allocated. When allocating a memory area for a function that is regarded as one function, the memory structure information indicated as a and the result of the total code size calculation step S3402 are used.
In the address calculation step S3404, all the functions are assigned to the memory area, and memory map information is created for the memory area and the function assigned to the memory area. Note that when assigning a function to a memory area, a static graph indicated by e in FIG. 10 and function size information indicated by f are used. The static graph indicated by e and the function size information indicated by f are preferably those obtained in the call relationship extraction step S31.

FIG. 11 is a diagram showing an assignment state of program source codes related to functions. FIG. 11 shows the allocation status of the program source code related to the function from the memory bank 11a to the memory bank 16a and from the memory bank 11b to the memory bank 16b.
The upper part of FIG. 11 shows an allocation situation when the storage area allocation method according to the present embodiment is not applied to the program source code. In the upper part of FIG. 11, the dotted line area displayed as an example portion corresponds to the function call status shown in the static call graph described in FIG. 4.

When the storage area allocation method according to the first embodiment is not applied, the allocation is performed in the following order.
In the program source code, the first layer function that is directly called from the parent function is arranged in the memory bank in order of address. Next, the second layer function that is further called from the first layer function is disposed when it can be disposed in the same memory bank as the first layer function. However, recursive calls are not considered.
Therefore, in the example part surrounded by the dotted line figure, the child function f_A2 of the first hierarchy and the child function f_B2 of the second hierarchy called from the child function f_A2 are allocated to the memory bank 13a. The child function f_A3 in the first hierarchy and the child function f_B3 in the second hierarchy called from the child function f_A3 are allocated to the memory bank 14a.

  The child function f_A1 and the child function f_C1 are allocated to the memory bank 12a. The child function f_B1 and the child function f_D1 are assigned to the memory bank 13a. The child function f_A4 and the child function f_B4 are assigned to the memory bank 15a. The child function f_A5, child function f_B5, and child function f_C2 are allocated to the memory bank 16a. The parent function f_MAIN is assigned to the memory bank 11a.

On the other hand, the lower part of FIG. 11 shows an allocation state when the storage area allocation method according to the first embodiment is performed on the program source code.
When the storage area allocation method according to the first embodiment is applied, the allocation is performed as follows.

  In the example part surrounded by the lower dotted line figure corresponding to the example part in the upper part of FIG. 11, the child function f_A2 in the first hierarchy is assigned to the memory bank 13b. Also, the function f_B2 * f_A3 that is regarded as one is assigned to the memory bank 14b as a child function of the first hierarchy. Here, in the upper part of FIG. 11, the child function f_B3 is a single child function, but by applying the storage area allocation method according to the first embodiment, the child function f_B3 is regarded as one child function f_B3. * F_B4 * f_B5 * f_C2 became a constituent element. As a result, the child function f_B3 is arranged in the memory bank 15b as a part of the child function f_B3 * f_B4 * f_B5 * f_C2 in the second hierarchy in the lower part of FIG.

  The child function f_A1 and the child function f_C1 are allocated to the memory bank 12b. The child function f_B1 and the child function f_D1 are assigned to the memory bank 13b. The child function f_A4 is assigned to the memory bank 15b. The child function f_A5 is assigned to the memory bank 16b. The parent function f_MAIN is assigned to the memory bank 11b.

The child function f_A3 and the child function f_B2 shown in the upper part of FIG. 11 have a recursive call relationship, but the child function f_A3 and the child function f_B2 are arranged in different memory banks. Then, the CPU sets the memory bank 13a and the memory bank 14a to the normal power supply state at the same time. This is because if one of the memory bank 13a or the memory bank 14a is in a power saving supply state and the other is in a normal power supply state, recursive calls cannot be made to each other.
On the other hand, the child function f_A3 and the child function f_B2 shown in the lower part of FIG. 11 are arranged in the same memory bank 14b as the child function f_B2 * f_A3 regarded as one. Accordingly, in order to perform the calling operation related to the child function f_B2 * f_A3 regarded as one, only the memory bank 14b needs to be in the normal supply state, and the memory bank 13b can be maintained in the power saving supply state.
Therefore, in the memory system 50 according to the first embodiment, an allocation method for allocating a storage area to the code included in the program according to the first embodiment is performed. The CPU included in the memory system 50 performs the memory bank according to the function call state. If the power supply state is controlled, the number of memory banks in the normal power supply state can be reduced. As a result, the power consumption of the memory system 50 can be reduced by implementing the allocation method for allocating the storage area to the code included in the program of the first embodiment.

  In the above description, the power supply state of each memory bank is controlled according to the assignment state of the source program code related to the function assigned to the memory bank by the CPU. However, even if the CPU generates an execution program with power supply control from the source program by the method shown in FIG. 12 and the CPU controls the power state of the memory bank by the control by the execution program with power supply control, Power consumption can be reduced.

FIG. 12 is a flowchart illustrating a memory system 120 that is a modification of the first embodiment and a method for generating an execution program with power supply control generated in the memory system 120. The left half of FIG. 12 is a flowchart for explaining a method for generating an execution program with power supply control, and the right half shows a memory system 120 which is a modification of the first embodiment.
The execution program generation method shown in the flowchart of FIG. 12 includes a compilation step S1, a control position calculation step S2, a memory map determination step S3, a control parameter determination / control code insertion step S4, and an assemble / link step S5.
In the compiling step S1, the source program is read into a processor in the CPU 110 and converted into assembly code or an object.
In the control position calculation step S2, the processor in the CPU 110 detects an assembly code or an object that controls on / off of the memory bank.
In the memory map (layout) determination step S3, the call relationship extraction step S31 to the memory allocation step S34 are performed to determine the memory map and output the memory map information.
Here, the memory map is a map indicating the correspondence between the assembly code or object representing the recursive calling unit and the address of the memory bank indicating the location where the assembly code or object is stored. The memory map information is composed of data representing the memory map with codes.
In the control parameter determination / control code insertion step S4, the position of the assembly code or object for controlling on / off of the memory bank is corrected based on the memory map information.
In the assemble and link step S5, the assembly code for controlling on / off of the memory bank or a program in which the position of the object is corrected is stored in the program storage area as an execution program with power control.

The right half of FIG. 12 shows the memory system 120. The memory system 120 includes a CPU 110, a control register group 30, a power supply line 45, a power supply control device 46, a memory unit 10, and a bus 40.
In the description of FIG. 1, the control register group 30, the power supply line 45, the power supply control device 46, the memory unit 10, and the bus 40 have been described.
The CPU 110 includes a processor, a memory controller, a source program storage area, and an execution program storage area with power control. In the description of FIG. 1, since the memory controller has already been described, description thereof is omitted. The source program storage area is an area for storing a source program given from the outside. The execution program storage area with power control is an area in which the CPU 110 itself stores the execution program with power control generated from the source program.
As described above, the memory system 120 holds the execution program with power supply control generated from the source program in the CPU as compared with the memory system 50 shown in FIG. 1, and easily controls the memory unit 10. be able to.

FIG. 13 is a diagram illustrating an allocation method for allocating storage areas to codes included in a program according to the second embodiment.
The allocation method for allocating a storage area to a code included in a program according to the second embodiment includes a call relation extraction step S35, a recursive call extraction step S32A, a recursive read processed static call graph creation step S32B, a recursive call degeneration step S36, And memory allocation process S37 is included.
The recursive call extraction step S32A and the recursive read processed static call graph creation step S32B are the same as the steps denoted by the same reference numerals as shown in FIG.
In the call relationship extraction step S35, the program source code, assembly, or object is scanned, and the number of function calls is counted for each function that appears. Next, a weight is added to the function call according to the count, and a static call graph with weight information is created. The recursive call extraction step S32 will be further described with reference to FIG.
In the recursive degeneration process S36, when a recursive call part is detected in the recursive call extraction process S32A, a recursive degeneracy that combines the recursive call parts is performed. That is, a function related to the recursive call unit is assumed to be a function having weighting information. Note that the function size information 81 is used in the recursive degeneration step S36. The recursive degeneration step S36 will be further described with reference to FIGS.
In the memory allocation step S37, a memory area is allocated as a unit with respect to the function regarded as one weighted. That is, a function that is regarded as one is stored in the same memory bank. The function regarded as one is extracted from the code obtained from the source code, the assembly, or the object 82.

FIG. 14 shows a flowchart, a static call graph, and an output data table after the call extraction related to the call relationship extraction step S35.
The static call graph with weight information shown in FIG. 14 is the same as the static call graph shown in FIG. However, the difference is that weighting is performed according to the number of calls in the function call relationship.
The output data table of the call relationship extraction step S35 in FIG. 14 is an output data table corresponding to the static call graph with weight information in FIG. In addition to the items described in the output data table of FIG. 4, the third column is different in that numerical values of weights for function calling relationships are described in the third column.
According to the flowchart of FIG. 14, the call relation extraction step S35 includes a function-specific call count counting step S351, a weighting step S352, a static call graph with weight information creation step S353, and a data creation step S354 related to the static call graph. .

The function-specific call count step S351 is a process of counting the number of calls from a call source function to a call destination function in response to an assembly, an object, and a function call history.
The weighting step S352 is a step of assigning a weight to the calling relationship between the function serving as the call source and the function serving as the call destination based on the number of calls in the function-specific call count counting step S351.
Here, the number of child function calls performed by the parent function f_MAIN based on the calling relationship in the program source code, assembly, or object is defined as the number of source code calls. Further, when the program is executed, the number of calls of the child function performed by the parent function f_MAIN based on the function format of the parent function f_MAIN, that is, based on the argument or the like, is set as the number of function-dependent calls. Since the source code call count is uniquely determined by the program source code, assembly, or object, it can be said to be a static call count. On the other hand, the number of function-dependent calls can be said to be a dynamic number of calls because the number of calls increases or decreases depending on an input argument or the like.
Therefore, the function-dependent call count is set as a weight for the source code call count, and the source code call count is set as the function-dependent call count.
Here, it is assumed that the number of function-dependent calls is X (= A11 + A12 +... + A1m + A21 + A22 +... + A2m) and the number of source code calls is Y (= Y1 + Y2). Here, in the program code, the number of calls to the source code of the child function f_A1 from the parent function f_MAIN is Y1, and for each call in the source code, the function-dependent call of the child function depending on the function form of the parent function The number of times is A11, A12,... A1m (m is a positive integer). The number of calls to the source code of the child function f_A2 corresponding to the parent function f_MAIN in the program code is Y2. Further, for each call in the source code, the function-dependent call of the child function depending on the function form of the parent function. The number of times is A21, A22,... A2m (m is a positive integer). Then, the weight is expressed as follows.
Weight P (f_MAIN, f_A1) = (Y1 × X + A11 × Y + A12 × Y +... + A1m × Y)
Weight P (f_MAIN, f_A2) = (Y2 × X + A21 × Y + A22 × Y +... + A2m × Y)
For example, if the child function f_A1 is called three times and the child function f_A2 is called twice in the program code corresponding to the parent function f_MAIN, the weight from the parent function f_MAIN to the child function f_A2 is set to 3, and the parent function The weight from f_MAIN to the number f_A2 is 2. Also, there are 10 calls from the parent function f_MAIN to the child function f_A1, 20 calls to the child function f_A2, 10 calls from the parent function f_MAIN to the child function f_A2, and 40 calls from the parent function f_MAIN to the child function f_A3. To do.
Weight P (f_MAIN, f_A1) = (3 × 80 + 5 × 10 + 5 × 10) = 340
Weight P (f_MAIN, f_A2) = (2 × 80 + 5 × 20 + 5 × 40) = 460
It becomes.
The static call graph with weight information creation step S353 is a step of creating a static call graph to which weight information is added and creating data related to the static call graph.

  FIG. 15 is a diagram for explaining the recursive degeneration step S36. The recursive degeneration step S36 is a routine that receives the output from the call relationship extraction step S35, the output from the recursive call setting step S32206, and the function size information 3604, and executes step S3601, step S3602, and step S3603. As a result, the recursive degeneration step S36 outputs a recursive call processed static call graph 3605, function degeneration information 3606, and recursive call processed function size information 3607.

Step S3601 performs a replacement operation for replacing each function related to the detected recursive call with the same function name in the static call graph as an output from the call function extraction S31. The replacement rule at this time is stored as function degeneration information 3606. The replacement rule includes information on the same function name used in the replacement operation. And after completion | finish of process S3301, said function degeneracy information 3606 is output for process S3602 and process S3603. A specific example of the replacement processing in step S3601 is shown in FIG.
Step S3602 is a step of deleting and integrating function call relationships using the function degeneration information 3606. In other words, as a result of the replacement operation in step S3301, if a function call relationship in which the call source function is the same as the call destination function is generated, the function call function is deleted from the static call graph. In addition, when the call source function and the call destination function are the same in a plurality of function call relationships and an overlapping function call relationship occurs, the plurality of function call relationships are integrated into one in the static call graph. . As a result, the function related to the recursive call is described as a function regarded as one on the static call graph. When step S3602 ends, a static call graph 3605 that has been subjected to recursive call processing is output from the static call graph after the function call relationship is deleted and integrated. A specific example of the deletion and integration of the function call relationship is also shown in FIG.
Step S3603 is a step of creating recursive call processed function size information using the function degeneration information 3606. That is, based on the function size information 3604, the function size of the function assumed to be one is estimated. Moreover, the weight of the function regarded as one is the sum of the weight of the function related to the recursive call. In step S3603, the function size information 3607 is created by adding the function size of the function that is regarded as one to the function size information 3604. A specific example of the process of step S3603 is shown in FIG.

FIG. 16 shows an example of a specific processing operation in the recursive degeneration step S36. FIG. 16 illustrates the output of the call relation output step S35, the output of the recursive call setting step S32206, the output of the step S3601, the function size information 3304, and the output of the recursive degeneration step S36.
The output of the call relationship extraction step S35 includes a column for displaying the weight of the call relationship in addition to the output of the call relationship output step S31. In the column for displaying the weight of the call relationship, the weight for the call relationship from the parent function f_MAIN to the child function f_A2 is 150, the weight for the call relationship from the parent function f_MAIN to the child function f_A3 is 450, and the parent relationship f_A2 to the child relationship f_B2 The weight of the calling relationship is 200, the weight for the calling relationship from the parent function f_A2 to the child function f_A3 is 100, the weight for the calling relationship from the parent function f_A3 to the child function f_B3 is 330, and the calling relationship from the parent function f_B2 to the child function f_A3 Is 300, and the weight for the calling relationship from the parent function f_B2 to the child function f_B3 is 50. Note that the example of the weight in S35 of FIG. 16 is an example different from the example shown in FIG.

The output of the recursive reduction process S36 includes the process S3602, a part of the output of the process S3601, and the output of the process S3603. Here, part of the output of step S 3601 is function degeneration information 3606.
In step S3602, the function f_B2 * f_A3 ascertained with respect to the function calling relationship in the output of step S3601 is deleted and integrated in the same manner as in step S3302. However, step S3602 is different from step S3302 in that a weight is added to one assumed function f_B2 * f_A3. As a result, a recursive call processed static call graph 3605 is formed.
In step S3603, the code size of the parent function, the child function, and the function f_B2 * f_A3 regarded as one is estimated. As a result, recursive call processed function size information 3607 is formed.

FIG. 17 is a flowchart illustrating the memory allocation step S37 according to the embodiment. The memory allocation step S37 includes a parent function selection step S3701, a memory allocation step S3702 without power control, a total code size calculation step S3703, a call frequency calculation step S3704, a memory allocation step S3705 with power control, and an address calculation step S3706.
In order to execute the memory allocation step S37, the recursive static call graph displayed as b output from the recursive reduction step S36, the recursive function size information indicated as c, and the function reduction indicated as d. Information 3707 including information is used. In order to execute the memory allocation step 37, the memory structure information 3708 labeled a is used. Further, in order to execute the memory allocation step S37, information 3709 including the static call graph indicated as e and the function size information indicated as f is used. Information 3707 and information 3709 are information obtained from the source code, object, or assembly 3711.
In the parent function selection step S3701, the call source function having the highest call frequency is selected as the parent function of the function for all functions except the main function. In selecting a parent function, a recursive static call graph, source code, object, or assembly 3711 labeled b is used. By this process, the hierarchy of the parent-child relationship with the main function as the vertex is specified.
In the memory allocation process S3702 without power control, a function in a certain call hierarchy is selected from the main function in the parent-child relation hierarchy with the main function specified in the parent function selection process S3701 as a vertex (for details, see Patent Literature 5), the selected function is assigned to a memory bank for which power control is not performed. In order to assign the selected function to the memory bank, the memory structure information 3708 indicated by a and the recursive call processed function size information indicated by c are used.

  In the total code size calculation step S3703, for each function belonging to the layer immediately below the parent-child relationship layer of the function assigned to the memory bank for which power control is not performed, a function group having each function as a representative function is created. The total code size of the group is calculated by the sum of the code sizes constituting the function group. This result is stored as a total code size table. A function group having each function as a representative function is a representative function descendant function (call destination function, call destination function call destination function, call destination function call destination function). ... indicates all). In calculating the total code size, the recursively processed function size information indicated as c is used. Further, the information on the number of call layers used in the memory allocation process without power control S3702 is also used in the total code size calculation process S3703.

In the call frequency calculation step S3704, the call frequency between the function groups configured in the total code size calculation step S3703 is calculated using the recursive call processed static call graph indicated as b. This result is stored as a call frequency table between function groups.
In step S3405 for allocating memory with power control, a memory area is allocated for a function other than the function allocated to the memory without power control. In allocating a memory area to a function, memory structure information indicated as a, a total code size table calculated in the total code size calculation step S3703, and a call frequency table between function groups calculated in the call frequency calculation step S3704 use. By assigning each function group configured in the total code size calculation step S3703, the call destination function having the highest call frequency from the call source function is placed in the same memory bank as the call source function, and the call frequency By using the result of the calculation step S3704, the call frequency for the second and subsequent functions can be assigned to the same memory bank as the call source function as much as possible.
In the address calculation step S3706, among the functions assigned in the memory allocation step S3702 without power control and the memory allocation step S3705 with power control, the functions combined by the recursive degeneration step S36 are restored to the original functions. Thereafter, a start address is calculated for each function, and memory map information is created. In calculating the start address and creating the memory map information, the memory structure information indicated by a, the function degeneration information indicated by d, the static call graph indicated by e, and the function size information indicated by f are used. Also, the allocation result in the memory allocation step S3702 without power control and the allocation result in the allocation step S3705 to the memory with power control are used.

As described above, in the memory system 50 according to the first embodiment, the allocation method for allocating the storage area to the code included in the program according to the second embodiment is performed, and the CPU included in the memory system 50 performs By controlling the power supply state of the bank, the number of memory banks in the normal power supply state can be reduced. Here, when the allocation method for allocating the storage area to the code included in the program of the second embodiment is performed, a call destination child function having a high call frequency is selected for the call source child function, and the call destination child function is selected in the same bank. Can be assigned. Then, compared to the case where the child function is assigned to the memory area by the assignment method of the first embodiment, the number of memory banks in which the child function is assigned to the memory area by the assignment method of the second embodiment is more normally supplied. Can be reduced.
If there are multiple callee child functions for the caller child function, assign a child function with a low call frequency to the same bank, while assign a child function with a high call frequency to another memory bank. This is because the frequency of setting to the normal power supply state increases.

In the second embodiment, an attempt is made to assign a call destination child function having a high call frequency to the same memory bank, but the memory capacity of the assignment destination memory bank is small, and all the call destination child functions are assigned to the same memory bank. It is assumed that it cannot be assigned. In this case, when the program of the third embodiment shown below is executed in the memory system 50, functions that are not assigned to the same memory bank are assigned to a predetermined memory bank. Here, the memory allocation process of the third embodiment is a process including a memory allocation unit with power control S4005 shown below instead of the memory allocation unit with power control S3705 in the memory allocation process S37 of the second example.
18A and 18B show the power allocation memory allocation unit S4005 according to the third embodiment.
The memory allocation process of the third embodiment includes a parent function selection process S3701, a memory allocation process without power control S3702, a total code size calculation process S3703, a call frequency calculation process S3704, a memory allocation process S4005 with power control, and an address calculation process. Including S3706. Among these, the parent function selection step S3701, the memory allocation step without power control S3702, the total code size calculation step S3703, the call frequency calculation step S3704, and the address calculation step S3406 are the same as those in the second embodiment. Execution of the memory allocation step S4005 with power control according to the third embodiment executes the following steps after the start.
First, the remaining memory size variable initialization step S400501 is performed. The remaining memory area size variable initialization step S400501 is a process of initializing the value of the variable m_rest that stores the remaining memory area size. That is, for the memory bank M that is not subjected to the power control allocated in the power allocation without memory control step S3702, the value of m_rest (m_rest [M]) is 0, and the value of m_rest for the other memory banks M (m_rest [ M]) is initialized with the capacity of the memory bank M.
Next, step S400502 for selecting a function group having the maximum total code size is performed. In step S400502 of selecting the function group having the maximum total code size, the total code size table is scanned, and the function group having the maximum code size is selected from the function groups not currently allocated to the memory bank and set as the maximum function group F_Max. In the third embodiment and the fourth embodiment which will be described later, the “function group” means a function group configured in the total code size calculation step S3703.
Next, step S400503 for determining the arrangement of the maximum function group is performed. Step S400503 for determining the placement of the maximum function group is a step for determining whether a memory bank in which the maximum function group F_Max can be placed can be detected. If a memory bank in which the maximum function group F_Max can be arranged is detected, the process proceeds to step S400504 for updating the remaining memory size variable. On the other hand, if the memory bank in which the maximum function group F_Max can be placed cannot be detected, the process proceeds to the maximum function group F_Max placement routine (including the remaining memory bank update step S400516 from the memory bank recognition step S4000051).

In step S400504 for updating the remaining memory size variable, the code amount (s (F_Max)) of the function group F_Max having the maximum code size is set to the remaining memory area size (in the memory bank detected in step S400503 for determining the placement of the maximum function group). This is a step of subtracting from m_rest [M]) and updating the remaining memory area size (m_rest [M]) of the memory bank after the maximum function group F_Max is arranged.
Next, step S400505 for generating a set Γ by call frequency recognition is performed. S400505 for generating the set Γ by the call frequency recognition step is a step for generating the set Γ including the function group F that is in a calling relationship from the maximum function group F_Max and is not assigned to the memory bank. Note that the determination of the call relationship from the maximum function group F_Max is made when the call frequency Q (F_Max, F) from the maximum function group F_Max is truly greater than zero. The call frequency Q (F_Max, F) is the sum of the weight P (φ, ψ) and the weight P (ψ, φ) for the combination of the function φ included in the function group F_Max and the function ψ included in the function group F. It is obtained by calculating all combinations and summing all calculated sums. However, since the functions included in the function group F_Max have already been assigned, and the call frequency Q (F_Max, F_Max) is excluded from the set Γ even if calculated as described above, the value of the call frequency Q (F_Max, F_Max) Is 0. That is, the call frequency Q (F_Max, F) is expressed by the following equation.
(Equation 1)
When Q (F_Max, F) = 0 F = F_Max
Σ (P (φ, φ) + P (φ, φ)) When F ≠ F_Max
φ∈F_Max
ψ∈F
Here, φ indicates a function included in the function group F_Max. ψ indicates a function included in the function group F.
Next, step S400506 is performed to determine whether the set Γ is an empty set. If the set Γ is an empty set, the process advances to step S400212 to determine whether the memory allocation has been completed. On the other hand, when the set Γ is not an empty set, the process proceeds to a memory area allocation routine S400507. The memory area allocation routine S400507 is a function other than the maximum function group F_Max, and is a routine for allocating memory areas for functions belonging to the set Γ, and will be described with reference to FIG. 18B.

The memory bank recognition step S400313 is a step of recognizing a memory bank in which the remaining memory area exists and naming it as M1, M2,..., Mn (n is a positive integer) in descending order of the remaining memory area size. If there are memory banks with the same value of the remaining memory area size, the memory banks with the same value, the memory bank with the remaining memory area size next to the memory bank with the same value, and the same value If a memory bank having the smallest remaining memory area size next to a certain memory bank is named so that addresses are continuous as much as possible, a desirable result is obtained for the reason described later.
Next, step S400514 of recognizing a memory bank to which the maximum function can be assigned is performed. In the step S400514 of recognizing the memory bank to which the maximum function can be allocated, the remaining memory areas are added in descending order, and the added memory area is larger than the code size of the maximum function group F_Max. Detect whether it hits a bank. That is, m that satisfies m_rest [M1] + m_rest [M2] +... + M_rest [Mm] ≧ s (F_Max) (m is a positive integer equal to or less than n) is detected. Here, s (F_Max) represents the code size of the maximum function group F_Max.

Next, a memory area allocation step S400515 is performed. The memory area allocation step S400515 is a step of allocating the maximum function group F_Max to a plurality of memory banks from M1 to Mm. A more desirable result is obtained when the addresses are continuous from the memory banks M1 to Mm. For example, as shown in FIG. 19D later, the memory bank 400521 and the memory bank 400522 having consecutive addresses are selected as the memory area to which the maximum function group F_Max is assigned, which is a desirable result. This is because if a memory bank having consecutive addresses is selected, a branch instruction for moving between memory banks can be omitted, and the power consumption of the processor can be reduced.
Next, a remaining memory area size update step S400516 is performed. The remaining memory area size update step S400516 is a step for performing the following operation. First, after setting m_rest [Mi] = 0 (i = 1,..., M−1), m_rest [Mm] = (m_rest [M1] + m_rest [M2] +... + M_rest [Mn]) − s (F_Max). Here, s (F_Max) represents the code amount of the maximum function group F_Max. That is, the remaining memory area size of the 1st to (m-1) th memory banks is set to 0, and the size of the portion of the maximum function group F_Max that cannot be arranged in the 1st to (m-1) th memory banks is set. , Subtract from the original memory area size of the mth memory bank to obtain the remaining memory area size of the mth memory bank.
When the remaining memory area update step S400516 is completed, the process proceeds to a call frequency recognition step S400505.

  Step S40052 for determining whether the memory allocation has been completed is a step for determining whether a memory area has been allocated for all the functions in the total code size table. That is, after a function included in the maximum function group F_Max and a function included in the function group having a calling relationship with the maximum function group F_Max are allocated to the memory area, the total code size table is not allocated to the memory area. This is a step of determining whether or not there is a function group. Here, when it is determined that another function group exists in the total code size table and the allocation of the memory area is not completed for the function group, the process proceeds to step S400502 for selecting the function group having the maximum total memory size. . On the other hand, if it is determined that the memory area allocation has been completed, the memory allocation process of the third embodiment is terminated.

FIG. 18B is a flowchart for describing the memory area allocation routine S400507.
The memory area allocation routine S400507 includes a process S400508 for selecting a function group F_Rel having the maximum call frequency, a determination process S400509 for a remaining memory area size (m_rest [M]), a process S400510 for allocating a function to the remaining memory area, Γ update step S40011.

In step S400508, the function group F_Rel having the maximum calling frequency is selected, and the function having the maximum calling frequency with the maximum function group F_Max is selected from the function group F included in the set Γ and set as the function group F_Rel. However, when there are a plurality of functions having the same call frequency, the function having the maximum code size is selected from the function groups that are candidates for the function group F_Rel having the maximum number of calls.
The remaining memory area size determining step S400509 is a step of determining whether the remaining memory area size (m_rest [M]) of the memory bank M is equal to or larger than the code amount of the function group F_Rel having the maximum calling frequency. However, the memory bank M indicates the memory bank assigned in step S400503 for determining the placement of the maximum function group, or the memory bank Mm in the memory area assignment step S400515. Which is pointed depends on the determination result in step S400503 for determining the placement of the maximum function group. If the remaining memory area size (m_rest [M]) is greater than or equal to the code amount (s (F_Rel)) of the function group F_Rel, the process proceeds to step S400510 for assigning the function group F_Rel to the remaining memory area, and the remaining memory area size (m_rest) If [M]) is truly smaller than the code amount (s (F_Rel)) of the function group F_Rel, the process proceeds to the set Γ update step S40011.

  The set Γ update step S40011 is a step of updating the set Γ by removing the function group F_Rel from the function group set Γ having a calling relationship from the maximum function group F_Max. This process is performed regardless of the result of the remaining memory area size determination process S400509. When the maximum call frequency function group F_Rel is larger than the remaining memory area size (m_rest [M]) of the memory bank M, the function group is not allocated to the memory area, but the memory allocation is completed. Through the step S40052 for determining whether or not the memory area is allocated, the memory area is allocated from the memory bank recognition process S4000051 to the remaining memory area size update process S400516.

  As described above, when the set Γ of the function group F having the calling relationship from the function group F_Max is not empty, the process enters the memory area allocation routine S400507 and ends the process S40011 for updating the set Γ. The process proceeds to step S400506 for determining whether or not.

FIG. 19 shows a specific example in which a function is allocated to each memory bank in the memory allocation step S4005 according to the third embodiment.
19A to 19C show the results of performing the total code size calculation step S3703 and the call frequency calculation step S3704 in starting the memory allocation step S4005 according to the third embodiment.
FIG. 19A shows a left table in which caller functions are listed as parent functions, and callee functions for these functions and weights based on the number of calls are listed. In addition, when there are two or more call source functions for one call destination function, the parent function in a state where the call source function is selected as one based on the weighting and the call destination functions are listed. The right table is shown. Comparing the left table and the right table, the function B4 is a call destination function of both the parent functions A2 and A3. According to the weighting, the parent function A2 is selected as the parent function of the function B4. I understand.
FIG. 19B shows a table in which the function group names F_A1, F_A2, and F_A3 and the representative functions A1 * B1 * C1 * D1, the representative function A2, and the representative function A3 of the function groups are described. The function A1 * B1 * C1 * D1 is a function that is regarded as one function because of the recursive call relationship. The table shown in FIG. 19B further includes a function that has a descendant relationship from the representative function (a function that is called from the representative function and a function that is further called from the function), and a total code size of the representative function and its descendant functions. Is described.
FIG. 19C is a table showing the call frequency between function groups calculated in the call frequency calculation step S3704. For two different function groups, the call frequency represents the frequency with which a function belonging to one function group becomes a caller and a call belonging to a function belonging to the other function group occurs. Accordingly, FIG. 19C shows the result of expressing the calling frequency for the function groups F_A1, F_A2, and F_A3 having a calling relationship from the function groups F_A1, F_A2, and F_A3. Since the call destination and call source of the call to which the function belonging to the function group F_A1 is the call source or call destination are the main function or the function belonging to the function group F_A1, respectively, the function group F_A1 and the function groups F_A1, F_A2, and F_A3 The call frequency of is 0. On the other hand, in a call in which a function belonging to the function group F_A2 is a call source or a call destination, the function A3 (belonging to the function group F_A3) calls the function B4 (belonging to the function group A2) with the frequency 20; Since the call destination or call source is a main function or a function belonging to the function group F_A2, the call frequency of the function group F_A2 and the function groups F_A1 and F_A2 is 0, but the call frequency of the function group F_A3 is 20. is there. Similarly, the frequency of calling the function group F_A3 and the functions belonging to the function groups F_A1 and F_A3 is 0, but the frequency of calling the function group F_A2 is 20.
FIG. 19D shows the result of performing memory allocation step S4005 with power control. In FIG. 19D, a function group (F_A1) 400518 having a main function 400517 and a function (function A1 * B1 * C1 * D1) regarded as one including the function A1 and a function group (F_A2) having the function A2 as a representative function. ) 400519, a function group (F_A3) 400520 having a function A3 as a representative function, a memory bank 40000521, a memory bank 40000522, a memory bank 4000052, and a memory bank 4000052.

The capacity of the memory banks 400521, 400522, and 400523 is 4 KB, which is a memory bank with power control. In addition, the memory areas of the memory banks 400521, 40000522, and 400523 have consecutive addresses for access.
The main function 400517 is a function that calls the function A1, the function A2, and the function A3. Further, since the power reduction effect is reduced in the method of controlling the power by entering and exiting the function, the main function 400517 is assigned to the memory bank 4000052 without power control. Hereinafter, specific examples of each process will be described with reference to the flowcharts of FIGS. 18A and 18B until the result of performing the memory allocation process with power control S4005 illustrated in FIG. 19D is obtained.
First, the remaining memory size variable initialization step S400501 is performed. The target of the memory size variable initialization is the memory banks 400521, 40000522, 40000523, and 400524. As a result of the initialization, the remaining memory area size m_rest [M] of each memory bank is 4KB, 4KB, 4KB, and 0KB. Since the main function 400517 is already arranged in the memory bank 4000052 and it has been decided to use it as a memory bank without power control, the remaining memory area size of the memory bank 4000052 is 0.
A function group F_A1 (400518) having a function (function A1 * B1 * C1 * D1) regarded as one including the function A1 as a representative function includes a function A1 * B1 * C1 * D1 and a function C2. The total code size of the function group F_A1 (400518) is 5 KB.
A function group F_A2 (400519) having the function A2 as a representative function includes a function A2, a function B2, a function B3, and a function B4. The total code size of the function group F_A2 (400519) is 4 KB.
A function group F_A3 (400520) having the function A3 as a representative function includes a function A3, a function B5, and a function B6. The function group F_A3 (400520) is 3 KB.

Next, step S400502 for selecting a function group having the maximum total code size is performed. As a result, the function group F_A1 (400518) is selected as the function group F_Max.
Next, step S400503 for determining the arrangement of the maximum function group is performed. As a result, since the function group F_A1 (400518) is 5 KB, it is determined that it cannot be placed in any memory bank. Next, the memory bank recognition step S400313 is performed. As a result, the remaining capacity of each memory bank and the remaining memory area size m_rest [M] are recognized as 4 KB, 4 KB, 4 KB, and 0 KB, and are arranged in the order of the memory banks 40051, 40052, 4000052, and 4000052, and M1, M2, Name them M3 and M4.
Next, step S400514 of recognizing a memory bank to which the maximum function can be assigned is performed. As a result, when the remaining memory size m_rest [M1] of M1 and the remaining memory area size m_rest [M2] of M2 are added, the result becomes 8 KB, which is equal to or larger than the capacity s (F_Max) of the function group F_A1 (400518). 2.
Next, a memory area allocation step S400515 is performed. As a result, of the function group F_A1 (400518), 4 KB is allocated to the memory bank 40000521, and the remaining 1 KB is allocated to the memory bank 400522.
Next, a remaining memory area size update step S400516 is performed. The remaining memory capacities of the memory banks 400521, 400522, 40000523, and 400524 are updated to 0 KB, 3 KB, 4 KB, and 0 KB.
Next, step S400505 for generating a set Γ by call frequency recognition is performed. As a result, the set Γ of the function group F whose call frequency is 0 or more from the function group F_Max becomes empty from FIG. 19C.
Next, step S400506 is performed to determine whether the set Γ is an empty set. As a result, since the set Γ is empty, the process proceeds to step S400212 where it is determined whether the memory allocation is completed. As a result, since the allocation of the function group F_A2 (400519) and the function group F_A3 (400520) has not been completed, the process proceeds to step S400502 for selecting the function group having the maximum code size.
Next, step S400502 for selecting a function group having the maximum code size is performed. As a result, the function group F_A2 (400519) is selected as the function group F_Max.
Next, step S400503 for determining the arrangement of the function group having the maximum code size is performed. As a result, the total code size of the function group F_A2 (400519) and the memory area of the memory bank 4000052 are the same as 4 KB, and the function group F_A2 (400519) is allocated without protruding from the memory bank 4000052. Therefore, the process proceeds to step S400504 for updating the remaining memory size variable.
Next, step S400504 for updating the remaining memory size variable is performed. As a result, the remaining memory area size (m_rest [M]) of the memory banks 400521, 40000522, 40000523, and 40000524 is updated to 0 KB, 3 KB, 0 KB, and 0 KB.
Next, step S400505 for generating a set Γ by call frequency recognition is performed. When the function group F_A2 (400519) is set to F_Max, the function group F_A3 exists as the function group F that is not assigned to the memory bank area because the function group F is not currently called from the maximum function group F_Max. A set Γ including the function group F_A3 is generated.
Next, step S400506 is performed to determine whether the set Γ is an empty set. Since a function whose call frequency is not 0 exists in the set Γ, the process proceeds to the memory area allocation routine S400507.
Next, step S400508 for selecting the function F_Rel having the maximum calling frequency in the memory area allocation routine S400507 is performed. As a result, the function group F_A3 is set as the function group F_Rel.
Next, a remaining memory area size determination step S400509 is performed. Since the remaining memory area size 3KB of the memory bank 4000052 is equal to or larger than the total code size 3KB of the function group F_Rel, the process proceeds to step S400510 for assigning to the remaining memory area.
Next, the set Γ update step S40011 is performed. The function group F_Fel, that is, the function group F_A3 is excluded from the set Γ.
Next, the process exits the memory area allocation routine S400507 and performs step S400506 for determining whether the set Γ is an empty set. As a result, since the set Γ is empty, the process proceeds to step S400212 where it is determined whether the memory allocation is completed. As a result, since the function group function group F_A3 (400520) is not allocated to the memory bank, the process proceeds to step S400502 for selecting the function group having the maximum code size.
Next, step S400502 for selecting a function group having the maximum code size is performed. As a result, the function group F_A3 (400520) is selected as the function group F_Max.
Next, step S400503 for determining the arrangement of the function group having the maximum code size is performed. As a result, since the total code size of the function group F_A3 (400520) is 3 KB and the remaining memory area of the memory bank 40000522 is 3 KB, the function group F_A3 (400520) is allocated without protruding from the memory bank 400523. Therefore, the process proceeds to step S400504 for updating the remaining memory size variable.
Next, step S400504 for updating the remaining memory size variable is performed. As a result, the remaining memory area size (m_rest [M]) of the memory banks 400521, 40000522, 40000523, and 40000524 is updated to 0 KB, 0 KB, 0 KB, and 0 KB.
Next, step S400505 for generating a set Γ by call frequency recognition is performed. When the function group F_A3 (400520) is F_Max, since there is no function group F that is currently not called by the function group F_Max and is not assigned to the memory bank area, the set Γ is empty. Set to
Next, step S400506 is performed to determine whether the set Γ is an empty set. Since the set Γ is empty, the process advances to step S40052 for determining whether the memory allocation is completed.
Next, step S40052 for determining whether the memory allocation is completed is performed. Since the function group not allocated to the memory area does not exist in the total code size table, the memory allocation process S4005 of the third embodiment is finished.

As described above, in the memory system 50, when the allocation method for allocating the storage area to the code included in the program of the third embodiment is performed, the function group F_A1 (400518) having the function A1 * B1 * C1 * D1 as a representative function is stored in the memory. Since it is larger than the memory area of the bank 400521, the allocation is concentrated on two memory banks, the memory bank 400521 and the memory bank 400522. In addition, since the total code size amount of the function group F_A2 having the function A2 as a representative function is smaller than the memory area of the memory bank 4000052, the functions included in the function group F_A2 are concentrated in one memory bank 4000052. The Further, since the total code size amount of the function group F_A3 having the function A3 as a representative function is smaller than the remaining memory area of the memory bank 4000052, the functions included in the function group F_A3 are concentrated on the memory bank 4000052. The
Therefore, if the CPU included in the memory system 50 controls the power supply state of the memory bank in accordance with the function call state, the number of memory banks in the normal power supply state can be reduced.

In the program shown in the third embodiment, after a maximum function group is assigned to a memory bank, a function group (call frequency with the maximum function group is truly greater than 0) within a range in which a new memory bank is not used. This is based on a method for assigning a function group. Although this method has the advantage that the function groups assigned to multiple memory banks can be reduced, as a result of assigning several function groups by this method, the remaining memory area size is small for each memory bank, and the remaining functions A situation can occur where a group is assigned to multiple memory banks. This is the situation, and the function group is composed of a small number of functions (therefore, the number of memory banks allocated to each function in the corresponding function group also increases), and the execution time of these functions is compared to other functions. If it is long, the effect of reducing power consumption may be reduced.
FIG. 20 shows an example in which the power consumption reduction effect decreases when the program shown in the third embodiment is executed.
In executing the memory allocation step S4005, it is assumed that the results shown in FIGS. 19A to 19C are obtained in the total code size calculation step S3703 and the call frequency calculation step S3704. However, the total code size of the function group F_A1 illustrated in FIG. 19B is 2.5 KB, the total code size of the function group F_A2 is 7 KB, and the total code size of the function group F_A3 is 3 KB. In addition to the components of the memory system 50 according to the third embodiment illustrated in FIG. 19D, a memory bank 4000052 having a memory capacity of 1 KB is added as a component of the memory system 50. Furthermore, in the memory system 50 according to FIG. 20, a main function 400517 is arranged in the memory bank 40055, and the memory bank 4000052 has a memory area in which addresses are continuous with the memory bank 4000052.
The main function 400517, the function group F_A1 (400518), the function group F_A2 (400519), the function group F_A3 (400520), the memory bank 40000521, the memory bank 40000522, and the memory bank 4000052 are the same as those in FIG. 19D. The description is omitted.
In the memory system 50 according to FIG. 20, when the memory allocation step S4005 is performed in the third embodiment, first, the function group F_A2 (400519) is set as the maximum function group and is allocated to the memory banks 40051 and 4000052. At this time, the remaining memory area sizes (m_rest [M]) of the memory banks 400521 and 400522 are 0 KB and 1 KB, respectively. A function group F_A3 (400520) exists as a function group that is not called from the maximum function group F_Max (= function group F_A2) and is not assigned to the memory bank area. Since the memory area size (m_rest [M]) is 1 KB and is smaller than the total code size (3 KB) of the function group F_A3 (400520), the function group F_A3 is not assigned to the memory bank at this time.
Subsequently, a function group F_A3 (400520) is set as the maximum function group and is assigned to the memory bank 4000052. At this time, the remaining memory area size (m_rest [M]) of the memory bank 400533 is 1 KB. Since there is no function group that is not called from the maximum function group F_Max (= function group F_A3) and is not assigned to the memory bank area, the selection of the maximum function group is executed again.
Subsequently, the function group F_A1 (400518) is set as the maximum function group. At this time, the remaining memory area sizes (m_rest [M]) of the memory banks 400521, 40000522, 40000523, and 40000524 are 0 KB, 1 KB, respectively. 1 KB and 1 KB. Therefore, the function group F_A1 (400518) is arranged over the memory banks 400522, 40000523, and 400524.
Here, if the memory banks 400522, 40000523, and 400524 are in the normal power supply state while the function of the function group F_A1 (400518) is being executed, the number of memory banks in the normal power supply state increases. The power consumption during the function execution of the group F_A1 (400518) becomes high. Furthermore, if the ratio of the execution time in all the programs of the function group F_A1 (400518) is high, the power consumption of the entire program also increases.
As described above, in the memory system 50 according to the first embodiment, it is conceivable to execute the following program according to the fourth embodiment and allocate the memory bank so that no space is generated.
By executing the memory allocation step S4105 shown in the fourth embodiment instead of the memory allocation unit with power control S3705 in the memory allocation step S37 of the second embodiment,
In the case of the program of the third embodiment, the power consumption can be reduced when the execution time of a function group assigned to a large number of memory banks and assigned to the large number of memory banks becomes long.
FIG. 21A shows a memory allocation step S4105 according to the fourth embodiment. The execution of the memory allocation step S4105 of the fourth embodiment is executed by performing the following steps after the start.
First, the remaining memory area size variable initialization step S410521 is performed. The remaining memory area size variable initialization step S410521 is a process for initializing the value of the variable m_rest that stores the remaining memory area size. That is, for the memory bank M that is not subjected to power control, the value of m_rest (m_rest [M]) is 0, and the value of m_rest (m_rest [M]) for the other memory banks M is the capacity of the memory bank M. initialize.
Next, step S410522 for selecting a function group having the maximum total code size is performed. In step S410522 for selecting the function group having the maximum total code size, the total code size table is scanned, the function group having the maximum total code size is selected, and set as the maximum function group F_Max.
Next, a memory bank recognition step S410523 is performed. The memory bank recognition step S410523 is a step of naming M1, M2,..., Mn (n is a positive integer) in descending order of the remaining memory area size. If there are memory banks with the same value of the remaining memory area size, the memory banks with the same value, the memory bank with the remaining memory area size next to the memory bank with the same value, and the same value If a memory bank having the remaining memory area size next to a certain memory bank is named so that addresses are continuous as much as possible, a more desirable result is obtained.
Next, a routine S410524 for assigning the maximum function group F_Max to the memory bank is performed. The routine S410524 for assigning the maximum function group F_Max to the memory bank will be separately described with reference to FIG.

Next, step S410525 for generating the set Γ by calling frequency recognition is performed. The step S410525 for generating the set Γ by calling frequency recognition is a step for setting the function group F that is in a calling relationship from the maximum function group F_Max and is not assigned to the memory bank to the set Γ. Note that the determination of the call relationship from the maximum function group F_Max is made when the call frequency Q (F_Max, F) from the maximum function group F_Max is truly greater than zero.
Next, step S40056 for determining whether or not the set Γ is an empty set is performed. When the set Γ is empty, the process proceeds to step S410527 for determining whether the memory allocation is completed. On the other hand, when the set Γ is not empty, the process proceeds to step S410528 for selecting the function group F_Rel having the maximum calling frequency.
Next, step S410528 for selecting the function group F_Rel having the maximum calling frequency is performed. The step S410528 of selecting the function group F_Rel with the maximum calling frequency is a process of selecting the function group with the maximum calling frequency with the maximum function group F_Max from the functions included in the set Γ and setting it as the function group F_Rel. However, when there are a plurality of function groups having the same call frequency, the function group having the maximum code size is selected from the function groups that are candidates for the function group F_Rel having the maximum number of calls.
Next, a routine S410529 for assigning the function group F_Rel to the memory bank is performed. Note that the routine S410529 for assigning the function group F_Rel to the memory bank will be separately described with reference to FIG. 21B.

Next, a set Γ update step S410530 is performed. The set Γ update step S410530 is a step of updating the set Γ by removing the function group F_Rel from the function group set Γ having a calling relationship from the maximum function group F_Max.
Next, the process returns to step S410526 for determining whether the set Γ is an empty set. Until the set Γ becomes empty, the processes from the step S410528 for selecting the function group F_Rel having the maximum calling frequency to the set Γ update step S410530 are repeated. Next, when the set Γ is empty, the process proceeds to step S410527 for determining whether the memory allocation is completed.

In step S410527 for determining whether the memory allocation has been completed, a function included in the maximum function group F_Max and a function included in the function group having a calling relationship with the maximum function group F_Max are allocated to the memory area, and then the total code size table This is a step of determining whether or not there is another function group not allocated to the memory area. Here, when it is determined that there are further function groups in the total code size table and the allocation of the memory area is not completed for the function groups, step S410522 for selecting the function group having the maximum total code size is performed. .
On the other hand, if there is no function in the total code size table, the memory allocation step S4105 according to the fourth embodiment is terminated.

FIG. 21B is a diagram for explaining a routine S410524 for assigning the maximum function group F_Max to the memory bank. The routine S410524 for assigning the maximum function group F_Max to the memory bank includes the following steps.
First, step S410524a for recognizing a memory bank to which all function groups can be assigned is performed. In step S410524a for recognizing a memory bank to which all the function groups can be assigned, M1, M2,..., Mn having consecutive addresses recognized in the memory bank recognition step S410523 are first to mth (m is This is a step of detecting the minimum m in which the memory area obtained as a result of adding the memory areas up to (positive integer satisfying n ≧ m) is not less than the code size of the maximum function group F_Max.
Next, a memory area allocation step S410524b is performed. The memory area allocating step S410524b is a step of allocating the maximum function group F_Max to the memory banks M1 to Mm.
Next, a remaining memory area size update step S410524c is performed. The remaining memory area size update step S410524c sets m_rest [Mi] = 0 (i = 1,..., M−1) and m_rest [Mm] = (m_rest [M1] + m_rest [M2] +. + M_rest [Mm]) − s (F_Max).
The routine S410524 for assigning the maximum function group F_Max to the memory bank is a routine for processing the maximum function group F_Max. However, the routine S410529 for assigning the function group F_Rel to the memory bank is used instead of the maximum function group F_Max. , The function group F_Rel is a routine for performing the same process as the routine S410524 for assigning the function group F_Max to the memory bank.

FIG. 22 shows a specific example in which a function is allocated to each memory bank in the memory allocation step S4105 according to the fourth embodiment.
In executing the memory allocation step S4105, it is assumed that the results shown in FIGS. 19A to 19C are obtained in the total code size calculation step S3703 and the call frequency calculation step S3704. However, the total code size of the function group F_A1 illustrated in FIG. 19B is 2.5 KB, the total code size of the function group F_A2 is 7 KB, and the total code size of the function group F_A3 is 3 KB. In addition to the components of the memory system 50 according to the third embodiment illustrated in FIG. 19D, a memory bank 4000052 having a memory capacity of 1 KB is added as a component of the memory system 50. Further, in the memory system 50 according to the fourth embodiment, the main function 400517 is disposed in the memory bank 40055, and the memory bank 4000052 has a memory area in which addresses are continuous with the memory bank 4000052.
The main function 400517, the function group F_A1 (400518), the function group F_A2 (400519), the function group F_A3 (400520), the memory bank 40000521, the memory bank 40000522, and the memory bank 4000052 are the same as those in FIG. 19D. The description is omitted.
When the memory allocation step S4105 according to the fourth embodiment is performed in the memory system 50 described above, first, the function group F_A2 is the function group F_Max having the maximum total code size by executing the step S410522 that selects the function group having the maximum total code size. Selected as.
Next, when the routine S410524 for allocating the maximum function group F_Max to the memory bank is executed, it is detected that the code size of the maximum function group F_Max is exceeded as a result of adding the memory capacities of the memory banks 400521 and 400522 (all function groups Step S410524a) for recognizing a memory bank to which can be assigned. Next, the remaining memory area size of the memory banks 40000521, 40000522, 40000523, and 40000524 is updated (remaining memory area updating step S410524c).
Next, a call frequency recognition step S410525 is performed. As a result, a set Γ including the function group F_A3 (400520) that is not yet assigned to the memory bank and whose calling frequency is not 0 from the function group F_Max (currently the function group F_A2) is set.
Next, step S40056 for determining whether or not the set Γ is an empty set is performed. Since the set Γ is not empty, step S410528 is executed to select the function group F_Rel with the highest call frequency, and the routine S410529 is performed, with the function group F_A3 as the function group F_Rel and assigned to the memory bank. As a result, the function group F_A3 is assigned to the memory bank 4000052.
Next, step S40056 for determining whether the set Γ is an empty set is performed again. Since the set Γ is empty, step S410527 for determining whether all the function groups have been assigned is executed. Since there is a function group F_A1 (400518) not assigned to the memory bank, the process proceeds to step S410522 for selecting a function group having the maximum total code size.
Next, step S410522 for selecting the function group having the maximum total code size is performed, and the function group F_A1 (400518) is selected as the function group F_Max.
Next, a memory bank recognition step S410523 and a routine S410524 for assigning a function group F_Max to a memory bank are performed, and a function group F_A1 (400518) which is the current function group F_Max is assigned to the memory banks 40000523 and 40000524.
Next, a call frequency recognition step S410525 is performed. When the function group F_Max having the maximum total code size is the function group F_A1, the set Γ is empty from FIG. 19C.
Next, step S40056 for determining whether the set F is an empty set is performed again. Since the set F is empty, step S410527 for determining whether all the function groups have been assigned is executed. Since it is determined that all the function groups are allocated to the memory bank, the memory allocation step S4105 of the fourth embodiment ends.

As described above, in the memory system 50, when the allocation method for allocating the storage area to the code included in the program of the fourth embodiment is performed, the following operation is performed. First, the maximum function group (the function group that has not been allocated to the memory bank yet has the largest total code size) and the allocation from the maximum function to the memory bank that is still in the calling relationship are performed. A plurality of memory banks having a memory area larger than the total code size amount of the function group not yet detected are detected. Thereafter, the maximum function group and the function group that has not yet been assigned to the memory bank in the calling relation from the maximum function group are sequentially arranged in the plurality of memory banks detected above.
Then, when the CPU included in the memory system 50 processes the maximum function and the function called from the maximum function, it is possible to easily specify the memory bank to be in the normal power supply state. As a result, the extra memory banks are not brought into the normal power state, and the number of memory banks in the normal power supply state can be reduced. Therefore, the power consumed by the memory bank can be reduced.
In addition, if the addresses are arranged in non-contiguous memory areas, the CPU needs several instructions when switching between the normal power supply state and the state where the addresses are not. However, when the maximum function and the function called from the maximum function are arranged in the memory area where the addresses are continuous, the CPU is used when switching between the normal power supply state and the state where it is not. Can be performed in one batch. Therefore, when the addresses are continuous, the load on the CPU can be reduced, and the power consumption of the CPU can be reduced.

The features of the present invention are described below.
(Appendix 1)
A process in which the processor extracts a calling relationship between functions in a program read by the processor;
The call relationship is traced along the function call chain based on the call relationship between the functions, and when the function that has been called once is called again, the call from the first call to the second call is performed. A recursive call extraction step in which a group of functions passed in between is a recursive call part;
A code allocating step for the processor to allocate a code included in the program representing the recursive calling unit to a memory bank capable of independently switching a supplied voltage state;
An allocation method for allocating a code included in a program to a memory area.
(Appendix 2)
In the code allocation step, the processor allocates a code included in the program representing the recursive calling unit as a unit to one of the memory banks, and allocates a code included in the program to a memory area The allocation method according to attachment 1.
(Appendix 3)
In the code allocation step, the processor allocates a code included in the program representing the recursive calling unit as a unit to two or more memory banks having consecutive addresses, and the code included in the program 2. The allocation method according to appendix 1, wherein the allocation is performed in the memory area.
(Appendix 4)
A processor capable of operating by reading a program containing code representing a function;
A memory bank capable of independently switching the voltage state supplied by the control from the processor,
The processor has a function of extracting a call relationship between functions in the program read by the processor;
The call relationship is traced along the function call chain based on the call relationship between the functions, and when the function that has been called once is called again, the call from the first call to the second call is performed. The function group between them as a recursive call part,
A memory system comprising: a function for the processor to allocate a code included in the program representing the recursive calling unit to a memory bank in which a supplied voltage state can be switched independently.
(Appendix 5)
A control register for setting the voltage state of the memory bank in response to an instruction from the processor;
The memory system according to claim 4, further comprising: a power supply control circuit that receives a signal from the control register and controls a voltage state of the memory bank.
(Appendix 6)
In a memory system comprising a processor and a memory bank,
A compiling step of loading a source program into the processor and converting the source program into assembly code or objects;
A control position calculation step in which the processor detects an assembly code or object for controlling on / off of the memory bank (control position calculation step S2);
A process in which a processor extracts a calling relationship between functions in a program read by the processor;
The call relationship is traced along the function call chain based on the call relationship between the functions, and when the function that has been called once is called again, the call from the first call to the second call is performed. A recursive call extraction step in which a group of functions passed in between is a recursive call part;
Assembly code or object representing the recursive call unit, the assembly code or object representing the recursive call unit included in the program assigned to the memory bank that can be switched independently of the supplied voltage state. Code allocation step of outputting the address of the memory bank indicating the location of storing as memory map information;
And a step of correcting an assembly code or object position for controlling on / off of the memory bank based on the memory map information.

  According to the present invention, a method for allocating a code included in a program code to a storage area, realizing a storage area allocation state capable of reducing power consumption by controlling the power state of the storage area, and executing the method A memory system can be provided.

10 memory units 11, 12, 13, 14, 15 memory bank 20 processor 30 control register group 40 bus 45 power supply line 46 power supply control device 50 memory system 61 function size information 62 program 63 recursive call processed static call graph 64 recursive call Processed function size information 65 Function degeneration information 66 Memory map information S31 Call relation extraction S32A Recursive call extraction S32B Recursive processed static call graph creation S33 Recursive call degeneration S34 Memory allocation

Claims (5)

A process in which the processor extracts a calling relationship between functions in a program read by the processor;
The call relationship is traced along the function call chain based on the call relationship between the functions, and when the function that has been called once is called again, the call from the first call to the second call is performed. A recursive call extraction step in which a group of functions passed in between is a recursive call part;
A code allocating step for the processor to allocate a code included in the program representing the recursive calling unit to a memory bank capable of independently switching a supplied voltage state;
An allocation method for allocating a code included in a program to a memory area.   In the code allocation step, the processor allocates a code included in the program representing the recursive calling unit as a unit to one of the memory banks, and allocates a code included in the program to a memory area The allocation method according to claim 1.   In the code allocation step, the processor allocates a code included in the program representing the recursive calling unit as a unit to two or more memory banks having consecutive addresses, and the code included in the program The allocation method according to claim 1, wherein the allocation to the memory area is performed. A processor capable of operating by reading a program containing code representing a function;
A memory bank capable of independently switching the voltage state supplied by the control from the processor,
The processor has a function of extracting a call relationship between functions in the program read by the processor;
The call relationship is traced along the function call chain based on the call relationship between the functions, and when the function that has been called once is called again, the call from the first call to the second call is performed. The function group between them as a recursive call part,
A memory system comprising: a function for the processor to allocate a code included in the program representing the recursive calling unit to a memory bank in which a supplied voltage state can be switched independently. A control register for setting the voltage state of the memory bank in response to an instruction from the processor;
5. The memory system according to claim 4, further comprising: a power supply control circuit that receives a signal from the control register and controls a voltage state of the memory bank.

Images