JP2005332333A - Grouping program and source code generator - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To reduce variation of complexity of functions of source codes to be generated from a model in a model base development environment. <P>SOLUTION: A personal computer 1 reads block groups continued by connection from a storage medium as grouping candidate parts from a specified model (a step 105) and cumulatively calculates the complexity of the read grouping candidate parts based on connection relation by kinds of the block groups and the connection of the block groups (a step 110). Then, when the calculated complexity is within a predetermined complexity reference range (steps 115, 130), the grouping candidate parts after blocks are newly included are made into subsystems (a step 135). Then, a C source code using the subsystems as one function is generated. <P>COPYRIGHT: (C)2006,JPO&NCIPI

Description

  The present invention generates a source code that realizes processing represented by a model, reads grouping information indicating that the constituent parts of the model are grouped at the time of generation, and converts the constituent parts into the source The present invention relates to a source code generation device as one function in code and a grouping program for generating grouping information to be read by the source code generation device.

  Conventionally, for example, in a program for operating an engine ECU of a vehicle, the developer does not directly describe the source code of the program, and the function of the target program is easier to create and has a better visibility In some cases (for example, see Patent Document 1).

  A developer uses a workstation, personal computer, or the like in which a program development environment corresponding to this model is installed, to automatically generate source code from the model. A program for realizing the function of generating source code from a model is called a code generation tool. Code generation tools are often built into model development environments. Program development that generates source code from a model is called model-based development.

  As a program development environment corresponding to model-based development, for example, there is Matlab (registered trademark) of Mothworks (registered trademark). In Matlab (registered trademark), a developer describes a model of a target program using Simulink (registered trademark) which is one function of Matlab (registered trademark).

  The model is described as a combination of functional units called blocks and connection lines indicating input / output relationships between the functional units. That is, an aggregate in which a plurality of blocks are connected by connection is a model.

  As a specific example of the block, one or both of input (import) and output of a signal are expressed. The contents of signal input and output are based on a predetermined rule assigned to the block. As a block, for example, a block that expresses the output of a sine function with the input signal as a variable, a block that expresses reading data from a file, and the result of performing specific four arithmetic operations on the input data There are a block expressing the output of a signal, a plurality of blocks, a subsystem as an upper block in which connections are grouped, and the like.

  The connection represents the connection between the output of one block and the input of another block. Specifically, if a ring is connected from the output of the block that represents the sine function and the output of the block that represents the staircase function to each input of the product operation block, the sine function and the staircase function are multiplied. It is expressed that it becomes a target item.

