JP2013127703A - Method and program for generating load module - Google Patents

Abstract

PROBLEM TO BE SOLVED: To suppress a memory usage for storing an object code without sacrifice of the high processing speed using a local address.SOLUTION: When generating a load module for multi-CPU core system capable of using a global address and a local address for referring to a local memory in a CPU core, instruction information for identifying in which local memory in the CPU core the data of a function are arranged and in which CPU the function is executed is made to follow a source program. An object code is generated on the basis of the instruction information, the object code for referring to at least one of a local address symbol and a global address symbol according to whether using the global address or the local address for a reference of a variable for every object. The global address and the local address are allocated based on the generated object code to generate a load module in common with a plurality of CPU cores.

Description

  The present invention relates to a method for generating a load module for a program executed by a multi-CPU core system using a plurality of CPU cores each having a local memory and a local memory that can be referred to by a global address, and to control the method. It relates to a computer program.

  Patent Documents 1 and 2 are examples of documents describing a method for generating a load module for a program executed by a multi-CPU core system. These describe a method of generating a load module of a program executed by a multi-core system that can refer to a local memory in another CPU core by using a special address, although the memory space is different for each CPU. The main points of this description are as follows. That is, for a reference from the function executed in the second CPU core to the data Y in the local memory in the second CPU core, the address is resolved by the “in-memory space linker” of the second CPU. And assign address y. On the other hand, for the reference from the function executed in the first CPU core to the data Y in the local memory in the second CPU core, using the above address y, the “inter-memory space linker” The address is resolved by “y + offset”. “offset” means an offset of the leading global address of the local memory in the second CPU core with respect to the leading local address of the local memory in the first CPU core.

Japanese Patent No. 4133107 JP 2004-78600 A

  The present inventor has studied a variable address resolution method in the case where the same variable is referenced from the same function executed on different CPU cores. FIG. 6 illustrates the result of the study by the present inventor. The local address given to the local memory LM1 in the first CPU core and the local address given to the local memory LM2 in the second CPU core are set to 0x000 to 0x0ff, respectively. Assume that the global address assigned to the local memory LM1 in the first CPU core is 0x100 to 0x1ff, and the global address assigned to the local memory LM2 in the second CPU core is 0x200 to 0x2ff. The offset of the leading global address of the local memory LM2 in the second CPU core relative to the leading local address of the local memory LM1 in the first CPU core is offset = 0x200.

  In FIG. 6, functions F and G refer to a variable Y included in a part of the description, and data of the variable Y is arranged on the local memory LM2 in the second CPU core. Reference is made to the data of the variable Y on the local memory LM2 in the second CPU core from among the functions F arranged on the local memory LM2 in the second CPU core, or For those calling the function G arranged on the local memory LM2 in the second CPU core, the addresses of F, Y and G are resolved by the “linker in memory space” for the second CPU. It is assumed that the function addresses whose addresses are resolved are f and g, and the resolved variable addresses are y (= 0x0aa). Here, if the function F is called from the first CPU core, the function F is correctly called by the address f + offset. However, since the addresses y and g in the function F that has already become the object code are the same values, if the function F called by the first CPU core is executed, an illegal on the local memory LM1 in the first CPU core is executed. By referring to the address, a malfunction occurs.

  In order to prevent this, the in-memory space linker for the first CPU core does not perform address resolution for the function variable f of the function address f on the local memory LM2 in the second CPU core, but by the inter-memory space linker, Address resolution using a global address is performed on the variable Y of the function f. As a result, when the address referring to the variable Y in the function F is the first CPU core, the global address is “0x2aa”, and when the address is the second CPU core, the local address is “0x0aa”. For this reason, the entity of the function F is required separately for both the first CPU core and the second CPU core. That is, when the function F as described above is called from a plurality of CPUs, each CPU core requires a separate object code related to the function F, and there is a problem that the amount of memory used increases when viewed from the entire system. .

  In this regard, the present inventor further generates an object code by resolving the address of the variable with the global address, and when it is desired to refer to the data on the local memory in the CPU core with the local address of the data, We also considered reducing the amount of memory used by converting addresses to local addresses during execution. However, if an address translation process is added at the time of execution, the high speed cannot be fully utilized even though a local address for speeding up the reference can be used.

  An object of the present invention is to provide a load module generation technique capable of suppressing an increase in the amount of memory used for storing an object code without sacrificing the high speed of processing by using a local address. .

  The above and other objects and novel features of the present invention will be apparent from the description of this specification and the accompanying drawings.

  The following is a brief description of an outline of typical inventions disclosed in the present application.

  That is, a load module for a program executed by a multi-CPU core system that can use a global address and a local address to refer to a local memory among a plurality of CPU cores each having a CPU and a local memory is generated. To do. In this case, instruction information for specifying in which CPU core the function data is allocated and in which CPU the function is executed is attached to the source program. Based on this instruction information, it is determined for each function whether the global address or the local address is used for referring to the variable, and at least one of the local address symbol and the global address symbol is determined according to the determination result. Generate object code that references one. For the generated object code, a global address is assigned to a global address symbol and a local address is assigned to a local address symbol to generate a load module common to a plurality of CPU cores.

  According to this, by delaying the address resolution processing for variables in a function until the time of linking across multiple CPUs, for functions called from multiple CPUs, global addresses are used as addresses for the data and functions to be referred to from among them. A code referring to the address for the address symbol is output. Since the output single code is correctly executed by a plurality of CPUs, there is no need to copy a function for each CPU, and the memory usage does not increase. Further, since it is not necessary to perform address conversion when the reference using the local address is possible, the high-speed processing by using the local address is not sacrificed.

  The effects obtained by the representative ones of the inventions disclosed in the present application will be briefly described as follows.

  That is, it is possible to generate a load module that can suppress an increase in memory usage for storing object code without sacrificing high-speed processing by using a local address.

FIG. 1 is a schematic block diagram of a development system that generates a load module for a program executed by a microcomputer as a multi-CPU core system. FIG. 2 is an explanatory view exemplifying an address map of a local memory by a local address and a global address. FIG. 3 is an explanatory diagram illustrating an access path of a local memory using a local address and a global address. FIG. 4 is a flowchart illustrating a processing flow for generating a load module. FIG. 5 is a flowchart illustrating another processing flow for generating a load module. FIG. 6 is an explanatory diagram exemplifying the result of the inventor's first examination of a variable address resolution method when different CPU cores refer to the same variable of the same function.

