JP2009199175A - Program dividing device and method thereof - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To solve the problem that dividing a program manually is cumbersome. <P>SOLUTION: An object data volume retaining part 10 retains a reference object data volume as a reference data volume. An end position setting part 14 determines a temporary end position of a division program starting at a start position specified by the division start position information detected by a start position information detection part 12. A conversion direction part 20 directs a predetermined compiler 200 to compile a temporary division program defined by the start position and the temporary end position determined by the end position setting part 14. A conversion result acquisition part 22 acquires an object data volume corresponding to the result of the conversion by the compiler 200 according to the direction by the conversion direction part 20 as an acquired data volume. A control part 24 compares the reference data volume retained by the object data volume retaining part 10 with the acquired data volume acquired by the conversion result acquisition part 22, and controls the end position setting part 14 according to the comparison result. <P>COPYRIGHT: (C)2009,JPO&INPIT

Description

  The present invention relates to a program dividing apparatus and a dividing method for dividing a program.

  In recent years, programming utilizing multi-threading has become popular. Multithreading is a technique in which one application is divided into a plurality of threads and processed in parallel by a processor. By dividing the processing time into very short units and processing them in order to a plurality of threads, it is possible to make a single core processor seem to perform a plurality of processes simultaneously.

  When the source program is divided into threads and processed in a time-sharing manner, the real-time property is impaired unless it is divided appropriately. The same applies when a multi-core processor simultaneously processes more threads than the number of cores.

  When a reconfigurable processor whose circuit configuration can be dynamically changed is used, a large amount of work is required to obtain the division position. The reconfigurable processor includes an ALU array in which multi-functional elements having a plurality of basic arithmetic functions called ALU (Arithmetic Logic Unit) are arranged in multiple stages. In a reconfigurable processor, it is difficult to estimate the number of execution steps necessary for executing the description from the description of the source program, and thus a suitable division position cannot be easily obtained.

  The applicant divided the source program to be executed by the reconfigurable processor by trial and error. That is, dividing the source program manually, compiling the divided program to obtain the number of execution steps, and determining the next division position based on the number of execution steps, the acquired number of execution steps is The process was repeated until the maximum number of execution steps was reached.