In such model-based development, a developer creates a model, and then automatically generates source code from the model using a code generation tool. At this time, the code generation tool converts each subsystem included in the model into one function in the source code.
Japanese Patent Laid-Open No. 2000-20291

  Such a conventional code generation tool converts a subsystem into a function regardless of the configuration of the internal blocks of the subsystem. Accordingly, the complexity of the function in the generated source code may be very large or very small depending on the size of the subsystem.

  In such a case, the execution efficiency of the object code generated from the source code and the inspection efficiency of the source code are deteriorated. Specifically, if there are many functions with too low complexity, useless processing time is spent on the overhead of function calls when executing object code. In addition, functions that are too complex have a huge amount of inspection scenarios during the quality inspection of the source code, and it takes time, and it is difficult to perform a coverage test to identify portions that are not actually executed in the source code. .

  In view of the above points, the present invention has an object to reduce the variation in the complexity of the function of the source code generated from the model in the model-based development environment.

  The feature of the present invention for achieving such an object is that “a source code that realizes a process expressed by a model is generated, and the components of the model are grouped at the time of generation. When the grouping information is read out, the grouping program for generating grouping information for causing the source code generation apparatus that reads the component as one function in the source code to read out the arithmetic unit, the (1) model Are read from the storage medium as grouping candidate parts, (2) the complexity of the read grouping candidate parts is calculated, and (3) the calculated complexity falls within a predetermined complexity reference range In some cases, the grouping information is made to function as a device that writes grouping information for grouping the grouping candidate portions to a storage medium.

  Since this is the case, the source code generation device reads out the grouping information for the constituent parts of the model whose complexity is within the predetermined complexity reference range, and the grouped constituent parts are read in the source code. Let it be one function. Therefore, the function in the source code has a complexity corresponding to the above-described predetermined complexity reference range, so that the complexity of the function of the source code generated from the model can be reduced.

  The function in the present invention is a concept including a class and a subroutine.

  In addition, source code that realizes signal processing expressed by “a model having a block that expresses output of a signal based on a predetermined rule and a connection that expresses a signal input / output connection between the blocks” When the grouping information indicating that the constituent parts of the model are grouped is read out at the time of the generation, the constituent parts are read into a source code generation device that functions as one function in the source code. A grouping program for generating grouping information to be output causes the computing device to read out (1) a block group connected by the connection from the storage medium as a grouping candidate part, and (2) the read grouping candidate part And (3) the calculated complexity is a predetermined complexity base. If within the range, the object of the invention is achieved also by function as an apparatus for writing grouping information indicating grouping the grouping candidate portions in the storage medium.

  In addition, the block group connected by the connection is that “any two different blocks included in the block group are connected via only one or more connections and zero or more blocks included in the block group. Such a block group.

  Further, the arithmetic unit may function by the grouping program so as to calculate the complexity of the read grouping candidate portion by weighting based on the type of block included in the grouping candidate portion.

  Further, according to the grouping program, the arithmetic unit sequentially reads out an output destination block that has undergone one connection from one block included in the grouping candidate portion from the storage medium and includes it in the grouping candidate portion. The grouping candidate part is updated, and when the calculated complexity exceeds a predetermined complexity threshold due to the presence of a newly included block, the block is newly included or before it is included The grouping information for grouping the grouping candidate portions may be written to the storage medium.

  In addition, the grouping program causes the arithmetic unit to cause the calculated complexity to exceed a predetermined complexity threshold due to the presence of a newly included block, and the grouping candidate portion forms one loop. Grouping information indicating that the remaining part of the group of blocks forming the loop is excluded from the grouping candidate part is grouped when only a part of the block and a block outside the loop are included It may function to write to.

  Further, the above-described invention calculates the complexity of the storage medium storing the model, the reading unit that reads the constituent parts of the model from the storage medium as the grouping candidate part, and the grouping candidate part read by the reading unit. A calculating unit that writes the grouping information for grouping the grouping candidate parts to the storage medium when the complexity calculated by the calculating unit is within a predetermined complexity reference range; Source code generation means for generating a source code that realizes the processing expressed by the model, based on the written grouping information of the model, as a function of one component part related to the grouping information of the model It can also be realized as a source code generator.

  Hereinafter, an embodiment of the present invention will be described. FIG. 1 shows a configuration of a personal computer 1 as a source code generation device according to the present embodiment. The personal computer 1 includes a display 11, an input device 12, a RAM 13, a ROM 14, an HDD (hard disk drive) 15, a CPU (corresponding to a computing device) 16, and the like.

  The display 11 displays the video signal input from the CPU 16 as a video to the user (developer).

  The input device 12 includes a keyboard, a mouse, and the like, and outputs a signal corresponding to the operation to the CPU 16 when operated by the user.

 The RAM 13 is a readable / writable volatile memory, the ROM 14 is a read-only nonvolatile memory, and the HDD 15 is a readable / writable nonvolatile memory. In the ROM 14 and the HDD 15, programs that are read and executed by the CPU 16 are stored in advance. The HDD 15 stores a model to be described later.

  The RAM 13 is used as a storage area for temporarily storing the program when the CPU 16 executes the program stored in the ROM 14 and the HDD 15 and a storage area for temporarily storing work data. .

  When the CPU 16 is started by turning on the power of the personal computer 1, the CPU 16 reads and executes a predetermined boot program from the ROM 14, and loads an operating system (hereinafter referred to as OS) and other programs defined in the boot program from the HDD 15. The activation process is performed by reading and executing. After the startup process, until the power is turned off, the CPU 16 executes various programs recorded in the HDD 15 as processes on the OS based on a signal from the input device 12, a schedule predetermined by the OS, and the like. . In the startup process and process described above, the CPU 16 receives a signal input from the input device 12 as necessary, outputs a video signal to the display 11, and controls data read / write to the RAM 13 and the HDD 15. I do.

  The configuration of a program executed by the CPU 16 of the personal computer 1 is shown in FIG. The CPU 16 executes a source code generation program 21, a subsystemization program 22, and the like.

  Hereinafter, the operation of the CPU 16 by executing the program will be described as the operation of the executed program itself.

  The source code generation program 21 reads a model stored in the HDD 15 and generates source code for realizing signal processing expressed by the read model.

  The model includes a block that represents outputting a signal based on a predetermined rule, and a connection that represents a connection of input and output of signals between the blocks. Such a model is created when the user uses a program executed by the CPU 16 on the OS, such as a model editor (not shown), and further stored in the HDD 15.

  As the model editor, for example, software called Simulink (registered trademark) operating on Matlab (registered trademark) can be used.

  FIG. 3 shows an example of a model created by such a model editor. In the figure, a block is a rectangle or circle. The block has either or both of an input end and an output end, and performs predetermined signal processing. The signal processing is based on a signal received from the input terminal if the block has an input terminal. If the block has an output end, the signal processing result is output from the output end.

  Moreover, the arrow line which connects between blocks represents a connection. The connection is such that the output end of the block is the starting point and the input end of the block is the end point. Note that the starting point and the ending point of the connection refer to an end point without an arrow and an end point with an arrow, respectively, representing the connection.

  The connection between the output end of a certain block A and the input end of a certain block B indicates that the output from the output end of the block A is input at the input end of the block B. That is, the connection represents the input / output relationship between the blocks.

  In FIG. 3, blocks 301, 302, 303, and 309 are IF blocks for conditional branching. The IF block has three input terminals including a condition signal input terminal (second input terminal from the top in the figure), and the other is based on whether the signal from the condition signal input terminal is on or off. One of the signals received from the two input terminals is output.

  Blocks 304 to 308 are four arithmetic operation blocks, which perform predetermined addition, subtraction, multiplication, and division using signals received from a plurality of input terminals, and output the results.

  Further, blocks other than blocks 301 to 309 in FIG. 3 are a data read block for outputting predetermined data stored in advance in the RAM 13, HDD 15 or the like, or a data write block for storing input data in the RAM 13, HDD 15 or the like. It is.

  FIG. 4 shows C source code generated by the source code generation program 21 based on the block of FIG.

  The first if block in the source code of FIG. 5 realizes the function of the block 301 and the related data read block, the second if block realizes the function of the block 302 and the related data read block, and the third The if block realizes the function of the block 303 and the data read block related thereto, and the fourth if block realizes the function of the block 309 and the data read block and data write block related thereto.

  In the fourth if block, the right side of the assignment expression in the first brace {} implements the functions of the blocks 304, 305, 306 and the data read block related thereto, and the second brace {} The right side of the substitution formula realizes the functions of the blocks 307 and 308 and the data read block related thereto.

  In addition, when generating the source code, the source code generation program 21 uses signal processing expressed by a group of blocks grouped as one subsystem in the model as one function in the source code. Here, the fact that the block group in the model is grouped as a subsystem itself corresponds to information indicating that the block group is grouped, that is, grouping information.

  As the source code generation program 21 as described above, C source code based on a model created by Simulink (registered trademark) called Real Time Workshop (registered trademark) that operates on Matlab (registered trademark) is generated. Software can be used.

  The subsystemization program 22 reads a model stored in the HDD 15, converts a part of the model into a subsystem based on a predetermined standard related to the complexity of the model, and converts the part of the model into the HDD 15. It is a program for memorizing. Subsystemization refers to grouping a plurality of blocks in a model into one subsystem. Then, storing the model having the subsystemized components in the HDD 15 corresponds to storing the grouping information.

  For example, in Real Time Workshop (registered trademark), the user selects a part of the model displayed on the display 11 using the input device 12, and further performs an operation for substituting them into the subsystem. By using this, the subsystemization is realized. In the present embodiment, the subsystemization program 22 realizes subsystemization by automatically performing such processing.

  FIG. 5 shows a flowchart of this subsystemization program 22. In step 105, the subsystemization program 22 reads one block from the model stored in the HDD 15 as a part of the model specified by the user by operating the input device 12 or the like, and reads it as one of the grouping candidate portions. Include in one. The inclusion in the grouping candidate portion specifically means that the block is registered in the grouping candidate list in the RAM 13. The grouping candidate list is a table including the names of blocks included in the grouping candidate portion, the cumulative complexity described later for each block, and For Loop starting point information described later.