1. First, an outline of a typical embodiment of the invention disclosed in the present application will be described. Reference numerals in the drawings referred to in parentheses in the outline description of the representative embodiments merely exemplify what are included in the concept of the components to which the reference numerals are attached.

[1] <Generation of load module common to multiple CPU cores>
The load module generation method according to the representative embodiment of the present invention is one of a plurality of CPU cores (201, 202) each having a CPU (211, 221) and a local memory (212, 222). A multi-CPU core system (2) using a global address for a CPU of a CPU core to reference a local memory in another CPU core and a local address for a CPU to reference a local memory in its own CPU core Is a load module generation method for generating the load module (151, 151A) of the program executed by the computer (1) by data processing of the computer (1). This method includes a compilation process (120, 120A) and a link process (130). The compile processing is performed by inputting a source program (140) having instruction information specifying which CPU is to allocate certain data on which local memory and which CPU executes a certain function. Based on the information, it is determined for each function whether the global address or the local address is used to refer to the variable, and the local address symbol (LY) and the global address symbol (GY) are determined according to the determination result. It is a process which produces | generates the object code (141, 141A) which refers at least one of these. In the link process, a global address is assigned to a symbol for global address and a local address is assigned to a symbol for local address to generate a load module (151, 151A) common to a plurality of CPU cores. It is processing.

  According to the above, by delaying the address resolution processing for the variables in the function until the time of linking across multiple CPUs, for functions called from multiple CPUs, as addresses for the data and functions to be referenced from among them, A code that refers to the address for the global address symbol is output, and the single code is correctly executed by a plurality of CPUs. Therefore, there is no need to copy a function for each CPU, and the memory usage does not increase. Furthermore, for the code that refers to the address for the symbol for the local address, the code that refers to the local address for the symbol for the local address is generated in the load module as the address for the data or function to be referenced from within the code. When a load module is originally executed for a function that can be referred to using a local address, it is not necessary to perform address conversion, and the processing speed by using the local address is not sacrificed.

[2] <Local address symbol is assigned to a variable in its own local memory by a single CPU, and global address symbol is assigned to a variable from the same execution function by a plurality of CPUs>
In the compile processing (120) in the load module generation method according to Item 1, in a function executed only by a single CPU, when a variable on a local memory in the CPU core is referred to, a code that refers to a symbol for a local address (G; = LY) is generated, and in the case of a function executed by a plurality of CPUs, a code (f; = GY) for referring to a global address symbol is generated to refer to the variable.

  According to the above, it is possible to refer to a variable by a function executed only by a single CPU using the local address at high speed within the CPU core. Since a global address is used for referring to a variable by a function executed by a plurality of CPUs, a global address signal output from the CPU core is routed inside the CPU core in the case of referring to its own CPU core. Is referred to. In the case of reference outside its own CPU core, the global address signal output from the CPU core is routed inside another CPU core for reference.

[3] <Local address symbol for referring to a variable in its own local memory by a single CPU, and variable reference symbol in accordance with the CPU to be executed in the case of a function executed by a plurality of CPUs>
In the compile processing in the load module generation method according to Item 1, in a function executed only by a single CPU, when referring to a variable on a local memory in the CPU core, first code that refers to a symbol for a local address (G in FIG. 5; = LY), in the case of a function that can be executed by a plurality of CPUs, a local address symbol and a global address depending on the location of the CPU that executes the function and the variable to be referred to A second code (f in FIG. 5; if (cpu == 2) = 0x0aa, else = GY) is generated to select a reference to the symbol for use.

  According to this, since a variable reference using a local address or a variable reference using a global address can be selected in one code even for a function that may be executed by a plurality of CPUs, If the time required for the CPU type determination process is shorter than the time required for the global address signal output from the CPU core to be routed inside the CPU core, it may be executed by a plurality of CPUs. It is possible to further speed up the reference of variables by functions.

[4] <Second code including a reference code using a local address symbol, a reference code using a global address symbol, and a determination statement indicating which code to use>
In the load module generation method according to Item 3, when the second code refers to data on a local memory in a specific CPU core in a function that may be executed by a plurality of CPUs, the function is A statement for determining whether or not to be executed by a specific CPU, a code for performing a reference using a local address symbol corresponding to a local address when the function is executed by the specific CPU, and the function When executed by another CPU, a code for performing a reference using a global address symbol corresponding to the global address is included.

  According to this, the effect of item 3 can be obtained based on simple code description.

[5] <Instruction information by pragma statement>
In the load module generation method according to any one of Items 1 to 4, the instruction information is information specified by a pragma statement in C language.

  According to this, the instruction information can be easily attached to the source program in C language.

[6] <Common address is assigned to multiple CPU cores by assigning a local address symbol to a reference to a variable in its own local memory by a single CPU and a global address symbol to refer to a variable from the same execution function by a plurality of CPUs. A simple load module>
In the load module generation method according to another aspect of the present invention, as in item 1, the CPU of one CPU core among the plurality of CPU cores each having a CPU and a local memory is local to another CPU core. Data processing of a computer generates a load module for a program executed by a multi-CPU core system using a global address for referring to a memory and a local address for a CPU to refer to a local memory in its own CPU core It is a method to do. In particular, the method includes input processing, code generation processing, address resolution processing, and address generation processing. The input process is a process of inputting a source program having instruction information specifying which CPU allocates certain data on a local memory in which CPU core and which CPU executes a certain function. The code generation process determines whether to use a global address or a local address for referring to the variable for each function based on the input information, and depending on the determination result, the local address symbol and the global address This is a process for generating an object code that refers to at least one of the symbols. The address resolution process is a process of resolving an address for the global address symbol generated by the code generation process, and resolving the address of the local address symbol based on the resolved address. In the address generation process, when referring to a variable on a local memory in a CPU core in a function executed only by a single CPU, a code using an address corresponding to the symbol for the local address (g in FIG. 4; = 0x0aa) ) And a code that uses an address corresponding to the symbol for global address (f in FIG. 4; = 0x2aa) is generated when a variable is referred to in a function that may be executed by a plurality of CPUs. .

  According to this, the same effects as those of the items 1 and 2 are obtained.