Patent Document 2 discloses a method for generating an embedded program that performs programming by combining processing blocks through GUI operations. This method calculates the hardware resource data, program capacity, and number of cycles required for the generated program based on the library information about the processing block, and the generated program exceeds the performance of one processor. In this case, the source program is generated separately for a plurality of processors connected in parallel or in series.
JP 2006-4345 A JP 2007-80049 A

  The manual division as described above is complicated and reduces the development efficiency of the application. The present invention has been made in view of such circumstances, and an object of the present invention is to provide a program dividing apparatus and method capable of easily dividing a source program at a suitable position.

  A program dividing apparatus according to an aspect of the present invention is a program dividing apparatus that divides a source program, an object data amount holding unit that holds a reference object data amount as a reference data amount, and a division start from within the source program A start position information detecting unit for detecting position information, an end position setting unit for determining a provisional end position of a divided program starting from a start position specified by the division start position information detected by the start position information detecting unit, and a start position A conversion instruction unit that instructs a predetermined compiler to compile a provisional divided program defined by the provisional end position determined by the end position setting unit, and a conversion result of the compiler according to the instruction by the conversion instruction unit A conversion result acquisition unit that acquires the object data amount as an acquisition data amount; and an object Comprises a reference amount of data held by Todeta amount holding unit, the conversion result is compared with the acquired amount of data acquired by the acquisition unit, and a control unit for controlling the end position setting unit according to the comparison result. The control unit controls the end position setting unit to change the provisional end position so that the reference data amount and the acquired data amount match or approach each other.

  Yet another embodiment of the present invention is a program dividing device. This apparatus is a program dividing apparatus that divides a source program, and includes a start position information detection unit that detects division start position information from within the source program, and an end position information detection unit that detects division end position information from within the source program. And a division program defined by the start position specified by the division start position information detected by the start position information detection unit and the end position specified by the division end position information detected by the end position information detection unit A conversion instruction unit that instructs a predetermined compiler to compile, and a conversion result acquisition unit that acquires a conversion result of the compiler according to an instruction from the conversion instruction unit.

  It should be noted that any combination of the above-described constituent elements and a conversion of the expression of the present invention between a method, an apparatus, a system, a recording medium, a computer program, and the like are also effective as an aspect of the present invention.

  According to the present invention, a source program can be easily divided at a suitable position.

  FIG. 1 is a block diagram illustrating a configuration of an information processing system 300 according to the first embodiment. The information processing system 300 includes a program dividing device 100 and a compiler 200. The program dividing apparatus 100 includes an object data amount holding unit 10, a start position information detecting unit 12, an end position setting unit 14, a temporary divided program registration unit 16, a temporary divided program holding unit 18, a conversion instruction unit 20, and a conversion result acquisition unit 22. And a control unit 24.

  These configurations can be realized in terms of hardware by a CPU, memory, or other LSI of an arbitrary computer, and in terms of software, they are realized by programs loaded in the memory. Draw functional blocks. Therefore, those skilled in the art will understand that these functional blocks can be realized in various forms by hardware only, software only, or a combination thereof.

  The object data amount holding unit 10 holds the object data amount to be used as a reference as a reference data amount. The amount of object data to be used as a reference may be the number of execution steps per unit time of the processor or the amount of object data defined by the used memory size. More specifically, it may be the maximum number of execution steps that can be executed per unit time of the processor, or the maximum memory area that can be used.

  The amount of object data to be used as a reference is an arithmetic unit array including y (y is an integer of 2 or more) arithmetic units, or two-dimensionally arranged in x × y (x and y are integers of 2 or more). Further, it may be an object data amount defined by the number of steps that can be executed in m (m is a natural number) cycles in an arithmetic array including a plurality of arithmetic units. In particular, the latter is a standard that can be applied when a reconfigurable processor is used. Details of this will be described later.

  The start position information detection unit 12 detects division start position information from within the source program. This source program is described in a high-level language such as C language, and division start position information is added to a position where division is to start. The division start position information is embedded as a comment by a program or the like. Further, when the program dividing apparatus 100 is implemented as a GUI operation tool in an integrated development environment, division start position information may be added by a mouse operation or the like. In many cases, the division start position information is added to a line where a substantial process is started in a portion describing a unit operation process that is semantically or functionally grouped. This unit calculation process may be regarded as a subroutine or a function.

  The end position setting unit 14 determines a provisional end position of the division program starting from the start position specified by the division start position information detected by the start position information detection unit 12. In the basic example of the first embodiment, a line advanced by a predetermined number of lines from the start position specified by the division start position information in the source program is set as the initial value of the provisional end position. For example, it may be a line advanced by one line. Hereinafter, the provisional end position is changed by an instruction from the control unit 24. The provisional end position does not exceed the last line of the unit calculation process including the start position.

  The temporary division program registration unit 16 registers the temporary division program in the temporary division program holding unit 18. When registering the temporary division program, descriptions other than those defined by the start position and the provisional end position are deleted from the unit calculation processing including the start position. Descriptions before and after the unit operation processing and unnecessary descriptions such as functions that are not executed in the provisional division program are deleted when compiled by the compiler 200, and therefore need not be deleted here. However, it is necessary to attach deletion-prohibited identification information to the compiler 200 so that the comment for operation assistance that should be left, such as designation of a sequencer to be described later, is not deleted.

  The temporary division program registration unit 16 registers the temporary division program every time the temporary end position is changed. Even when the provisional end position is changed, if there is an instruction from the control unit 24 that it is not necessary to register, registration is not performed.

  The temporary division program holding unit 18 holds the temporary division program registered by the temporary division program registration unit 16. All temporary division programs registered by the temporary division program registration unit 16 may be held, or only the most recently registered temporary division program may be held, and the previously registered temporary division program may be deleted. Good.

  The conversion instruction unit 20 instructs a predetermined compiler 200 to compile a provisional division program defined by the start position and the provisional end position determined by the end position setting unit 14. The data to be passed to the compiler 200 may be the same as the data that the temporary divided program registration unit 16 passes to the temporary divided program holding unit 18.

  The conversion instruction unit 20 instructs the compiler 200 to convert the temporary divided program every time the provisional end position is changed. Even when the provisional end position is changed, if the control unit 24 instructs the compiler 200 not to instruct compilation, the compiler 200 is not instructed.

  The conversion result acquisition unit 22 acquires the object data amount corresponding to the conversion result of the compiler 200 in accordance with the instruction from the conversion instruction unit 20 as the acquisition data amount. The conversion result acquisition unit 22 may acquire the acquired data amount in the same format as the reference data amount, for example, the number of execution steps of the processor, or may specify the number of execution steps from the acquired object file.

  The control unit 24 compares the reference data amount held by the object data amount holding unit 10 with the acquired data amount acquired by the conversion result acquisition unit 22, and controls the end position setting unit 14 according to the comparison result. To do. The control unit 24 controls the end position setting unit 14 to change the provisional end position so that the reference data amount and the acquired data amount match or approach each other. Exceptionally, if the provisional division program includes all unit operation processing including the start position, and the acquired data amount that is the conversion result of the provisional division program is smaller than the reference data amount, the difference between the two data amounts is brought closer. Instead, the temporary division program is made an official division program.

  More specific description will be given below. When the acquired data amount is less than the reference data amount and the provisional end position has not reached the end of the unit calculation process including the start position, the control unit 24 sets the provisional end position to n (n is a natural number) rows, The end position setting unit 14 is instructed to proceed. When the acquired data amount exceeds the reference data amount, the control unit 24 sets the temporary divided program registered last before exceeding the temporary divided program holding unit 18 as the formal divided program. When the acquired data amount matches the reference data amount, the control unit 24 sets the temporary division program at that time as a formal division program. Even when the provisional end position reaches the end of the unit calculation process, the provisional division program at that time is set as a formal division program.

  When the provisional end position reaches a lower nest than the nest of the start position, the control unit 24 instructs the conversion instruction unit 20 not to instruct the compiler 200 to compile the temporary divided program, and is the same as the start position. The end position setting unit 14 is instructed to advance the provisional end position until the nest is reached. Since the division is not performed in the unit calculation process lower than the unit calculation process including the start position, unnecessary registration and compilation of the temporary divided program can be avoided.

  When the conversion result acquisition unit 22 acquires an error from the compiler 200, the control unit 24 instructs the temporary division program registration unit 16 not to register the temporary division program at that time in the temporary division program holding unit 18. An error occurs if it is split at a position that should not be split grammatically. For example, If. . Sentence, elseif. . Sentences, else sentences, etc. cannot be cut grammatically in the middle of a sentence.

  The compiler 200 compiles the temporary division program instructed from the conversion instruction unit 20 and passes the conversion result to the conversion result acquisition unit 22. Note that the same format as the reference data amount held in the object data amount holding unit 10, for example, the number of execution steps of the processor may be output, or the object file may be simply passed to the conversion result acquisition unit 22. If an error occurs during conversion, the conversion result acquisition unit 22 is notified of this.

  FIG. 2 is a flowchart showing an operation example of the program dividing apparatus 100 according to the first embodiment. It is assumed that the maximum number of execution steps of the processor per unit time is held in the object data amount holding unit 10 as a reference data amount. In addition, it is assumed that a comment specifying the division start position is embedded in the source program to be divided.

  First, a source program file is read into the program dividing apparatus 100 (S10), and the start position information detection unit 12 checks whether or not the division start position is embedded as a comment in the source program (S12). If the comment is not embedded (N in S12), the process is terminated as impossible. If it is embedded (Y in S12), the process proceeds to the next process.

  The start position information detection unit 12 sets the line with the comment as the division start position, and the end position setting unit 14 sets the initial value of the provisional end position at which the next line of the line is to be divided (S14). . The provisional division program registration unit 16 deletes the description of the source program that is not related from the start position to the provisional end position within the function with the comment (hereinafter referred to as an entry function as appropriate) (S16). At that time, the initial value is assigned to a variable for which no initial value is set, such as a variable whose value needs to be called from the header file.

  The temporary division program registration unit 16 temporarily stores the source program after the deletion of the description as a temporary division program file in the temporary division program holding unit 18 (S18). At this time, the function name of the temporary divided program may be changed from the function name in the pre-division source program to the function name described in the parameter file used by the compiler 200.

  The conversion instruction unit 20 causes the compiler 200 to compile the provisional division program (S20). The control unit 24 determines whether the conversion result acquisition unit 22 has received an error notification from the compiler 200 (S22). If not received (N in S22), the process proceeds to step S24. If received (Y in S22), the process proceeds to step S30. The occurrence of an error indicates that the program is a temporary division program divided at a position where it cannot be divided, and the processes in steps S24, S26, and S28 do not need to be executed, and those processes are skipped. Note that the temporary divided program in which an error has occurred is deleted from the temporary divided program holding unit 18.

  In step S24, the conversion result acquisition unit 22 acquires the number of execution steps as a conversion result from the compiler 200 (S24). The control unit 24 determines whether or not the number of execution steps is smaller than the reference data amount (S26). If the number of execution steps is smaller than the reference data amount (N in S26), the process proceeds to step S28. If the number of execution steps is equal to or greater than the reference data amount (Y in S26), the process proceeds to step S36.

  In step S28, the control unit 24 determines whether or not the provisional end position has exceeded the last line of the entry function (S28). If it exceeds the last line of the entry function (Y in S28), the process proceeds to step S38. If it does not exceed the final line of the entry function (N in S28), the process proceeds to step S30.

  The end position setting unit 14 increments the provisional end position by one line in accordance with an instruction from the control unit 24 (S30). The control unit 24 determines whether or not the incremented provisional end position has entered a lower nest than the entry function (S32). For example, this corresponds to a case where the provisional end position enters a loop such as a for sentence, a while sentence, and a do while sentence. If the lower nest is entered (Y in S32), the process proceeds to step S30, and the temporary end position is incremented until the lower nest is exited (N in S32). If the lower nest is left, or if the lower nest is not entered (N in S32), the process proceeds to step S34.

  The control unit 24 determines whether or not the provisional end position has entered a higher nest than the entry function (S34). When the upper nest is entered (Y in S34), the process proceeds to step S38. Since the target division position has been reached, no new division is performed. If it is not in the upper nest (N in S34), the process proceeds to step S16, and the division at the new division position is continued.

  In step S26, when the number of execution steps acquired is equal to or larger than the reference data amount (Y in S26), the control unit 24 determines whether or not the number of execution steps matches the reference data amount (S36). . If they match (Y in S36), the temporary division program stored last in the temporary division program holding unit 18 is determined to be an official division program (S37). If they do not match (N in S36), the temporary division program previously stored in the temporary division program holding unit 18 is determined as an official division program (S38).

  The control unit 24 deletes unnecessary descriptions such as functions that are not used in the split program before and after the entry function from the split program determined in step S37 or step S38, and converts the final split program into a split source program file. (S39). Thus, the entire process ends.

  FIG. 3 is a diagram illustrating a configuration of a processor 500 equipped with the reconfigurable circuit 50 that is to execute the division program according to the embodiment. The processor 500 includes a setting data holding unit 30, a sequencer device 40, a reconfigurable circuit 50, and an output data holding unit 60.

  The setting data holding unit 30 holds setting data for configuring a desired circuit in the reconfigurable circuit 50 and supplies the setting data to the reconfigurable circuit 50. The sequencer device 40 selects setting data to be supplied from the setting data holding unit 30 to the reconfigurable circuit 50.

  The reconfigurable circuit 50 has a plurality of ALUs whose functions can be changed. Specifically, an x × y ALU array in which x ALUs in the vertical direction and y ALUs in the horizontal direction are arranged is provided. Here, four are arranged in the vertical direction and six are arranged in the horizontal direction. In addition to the ALU array, a connection unit that can set the connection relationship between the output of the preceding ALU column and the input of the subsequent ALU column is provided. The function of each ALU and the connection relationship between each ALU are set by the setting data. Normally, one stage of ALU (y units) operates simultaneously with one clock. The amount of the program executed by this one-stage ALU is the basic execution unit of the thread.

  The output data holding unit 60 holds data output from the reconfigurable circuit 50. This data can be output to the outside or fed back to the input of the reconfigurable circuit 50.

  As described above, the number of execution steps of the processor can be adopted as the amount of object data to be used as a reference. In a processor having a reconfigurable configuration as shown in FIG. 3, the number of execution steps can be defined as follows. First, a process that can be executed in one cycle of one ALU array arranged in the horizontal direction can be defined as the number of unit execution steps. Furthermore, a process that can be executed in one cycle of the entire ALU array arranged x in the vertical direction and y in the horizontal direction can be defined as the number of unit execution steps. When the number of execution steps is set as m as the reference data amount, the maximum amount of programs that can be executed by using one stage or the entire ALU array m times is the maximum amount of threads to be divided. If the entire ALU array is used as a reference, the free time of the ALU column can be suppressed, and commands can be assigned more efficiently.

  As shown in FIG. 3, the processor 500 has a configuration in which the data output to the output data holding unit 60 is fed back to the first stage of the reconfigurable circuit 50. Therefore, even when the reconfigurable circuit 50 is used for a plurality of cycles. The total number of stages can be used as the reference data amount as it is.

  Hereinafter, a source program dividing process using the program dividing apparatus 100 according to the first embodiment and a process of causing the processor 500 shown in FIG. 3 to execute the divided program divided by the process will be described using an actual specific example. explain.

  FIG. 4 shows a first example of a source program in which the division start position to be divided by the program dividing apparatus 100 according to the first embodiment is embedded as a comment. FIG. 5 shows a provisional division program of the source program of FIG. FIG. 6 shows a final divided program of the source program of FIG. FIG. 7 shows a data flow graph corresponding to the source program of FIG. FIG. 8 shows a data flow graph corresponding to the source program of FIG.

  The data flow graph here represents the dependency of the execution order between the operations to be executed by each ALU of the reconfigurable circuit 50, and shows the flow of operations of input variables and constants in a graph format. is there. 7 and 8 show data flow graphs to be executed by the reconfigurable circuit 50 having a 4 × 6 ALU array. In each data flow graph, “◯” indicates an operation instruction (hereinafter referred to as a node as appropriate), and “□” indicates an input variable or output variable. If the arrangement configuration of the ALU array corresponds to the configuration of the data flow graph, the number of unit execution steps is one stage of data flow graph (corresponding to one stage of the ALU array) or one unit (corresponding to the entire ALU array). Can be captured.