Here, the block to be read is specifically one of the blocks satisfying either of the following conditions (1) and (2).
Condition (1): Condition that does not have an input terminal (2): Each block that is connected to its own input terminal via one connection is already subsystemized or registered in the grouping candidate list Then, to which grouping candidate list the read block is registered is determined based on the following criteria (1) and criteria (2).

  Criterion (1): If the read block does not have an input end, or all of the blocks connected to the input end of the block through one connection are already subsystemized, A new grouping candidate list is generated, and the read block is registered in the generated grouping candidate list.

  Criterion (2): When the read block has at least one “input end connected to the block registered in the grouping candidate list via one connection”, the one or more grouping candidates The lists are combined into one, and the read blocks are registered in the grouping candidate list combined into one. When grouping candidate lists are combined into one, the grouping candidate list that is grouped includes the information if the grouping candidate list before the grouping includes For loop start point information.

  In this way, the subsystemization program 22 generates the grouping candidate list, so that the grouping candidate part is a new grouping candidate part from one block included in the grouping candidate part to the output destination block. By being included, it is updated sequentially. As a result, the grouping candidate portion becomes a block group connected by connection. In addition, the block group connected by the connection is that “any two different blocks included in the block group are connected via only one or more connections and zero or more blocks included in the block group. Such a block group.

  Next, in step 110, the complexity of the grouping candidate part corresponding to the grouping candidate list including the block read immediately before is determined by the type of block included in the grouping candidate list and the connection between the blocks. Calculate based on relationships. Specifically, along the connection between the blocks, the complexity is sequentially inherited from the output side block to the input side block, and the complexity in the last block is set as a grouping candidate. Let the complexity of the part. The method of cumulative inheritance of complexity in each block is determined in advance for each block type and stored in the HDD 15.

  In the present embodiment, the number of output patterns is used as the complexity. The cumulative inheritance method in the if block, comparison block, and switch block is the sum of the cumulative number of output patterns in the block connected to each of the two input terminals other than the condition signal input terminal via one connection. Is to take. Further, the cumulative inheritance method in the four arithmetic operation blocks is to take the total product of the cumulative number of output patterns in the block connected to each of the plurality of input terminals through one connection.

  In step 110, for this calculation, the type of the block read immediately before is specified, and the cumulative number of output patterns in the block connected to the input end of the block via one connection is read from the block candidate list, Based on the cumulative inheritance method of the type of the block, the operation specified by the inheritance method is performed on the read output pattern number, and the calculation result is set as the cumulative output pattern number in the block, Further, the calculation result is set as the number of output patterns as the complexity of the grouping candidate portion.

  In the present embodiment, it is assumed that the number of output patterns in a block having no input terminal is 2. Further, it is assumed that the number of output patterns from the subsystems subsystemized by the subsystemization program 22 is one.