[7] <Local address symbol for referring to a variable in its own local memory by a single CPU, and in the case of a function executed by a plurality of CPUs, a variable reference symbol is indicated according to the CPU to be executed, Generating a load module common to multiple CPU cores>
In the load module generation method according to still another embodiment of the present invention, the CPU of one CPU core among the plurality of CPU cores each having a CPU and a local memory is another CPU core as in item 1. The load module of the program executed by the multi-CPU core system using a global address for referring to the local memory in the memory and a local address for referring to the local memory in the CPU core of the CPU is stored in the computer data. It is a method of generating by processing. In particular, the method includes input processing, code generation processing, address resolution processing, and address generation processing. The input process is a process of inputting a source program having instruction information specifying which CPU allocates certain data on a local memory in which CPU core and which CPU executes a certain function. Based on the input information, the code generation process refers to a first code that refers to a local address symbol when referring to a variable in a local memory in the CPU core in a function executed only by a single CPU. (G in FIG. 5; LY) is generated, and when the function refers to data on a local memory in a specific CPU core in a function that may be executed by a plurality of CPUs, the function is the specific CPU. A statement for determining whether or not the function is executed, a code for performing a reference using a symbol for a local address corresponding to a local address when the function is executed by the specific CPU, and the function for other CPUs Is executed by the second code (see FIG. 5) including a code for performing a reference using a global address symbol corresponding to the global address. ; If (cpu == 2) = LY, a process of generating an else = GY). The address resolution process is a process of resolving an address for the global address symbol generated by the code generation process, and resolving the address of the local address symbol based on the resolved address. The address generation process is a process of generating a code using a global address corresponding to a global address symbol for the object code and generating a code using a corresponding local address for a local address symbol.

  According to this, the same effects as the items 1, 3 and 4 are obtained.

[8] <Load module generation program common to multiple CPU cores>
In a load module generation program according to still another embodiment of the present invention, a CPU of one CPU core among a plurality of CPU cores each having a CPU and a local memory refers to a local memory in another CPU core. For generating a load module (151, 151A) for a program executed by a multi-CPU core system using a global address for the CPU and a local address for the CPU to refer to a local memory in its own CPU core A load module generation program executable by a computer. This program controls compile processing (120, 120A) and link processing (130). Compile processing inputs a source program having instruction information specifying which CPU allocates certain data on which local memory in which CPU core and which CPU executes a certain function, and based on the input information For each function, determine whether to use the global address or local address for the reference of the variable for each function, and refer to at least one of the local address symbol and the global address symbol according to the determination result This is a process for generating the code (141, 141A). In the link process, a global address is assigned to a symbol for global address and a local address is assigned to a symbol for local address to generate a load module (151, 151A) common to a plurality of CPU cores. It is processing.

  By using this load module generation program, the method of item 1 can be easily realized.

[9] <Local address symbol is given to reference to variable in own local memory by single CPU, and global address symbol is given to variable reference from same execution function by multiple CPUs>
In the compile process controlled by the load module generation program according to Item 8, in a function executed only by a single CPU, when a variable on a local memory in the CPU core is referred to, a code that refers to a symbol for a local address ( (G; = LY) in FIG. 4 is generated, and in the case of a function executed by a plurality of CPUs, a code (f; = GY in FIG. 4) that references a symbol for a global address is generated to refer to the variable. Control.

  By using this load module generation program, the method of item 2 can be easily realized.

[10] <Local address symbol is designated for reference to a variable in its own local memory by a single CPU, and a variable reference symbol is designated according to the CPU to be executed in the case of a function executed by a plurality of CPUs>
In the compile process controlled by the load module generation program according to Item 8, when a variable on a local memory in the CPU core is referred to in a function executed only by a single CPU, a first reference is made to a local address symbol. In the case of a function that is likely to be executed by a plurality of CPUs, a local address symbol is generated according to the location of the CPU that executes the function and the variable to be referred to. Control is performed to generate a second code (f in FIG. 5; if (cpu == 2) = LY, else = GY) for selecting a reference to the global address symbol.

  By using this load module generation program, the method of Item 3 can be easily realized.

[11] <Second object code including a code that performs a reference using a symbol for local address, a code that performs a reference using a symbol for global address, and a determination statement indicating which code to use>
In the load module generation program according to item 10, when the second code refers to data on a local memory in a specific CPU core in a function that may be executed by a plurality of CPUs, the function is A statement for determining whether or not to be executed by a specific CPU, a code for performing a reference using a local address symbol corresponding to a local address when the function is executed by the specific CPU, and the function When executed by another CPU, a code for performing a reference using a global address symbol corresponding to the global address is included.

  According to this, the effect of item 10 can be obtained based on simple code description.

[12] <Common address shared by multiple CPU cores by assigning local address symbols to refer to variables in its own local memory by a single CPU, and global address symbols to refer to variables from the same execution function by multiple CPUs Program that controls the generation of load modules>
In the load module generation program according to another aspect of the present invention, as in item 8, the CPU of one CPU core among the plurality of CPU cores each having a CPU and a local memory is local to another CPU core. A load module (151) of a program executed by a multi-CPU core system (2) using a global address for referring to a memory and a local address for a CPU to refer to a local memory in its own CPU core A computer-executable program generated by data processing of the computer (1). This program controls input processing (121), code generation processing (122, 123), address resolution processing (131), and address generation processing (132). The input process is a process of inputting a source program (140) having instruction information specifying which CPU is to allocate certain data on which local memory and which CPU is to execute a certain function. . The code generation process determines whether to use a global address or a local address for referring to the variable for each function based on the input information, and depending on the determination result, the local address symbol and the global address This is a process for generating an object code (141) referring to at least one of the symbols. The address resolution process is a process of resolving an address for the global address symbol generated by the code generation process, and resolving the address of the local address symbol based on the resolved address. In the address generation process, when referring to a variable on a local memory in a CPU core in a function executed only by a single CPU, a code using an address corresponding to the symbol for the local address (g in FIG. 4; = 0x0aa) ) And a code that uses an address corresponding to the symbol for global address (f in FIG. 4; = 0x2aa) is generated when a variable is referred to in a function that may be executed by a plurality of CPUs. .

  According to this, the same effects as the items 8 and 9 are obtained.

