JP6137962B2 - Information processing apparatus, information processing method, and program - Google Patents

Description

  The present invention relates to an information processing apparatus, an information processing method, and a program.

Algorithm development for signal processing programs such as image processing is often performed using floating point arithmetic. In the hardware design stage, the user considers mounting the developed algorithm on the hardware. At this time, the user manually converts from a reference program previously described by floating point arithmetic using a C language program or the like to a program described by integer / fixed point arithmetic with a fixed bit width. ing.
When a user manually converts a floating-point arithmetic program to an integer / fixed-point arithmetic program, a user uses a class library called SystemC, which is a kind of hardware description language, that can be compiled with a C ++ language compiler. There is. The SystemC class library provides a type that supports integer / fixed-point conversion called sc_int. In the sc_int type, a bit width is fixedly defined using a template which is a function provided by the C ++ language as a type on a program code. For this reason, when the user wants to change the bit width and obtain the execution result, the user needs to change the program code and compile again to generate the object program.
As a method for supporting conversion of a program using floating point to a program using integer / fixed point, the following method is disclosed.

Patent Document 1 discloses the following technique. First, the technique disclosed in Patent Document 1 uses an attribute value such as a fixed-point bit width as pre-processing for searching an attribute value such as a bit width for conversion to a program using an integer / fixed point. Determine the initial value to be set. The technique disclosed in Patent Document 1 acquires a history of values to be assigned to variables of a floating-point program, and determines an initial value from the maximum value and the minimum value of the absolute value of the assigned value. The technique disclosed in Patent Document 1 creates a program using integer / fixed-point variables using the determined initial value, compiles the created program, executes the compiled program, and an execution result is desired. Evaluate whether the accuracy is satisfied. When the evaluation result does not satisfy the desired accuracy, the technique disclosed in Patent Document 1 corrects the program again to change the attribute value such as the bit width, compiles the corrected program, and again Run the compiled program and evaluate the execution results. As described above, the technique disclosed in Patent Literature 1 determines integer / fixed-point attribute values by repeating trials of program correction, compilation, and execution result evaluation.
In Patent Document 2, a numerical element used in a program using floating point is extracted, an assignment expression or an arithmetic expression in the program is analyzed, and the numerical element data is obtained based on the relation information of each numerical element. A technique for determining a type attribute value is disclosed.

JP 2008-33729 A JP 2001-101012 A

When a floating-point variable in a program is manually converted to a fixed-point variable, the user needs to rewrite and recompile the program every time the bit width is changed.
The technique disclosed in Patent Document 1 automatically determines the bit width of a variable, but evaluates accuracy for each variable to determine the bit width. However, when the desired accuracy is not satisfied after the evaluation of the execution result, the technique disclosed in Patent Document 1 needs to be changed after the program is changed and compiled in order to change the bit width. .
The technique disclosed in Patent Document 2 analyzes a partial substitution expression or arithmetic expression in a program, and determines a data type attribute value based on relation information of each variable. Even in the technique disclosed in Patent Document 2, if the desired accuracy is not satisfied after the evaluation of the execution result, in order to change the bit width, it is necessary to change the program again, compile and execute it.
An object of the present invention is to provide a technique for reducing the examination time when examining attributes of a type such as the bit width of a variable in integer / fixed-point conversion.

  Therefore, the present invention provides a reading unit that reads the compiled program in which the attribute of the target variable is parameterized, and the program based on the parameter information related to the attribute when executing processing based on the program read by the reading unit. Setting means for setting an attribute value for the attribute of the target variable, and execution means for executing processing based on a program in which the attribute value is set by the setting means.

  ADVANTAGE OF THE INVENTION According to this invention, the technique which reduces examination time can be provided in the case of examination of type attributes, such as the bit width of the variable in integer and fixed point conversion.

It is a figure which shows an example of the hardware constitutions of a type | mold search apparatus. FIG. 3 is a diagram illustrating an example of a software configuration of the type search apparatus according to the first embodiment. It is a figure which shows an example of a parameter file. It is a figure which shows an example of a structure of a type | mold simulation part. 5 is a flowchart illustrating an example of a type search process according to the first embodiment. It is a figure which shows an example of a program. It is a flowchart which shows an example of a program creation process. It is a figure which shows an example of a header file. It is a flowchart which shows an example of a type | mold simulation process. It is a flowchart which shows an example of a calculation process. It is a figure which shows an example of the software configuration of the type | mold search apparatus of Embodiment 2. FIG. It is a figure which shows an example of the table format file which shows the candidate value of a parameter. 10 is a flowchart illustrating an example of a type search process according to the second embodiment. FIG. 10 is a diagram illustrating an example of a software configuration of a type search apparatus according to a third embodiment. 10 is a flowchart illustrating an example of a type search process according to a third embodiment.

The best mode for carrying out the present invention will be described below with reference to the drawings.
<Embodiment 1>
A variable type search method for searching for variable types in the program will be described below. In the present embodiment, a method for searching a fixed-point type attribute when converting a floating-point variable in a program to a fixed-point variable will be described. In the following description, the floating point variable program before the variable type conversion is referred to as a first program, and the fixed point variable program after the conversion is referred to as a second program. The floating point variable type is the first type, and the fixed point type is the second type.
The variable type search method according to the present embodiment includes, for example, several programs for implementing a program written using floating-point arithmetic developed in algorithm development of a signal processing program such as image processing in hardware. Applied to convert variable type to fixed point type.