Next, in step 112, when the grouping candidate list including the block read immediately before enters the For loop, the For loop start point information having the position of the block as the For loop start position is added to the grouping candidate list. include. Note that “the grouping candidate list including the block read immediately before has entered the For loop” means that the block read immediately before is in the subsystem constituting the For loop and the discussion block is The included grouping candidate list can be specified by not including any other block inside the subsystem constituting the For loop.

  Next, in step 115, it is determined whether or not the calculated complexity of the grouping candidate portion is smaller than a predetermined threshold (for example, 10). If it is smaller, then step 120 is executed. Step 130 is executed.

  In step 120, it is determined whether or not reading of all the blocks of the specified model is completed, that is, whether or not the block read immediately before is the block read last in the model. .

  If all blocks have been read, then step 125 is executed. If not, step 105 is executed.

  In step 125, the current grouping candidate portion, that is, the grouping candidate portion including the block read immediately before is formed into a subsystem. However, when only the relevant block is included in the grouping candidate portion, the subsystem is not formed. After step 125, execution of subsystemization program 22 ends.

  In step 130, it is determined whether or not the block read immediately before is a block in the For loop. If it is a block in the For loop, step 135 is subsequently executed, and if it is not a block in the For loop, step 145 is subsequently executed.

  In step 135, as in step 125, the current grouping candidate portion is made into a subsystem. After step 135, the process of step 105 is subsequently executed.

  In step 145, the blocks up to immediately before the For loop start position in the current grouping candidate portion are made into subsystems. Specifically, the block at the For loop start position is identified from the block candidate list for the current grouping candidate portion based on the For loop start point information stored in Step 112, and the identified block and the output of the block are identified. Blocks connected after the end are deleted from the block candidate list, and the remaining blocks are made into subsystems. When there are two or more start points of the block in the start point information, the remaining portion is made into a subsystem for each block connected by connection.

  After step 145, the process of step 105 is subsequently executed.

  By executing the subsystemization program 22 as described above, the CPU 16 reads from the storage medium a group of blocks connected by connection as a grouping candidate portion from the specified model (see step 105), and the grouping thus read out The complexity of the candidate part is cumulatively calculated based on the type of block group and the connection relationship by connection of the block group (see step 110).

  If the calculated complexity is within the predetermined complexity reference range, that is, the new block is included in the grouping candidate portion, the complexity exceeds the predetermined complexity threshold (see step 115). ), And if it is possible to generate C source code having the grouping candidate part as an independent function (see step 130), the grouping candidate part is sub-systemized after the block is newly included. (See step 135).

  Here, “when it is possible to generate C source code having the grouping candidate part as an independent function” means “only a part of a block group in which the grouping candidate part forms a For loop” This corresponds to a case other than the case where a block outside the For loop is included.

  Further, the CPU 16 adds a new block to the grouping candidate part, so that the complexity exceeds a predetermined complexity threshold (see step 115), and the C source code uses the grouping candidate part as an independent function. When it is impossible to generate (see step 130), the remaining part of the group of blocks forming the For loop is removed from the grouping candidate part and the remaining part is made into a subsystem (see step 145). .

  In such processing, the loop by returning from step 120, 135, 145 to step 105 is repeated, whereby subsystemization is performed for all blocks of the specified model.

  Note that the grouping candidate portion before the block is newly included may be made into a subsystem instead of the grouping candidate portion after the block is newly included.

  FIG. 6 shows a model that the subsystemization program 22 outputs to the HDD 15 when the model shown in FIG. 3 is specified and the subsystemization program 22 is executed. However, in this example, the threshold value for the number of output patterns described above is 10.

  In FIG. 6, a block group including the block 303 and the preceding block is sub-systemized as a sub-system 401. In the remaining block group, the last block (that is, a block having no output end) is sub-systemized as a sub-system 402.

  This is realized by calculating the number of output patterns by executing the subsystemized program 22 as follows. That is, the number of output patterns in the if blocks 301 and 302 is (2 + 2) = 4, the number of output patterns in the if block 303 is (4 + 4) = 8, and the number of output patterns in the product operation block 304 is (8 × 2) = 16 Therefore, in step 115 immediately after reading the product operation block 304, the complexity exceeds the threshold value, and in step 135, the block group including the product operation block 304 and the previous block of the product operation block 304 is made into a subsystem.

  The number of output patterns in the sum operation block 305 is (2 × 1) = 2, the number of output patterns in the difference operation block 306 is (2 × 2) = 4, and the number of output patterns in the product operation block 307 is (2 × 1). 2) = 4, the number of output patterns in the product operation block 308 is (2 × 4) = 8, and the number of output patterns in the if block 309 is (4 + 8) = 12. Therefore, in step 115 immediately after reading the if block 309, the complexity exceeds the threshold value, and in step 135, a block group consisting of blocks preceding the product operation block 309 (except for the block group of the subsystem 401) is sub Systematized.

  FIG. 7 shows the C source code generated by the source code generation program 21 based on the model after being subsystemized in this manner.

  The function sample1sub_cal () at the bottom of FIG. 7 is a part showing the entire model of FIG. 6, and the functions Subsystem1 () and Subsystem2 () called in this function are parts corresponding to the subsystems 401 and 402, respectively. It is. Thus, the source code generation program 21 generates C source code with the subsystem as one function.

  At this time, since the subsystems are partitioned based on a predetermined complexity threshold value, the complexity of the generated function is small. Therefore, C source code having a function maintaining an appropriate complexity is generated.

  Next, FIG. 8 shows a model having a subsystem 801 indicating a For loop as another example of the model.

  A block 601 is a comparison block that outputs a larger value of two inputs, and a block 602 is a comparison block that outputs a smaller value of two inputs. Also, block 609 outputs which of the signals received from the other three input terminals based on whether the condition signal received from the uppermost input terminal in the figure indicates 1, 2, or 3. This is a switch block for selecting.

  The For sub-system 801 is a sub-system representing a function that repeatedly executes a function by a block included in the sub-system for a certain number of times. FIG. 9 shows C source code generated by the source code generation program 21 based on the model of FIG.

  In FIG. 9, a part for realizing the function of the For subsystem 801 is a for source block 901.

  In this way, the processing shown in the For subsystem 801 in FIG. 8 is realized by the source code generation program 21 as the source code inside the for source block 901, and as a result, the number of times corresponding to the variable NUM The process is repeated.

  Only a part of such a for source block cannot be functionalized with other source code. Therefore, even if only a part of the block group inside the For subsystem 801 is made into a subsystem together with the block outside the For subsystem 801, a source code that functions normally cannot be generated.

  When the subsystemized program 22 is executed after a model as shown in FIG. 8 is designated, only a part of the blocks constituting the For subsystem 801 is processed by the above-described steps 112, 130, and 145. Can be sub-systemized so that it is not sub-systemized with other external blocks. In this case, it is assumed that the complexity threshold is 10.

  Specifically, by executing the subsystemization program 22, the CPU 16 calculates the number of output patterns as follows. That is, the number of output patterns in the comparison block 601 is (2 + 2) = 4, and the number of output patterns in the comparison block 602 is (2 + 4) = 6.

  Then, when the block 603 is read in step 105, For loop start point information having the position of this block as the For loop start position is added to the grouping candidate list in step 112.

  The number of output patterns in the comparison block 602 is (6 × 2) = 12. At this time, since the number of output patterns exceeds the threshold value (see step 115) and the current block is in the for loop (see step 130), the CPU 16 performs step 145 until the for loop start position, that is, block 602. And the previous stage is made into a subsystem. This corresponds to the subsystem 701 in FIG.

  The number of output patterns in the product operation block 603 is (1 × 2) = 2, the number of output patterns in the product operation block 604 is (2 × 2) = 4, and the number of output patterns in the product operation block 605 is (4 × 2) = 8, and the number of output patterns in the product calculation block 606 is (8 × 2) = 16. Here, since the number of output patterns exceeds the threshold value, a block group (except for the block group of the subsystem 701) consisting of the preceding block of the product operation block 606 is made into a subsystem in step 135. This corresponds to the subsystem 702 in FIG.

  Further, the number of output patterns in the sum calculation block 607 is (2 × 2) = 4, the number of output patterns in the difference calculation block 608 is (2 × 1) = 2, and the number of output patterns in the switch block 609 is (1 + 4 + 2) = 7 and the number of output patterns in the last data write block is 7. Therefore, since all blocks have been read before the complexity exceeds the threshold value (see step 120), blocks included in the current grouping list, that is, blocks not included in the subsystems 701 and 702 are included in the subsystem. It becomes. This corresponds to the subsystem 703 in FIG.

  FIG. 11 shows the C source code generated by the source code generation program 21 based on the model that has been subsystemized by executing the subsystemization program 22 in this manner.

  The function sample2_cal () at the bottom of FIG. 11 is a part showing the entire model of FIG. 6, and the functions Subsystem 1 (), Subsystem 2 () and Subsystem 3 () called in this function are subsystems 701 and 702, respectively. And 703.

  At this time, since the subsystems are partitioned based on a predetermined complexity threshold value, the complexity of the generated function is small. Therefore, C source code having a function maintaining an appropriate complexity is generated. In addition, since only a part of the blocks constituting the For subsystem 801 is not subsystemized together with other blocks, a normal executable source code is generated.

  In the above-described embodiment, the subsystemization program 22 corresponds to a grouping program, the personal computer 1 corresponds to a source code generation device, and the RAM and HDD correspond to storage media.

  Further, the CPU 16 functions as a reading unit by executing the processing of step 105 of the subsystemization program 22.

  Further, the CPU 16 functions as a calculation unit by executing the processing of step 110 of the subsystemization program 22.

  Further, the CPU 16 functions as a writing unit by executing the processing of steps 115, 130, 135, and 145 of the subsystemization program 22.

  Further, the CPU 16 functions as source code generation means by executing the source code generation program 21.

  In addition, the above-described subsystemization program 22 prevents only a part of the blocks constituting the For loop from being subsystemized together with other blocks by the processing of steps 112, 130, and 145. The target for preventing only a part of the component from being subsystemized together with other blocks is not necessarily limited to the For loop. For example, the above-described processing may be performed for all Simulink (registered trademark) atomic subsystems, such as a while loop subsystem. That is, in the For loop, when only a part of the constituting blocks is made into a subsystem together with other external blocks, the source code generation program 21 that generates the subsystem as a function cannot generate a normal program. Can be generalized as a component of the model.

  In the above-described embodiment, the number of output patterns is used as the complexity of the block group. In addition to this, the number of blocks, the display area occupied by the block group when the model is displayed on the display 11, etc. May be used. Further, the number of nesting, the number of code lines, the number of loops, the number of substitution variables, and the like corresponding to the block group in the generated source code may be used as the complexity of the block group.

  Whether or not an index is complexity is specified by whether or not there is a strong correlation between the value of the index for a group of blocks and the total number of blocks in the block group. Can do.

  The block described as the data read block in the above embodiment is shown as an example of a block for which a complexity value may be arbitrarily set, and may not necessarily be realized as a data read block.

  Also, the method of cumulative inheritance of complexity for each block type may be input using the input device 12.

  The source code generated by the source code generation program 21 is not limited to the programming language C. Java (registered trademark) or C ++ source code may be used.