[13] <Indicating a local address symbol for referring to a variable in its own local memory by a single CPU, and in the case of a function executed by a plurality of CPUs, indicating a variable reference symbol according to the CPU to be executed, Program for controlling generation of load module common to multiple CPU cores>
In the load module generation program according to another aspect of the present invention, as in item 8, the CPU of one CPU core among the plurality of CPU cores each having a CPU and a local memory is local to another CPU core. A load module (151A) of a program executed by the multi-CPU core system (2) using a global address for referring to a memory and a local address for a CPU to refer to a local memory in its own CPU core A computer-executable program generated by data processing of the computer (1). This program controls input processing (121), code generation processing, address resolution processing (131), and address generation processing (132). The input process is a process of inputting a source program (140) having instruction information specifying which CPU is to allocate certain data on which local memory and which CPU is to execute a certain function. . Based on the input information, the code generation process refers to a first code that refers to a local address symbol when referring to a variable in a local memory in the CPU core in a function executed only by a single CPU. (G in FIG. 5; LY) is generated, and when the function refers to data on a local memory in a specific CPU core in a function that may be executed by a plurality of CPUs, the function is the specific CPU. A statement for determining whether or not the function is executed, a code for performing a reference using a symbol for a local address corresponding to a local address when the function is executed by the specific CPU, and the function for other CPUs Is executed by the second code (see FIG. 5) including a code for performing a reference using a global address symbol corresponding to the global address. ; If (cpu == 2) = LY, a process of generating an else = GY). The address resolution process is a process of resolving an address for the global address symbol generated by the code generation process, and resolving the address of the local address symbol based on the resolved address. The address generation process is a process of generating a code using a global address corresponding to a global address symbol for the object code and generating a code using a corresponding local address for a local address symbol.

  According to this, the same effects as those of the items 8, 10, and 11 are obtained.

2. Details of Embodiments Embodiments will be further described in detail.

[Embodiment 1]
《Load module development system》
FIG. 1 illustrates an outline of a development system that generates a load module of a program executed by a microcomputer as a multi-CPU (central processing unit) core system.

  1 is a personal computer (PC) system as a computer system used for generating a load module, 2 is a microcomputer for executing the load module generated by the PC system 1, and 3 is a PROM writer for writing the load module into the microcomputer 2. is there. The writing of the load module is not limited to the configuration using the PROM writer 3. For example, the microcomputer 2 downloads the load module from the PC system 1 via a network (not shown), and loads the downloaded load module with its own write control program. It is also possible to write it independently. An engineering workstation or the like can be employed instead of the PC system 1.

  The PC system 1 includes, for example, a display 100 typically shown as a display device, a keyboard 101 typically shown as an input device, and a PC main body 102. The PC main body 102 includes a CPU module (CPUM) 110 on which a processor, an accelerator, a cache memory, and the like are mounted, a hard disk drive (HDD) 111 typically shown as an auxiliary storage device, a RAM 112, and an external input / output circuit (not shown) Such circuit units are configured to be interfaceable via the bus 113.

  The RAM 112 stores a program for generating the load module 206 of the microcomputer 2 from the source program. The CPU module executes a RAM program in accordance with an instruction input from a keyboard or the like. Details thereof will be described later.

<Microcomputer>
The microcomputer 2 shown in FIG. 1 has, for example, two first CPU cores 201 and second CPU cores 202 as a plurality of CPU cores, and these are connected to a bus 203. For example, a RAM 204 and a ROM 205 are further connected to the bus 203. For example, the load module 206 is written in the ROM 205. The first CPU core 201 has a CPU (CPU_1) 211 and a local memory (LM_1) 212, and the second CPU core 202 has a CPU (CPU_2) 221 and a local memory (LM_2) 222. The CPUs 211 and 221 perform system control such as task scheduling, memory management, and interrupt control according to the operating system possessed by the ROM 204. Further, the CPUs 211 and 221 fetch and execute the instruction codes included in the load module 206 held by the ROM 204 in the respective instruction execution order.

  Each of the CPUs 211 and 221 can use a global address and a local address to refer to the local memories 212 and 222 in its own CPU cores 201 and 202. Naturally, each of the CPUs 211 and 221 uses a global address to refer to the local memories 212 and 222 outside the CPU cores 201 and 202 thereof.

  FIG. 2 illustrates such an address map for the local memories 212 and 222. The local address LA common to both local memories (LM_1, LM_2) 212, 222 is assigned to 0x000 ≦ LA <0x100, and the global address GA_1 of the local memory (LM_1) 212 is assigned to 0x100 ≦ GA_1 <0x200, and the local memory The global address GA_2 of (LM_2) 222 is assigned to 0x200 ≦ GA_2 <0x300.

  As is apparent from the address map of FIG. 2, when accessing the local memory (LM_1) 212 from the CPU (CPU_1) 211 and when accessing the local memory (LM_2) 222 from the CPU (CPU_2) 221, respectively. Use local addresses. That is, the local address is used when access to the local memory is closed in each CPU core. Therefore, when the local memory (LM_1) 212 is accessed from the CPU (CPU_1) 211, the top address of the local memory (LM_1) 212 is 0x000. Similarly, the local memory (LM_2) 222 is accessed from the CPU (CPU_2) 221. At this time, the top address of the local memory (LM_2) 222 is also 0x000.

  The CPUs 211 and 221 output the address signal to the bus 203 when accessing using a global address. The output address signal is routed by the router of the bus 203 toward the circuit module having the address indicated by the bus 203. For example, when the first CPU 211 accesses the local memory (LM_1) 211, if the global address is used, it takes longer time to access than when the local address is used. This is the same as when the CPU accesses a local memory in another CPU core using a global address.

  FIG. 3 illustrates an access path of a local memory using a local address and a global address. A path (a) shown in each of the first CPU core 210 and the second CPU core 202 indicates an access path based on a local address. The CPUs 211 and 221 determine that the access is performed using a local address, for example, because the first digit of the address signal 0x000 is 0.

  A path (b) indicates a path when the CPU (CPU_1) 211 accesses the local memory (LM_1) 212 using a global address. For example, since the first digit of the access address 0x100 is not 0, the CPU (CPU_1) 211 outputs an access request to the external bus 203. Since the first digit of the address of the router of the bus 203 is 1, the access request is routed to the local memory (LM_1) 212 in the first CPU core 201, and this is received by the CPU (CPU_1) 211. Access its own local memory (LM_1) 212. In this case, since the access route becomes longer than the route (a), access takes time.

  A path (c) indicates a path when the CPU (CPU_1) 211 accesses the local memory (LM_2) 222 in the second CPU core 202 using the global address. The CPU (CPU_1) 211 outputs an access request to the external bus 203 because the first digit of the access address 0x200 is not 0, for example. Since the first digit of the address of the router of the bus 203 is 2, the access request is routed to the local memory (LM_2) 222 in the second CPU core 201, and this is routed by the CPU (CPU_2) 221. Accept and access its own local memory (LM_2) 222. In this case as well, the access path becomes longer than the path (a), so it takes time to access, but this is because the CPU (CPU_1) 211 accesses the local memory (LM_2) 222 in another second CPU core. This is the time that is absolutely necessary.