Hereinafter, in this example, it is assumed that the processing that can be executed by the 4 × 6 ALU array is the unit execution step number, and the execution step number = 2 is set as the reference data amount described above.
The source program shown in FIG. 4 executes arithmetic processing for sequentially adding the values stored in elements 0 to 7 of the array x and adding the values of the variables z1 and z2 to the value after the addition. Specifically, the variable y = 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 100 + 200 is calculated.

  In this source program, a comment “_VMSIZE_CHK_START_” is embedded. When the start position information detection unit 12 detects this comment, the start position information detection unit 12 sets this line as the start position to be divided.

  FIG. 5 shows the temporary division program divided at the end of the for sentence. That is, the addition of the variable z1 and the variable z2 to the variable y is not included. In FIG. 5, the function name in the temporary division program is “divide_tmp”.

  FIG. 6 shows an officially determined division program. Since the division position is the same as the provisional division program of FIG. 5, it can be seen that the division position is the maximum division position that satisfies the reference data amount. In FIG. 6, the function name in the formal division program is “Divide_Result”.

  FIG. 7 is a data flow graph in which the source program of FIG. “MOV” in the node is through, and “+” is addition processing. Here, since the number of execution steps = 3, that is, the time when the final result is output is the third cycle of the ALU array, the condition of the number of execution steps = 2, which is the reference data amount, is not satisfied.

  FIG. 8 is a data flow graph in which the source program of FIG. Here, the number of execution steps = 2, that is, the time when the final result is output is the final stage of the second cycle of the ALU array, so the condition of the number of execution steps = 2, which is the reference data amount, is satisfied.

  FIG. 9 shows a second example of a source program in which the division start position to be divided by the program dividing apparatus 100 according to the first embodiment is embedded as a comment. FIG. 10 shows a provisional division program of the source program of FIG. FIG. 11 shows a final divided program of the source program of FIG. FIG. 12 shows a data flow graph corresponding to the source program of FIG. FIG. 13 shows a data flow graph corresponding to the source program of FIG.