FIG. 1 is a diagram illustrating an example of a hardware configuration of a type search apparatus 100 that searches for types of variables in a program. The type searching apparatus 100 is an example of an information processing apparatus.
The type search apparatus 100 includes a CPU 101, a RAM 102, a ROM 103, an HDD 104, an input device 105, a display device 106, a network I / F 107, and a system bus 108. The CPU 101, the RAM 102, the ROM 103, the HDD 104, the input device 105, the display device 106, and the network I / F 107 are connected via a system bus 108 so as to communicate with each other.
The CPU 101 controls the entire type search apparatus 100. When the CPU 101 executes a program stored in the ROM 103 or the like, the function (software configuration) of the type search apparatus 100 described later and processing related to the flowchart are realized.
The RAM 102 is a memory that functions as a work area for the CPU 101 to execute a program and a temporary storage area.
The ROM 103 is a memory that stores programs executed by the CPU 101.
The HDD 104 is a hard disk drive that stores various data including threshold values, setting values related to parameters, various programs, and the like.
The input device 105 is a keyboard, a mouse, or the like for the user to perform an input operation on the pattern search device 100.
The display device 106 is a display or the like for the type searching device 100 to display various screens.
The network I / F 107 is an interface for communicating with other devices via an external network.

FIG. 2 is a diagram illustrating an example of a software configuration of the type search apparatus 100 according to the first embodiment.
In this embodiment, the type search apparatus 100 converts a floating-point variable in a program into a fixed-point variable. However, the present invention is not limited to this. For example, the bit width of the mantissa part and exponent part of the floating-point variable in the program is variable. It may be applied when converting to a floating-point variable.
The program creation unit 701 creates a parameterized program from the input first program so that the type attributes necessary for the variable type expression can be set at the time of execution. By making the variable type attribute a parameter that can be set at the time of execution by the program creation unit 701, the type search apparatus 100 can change the variable type without compiling when the program is changed or the attribute value is changed. It is possible to simulate a behavior equivalent to the case of conversion. In the present embodiment, the user inputs the first program and one or more variable names that are to be converted into fixed-point variables. Then, the program creation unit 701 creates a fixed-point simulation program in which the variable type in the first program is changed to the fixed-point simulation type according to the input variable name. The fixed-point simulation type is a type in which the bit width, the decimal point position, and the like, which are fixed-point attributes, are parameterized so that they can be set during execution. In the present embodiment, the fixed-point simulation type is implemented as a C ++ language class. Details of the fixed-point simulation type will be described later with reference to FIG. In the type search apparatus 100 according to the present embodiment, the program creation unit 701 automatically changes the input by referring to the input variable name, but the user manually sets the type of the desired variable to the fixed-point simulation type. It is good also as what changes to. A fixed-point simulation program in which the type of a variable to be converted into a fixed-point variable in the first program is changed to a fixed-point simulation type is a program that can simulate the behavior of the variable type based on attribute values set at the time of execution It is.

The compiling unit 702 compiles the fixed-point simulation program created by the program creating unit 701 and generates an object program.
The attribute value preparation unit 703 prepares in advance an attribute value to be set as a variable type attribute at the time of program execution for a fixed-point simulation type variable in the fixed-point simulation program. More specifically, the attribute value preparation unit 703 associates a target variable (variable information) designated by the user and desired to be converted to a fixed point with an attribute value (attribute value information) set in the attribute of the target variable. Create a parameter file and store it in memory. The parameter file is an example of parameter information. The parameter file may be in any format, but for example, a tabular parameter file as shown in FIG. 3 can be used. Here, FIG. 3 is a diagram illustrating an example of the parameter file. The user may input the correspondence between the target variable to be set and the attribute value via the input device 105 using a GUI on the system or the like. The process in which the attribute value preparation unit 703 creates a parameter file is an example of a parameter information creation process.

The type simulation unit 704 executes the object program generated by the compiling unit 702. Here, the configuration of the mold simulation unit 704 will be described with reference to FIG. FIG. 4 is a diagram illustrating an example of the configuration of the mold simulation unit 704.
The type simulation unit 704 includes a program reading unit 1201, an attribute value holding unit 1202, an attribute value setting unit 1203, and a calculation unit 1204.
When the execution of the object program generated by the compiling unit 702 is started, the program reading unit 1201 reads the object program into the memory.
The attribute value holding unit 1202 expands the correspondence between the attribute of the variable type described in the parameter file input by the attribute value preparation unit 703 and the attribute value on the memory, and holds it on the memory during program execution. . Although the attribute value holding unit 1202 is used in the present embodiment, the type search apparatus 100 may directly access the file when setting the attribute value without holding the parameter file on the memory.
The attribute value setting unit 1203 sets the attribute value of the type to a parameterized attribute. In the present embodiment, the attribute value setting unit 1203 refers to the parameter file held in the memory by the attribute value holding unit 1202 during initialization of a fixed-point simulation type variable during program execution, and sets the attribute value to the variable value. Set to type attribute. Further, the attribute value setting unit 1203 may set the attribute value every time the calculation process or the substitution process is performed without setting the attribute value at the time of initialization. As described above, the attribute value setting unit 1203 can set an attribute value from outside the program. Thereby, the type | mold search apparatus 100 can change an attribute value, without performing a change and compilation of a program.
The calculation unit 1204 performs a calculation that simulates the behavior of the type according to the attribute value set by the attribute value setting unit 1203. For example, when calculating two values having different bit widths and decimal point positions, the calculation unit 1204 performs bit shift and performs the calculation after matching the bit positions. Details of the arithmetic processing will be described later with reference to FIG.
The above is the description of the mold simulation unit 704.

Returning to FIG.
The execution result output unit 705 outputs the execution result (simulation result information) of the fixed-point simulation program.
The execution result evaluation unit 706 calculates accuracy (S / N ratio) from the execution result (execution result information) of the first program and the execution result of the fixed-point simulation program output from the execution result output unit 705. For example, when evaluating using the error, the execution result evaluation unit 706 uses the execution result A of the first program and the execution result B of the fixed-point simulation type program ((BA) ^ 2) / (A ^ 2) is calculated. The execution result evaluation unit 706 satisfies the required accuracy if the calculation result is equal to or less than a predetermined threshold. When the execution result satisfies the desired accuracy, the execution result evaluation unit 706 determines the attribute value set in the attribute of the target variable as the set value. Then, the program generation unit 707 executes processing that will be described later. On the other hand, when the execution result does not satisfy the desired accuracy, the attribute value preparation unit 703 creates a parameter file again based on input of different attribute values from the user.
The program generation unit 707 generates a second program in which the target variable is converted into a fixed-point variable using the relationship between the target variable and attribute determined by the execution result evaluation unit 706 and the attribute value. In the present embodiment, the program generation unit 707 generates a program using the target variable input from the execution result evaluation unit 706 and the corresponding attribute value. The program generation unit 707 may describe the generated program in any language. For example, the program generation unit 707 generates a program for hardware or firmware.
The above is the description of the software configuration of the type search apparatus 100 in the present embodiment.