<< Load module generation process >>
For example, the RAM 112 in FIG. 1 stores a compiler 120 and a linker 130 as a program for generating a load module. In the notation of FIG. 1, it is described as if the compiler 120 and the linker 130 read necessary information and generate code for convenience, but actually, the CPU module 110 needs to execute the compiler 120 and the linker 130 while executing them. It should be understood that the code is generated by reading various information.

  The details of each process will be described later. By executing the compiler 120, the CPU module 110 controls the data / function information input process 121, the MAS output process 122, the MAS reference code generation process 123, etc. An object code 141 containing a MAS and a MAS reference code is generated from the source program 140 with data / function information. MAS stands for Multiply Addressed Symbol. The CPU module 110 executes the linker 130 to control the local address resolution processing 131 and the MAS address generation processing 132 while referring to the address map information 150 and the like, and the object code 141 including the MAS and MAS reference codes. The load module 151 is generated from the above. The generated load module 151 is written into the ROM 204 of the microcomputer 2 by the ROM writer 3 under the control of the ROM writing tool 152.

  FIG. 4 illustrates a processing flow for generating a load module.

  The source program to be compiled is accompanied by instruction information specifying which CPU is to allocate certain data on which local memory and which CPU is to execute a certain function. This instruction information is referred to herein as data / function information, and the compiler 120 inputs a source program 140 with data / function information. In the example of FIG. 4, the source program 140 with data / function information includes two pragma statements and two functions F and G. The pragma statement is a statement provided in the C language for giving additional information to the compiler.

  Here, “#pragma Y in LM2” shown in FIG. 4 indicates that the variable Y is arranged in the local memory (LM_2) 222.

  “Pragma G exec on CPU2” indicates that the function G is executed by the CPU (CPU_2) 202.

  Each of the two figures shown below the pragma statement is a schematic representation of functions F and G. As shown in the legend of FIG. 4, the graphic composed of two rectangles represents the function name on the left side and a part of the code written in the function body on the right side. In the functions F and G, the description “= Y” indicates that the functions F and G include a statement that refers to the variable Y.

  In the data / function information input processing 121 using the compiler 120, two pragma statements in the source program with data / function information are input and interpreted, and “the variable Y is arranged in the local memory (LM_2) 222”. And information indicating that the function G is executed by the second CPU (CPU_2) 202 is fetched.

  In the MAS output process 122, two pieces of symbol information “GY” and “LY” for the variable Y are output to the object code. Here, GY is a symbol corresponding to the global address, and LY represents a symbol corresponding to the local address.

  In the MAS reference code generation process 123, for the reference of the variable Y in the function F, there is information that Y is arranged on the local memory (LM_2) 222, but there is no information on which CPU the function is executed on. Therefore, the function F is determined to be referred to using the symbol GY corresponding to the global address, and the code f using the global address symbol GY is output in the object code 141. The code f means a code compiled by the compiler 120 for the function F.

  Further, in the MAS reference code generation process, with respect to the reference of the variable Y in the function G, information that the variable Y is arranged in the local memory (LM_2) 222 and information that the function G is executed by the second CPUY (CPU_2) 221 Therefore, the function G is determined to be referred to using the local address symbol LY corresponding to the local address, and the code g using the local address symbol LY is output in the object code 141. The code g means a code compiled by the compiler 120 for the function G.

  As a result, the object code including the MAS and MAS reference code in FIG. 4 includes a symbol information table including the global address symbol GY of the variable Y and the local address true LY of the variable Y, and object codes for the functions F and G. f and g are shown.

  In the processing by the linker 130, the object code 141 including the MAS and SAM reference code and the address map information 150 are input, and first, the address for the global address variable is resolved by the existing technology of the linker 130. The address map information is in accordance with the information illustrated in FIG. 2, for example, from the number of the local memory (the number of the local memory LM_1 is “1” and the number of the local memory LM_2 is “2”) to the first digit number of the global address (local memory The first digit number of the global address in LM_1 is “1” and the first digit number of the global address in the local memory LM_2 is “2”), that is, how to obtain the first address of the address for LM_n It includes information that the digit number is n and information for specifying a method for obtaining a local address from the global address, that is, information that performs a logical product of the first digit number of the address and “0x0”.

  For example, since the variable Y is first arranged in the local memory (LM_2) 222, the address of the global address symbol GY of Y is determined to be “0x2aa”, so that the global address variable corresponding to the global address symbol GY Resolve the address.

  Next, the local address resolution processing 131 determines the address of the Y local address symbol LY as “0x0aa” from the address “0x2aa” of the global address symbol GY and the address map information 150.

  The MAS address generation process 132 outputs a code that uses a local address for a local address symbol and uses a global address for a global address symbol. Accordingly, for example, a code using the address “0x2aa” for the reference to the global address symbol GY in the object code 141 and the address “0x0aa” for the reference to the local address symbol LY is output.

  As a result, the core 1 and core 2 shared load module 151 illustrated in FIG. 4 is obtained. The core 1 and core 2 shared load module 151 is composed of two functions f and g after address resolution. f and g actually represent the addresses of functions F and G, respectively. Addresses “0x2aa” and “0x0aa” appearing in the body of the function f and function g represent a global address and a local address for the variable Y, respectively. Since the variable Y is arranged in the local memory (LM_2) 222, the function g executed by the second CPU (CPU_2) 221 makes a local address reference (the first digit is 0), and the function f is the first CPU ( Since it is unknown which of the CPU_1) 211 and the second CPU (CPU_2) 221 is executed, the address for Y on the local memory (LM_2) 222 is designated by a global address (first digit is 2).

  According to the load module generation method according to the first embodiment, in a source program executed by all CPU cores, data that is referred to by a function, that is, a variable is allocated in a local memory in which CPU core, and a certain function Is executed on only one CPU, information (data / function information) indicating on which CPU it is executed is added to the source program. The compiler 120 inputs this information, determines whether to use a global address or a local address for each function, and the linker can output two different addresses related to the same variable data. In order to make it possible, two types of symbol information GY and LY and an object code (an object code including a MAS and a MAS reference code) 141 that refers to each of them are generated. The linker 130 resolves an address for a symbol having a global address using existing technology, and resolves an address for the symbol LY having a local address by reading the relationship between the two types of different addresses from the address map information 150. I did it. Further, a load module common to the first CPU core 202 and the second CPU core 201 is output by outputting a local address and a global address to the symbol GY having the global address and the symbol LY having the local address, respectively. 151 is generated.

  As a result, it is possible to determine when a certain CPU refers to certain data on the local memory in the CPU core, so that an optimum code using a local address can be output. As previously discussed by the present inventor, all address resolution is performed with a global address, and when referring to certain data on the local memory, compared to a method of converting a global address to a local address at the time of instruction execution, Speeding up of reference can be realized. In short, the high speed of processing by using a local address is not sacrificed.

  Since it can be determined that a certain function is executed on a plurality of CPU cores, a code using a global address that can be executed on the first CPU (CPU_1) 211 and the second CPU (CPU_2) 222 is output. This eliminates the need to make a copy of the function for each CPU for the same function as in the prior art, so that the amount of memory used can be reduced.