Hereinafter, in this example, it is assumed that processing that can be executed by a 4 × 6 ALU array is the number of unit execution steps, and the number of execution steps = 3 is set as the reference data amount described above.
The basic structure of the source program of FIG. 9 is that when the variable EXT_in1 read from the header file is smaller than 0, “variable G_aaa” = “variable G_aaa1” + 2 + 3 + “variable EXT_in1” +1 is calculated. G_aaa ”=“ variable G_aaa ”+ 1 + 1 is calculated.

  A comment “_VMSIZE_CHK_START” is embedded in the source program. When the start position information detection unit 12 detects this comment, the start position information detection unit 12 sets this line as the start position to be divided.

  FIG. 10 shows a temporary division program that is divided at the end of the “if” sentence that appears for the second time. That is, the third and fourth if statements are not included. FIG. 11 shows an officially determined division program. Since the division position is the same as the temporary division program of FIG. 10, it can be seen that the division position is the maximum division position that satisfies the reference data amount. Comparing FIG. 10 with FIG. 11, it can be seen that void func3 () {G_aaa + = 3;} is deleted in FIG. This process is a function executed based on the determination result of the third if statement, and is an unnecessary description and deleted as long as the third if statement is not included in the divided program.

  FIG. 12 is a data flow graph in which the source program of FIG. 9 is converted by the compiler 200. A solid line between nodes indicates an actual data flow, and a dotted line indicates a flow of a control signal, for example, a condition determination result. “> =” And “! =” In the node are condition determination processing, and “merge” is processing to switch input data in accordance with a control signal. For example, “merge” in the node located in the second row of the second row of the data flow graph receives “1” in response to a control signal from the node located in the first row or the first row, or sets the variable “G_stage”. Decide whether to import.

  In the data flow graph of FIG. 12, the number of execution steps = 4, that is, the time point when the final result is output is the fourth cycle of the ALU array, so the condition of the number of execution steps = 3, which is the reference data amount, is not satisfied.

  FIG. 13 is a data flow graph in which the source program of FIG. 11 is converted by the compiler 200. Here, the number of execution steps = 3, that is, the time point when the final result is output is the final stage of the third cycle of the ALU array, so the condition of the number of execution steps = 3 which is the reference data amount is satisfied.

  Next, a modification of the program dividing apparatus 100 according to the first embodiment will be described. In this modification, the provisional end position is not moved sequentially as in the basic example, but the provisional end position is moved using a bisection method.