1 is a diagram illustrating a configuration of a personal computer 1. FIG. It is a figure which shows the program which CPU16 performs. It is a figure which shows an example of a model. It is a figure which shows the C source code which the source code generation program 21 produced | generated based on the model shown in FIG. It is a flowchart of the subsystemization program 22. It is a figure which shows the model which the subsystem-ized program 22 produces | generates based on the model shown in FIG. It is a figure which shows the C source code which the source code generation program 21 produced | generated based on the model shown in FIG. It is a figure which shows an example of the model which has a For loop. It is a figure which shows the C source code which the source code generation program 21 produced | generated based on the model shown in FIG. It is a figure which shows the model which the subsystem-ized program 22 produces | generates based on the model shown in FIG. It is a figure which shows the C source code which the source code generation program 21 produced | generated based on the model shown in FIG.

Explanation of symbols

DESCRIPTION OF SYMBOLS 1 ... Personal computer, 11 ... Display, 12 ... Input device, 13 ... RAM,
14 ... ROM, 15 ... HDD, 16 ... CPU, 21 ... Source code generation program,
22 ... Subsystemization program, 301 to 309 ... block,
401, 402 ... subsystem, 601-609 ... block,
701 to 703 ... subsystem, 801 ... For loop subsystem,
901 ... for source block.