<< Load module generation program >>
The load module generation method is realized by causing a computer such as the PC system 1 to execute a load module generation program. Such a program controls compile processing by the compiler 120 and link processing by the linker 130. Compile processing inputs a source program having instruction information specifying which CPU allocates certain data on which local memory in which CPU core and which CPU executes a certain function, and based on the input information For each function, determine whether to use the global address or local address for the reference of the variable for each function, and refer to at least one of the local address symbol and the global address symbol according to the determination result What is necessary is just to perform the process which produces | generates a code | cord | chord, for example, may comprise by the said data and function information input process 121, the MAS output process 122, and the MAS reference code production | generation process 123. FIG. The link processing may be performed by assigning a global address to the global address symbol and assigning a local address to the local address symbol to generate a load module common to a plurality of CPU cores. For example, it may be configured by existing global address resolution processing, local address resolution processing 131, and MAS address generation processing.

  By using this load module generation program, the load module generation method according to the first embodiment can be easily realized.

[Embodiment 2]
FIG. 5 illustrates another processing flow for generating a load module. Here, although not particularly illustrated, a process of generating a load module of the microcomputer 2 using a computer similar to the PC system 1 of FIG. 1 will be described. A difference from FIGS. 1 and 4 is a part of processing by the compiler 120A. As a result, the processing result by the linker 130 is different. Hereinafter, details of the processing will be described focusing on the differences from FIGS.

  The compiler 120A performs the same data / function information input processing and MAS output processing as in the first embodiment. In the MAS reference code generation processing, the variable Y is a local memory (LM_2) with respect to the reference of the variable Y in the function F. Although there is no information on which CPU of the first CPU (CPU_1) 211 and the second CPU (CPU_2) 221 is the function F, the function F is the second CPU (CPU_2). Codes divided into the case of being executed at 221 and the case of being executed by another CPU are output. That is, a statement for determining whether or not the function F is executed by the second CPU (CPU_2) 221 (if (cpu == 2)). When the function F is executed by the second CPU (CPU_2) 221, the local address is set. A code (= LY) for performing a reference using the corresponding symbol LY, and a code (= GY) for performing a reference using the symbol GY corresponding to the global address when the function F is executed by another CPU. The code f is output in the object code 141 A. On the other hand, the MAS reference code output unit receives information about the variable Y being placed on the local memory (LM_2) 222 and the function G in response to the reference of the variable Y in the function G. It is determined from the information that it is executed by the 2CPU (CPU_2) 221 that the reference using the symbol LY corresponding to the local address is performed. And it outputs the code g containing a reference code (= LY) using Le LY into object code 141A.

  The processing performed by the linker 130 is the same as that of the first embodiment, but the MAS and SAM reference code-containing object code 141A shown in FIG. 5 and the address map information 150 described above are input as input. To resolve the address for the global address variable. The contents of the address map information 150 are the same as those in the first embodiment. At this time, in the MAS address generation process for the object code 141A including the MAS and the SAM reference code, for example, since the variable Y is first arranged in the local memory (LM_2) 222, the address of the Y global address symbol GY is By determining “0x2aa”, the address for the global address variable corresponding to the global address symbol GY is resolved. Next, in the local address resolution processing, from the address “0x2aa” of the global address symbol GY and the address map information 150, the address of the Y local address symbol LY is determined as “0x0aa”. The MAS address generation process 132 outputs a code that uses a local address for a local address symbol and uses a global address for a global address symbol. Accordingly, for example, a code using the address “0x2aa” for the reference to the global address symbol GY in the object code 141 and the address “0x0aa” for the reference to the local address symbol LY is output.

  As a result, the core 1 and core 2 shared load module 151A illustrated in FIG. 5 is obtained according to the description of the object code 141A including the MAS and the MAS reference code. The core 1 and core 2 shared load module 151A is composed of two functions f and g after address resolution. f and g actually represent the addresses of functions F and G, respectively. Addresses “0x2aa” and “0x0aa” appearing in the body of the function f and function g represent a global address and a local address for the variable Y, respectively. Since the variable Y is arranged in the local memory (LM_2) 222, the function g executed by the second CPU (CPU_2) 221 is referred to the local address “0x0aa”. Further, a code for determining whether or not the CPU executing the function f is the second CPU (CPU_2) 221; in the case of the second CPU (CPU_2) 221, the local address “0x0aa” is referenced; A code indicating the reference of the address “0x2aa” is generated.

  In the second embodiment, when the MAS reference code generation process refers to data on a local memory in a specific CPU core in a function that may be executed by a plurality of CPUs, the function is the specific CPU. A statement for determining whether or not the above function is executed, if the above function is executed by the specific CPU, a code for performing a reference using a symbol corresponding to a local address, and the above function is executed by another CPU. In this case, a compiler 120A is employed that outputs a code for performing a reference using a symbol corresponding to a global address to an object code. Therefore, the MAS and MAS reference code-containing object code 141A is generated with a conditional statement according to whether or not the local memory access is an access within the own CPU core according to the CPU number that executes the function F in the MAS reference code generation processing. Therefore, the CPU number for executing the function F is determined during the program execution. When the CPU number is 2, the local memory in the CPU core can be referred to at high speed. As a result, if the total time required for the determination process and the reference to the local memory in the own CPU core is less than the time for referring to the local memory in the other CPU core, the execution of the program is further accelerated than in the first embodiment. Can do.