Hereinafter, operations different from the basic example of the components shown in FIG. 1 will be described.
The end position setting unit 14 includes, in the source program to be divided, the line of the start position specified by the division start position information detected by the start position information detection unit 12 and the last line of the unit calculation process including the start position. The line at half the position is the initial value of the provisional end position. If the number of lines in the whole unit operation process is not divisible, round down or round up to the nearest whole number. Hereinafter, the same applies to other divisions in this modification.

  When the acquired data amount exceeds the reference data amount, the control unit 24 initially moved the quarter number of lines from the start position line to the last line, and the second and subsequent times, the temporary end position was moved last time. The end position setting unit 14 is instructed to return the number of lines that is half the number of lines. Conversely, when the amount of acquired data is less than the reference data amount, the number of rows from the start position to the last row is ¼ at the beginning, and the number of rows from which the provisional end position has been moved last time after the second time. The end position setting unit 14 is instructed to advance by half the number of lines. When the acquired data amount matches the reference data amount, the temporary division program last registered in the temporary division program holding unit 18 is set as a formal division program. When the provisional end position is the number of lines moved last time, among the temporary division programs whose acquired data amount is equal to or less than the reference data amount, the temporary division program last registered in the temporary division program holding unit 18 is officially divided. A program.

  The control unit 24 may instruct not to register the temporary division program when the acquired data amount exceeds the reference data amount in the temporary division program registration unit 16 or after being registered in the temporary division program holding unit 18. The temporary division program may be deleted from the temporary division program holding unit 18.

  FIG. 14 is a flowchart showing an operation example of the program dividing apparatus 100 according to the modification of the first embodiment. It is assumed that the maximum number of execution steps of the processor per unit time is held in the object data amount holding unit 10 as a reference data amount. In addition, it is assumed that a comment specifying the division start position is embedded in the source program to be divided.

  First, a source program file is read into the program dividing apparatus 100 (S40), and the start position information detection unit 12 checks whether or not the division start position is embedded as a comment in the source program (S42). If the comment is not embedded (N in S42), the process ends as impossible. If it is embedded (Y in S42), the process proceeds to the next process.

  The start position information detection unit 12 sets the line with the comment as the division start position, and the end position setting unit 14 divides the line located at half of the line and the last line of the function including the line. Set to the initial value of the provisional end position (S44). The provisional division program registration unit 16 deletes the description of the source program that is not related from the start position to the provisional end position in the entry function (S46). The temporary division program registration unit 16 temporarily stores the source program after the deletion of the description as a temporary division program file in the temporary division program holding unit 18 (S48).

  The conversion instruction unit 20 causes the compiler 200 to compile the temporary divided program (S50). The conversion result acquisition unit 22 acquires the number of execution steps as a conversion result from the compiler 200 (S52). The control unit 24 determines whether or not the number of execution steps matches the reference data amount (S54). If they match (Y in S54), the process proceeds to step S64. If they do not match (N in S54), the process proceeds to step S56.

  In step S56, the control unit 24 determines whether or not the provisional end position can be further moved by the bisection method (S56). When the previous number of moving lines is one, it becomes impossible to move. If it is movable (Y in S56), the process proceeds to step S58, and if it is not movable (N in S56), the process proceeds to step S64.

  In step S58, the control unit 24 determines whether the acquired number of execution steps is larger or smaller than the reference data amount (S58). If larger (Y in S58), the end position setting unit 14 is instructed to retract the provisional end position by the bisection method. Specifically, an instruction is given to reverse the number of lines that is half the number of lines moved last time (S60). If it is smaller (N in S58), the end position setting unit 14 is instructed to advance the provisional end position by the bisection method (S62). Specifically, an instruction is given to advance the number of lines that is half the number of lines moved last time. After step S60 or step S62, the process proceeds to step S46, and the division at the new division position is continued.

  In step S64, the control unit 24 determines that the temporary division program registered last among the temporary division programs whose acquired number of execution steps is equal to or larger than the reference data amount is an official division program (S64).

  Although not described in the flowchart, if this formal divided program is one for which an error has been notified from the compiler 200, the end position of the divided program is moved backward to a position where no error occurs when compiling. The setting unit 14 is instructed, and the provisional division program at that position is determined as an official division program.

  In addition, if the end position of the formal division program is in a nest lower than the nest of the start position, the end position is set so that the end position of the temporary division program is moved backward to a position that is the same as the nest of the start position. The unit 14 is instructed. The temporary division program at that position is determined to be an official division program.

  The control unit 24 deletes unnecessary descriptions such as functions not used in the divided program before and after the entry function from the official divided program, and generates a final divided program as a divided source program file (S66). Thus, the entire process ends.

  As described above, according to the first embodiment, the system determines the end position as an optimal position simply by registering the object amount to be used as a reference and specifying the division start position. The program can be divided at a suitable position. It is possible to divide at a position where the maximum processing amount that guarantees real-time performance can be executed. As a result, when a plurality of threads are processed in a time-sharing manner, the entire processing time can be shortened while ensuring the real-time property of each thread. Therefore, it is possible to improve the development efficiency of an application that supports multithreading. In particular, it is effective when developing an application that is required to be executed in a processor equipped with a reconfigurable circuit and that is required to keep the number of execution steps below a certain value in a short cycle time.

  In addition, by actually compiling the temporary divided program and obtaining the number of execution steps, the accurate number of execution steps reflecting the optimization by the compiler can be obtained. It is difficult to obtain an accurate number of execution steps that reflect optimization simply by making predictions based on library information.

  In addition, when the bisection method is employed to search for the optimal end position, the time until the optimal end position is searched can be leveled. The control unit 24 may determine whether to employ sequential search or bisection search according to the length of the unit calculation process including the start position. That is, the former is adopted when the number is shorter than the predetermined number of rows, and the latter is adopted when the number is longer. Thereby, the search time to the optimal end position can be further optimized.

  FIG. 15 is a block diagram illustrating a configuration of the information processing system 300 according to the second embodiment. The information processing system 300 includes a program dividing device 100 and a compiler 200. The program dividing apparatus 100 includes a start position information detection unit 12, an end position information detection unit 15, a conversion instruction unit 20, and a conversion result acquisition unit 22.

  The start position information detection unit 12 detects division start position information from within the source program. The end position information detection unit 15 detects division end position information from within the source program. In this source program, division start position information is added to the position where the division is to be ended, similarly to the division start position information.

  The conversion instruction unit 20 is defined by a start position specified by the division start position information detected by the start position information detection unit 12 and an end position specified by the division end position information detected by the end position information detection unit. The predetermined compiler 200 is instructed to compile the divided program. The conversion result acquisition unit 22 acquires the conversion result of the compiler 200 according to the instruction from the conversion instruction unit 20. Here, at least one of the object data amount and the presence / absence of an error is acquired. When the object data amount is defined by the number of execution steps, the object data amount may be acquired from the compiler 200 as the number of execution steps of the processor, or the number of execution steps of the processor is obtained from the acquired object file on the program dividing device 100 side. May be.

  FIG. 16 is a flowchart showing an operation example of the program dividing apparatus 100 according to the second embodiment. As a premise, it is assumed that a comment specifying the division start position and a comment specifying the division end position are embedded in the source program to be divided.

  First, a source program file is read into the program dividing apparatus 100 (S70), and the start position information detection unit 12 and the end position information detection unit 15 embed the division start position and the division end position as comments in the source program, respectively. It is investigated whether it exists (S72). If at least one of the comments is not embedded (N in S72), the process ends as impossible. If both are embedded (Y in S72), the process proceeds to the next process.

  The start position information detection unit 12 and the end position information detection unit 15 delete the description of the source program that is not related from the start position to the end position in the entry function with the comment (S74). The conversion instruction unit 20 causes the compiler 200 to compile the divided program from the start position to the end position (S76). The conversion result acquisition unit 22 determines whether an error notification has been received from the compiler 200 (S78). If it is received (Y in S78), it is not necessary to acquire the number of execution steps, and the process is terminated. If not received (N in S78), the number of execution steps is acquired from the compiler 200 (S80). The conversion result acquisition unit 22 deletes unnecessary descriptions such as functions not used in the divided program before and after the entry function from the divided program, and generates a final divided program as a divided source program file (S82). Thus, the entire process ends.

  FIG. 17 shows a source program in which the division start position to be divided by the program dividing apparatus 100 according to the second embodiment is embedded as a comment. FIG. 18 shows a final divided program of the source program of FIG. FIG. 19 shows a data flow graph corresponding to the source program of FIG.

  The source program of FIG. 17 is a program for executing the same calculation as the source program of FIG. 4 described above. In this source program, comments “_VMSIZE_CHK_START_” and “_VMSIZE_CHK_END_” are embedded. When the start position information detection unit 12 detects “_VMSIZE_CHK_START_”, this line is set as the division start position. When the end position information detection unit 15 detects “_VMSIZE_CHK_END_”, the end position information detection unit 15 sets this line as the division end position. In FIG. 18, in the entry function, the range-specified arithmetic processing, that is, descriptions other than “y + = z1” and “y + = z2” are deleted as unnecessary descriptions. FIG. 19 is a data flow graph in which the source program of FIG. When the entire ALU array is defined as the number of unit execution steps, the number of execution steps = 1, and when one stage of the ALU array is defined as the number of unit execution steps, the number of execution steps = 3.

  As described above, according to the second embodiment, it is possible to easily confirm the exact number of execution steps after compilation of the divided program to be divided simply by specifying the division start position and the division end position. . It is also possible to easily confirm whether or not an error occurs when dividing at that position.

  The present invention has been described based on some embodiments. It is understood by those skilled in the art that these embodiments are exemplifications, and that various modifications can be made to combinations of the respective constituent elements and processing processes, and such modifications are also within the scope of the present invention. By the way.

  For example, in the above-described first embodiment, the number of execution steps is used as the reference data amount (determination process such as step S26), but instead of this, what may become a bottleneck, such as the amount of memory used or the number of memory accesses, is used. It may be used as a reference data amount. Further, a plurality of reference data amounts corresponding to a plurality of elements may be combined, and determination may be made based on whether or not at least one element exceeds the reference data amount corresponding thereto.

  In the flowcharts of FIGS. 2 and 14, if the division start position is not embedded as a comment, the process ends as an error. In this regard, the division start position may be set at the head of the source program to be divided without ending. In this case, the fact that no comment or the like is attached may be regarded as division start position information that designates the division start position at the head.

  In the flowchart of FIG. 2, when the temporary end position reaches a nest lower than the start position, compilation is skipped until the nest of the peer is reached. Also good.