Claims (6)

When source code that realizes processing represented by a model is generated and grouping information indicating that the constituent parts of the model are grouped at the time of generation is generated, the constituent parts are represented as 1 in the source code. A grouping program for generating grouping information to be read by a source code generation device as one function,
Reading means for reading out the constituent parts of the model from the storage medium as grouping candidate parts,
A calculating unit that calculates the complexity of the grouping candidate portion read by the reading unit; and, when the complexity calculated by the calculating unit is within a predetermined complexity reference range, the grouping candidate portion is grouped A grouping program for causing an arithmetic unit to function as writing means for writing grouping information to a storage medium. Generating a source code that realizes signal processing expressed by a block that expresses output of a signal based on a predetermined rule and a model that has a connection that expresses a connection of input and output of signals between the blocks, and At the time of generation, when the grouping information indicating that the constituent parts of the model are grouped is read, the source code generating apparatus that reads the constituent parts as one function in the source code A grouping program for generating grouping information,
Reading means for reading from the storage medium the group of blocks connected by the connection as a grouping candidate part,
A calculation unit that calculates the complexity of the grouping candidate portion read by the reading unit based on a connection relationship by connection of the block group, and the complexity calculated by the calculation unit is within a predetermined complexity reference range A grouping program that causes the arithmetic unit to function as a writing unit that writes grouping information for grouping the grouping candidate portions to a storage medium. The grouping program according to claim 2, wherein the calculating unit calculates the complexity of the grouping candidate portion read by the reading unit based on a type of a block included in the grouping candidate portion. . The reading means newly reads an output destination block from one block included in the grouping candidate portion from one storage medium and includes it in the grouping candidate portion so that the grouping candidate portions are sequentially added. Updated,
When the complexity calculated by the calculation unit exceeds a predetermined complexity threshold due to the presence of a newly included block, the writing unit is a group after or before the block is newly included 4. The grouping program according to claim 2, wherein grouping information for grouping candidate groups is written to a storage medium. The writing means has a complexity calculated by the calculating means exceeding a predetermined complexity threshold due to the presence of a newly included block, and the grouping candidate portion is a block group that forms one loop. When only a part and a block outside the loop are included, grouping information indicating that the remaining part of the group of blocks forming the loop is excluded from the grouping candidate part is written to the storage medium. The grouping program according to claim 4, wherein: A storage medium storing the model;
Reading means for reading the constituent parts of the model from the storage medium as grouping candidate parts;
Calculating means for calculating the complexity of the grouping candidate portion read by the reading means;
A writing unit that writes grouping information for grouping the grouping candidate parts to a storage medium when the complexity calculated by the calculating unit is within a predetermined complexity reference range;
Based on the grouping information of the model written by the writing unit, the source code generating unit that generates the source code that realizes the processing expressed by the model, having as a function of one component part related to the grouping information of the model And a source code generation device.

Images