Next, the flow of variable type search processing for searching for variable types in a program according to the present embodiment will be described with reference to FIG. FIG. 5 is a flowchart illustrating an example of the type search process.
In S100, the program creation unit 701 creates a program in which the type of the input variable is changed to the fixed-point simulation type from the input first program and one or more variable names to be converted into fixed-point variables. To do. In the present embodiment, the program creation unit 701 automatically performs the program creation processing in S100, but may be performed manually by the user. In this embodiment, the program creation unit 701 converts the first program using the floating-point type. However, when the user creates the program, the program using the fixed-point simulation type from the beginning. It may be created. Details of the program creation processing will be described later with reference to FIG.
In S101, the compiling unit 702 compiles the fixed-point simulation program created in S100 and generates an object program.
In step S102, the attribute value preparation unit 703 prepares by storing in advance in the memory parameter information relating to the attribute value to be set in the variable type attribute parameterized in step S100. In the present embodiment, the user inputs the target variable to be converted to a fixed-point number and the attribute value set to the attribute of the type of the target variable via the input device 105 using a GUI or the like on the system. The attribute value preparation unit 703 creates a parameter file based on the user input received via the input device 105, and stores the parameter file in the memory.

In S103, the type simulation unit 704 executes the object program of the fixed-point simulation program generated in S101. More specifically, the type simulation unit 704 refers to the parameter file created in S102 based on the attribute of the target variable in the object program. Then, the type simulation unit 704 sets using the attribute value of the parameter file when initializing each variable in the object program. Further, the type simulation process S103 performs an operation for simulating the behavior of the type according to the set attribute value. Details of the mold simulation processing in S103 will be described later with reference to FIG.
In S104, the execution result output unit 705 outputs the execution result of the program executed in S103. The output format may be any format. For example, the execution result output unit 705 may write the output result in a file or the like.
In step S105, the execution result evaluation unit 706 performs an evaluation on the result output in step S104. More specifically, in the execution result evaluation unit 706, the accuracy based on the execution result of the first program and the execution result output in S104 is input from the outside by the user and stored in the memory in advance. It is determined by evaluating whether or not the accuracy indicated by the accuracy information is satisfied. The accuracy calculation method by the execution result evaluation unit 706 has been described above with reference to FIG. If the execution result evaluating unit 706 determines that the accuracy is satisfied, the process proceeds to S106, and if it is determined that the accuracy is not satisfied, the process returns to S102.
In S106, the program generation unit 707 generates a fixed point type program. More specifically, the program generation unit 707 converts the first program shown in FIG. 6A to a fixed point using the attribute value determined and determined to satisfy the accuracy in S105. To generate a second program in which the variables and the arithmetic expressions thereof are converted. FIG. 6 is a diagram illustrating an example of a program. The program generation process in S106 may be performed manually by the user based on the attribute value of the target variable determined to satisfy the accuracy in S105.
The above is the flow of the variable type search process for searching for the variable type in the program in the present embodiment.

Next, details of the program creation processing in S100 will be described.
Here, FIG. 6A is a diagram showing an example of the first program as described above. On the other hand, FIG. 6B is a diagram showing an example of a fixed-point simulation program created by the program creation process.
The first program 20 is a program developed by the user, and is a fixed-point simulation program 21 or an original program that is converted into a second program.
Description 201, description 202, and description 203 are floating point declarations. The description 204 is an example of the description of the arithmetic processing using the variables declared in the description 201, the description 202, and the description 203.

Next, the processing of S100 in which the program creation unit 701 converts the first program into a fixed-point simulation program will be described using FIG. 6B and FIG. The program creation unit 701 converts the first program in FIG. 6A to the fixed-point simulation program in FIG. 6B by performing the processing shown in FIG. FIG. 7 is a flowchart illustrating an example of a program creation process in S100.
First, in S400, the program creation unit 701 inserts an header include statement. More specifically, the program creation unit 701 includes FixedPointSim.com including a fixed-point simulation class as shown in the description 211. h is included. In addition, the program creation unit 701, as shown in the description 212, reads ParamSetting. h is included. ParamSetting. h defines a method described in the parameter file for expanding the correspondence between the attribute of the variable type and the attribute value on the memory. ParamSetting. h defines a CParamSetting class which is a class having a pointer to an address on the expanded memory as a member. When the attribute value preparation unit 703 expands the correspondence on the memory as in this embodiment, the type simulation unit 704 accesses the file every time a fixed-point simulation type variable declaration is executed in the fixed-point simulation program. There is no need. Therefore, the processing speed is improved. The attribute value preparation unit 703 may be mounted so that the type simulation unit 704 refers to the parameter file each time a variable is declared without expanding the parameter file on the memory. The CparamSetting class defines a method for obtaining a list of attribute values corresponding to one or more attributes of a variable type when a variable name is given as an argument as a key.

Next, in S401, the program creation unit 701 inserts a parameter file setting statement. In the present embodiment, the program creation unit 701 inserts a setting statement using a macro definition that sets a parameter file as described in the description 213. The macro definition for setting the parameter file shown in the description 213 is “FixedPointSim. It is defined by h. The macro definition for setting the parameter file will be described later with reference to FIG. In the present embodiment, the program creation unit 701 uses a macro definition for setting a parameter file. However, the present invention is not limited to this method. For example, the program creation unit 701 may be designated by a command line argument at the time of execution.
In S402, the program creation unit 701 converts the target variable declaration to be converted to a fixed point. In the present embodiment, the program creation unit 701 converts the description 201, description 202, and description 203 in FIG. 6A to the description 214, description 215, and description 216 in FIG. 6B. Variable x, variable y, and variable z, which are target variables, are variables whose type attributes are determined using a fixed-point simulation type variable, that is, a fixed-point simulation type. In the present embodiment, FixedPointSim. Although the macro definition defined in h is used for declaration, the program creation unit 701 may input the contents described in the macro definition directly into the program. The target variable may be determined in advance by the user, or the program creation unit 701 may convert all the float types in the program. In addition, the program creation unit 701 may convert only the float type in the specified file.
The above is the procedure for the program creation unit 701 to convert the first program into a fixed-point simulation program.