1 is a block diagram illustrating a configuration of an information processing system according to a first embodiment. 4 is a flowchart illustrating an operation example of the program dividing device according to the first embodiment. It is a figure which shows the structure of the processor carrying the reconfigurable circuit which should run the division | segmentation program which concerns on embodiment. It is a figure which shows the 1st example of the source program with which the division | segmentation start position which should be divided | segmented with the program division | segmentation apparatus which concerns on Embodiment 1 is embedded as a comment. It is a figure which shows the temporary division | segmentation program of the source program of FIG. It is a figure which shows the final division | segmentation program of the source program of FIG. It is a figure which shows the data flow graph corresponding to the source program of FIG. It is a figure which shows the data flow graph corresponding to the source program of FIG. It is a figure which shows the 2nd example of the source program with which the division | segmentation start position which should be divided | segmented with the program division | segmentation apparatus which concerns on Embodiment 1 is embedded as a comment. It is a figure which shows the temporary division | segmentation program of the source program of FIG. It is a figure which shows the final division | segmentation program of the source program of FIG. It is a figure which shows the data flow graph corresponding to the source program of FIG. It is a figure which shows the data flow graph corresponding to the source program of FIG. 10 is a flowchart showing an operation example of a program dividing apparatus according to a modification of the first embodiment. 6 is a block diagram showing a configuration of an information processing system according to Embodiment 2. FIG. 10 is a flowchart illustrating an operation example of the program dividing device according to the second embodiment. It is a figure which shows the source program by which the division | segmentation start position which should be divided | segmented with the program division | segmentation apparatus which concerns on Embodiment 2 is embedded as a comment. It is a figure which shows the final division | segmentation program of the source program of FIG. It is a figure which shows the data flow graph corresponding to the source program of FIG.