<< Load module generation program >>
Needless to say, the load module generation method described with reference to FIG. 5 is implemented by causing a computer such as the PC system 1 to execute a load module generation program. Such a program controls the compiling process by the compiler 120A and the linking process by the linker 130. Compile processing inputs a source program having instruction information specifying which CPU allocates certain data on which local memory in which CPU core and which CPU executes a certain function, and based on the input information Each function determines whether to use the global address or local address to refer to the variable. Compile processing may be performed by generating object code that refers to at least one of the local address symbol and the global address symbol in accordance with the determination result. For example, the data / function information input processing 121 and MAS output processing 122 similar to those in the first embodiment and the MAS reference code generation processing unique to the second embodiment may be used. In this MAS reference code generation process, as described above, when a function that can be executed by a plurality of CPUs refers to data on a local memory in a specific CPU core, the function is executed by the specific CPU. Code for determining whether or not the function is executed, code for performing a reference using a symbol corresponding to the local address when the function is executed by a specific CPU, and when the function is executed by another CPU May be generated as an object code that performs a reference using a symbol corresponding to a global address. As described above, the link processing may be configured by, for example, existing global address resolution processing, local address resolution processing, and MAS address generation processing.

  By using this load module generation program, the load module generation method according to the second embodiment can be easily realized.

  Although the invention made by the present inventor has been specifically described based on the embodiments, it is needless to say that the present invention is not limited thereto and can be variously modified without departing from the gist thereof.

  For example, in a multi-CPU core system to which a load module is applied, the number of CPU cores is not limited to two, and may be three or more. The internal configuration of the computer represented by the multi-CPU core system represented by the microcomputer 2 and the PC main body 1 for controlling the generation of the load module is not limited to the description of FIG.

1 PC system 2 Microcomputer 102 PC body 110 CPU module (CPUM)
111 Hard disk drive (HDD)
112 RAM
201 First CPU core 202 Second CPU core 203 Bus 204 RAM
205 ROM
211 CPU (CPU_1)
212 Local memory (LM_1)
221 CPU (CPU_2)
222 Local memory (LM_2)
120 Compiler 130 Linker 121 Data / Function Information Input Processing 122 MAS Output Processing 123 MAS Reference Code Generation Processing 140 Source Program with Data / Function Information 141 Object Code with MAS Reference Code 150 Address Map Information 131 Local Address Resolution Processing 132 MAS Address Generation Processing 151 Load module

Claims (13)