A description 217 is an example of an expression of addition operation and substitution operation between fixed-point simulation types. The arithmetic processing will be described later with reference to FIG. Note that the description 204 in the first program in FIG. 6A can be used without changing the equation as in the description 217 even when it is converted into a fixed-point simulation program. In this embodiment, as described above, the program creation unit 701 can convert the first program to the fixed-point simulation program with a minimum load.
Here, the header file 30 defining the fixed-point simulation type will be described with reference to FIG. FIG. 8 is a diagram illustrating an example of a header file defining a fixed-point simulation type.
A description 301 is a definition of a fixed-point simulation class. The fixed-point simulation class is a class that provides a fixed-point simulation type that can be used in the same way as a C ++ language floating-point type and a numeric type such as an integer type.
A description 311 is a data holding unit in the class and holds data members. Hereinafter, data members held by the data holding unit will be described.
The description 312 holds a fixed-point simulation type value as a 32-bit integer. That is, in this class, it is possible to simulate a fixed point type having a bit width of 32 bits or less.

The description 313 holds the decimal point position. The decimal point position may be managed in any way, but in the present embodiment, the position on the right side of the least significant bit is set to 0 position, negative when shifting to the upper bit side, and positive when shifting to the lower bit side . Further, the decimal point position can be set without being limited to the bit width. For example, when expressing an unsigned 3-bit fixed point and the decimal point position of the description 313 is 2, the value that can be expressed is 11100 to 00000 in binary number, and the value from 0 to 28 in decimal number is skipped by 4. It can be expressed as In the present embodiment, the description 312 and the description 313 hold fixed-point simulation type numerical values with integers and decimal point positions. However, the data holding method is not limited to this, and for example, a floating-point type A discrete value corresponding to a fixed point may be held in the data.
Description 314 holds the bit width.
The description 315 holds a mode of value rounding processing of the operation result. For example, the rounding mode is set to 0, the rounding mode is set to 1, the rounding mode is set to 2, and the mode is switched according to the held numerical value.
The description 316 holds the mode at the time of overflow or underflow. For example, a mode for allowing overflow or underflow is set to 0, a mode for performing saturation processing is set to 1 or the like in advance, and the mode is switched according to the held numerical value.
A description 317 is a reference pointer to a memory in which information in the parameter file is expanded. In the present embodiment, the attribute value preparation unit 703 develops and holds the correspondence between the attribute of the type described in the parameter file and the attribute value in the CParamSetting class in the memory. The method of referring to the parameter file is not limited to this. For example, a method of accessing a file every time a variable is instantiated or a method of accessing a file every time an operation is performed may be used.

Description 321 is a class constructor. In the present embodiment, the attribute value setting unit 1203 obtains an attribute value to be set for a type attribute when instantiated from a memory in which the correspondence between the variable type and the attribute in the parameter file is expanded. To do.
The description 331 is an operator definition part.
Description 332 and description 333 are examples of operator processing definitions.
The description 332 is an example of the definition of the addition operation process, and is a method for performing addition between fixed-point simulation classes. In addition, the addition operation defined in the description 332 performs an operation according to the attribute value set by the constructor of the description 321. For example, a case where a value to be added having a 3-bit width and decimal point position 2 and an addition value having a 3-bit width and decimal point position −1 are added will be described. In this case, the arithmetic unit 1204 shifts the integer value of the description 312 held in the instance of the addition value to the left by 3 bits, and performs addition after matching the decimal point position of the value to be added.
A description 333 is a definition of the processing of the assignment operation. In the assignment operation defined in the description 333, an assignment process according to the attribute value set by the constructor of the description 321 is performed. In the present embodiment, the arithmetic unit 1204 converts the numerical values according to the various modes held in the description 315 and the description 316, refers to the decimal point position and the bit width held in the description 313 and the description 314, and converts them. The integer value of the description 312 is stored from the obtained value.

A description 341 is a definition part of the processing at the time of substitution calculation.
A description 342 is a definition of the rounding process. The computing unit 1204 refers to the rounding processing mode held in the description 315 and performs rounding processing according to the mode.
A description 343 is a definition of an overflow or underflow process. The arithmetic unit 1204 refers to the overflow or underflow processing mode held in the description 316 and performs overflow or underflow processing according to the mode. Details of the processing unit for substitution calculation will be described later with reference to FIG.
In the present embodiment, by defining an operation in accordance with the attribute value set by the constructor of the description 321 like the definition part of the operator of the description 331 and the assignment operation processing unit of the description 341, the calculation is performed. The unit 1204 can perform an operation for simulating the behavior of the mold.
The description 302 is a macro definition and is hidden so that the fixed-point simulation class of the description 301 can be used as a fixed-point simulation type without the user being aware of it as a class in the fixed-point simulation program 21 used by the user. .
The description 351 is a macro definition for hiding the constructor, and the user can use the class without specifying the file name every time the variable declaration in the fixed-point simulation program 21 is performed.
The description 352 is a macro definition for concealing the parameter file expansion class and the memory expansion method of the file, and the user can use it only by specifying the file name.
The above is the description of the header file 30.