Explanation of symbols

  DESCRIPTION OF SYMBOLS 10 Object data amount holding | maintenance part, 12 Start position information detection part, 14 End position setting part, 15 End position information detection part, 16 Temporary division program registration part, 18 Temporary division program holding part, 20 Conversion instruction | indication part, 22 Conversion result acquisition Unit, 24 control unit, 30 setting data holding unit, 40 sequencer device, 50 reconfigurable circuit, 60 output data holding unit, 100 program dividing device, 200 compiler, 300 information processing system, 500 processor.

Claims (10)

A program dividing device for dividing a source program,
An object data amount holding unit for holding, as a reference data amount, an object data amount to be a reference;
A start position information detecting unit for detecting division start position information from within the source program;
An end position setting unit for determining a provisional end position of a division program starting from a start position specified by the division start position information detected by the start position information detection unit;
A conversion instruction unit for instructing a predetermined compiler to compile the provisional division program defined by the start position and the provisional end position determined by the end position setting unit;
A conversion result acquisition unit that acquires, as an acquisition data amount, an object data amount corresponding to the conversion result of the compiler in response to an instruction from the conversion instruction unit;
A control unit that compares the reference data amount held by the object data amount holding unit with the acquisition data amount acquired by the conversion result acquisition unit, and controls the end position setting unit according to the comparison result; With
The said control part controls the said end position setting part so that the said provisional end position may be changed so that the said reference | standard data amount and the said acquisition data amount may correspond or approach, The program division | segmentation apparatus characterized by the above-mentioned. The end position setting unit sets a line advanced by a predetermined number of lines with respect to the start position specified by the division start position information in the source program as an initial value of the provisional end position,
The control unit, when the acquired data amount is less than the reference data amount, and the provisional end position has not reached the end of the semantically or functionally unit operation processing including the start position, Instructing the end position setting unit to advance the provisional end position by n (n is a natural number) lines,
2. The program dividing apparatus according to claim 1, wherein when the provisional end position reaches the end of the unit calculation process, the temporary dividing program at that time is an official dividing program. A temporary division program holding unit for holding the temporary division program;
A temporary division program registration unit for registering the temporary division program in the temporary division program holding unit each time the provisional end position is changed;
The conversion instruction unit instructs the compiler to compile the temporary divided program every time the temporary end position is changed,
The control unit, when the acquired data amount exceeds the reference data amount, sets the temporary division program registered last before exceeding the temporary division program holding unit as a formal division program. Item 3. The program dividing device according to Item 1 or 2.   The control unit instructs the conversion instruction unit not to instruct the compiler to compile the temporary divided program when the provisional end position reaches a lower nest than the start position nest, and the start position 4. The program dividing device according to claim 1, wherein the end position setting unit is instructed to advance the provisional end position until the nest of the same level is reached. 5. A temporary division program holding unit for holding the temporary division program;
A temporary division program registration unit for registering the temporary division program in the temporary division program holding unit each time the provisional end position is changed;
The end position setting unit includes, in the source program, a line of a start position specified by the division start position information and a final line of a unit operation process that is semantically or functionally grouped including the start position. The line at half the position is the initial value of the provisional end position,
When the acquired data amount exceeds the reference data amount, the control unit initially sets a quarter number of lines from the start position line to the last line, and after the second time, sets the provisional end position to the previous time. Instruct the end position setting unit to return the number of lines that is half the number of moved lines,
When the amount of acquired data is less than the reference data amount, initially, the number of lines is ¼ from the line at the start position to the last line, and after the second time, the provisional end position is the number of lines that have been moved last time. Instruct the end position setting unit to advance by half the number of lines,
When the temporary end position is the number of lines moved last time, among the temporary division programs whose acquired data amount is equal to or less than the reference data amount, the temporary division program last registered in the temporary division program holding unit is formally The program dividing apparatus according to claim 1, wherein the program dividing apparatus is a unique dividing program.   When the conversion result acquisition unit acquires an error from the compiler, the control unit instructs the temporary division program registration unit not to register the temporary division program at that time in the temporary division program holding unit. The program dividing apparatus according to claim 3 or 5.   7. The program division according to claim 1, wherein the object data amount holding unit holds an object data amount defined by the number of execution steps per unit time of a processor or a used memory size. apparatus.   The object data amount holding unit is a computing unit array including y computing units (y is an integer of 2 or more), or a plurality of two-dimensionally arranged x × y (x and y are integers of 2 or more). 7. The program dividing apparatus according to claim 1, wherein an object data amount defined by the number of steps executable in m (m is a natural number) cycle is held in an arithmetic array including an arithmetic unit. . A dividing method for dividing a source program,
A first step of holding the object data amount to be a reference as a reference data amount in the object data amount holding unit;
A second step of detecting division start position information from within the source program by a start position information detection unit;
A third step of determining a provisional end position of the division program starting from the start position specified by the division start position information detected by the start position information detection section by the end position setting section;
A fourth step of instructing a predetermined compiler to compile a provisional division program defined by the start position and the provisional end position determined by the end position setting unit by a conversion instruction unit;
A fifth step of acquiring, by the conversion result acquisition unit, an object data amount corresponding to the conversion result of the compiler in accordance with an instruction from the conversion instruction unit as an acquisition data amount;
The reference data amount held by the object data amount holding unit is compared with the acquired data amount acquired by the conversion result acquiring unit, and the end position setting unit is controlled by the control unit according to the comparison result. 6 steps,
In the sixth step, the end position setting unit is controlled so as to change the provisional end position so that the reference data amount and the acquired data amount match or approach each other. A program dividing device for dividing a source program,
A start position information detecting unit for detecting division start position information from within the source program;
An end position information detection unit for detecting division end position information from within the source program;
A division program defined by a start position specified by the division start position information detected by the start position information detection unit and an end position specified by the division end position information detected by the end position information detection unit A conversion instruction section for instructing a predetermined compiler to compile,
A conversion result acquisition unit that acquires a conversion result of the compiler in response to an instruction from the conversion instruction unit;
A program dividing apparatus comprising:

Images