A global address for the CPU of one CPU core among the plurality of CPU cores each having a CPU and a local memory to refer to a local memory in another CPU core, and a local memory in the CPU core of the CPU itself A load module generating method for generating a load module of a program executed by a multi-CPU core system using a local address for referring to a computer by data processing,
A source program having instruction information designating which CPU core a certain data is arranged on which local memory and which CPU executes a certain function is input, and each function is based on the input information. Determine whether to use the global address or local address to refer to the variable, and generate object code that references at least one of the local address symbol and the global address symbol according to the determination result Compilation process,
A link process that assigns a global address to a global address symbol and assigns a local address to a local address symbol for the object code, and generates a load module common to a plurality of CPU cores,
A load module generation method including:   In the compile process, when a function that is executed only on a single CPU refers to a variable on a local memory in the CPU core, a code that refers to a symbol for a local address is generated and executed on a plurality of CPUs. 2. The load module generation method according to claim 1, wherein in the case of a function, a code for referring to a global address symbol is generated to refer to the variable.   In the compile process, when a function executed only on a single CPU refers to a variable on a local memory in the CPU core, a first code that refers to a symbol for a local address is generated. In the case of a function that can be executed, a second code that selects a reference between the symbol for the local address and the symbol for the global address is generated according to the location of the CPU that executes the function and the variable to be referenced. Item 2. A load module generation method according to Item 1.   When the second code refers to data on a local memory in a specific CPU core in a function that can be executed by a plurality of CPUs, whether or not the function is executed by the specific CPU. A statement for determining whether or not the above function is executed by the specific CPU, a code for performing a reference using a local address symbol corresponding to the local address, and when the above function is executed by another CPU. 4. The load module generation method according to claim 3, further comprising: a code for performing a reference using a global address symbol corresponding to the global address.   The load module generation method according to claim 1, wherein the instruction information is information specified by a pragma statement in C language. A global address for the CPU of one CPU core among the plurality of CPU cores each having a CPU and a local memory to refer to a local memory in another CPU core, and a local memory in the CPU core of the CPU itself A load module generating method for generating a load module of a program executed by a multi-CPU core system using a local address for referring to a computer by data processing,
An input process for inputting a source program having instruction information designating which CPU allocates certain data on a local memory in which CPU core and which CPU executes a certain function;
Based on the input information, it is determined whether a global address or a local address is used for referring to the variable for each function, and at least one of the local address symbol and the global address symbol is determined according to the determination result. Code generation processing to generate object code that references one;
Address resolution processing for resolving an address for the global address symbol generated by the code generation processing, and resolving the address of the symbol for local address based on the resolved address;
When a function that is executed only on a single CPU refers to a variable on the local memory in the CPU core, a code that uses an address corresponding to the symbol for the local address may be generated and executed on multiple CPUs. When referring to a variable in a certain function, address generation processing for generating code that uses an address corresponding to the symbol for global address,
A load module generation method including: A global address for the CPU of one CPU core among the plurality of CPU cores each having a CPU and a local memory to refer to a local memory in another CPU core, and a local memory in the CPU core of the CPU itself A load module generating method for generating a load module of a program executed by a multi-CPU core system using a local address for referring to a computer by data processing,
An input process for inputting a source program having instruction information designating which CPU allocates certain data on a local memory in which CPU core and which CPU executes a certain function;
Based on the input information, when referring to a variable on a local memory in a CPU core in a function executed only by a single CPU, a first code that references a local address symbol is generated, A statement for determining whether or not the function is executed by the specific CPU when referring to data on a local memory in the specific CPU core in a function that may be executed by the CPU; Is executed by the specific CPU, a code for making a reference using a local address symbol corresponding to the local address, and a global address corresponding to the global address when the function is executed by another CPU. A code generation process for generating a second code including a code for performing a reference using a symbol for use;
Address resolution processing for resolving an address for the global address symbol generated by the code generation processing, and resolving the address of the symbol for local address based on the resolved address;
An address generation process for generating a code using a global address corresponding to a symbol for a global address with respect to the object code, and generating a code using a corresponding local address for a symbol for a local address;
A load module generation method including: A global address for the CPU of one CPU core among the plurality of CPU cores each having a CPU and a local memory to refer to a local memory in another CPU core, and a local memory in the CPU core of the CPU itself A computer-executable load module generation program for generating a load module of a program executed by a multi-CPU core system using a local address for referring to
A source program having instruction information designating which CPU core a certain data is arranged on which local memory and which CPU executes a certain function is input, and each function is based on the input information. Determine whether to use the global address or local address to refer to the variable, and generate object code that references at least one of the local address symbol and the global address symbol according to the determination result Compilation process,
A link process that assigns a global address to a global address symbol and assigns a local address to a local address symbol for the object code, and generates a load module common to a plurality of CPU cores,
Load module generation program to control   In the compile process, when a function that is executed only on a single CPU refers to a variable on a local memory in the CPU core, a code that refers to a symbol for a local address is generated and executed on a plurality of CPUs. 9. The load module generation program according to claim 8, wherein in the case of a function, control is performed to generate a code for referring to a global address symbol to refer to the variable.   In the compile process, when a function executed only on a single CPU refers to a variable on a local memory in the CPU core, a first code that refers to a symbol for a local address is generated. In the case of a function that may be executed, control is performed to generate a second code that selects a reference to the symbol for the local address and the symbol for the global address according to the location of the CPU that executes the function and the variable to be referenced. The load module generation program according to claim 8, which is executed.   When the second code refers to data on a local memory in a specific CPU core in a function that can be executed by a plurality of CPUs, whether or not the function is executed by the specific CPU. A statement for determining whether or not the above function is executed by the specific CPU, a code for performing a reference using a local address symbol corresponding to the local address, and when the above function is executed by another CPU. 11. The load module generation program according to claim 10, comprising a code for performing a reference using a global address symbol corresponding to the global address. A global address for the CPU of one CPU core among the plurality of CPU cores each having a CPU and a local memory to refer to a local memory in another CPU core, and a local memory in the CPU core of the CPU itself A computer-executable load module generation program for generating a load module of a program executed by a multi-CPU core system using a local address for referring to the computer by data processing,
An input process for inputting a source program having instruction information designating which CPU allocates certain data on a local memory in which CPU core and which CPU executes a certain function;
Based on the input information, it is determined whether a global address or a local address is used for referring to the variable for each function, and at least one of the local address symbol and the global address symbol is determined according to the determination result. Code generation processing to generate object code that references one;
Address resolution processing for resolving an address for the global address symbol generated by the code generation processing, and resolving the address of the symbol for local address based on the resolved address;
When a function that is executed only on a single CPU refers to a variable on the local memory in the CPU core, a code that uses an address corresponding to the symbol for the local address may be generated and executed on a plurality of CPUs. When referring to a variable in a certain function, address generation processing for generating code that uses an address corresponding to the symbol for global address,
Load module generation program to control A global address for the CPU of one CPU core among the plurality of CPU cores each having a CPU and a local memory to refer to a local memory in another CPU core, and a local memory in the CPU core of the CPU itself A computer-executable load module generation program for generating a load module of a program executed by a multi-CPU core system using a local address for referring to the computer by data processing,
An input process for inputting a source program having instruction information designating which CPU allocates certain data on a local memory in which CPU core and which CPU executes a certain function;
Based on the input information, when referring to a variable on a local memory in a CPU core in a function executed only by a single CPU, a first code that references a local address symbol is generated, A statement for determining whether or not the function is executed by the specific CPU when referring to data on a local memory in the specific CPU core in a function that may be executed by the CPU; Is executed by the specific CPU, a code for making a reference using a local address symbol corresponding to the local address, and a global address corresponding to the global address when the function is executed by another CPU. A code generation process for generating a second code including a code for performing a reference using a symbol for use;
Address resolution processing for resolving an address for the global address symbol generated by the code generation processing, and resolving the address of the symbol for local address based on the resolved address;
An address generation process for generating a code using a global address corresponding to a symbol for a global address with respect to the object code, and generating a code using a corresponding local address for a symbol for a local address;
Load module generation program to control

Images