Next, details of the mold simulation process in S103 will be described with reference to FIG. 6B and FIG. FIG. 9 is a flowchart showing an example of the mold simulation process.
In S501, when the execution of the object program of the fixed-point simulation program compiled in S101 is started, the program reading unit 1201 reads the object program into the memory in order to perform processing described in the program.
In step S502, the attribute value holding unit 1202 holds the parameters described above. In the present embodiment, the attribute value holding unit 1202 executes the macro definition defined by the description 213 in the fixed-point simulation program shown in FIG. The macro definition is defined in the CFixedPointSim class, and the attribute value holding unit 1202 reads “Param.csv”, which is a specified parameter file, and holds the correspondence between the type attribute and the attribute value in the memory. Keep it.
In step S503, the attribute value setting unit 1203 performs processing in a constructor for instantiating a variable using a fixed-point simulation class when a variable declaration in the program is executed. Here, a case where attention is paid to the variable x in FIG. 6B will be described. First, in the declaration part of the description 214, a fixed-point simulation type variable declaration instruction is executed. The declaration part of the description 214 is a macro definition of the description 351 defined by the CFixedPointSim class, and the process described in the macro definition of the description 351 is executed. When the declaration part of the description 214 is executed, the constructor of the description 321 is executed, and the CFixedPointSim class is instantiated. At the time of instantiation, the attribute value setting unit 1203 sets an attribute value corresponding to the variable type attribute as a data member in the instance. In the present embodiment, the attribute value setting unit 1203 refers to the correspondence between the variables, type attributes, and attribute values held in the memory in S502, and acquires attribute values.

In step S504, the calculation unit 1204 performs a calculation that simulates the behavior of the type in accordance with the attribute value set in step S503. In the present embodiment, the calculation unit 1204 performs a fixed-point simulation type calculation. When the calculation unit 1204 executes the calculation of the description 217 in FIG. 6B, the calculation unit 1204 executes a definition method for the addition calculation process defined as the description 332 in the fixed-point simulation class. The operation unit 1204 also executes an assignment operation to the variable z in the operation of the description 217. When the assignment operation process is performed, the definition method defined in the description 333 in the assignment operation process is executed. In the present embodiment, only the addition operation and the assignment operation have been described, but the same applies to other operations.
The above is the details of the flow of the mold simulation process in S103. Thus, the type simulation unit 704 can change the attribute value without changing and compiling the program by enabling the attribute value to be set from outside the program. Further, by defining the operation so as to perform the type operation according to the attribute value, the type simulation unit 704 can simulate the behavior of the type.

Next, details of the flow of the substitution calculation process in the calculation process of the type simulation process described above in S504 will be described with reference to FIG. FIG. 10 is a flowchart illustrating an example of the calculation process.
In step S600, the arithmetic unit 1204 performs rounding processing on the value to be assigned to the variable, the value of the lower-order bit that can be expressed by the bit width set in the variable type. In this embodiment, the arithmetic unit 1204 performs processing according to the mode of the value rounding processing mode of the description 315 held by the data holding unit of the description 311 of the CFixedPointSim class. In the present embodiment, a case will be described in which the value “11011.1” is assigned to a variable having a type of 3 bits wide and decimal point position 1. For example, in the round-up mode of “11011.1”, since the 0th digit of 2 is 1, if rounded up, “11100.0” is obtained.
In S <b> 601, the arithmetic unit 1204 performs an overflow or underflow process when the value to be assigned to the variable exceeds the maximum value and the minimum value. The calculation unit 1204 performs processing according to the overflow or underflow mode held by the data holding unit of the description 311 of the CFixedPointSim class. In the present embodiment, a case where the overflow or underflow mode acceptance mode is 0 and the saturation processing mode is 1 will be described. When the mode is 0, the arithmetic unit 1204 causes an overflow or underflow in a pseudo manner. For example, if “11100.0” is assigned to a variable with a 3-bit width and decimal point position 1 type, the maximum value is exceeded, so if overflow or underflow processing is performed, the most significant bit is the fourth power of 2 Since it is the second digit, the digit of the fifth power digit or higher is reset to zero. Therefore, the calculation unit 1204 processes the value to be substituted as “1100”. In addition, in the saturation processing mode in which the overflow mode or the underflow mode is 0, “11100.0” exceeds the maximum value, so the arithmetic unit 1204 performs the saturation processing. Accordingly, the calculation unit 1204 processes the value to be substituted as the maximum value “1110”.
In step S <b> 602, the calculation unit 1204 stores data in the data holding unit of the description 311 of the CFixedPointSim class. For example, when storing “1100” in a variable having a 3 bit width and decimal point position 1 type, the arithmetic unit 1204 first shifts 1 bit to the right, and then adds the upper 3 bits “110” to the description 312. Store. The above is the flow of the substitution operation process.

  In the present embodiment, the type search device 100 has described the process of parameterizing the type attributes necessary for the variable type expression so that they can be set at the time of execution. Thereby, the type search apparatus 100 can set an attribute value from outside the program, and can perform an operation for simulating the behavior of the type in accordance with the set attribute value. Further, when setting the attribute value, the type search apparatus 100 does not need to rewrite or compile the program, and only changes the value set from outside the program. Therefore, the type search apparatus 100 can perform the type attribute examination more efficiently than the conventional method of rewriting the program every time the attribute is changed.

<Embodiment 2>
In the first embodiment, when the type search apparatus 100 examines a type attribute such as a bit width of a variable of a fixed-point type, it is not necessary to rewrite a program or compile after rewriting, and only change a parameter file. The method of attribute examination was shown in. However, in the first embodiment, it is assumed that the user searches for an attribute by changing the parameter file. Here, when there are a plurality of variables, there may be a trade-off between the attributes of each variable. In that case, it is difficult for the user to search for an optimum attribute value. Therefore, in the present embodiment, a method in which the type search apparatus 100 searches for an optimal attribute value using a design optimization support tool will be described. As in the first embodiment, the floating point variable program before the variable type conversion is called a first program, and the fixed point variable program after the conversion is called a second program. The optimum attribute value here is an attribute value desired by the user, and the same applies in the following description. In addition, the function of the design optimization support software is realized by the CPU 101 of the type search apparatus 100 according to the present embodiment executing a program stored in the ROM 103.
First, the type | mold search apparatus 100 in Embodiment 2 is demonstrated using FIG. FIG. 11 is a diagram illustrating an example of a software configuration of the type search apparatus 100 according to the second embodiment.
Here, since the functions of the program creation unit 701, the compilation unit 702, the type simulation unit 704, and the program generation unit 707 are the same as those described in the first embodiment, description thereof is omitted.
In the present embodiment, the type search apparatus 100 searches for an optimum attribute value using a design optimization support tool. The attribute value preparation unit 903 and the execution result output unit 905 function together with the type simulation unit 704 by a design optimization support tool. As a design optimization support tool, an original tool may be created, or existing design optimization support software may be used. For example, examples of existing design optimization support software include modeFrontier (registered trademark) and Optimus (registered trademark).

  The attribute value preparation unit 903 prepares in advance an attribute value to be set as a variable type attribute when executing a program for a fixed-point simulation type variable in the fixed-point simulation program. In the present embodiment, the user inputs a target variable to be converted to a fixed point and a range of candidate values that can be taken by the attribute of the target variable using a design optimization support tool. The design optimization support tool automatically selects candidate values from a range of candidate values that can be taken from externally input attributes, and the correspondence between the attributes of all variables and the attribute values is described. Output the parameter set. Here, the number of parameter sets output by the design optimization support tool may be preset by the user, or the design optimization support tool outputs parameter sets of all combinations for candidate values of target variable attributes. You may do it. In this embodiment, the user inputs variables, variable type attributes, and ranges of candidate values as a table format file as shown in FIG. 12, but the input format is not limited. You may set using GUI etc. on an optimization assistance tool. FIG. 12 is a diagram illustrating an example of a tabular file indicating parameter candidate values. When the target variable and the range of candidate values that can be taken by the attribute of the variable are input in the tabular data shown in FIG. 12, the bit width that can be taken by the variable x, variable y, and variable z is 7 bits to 9 bits. is there. For example, a case where the design optimization support tool outputs [(bit width of variable x), (bit width of variable y), (bit width of variable z),...] As a parameter set will be described as an example. . In that case, the design optimization support tool can output [7, 7, 7,...] And [7, 7, 8,. In the present embodiment, the attribute value preparation unit 903 creates a parameter set as a parameter file of tabular data as shown in FIG.

The execution result output unit 905 aggregates the results executed by the type simulation unit 704 and analyzes the results. Here, a case where it is necessary to obtain a solution that minimizes the calculation accuracy and minimizes the processing cost will be described. When the user sets the calculation accuracy error and the processing cost as objective functions using the design optimization support tool, the execution result output unit 905 outputs a graph with the calculation accuracy on the horizontal axis and the processing cost on the vertical axis. It becomes possible to do. As described above, by using the design optimization support tool, the attribute value preparation unit 903 creates a parameter file based on the parameter set from each variable and the range of candidate values that can be taken by the attribute of the target variable type. . Then, the mold simulation unit 704 repeats the process of executing the simulation program using the parameter file. Further, the execution result output unit 905 aggregates the results executed by the mold simulation unit 704 as described above, and analyzes the results.
Based on the analysis result acquired from the execution result output unit 905, the execution result evaluation unit 906 presents information for determining whether to determine a parameter set or to narrow down attribute values again to the user. More specifically, the execution result evaluation unit 906 presents the optimal solution to the user when the optimal solution that uniquely determines the design optimization support tool can be obtained. On the other hand, when the attributes are in a trade-off relationship with the objective function, it is difficult to automatically find the optimum solution, and the user needs to interactively narrow down the attribute search range. In such a case, the execution result evaluation unit 906 presents the search range narrowing to the user using a multidimensional chart or the like. The user again inputs the target variable to be converted to a fixed point and the range of candidate values that can be taken by the attribute of the target variable type from the presented search range. In addition, when a desired performance value that satisfies the user is obtained, the pattern search apparatus 100 can also end the attribute search in accordance with a user instruction received via the input apparatus 105.
The above is the description of the software configuration of the type search apparatus 100 in the present embodiment.

Next, the flow of variable type search processing for searching for variable types in a program according to the present embodiment will be described with reference to FIG. FIG. 13 is a flowchart showing an example of the type search process in this embodiment.
The processing in S1100 and S1101 is the same as the processing in S100 and S101 described with reference to FIG.
In step S1102, the attribute value preparation unit 903 prepares in advance an attribute value to be set in the variable type attribute when the program is executed. More specifically, first, the user uses a design optimization support tool to input a target variable to be converted to a fixed point and a range of candidate values that can be taken by the attribute of the type of the target variable. Then, the design optimization support tool automatically selects a value from the input candidate value range and creates a parameter set. Furthermore, the attribute value preparation unit 903 creates a parameter file based on the parameter set.
The processing in S1103 is the same as the processing in S103 described with reference to FIG.
In S1104, the design optimization support tool determines whether or not a predetermined number of parameter sets have been executed for the combinations of values within the range of candidate values of variables input in the attribute value preparation process of S1102. judge. If it is determined that the design optimization support tool has been executed, the process proceeds to S1105. If it is determined that the design optimization support tool has not been executed, the process returns to S1102.

In step S <b> 1105, the execution result output unit 905 analyzes the execution result obtained from the mold simulation unit 704 by the design optimization support tool. For example, when it is necessary to obtain a solution that minimizes the calculation accuracy and minimizes the processing cost, the execution result output unit 905 outputs a graph with the calculation accuracy on the horizontal axis and the processing cost on the vertical axis.
In step S1106, the execution result evaluation unit 906 presents information for determining whether to determine a parameter set or to optimize an attribute again based on the analysis result obtained in step S1105. The execution result evaluation unit 906 advances the process to S1107 when determining a parameter set based on a user instruction, and advances the process to S1102 when optimizing the attribute again.
The processing in S1107 is the same as the processing in S106 described with reference to FIG.
The flow of the variable type search process for searching for the variable type in the program in the present embodiment has been described above.
According to the present embodiment, the type search apparatus 100 can select an attribute value that can obtain a desired execution result even when there are a plurality of variables and a trade-off occurs in the attributes of each variable. It becomes.

<Embodiment 3>
In general, a user develops an algorithm of a signal processing program such as image processing using a floating-point type variable, and performs hardware design examination after the algorithm development is completed. Therefore, a program created at the time of algorithm development is described using a floating point type. For this reason, the user needs to convert the program created at the time of algorithm development when examining attributes of a type such as a fixed-point bit width at the hardware design examination stage.
In the first embodiment and the second embodiment, the method of examining the attribute of the type such as the bit width at the time of hardware design examination after algorithm development has been described. In this embodiment, not only the type attribute but also the type itself can be selected from the parameter development at the time of algorithm development, and the type such as bit width can be changed without changing the program developed by the algorithm development at the time of hardware design examination. A method for performing attribute examination will be described.
The type | mold search apparatus 100 in this embodiment is demonstrated using FIG. FIG. 14 is a diagram illustrating an example of a software configuration of the type search apparatus 100 according to the present embodiment. The type searching apparatus 100 according to the present embodiment is a type searching apparatus capable of searching for variable types without changing a program in hardware design after algorithm development.

The program creation unit 1301 creates a program using a type that can select one type from a plurality of types. In this embodiment, the program creation unit 1301 creates a program using a decimal point selection type having parameters for selecting either the fixed-point simulation type or the floating-point type shown in the first embodiment. The program created by the program creation unit 1301 is an algorithm development program capable of searching for variable types without changing the program in hardware design after algorithm development. Further, the variable for which the decimal point selection type is to be used may be arbitrarily selected by the algorithm developer, or all variables desired to be the floating point type may be the decimal point selection type.
Here, the decimal point selection type will be described. The decimal point selection type is defined as a class using the C ++ language in this embodiment. First, the data holding unit holds the floating-point type data and the instance of the CFixedPointSim class shown in the first embodiment as data, and further holds the type selection parameter value. The type selection parameter value is a value that determines a type to be used during program execution. In this embodiment, the type selection parameter value is used when selecting a floating point type and a fixed point simulation type. The decimal point selection type constructor refers to the type selection parameter value input from the parameter file, and acquires and holds the type selection parameter value read from the parameter file. The program creation unit 1301 determines whether to use a floating-point type or a CFixedPointSim class from the acquired type selection parameter value. In addition, a definition method for operator processing is declared as a method in the class, and is defined to perform an operation according to the type selection parameter value. The above is the explanation of the decimal point selection type.

The compiling unit 1302 compiles the algorithm development program created by the program creating unit 1301 and generates an object program.
The attribute value preparation unit 1303 prepares in advance an attribute value to be set as the decimal point selection type attribute. In the present embodiment, the attribute value preparation unit 1303 prepares a type selection parameter value for determining whether to use a floating-point type or a fixed-point simulation type, in addition to attributes necessary for the fixed-point simulation type. For example, the attribute value preparation unit 1303 sets a selection parameter value of “0” for the floating point type and “1” for the fixed point simulation type. Also, the attribute value preparation unit 1303 sets “0” when it is desired to use a floating-point type for a variable in the algorithm development program. That is, the attribute value preparation unit 1303 prepares a parameter file in which type selection parameter values are described in addition to the fixed-point simulation type attribute values shown in the first and second embodiments for variables in the algorithm development program. . In this embodiment, the floating-point type and the fixed-point simulation type are used. However, the type is not limited to this, and for example, an integer type may be further added.

The type simulation unit 1304 executes an object program obtained by compiling the algorithm development program created by the program creation unit 1301. The type simulation unit 1304 has a function of selecting one type from a plurality of types in addition to the function of the type simulation unit 704 shown in the first and second embodiments. Here, the type simulation unit 1304 refers to the parameter file in which the type selection parameter value prepared by the attribute value preparation unit 1303 is described, determines the variable type in the algorithm development program, and executes the program.
The execution result output unit 1305 has the functions of the execution result output unit 705 and the execution result output unit 905 described in the first and second embodiments, and further has a function of acquiring a program execution result at the time of algorithm development. For example, when the user is developing an algorithm for detecting a person from an image, the pattern simulation unit 1304 inputs a plurality of images and executes the program a plurality of times. Then, the execution result output unit 1305 acquires a person detection rate.
The execution result evaluation unit 1306 has the functions of the execution result evaluation unit 706 and the execution result evaluation unit 906 described in the first and second embodiments, and the program execution result at the time of algorithm development is predetermined by the user. It is evaluated whether it meets the performance. For example, when the user is developing an algorithm for detecting a person from an image, the execution result evaluation unit 1306 satisfies the performance based on whether or not the detection rate of the person is equal to or higher than a threshold predetermined by the user. Evaluate whether or not.
Since the function of the program generation unit 707 is as described in the first and second embodiments, the description thereof is omitted here.
The above is the description of the software configuration of the type search apparatus 100 in the present embodiment.

Next, the flow of the type search process in this embodiment will be described with reference to FIG. FIG. 15 is a flowchart showing an example of the type search process in this embodiment. The processes from S1400 to S1405 are processes related to algorithm development. Further, the processing from S1406 to S1411 is processing related to examination of type attributes such as bit width at the time of hardware design examination.
In S1400, the program creation unit 1301 creates an algorithm development program using a decimal point selection type that is a type having a parameter for selecting a type. In the present embodiment, the program creation unit 1301 creates an algorithm development program using a decimal point selection type capable of selecting a floating point type and a fixed point simulation type.
In S1401, the compiling unit 1302 compiles the algorithm development program created in S1400 and generates an object program.
In S1402, the attribute value preparation unit 1303 prepares a parameter file in which a type selection parameter value for determining the type parameterized in S1401 is described. In the present embodiment, the attribute value preparation unit 1303 selects either the floating-point type or the fixed-point simulation type, and describes the type selection parameter value for selecting the floating-point type in the parameter file when developing the algorithm. Keep it.
In step S1403, the type simulation unit 1304 executes the object program of the algorithm development program compiled in step S1401. Then, the type simulation unit 1304 refers to the parameter file based on the object program, and sets the variable type from the type selection parameter value prepared in S1402. The details of the processing of S1403 are the same as the processing flow shown in the first embodiment. For example, when the user is developing an algorithm for detecting a person from an image as in the present embodiment, the pattern simulation unit 1304 executes the program a plurality of times for a plurality of image inputs.

In step S1404, the execution result evaluation unit 1306 analyzes the program execution result. For example, when the user is developing an algorithm for detecting a person from an image as in the present embodiment, the execution result evaluation unit 1306 calculates a detection rate from the results executed a plurality of times in S1403, and calculates the detection rate. Output to be presented to the user. The output format may be any format, and the execution result evaluation unit 1306 may write the output result in, for example, a file.
In step S1405, the execution result evaluation unit 1306 evaluates whether the human detection rate output in step S1404 satisfies a preset performance value (threshold value). The process proceeds to S1406. On the other hand, when the performance value is not satisfied, the execution result evaluation unit 1306 returns the process to S1400 in order to correct the algorithm development program again.
In step S1406, the attribute value preparation unit 1303 prepares a parameter file in which the type selection parameter value is described in addition to the processing in step S102 described above with reference to FIG. In this embodiment, it is assumed that a floating point type and a fixed point simulation type can be selected. The attribute value preparation unit 1303 uses a parameter file to select a parameter value for selecting a floating-point type at the time of algorithm development and a type selection parameter value for selecting a fixed-point simulation type when considering hardware. It is described in.
The processing from S1407 to S1411 is the same as the processing from S1103 to S1107 described with reference to FIG.
The flow of the type search process for searching for variable types in the present embodiment has been described above.
If the method for generating a fixed-point program according to the present embodiment is used, the type search apparatus 100 can examine the attributes of the type such as the bit width without changing the program developed in the algorithm development at the time of hardware design examination. Become.

<Other embodiments>
The present invention can also be realized by executing the following processing. That is, software (program) that realizes the functions of the above-described embodiments is supplied to a system or apparatus via a network or various storage media, and a computer (or CPU, MPU, etc.) of the system or apparatus reads the program. It is a process to be executed.

  As described above, according to each of the embodiments described above, when examining type attributes such as the bit width of a variable in integer / fixed-point conversion, the type search apparatus 100 reads and sets the variable type attribute value at the time of execution. Then, an operation according to the attribute value is performed. As a result, the type search apparatus 100 can change the type attribute without rewriting or compiling the program, and can reduce the examination time. In addition, by using a fixed-point program, the type search apparatus 100 can examine type attributes such as bit width without changing the program developed by the algorithm development at the time of hardware design examination.

  The preferred embodiment of the present invention has been described in detail above, but the present embodiment is not limited to the specific embodiment, and various modifications can be made within the scope of the gist of the present invention described in the claims.・ Change is possible.

Claims (13)

Reading means for reading the compiled program with the attributes of the target variable parameterized,
Setting means for setting an attribute value to an attribute of a target variable of the program based on parameter information regarding the attribute when executing processing based on the program read by the reading means;
Execution means for executing processing based on a program in which attribute values are set by the setting means;
An information processing apparatus. And a creation means for creating a program that parameterizes the attributes of the target variable in the second type based on the first program including the variable in the first type and the variable information indicating the target variable;
The information processing apparatus according to claim 1, wherein the reading unit reads a program obtained by compiling a program created by the creating unit.   The creating means parameterizes the attribute of the target variable of the fixed type of the second type based on the first program including the variable of the floating type of the first type and the variable information. The information processing apparatus according to claim 2, which creates a program. The creating means parameterizes the type of the target variable based on the first program and the variable information, and generates a program parameterizing the attribute of the target variable,
The setting means sets the type of the target variable based on parameter information related to the type of the target variable and the attribute, and sets an attribute value to the attribute of the target variable in the set type. The information processing apparatus described. The execution means executes a calculation process related to a simulation based on a program in which the attribute value is set,
5. The determination unit according to claim 2, further comprising: a determination unit configured to determine whether or not an attribute value set in the attribute of the target variable is determined as a setting value based on simulation result information relating to processing executed by the execution unit. The information processing apparatus according to any one of claims.   The determination means calculates accuracy based on the execution result information of the first program and the simulation result information, and based on whether or not the calculated accuracy is equal to or greater than a predetermined threshold value, The information processing apparatus according to claim 5, wherein it is determined whether or not an attribute value set in the attribute of the target variable is determined as a setting value. If there is a plurality of simulation result information related to the processing executed by the execution means, further comprising an output means for outputting the simulation result information according to a preset objective function,
The determination unit determines whether or not to determine an attribute value set in the attribute of the target variable as a setting value based on a user instruction based on simulation result information output by the output unit. Information processing device.   Generation means for converting the first program and generating a second program related to the second type based on attribute value information related to the set attribute value when it is determined to be determined by the determination means The information processing apparatus according to claim 5, further comprising:   The information processing apparatus according to any one of claims 5 to 7, wherein when the determination unit determines that the value is not determined, the setting unit changes and sets an attribute value to be set to the target variable based on the parameter information. . Parameter information creating means for creating parameter information in which variable information indicating a variable and attribute value information of the variable are associated with each other;
The setting means acquires attribute value information from the parameter information created by the parameter information creation means based on the attribute of the target variable, and sets the attribute value related to the acquired attribute value information as the attribute of the target variable The information processing apparatus according to any one of claims 1 to 9.   The information processing apparatus according to claim 10, wherein the parameter information creating unit creates parameter information in which the variable information is associated with attribute value information related to a range of attribute values of the variable. An information processing method executed by an information processing apparatus,
A read step that loads the compiled program with the attributes of the target variable parameterized,
A setting step for setting an attribute value to an attribute of a target variable of the program based on parameter information regarding the attribute when executing a process based on the program read by the reading step;
An execution step of executing processing based on the program in which the attribute value is set by the setting step;
An information processing method including: On the computer,
A read step that loads the compiled program with the attributes of the target variable parameterized,
A setting step for setting an attribute value to an attribute of a target variable of the program based on parameter information regarding the attribute when executing a process based on the program read by the reading step;
An execution step of executing processing based on the program in which the attribute value is set by the setting step;
A program for running

Images