JPH11316688A - Device and method for processing programming language and recording medium - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a device and a method for processing programming language and a recording medium with which a parallel processing function in comparatively small scale provided in a processor can be efficiently utilized. SOLUTION: Concerning a source program described in an sDPCE language expanding a C language by adding a syntax to be used for the processor with parallel processing function, according to a preprocessor program 12, a sentence or expression based on the syntax concerning a vector or a matrix of that source program is transformed into of sentence or expression in the C language for calling a routine 21-1 for parallel processing out of a library 14-i.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a programming language for generating a binary program corresponding to a source program described in a parallel processing programming language obtained by extending a predetermined programming language for parallel processing. The present invention relates to a processing device, a programming language processing method, and a recording medium.

[0002]

2. Description of the Related Art For example, SIMD (Single) such as Pentium (trademark) with MMX (trademark) function manufactured by Intel Corporation.
A processor having an instruction stream multiple data stream (parallel processing) function has been developed. FIG.
FIG. 3 is a diagram showing a 64-bit MMX register provided in a Pentium processor having an MMX function. This register can store eight byte data, four word data, or two double word data, and these data are processed in parallel by the same instruction. Details are described in "MMX Technology Technical Overview" provided by Intel Corporation.

When a binary program to be executed by such a processor is created, a predetermined programming language such as C language is used when a source program is created, and a predetermined library is used to use a parallel processing function. A statement for calling the included parallel processing routine is described. Then, a binary program for the processor is generated from the source program by using a compiler corresponding to the processor. Further, the library used when generating the binary program is prepared for each processor because the specifications of the binary program are different for each processor model.

As described above, when a binary program for a predetermined processor having a SIMD type parallel processing function is generated, a source program described in a predetermined programming language is converted based on a compiler and a library corresponding to the processor. Converted to a program.

When a binary program for a parallel computer for executing a large-scale parallel calculation is generated, a method using a compiler and a library for the parallel computer as described above, for example, US Pat. No. 5,381,550 How to use a language processor for parallel computers described in
A programming language that is an extension of the C language and has a syntax corresponding to vector and matrix operations, for example, "Data Par
allel C Extensions "(Numerical C Extensions Group
of X3J11, Technical Report, Version 1.6, X3J11 / 94-
080, WG14 / N395, December 31, 1994)
A method using the E (Data Parallel C Extensions) language is conceivable.

[0006] The DPCE language has a shape type for describing vectors and matrices, and has a syntax corresponding to the operation of vectors and matrices. A source program for a parallel computer that does not depend on a machine type can be described without particularly describing a statement for calling a routine.

[0007]

Since the conventional programming language processing method is configured as described above, a statement for calling a routine included in a library corresponding to the model of the processor using a predetermined programming language. When using the parallel processing function of a processor described in a source program, detailed knowledge such as the name of a statement that calls the routine (that is, the name of a routine or a function) and the types of arguments required for the statement is required. Therefore, those who do not have such detailed knowledge have to refer to the manual of the library and the like, and there is a problem that the creation of the source program is complicated.

When using the DPCE language,
Although the above knowledge is hardly necessary, the DPCE language is intended for parallel computers that execute large-scale parallel computations, so it uses relatively small-scale parallel processing functions provided in processors such as Pentium. DP to do
If the CE language is used as it is, there is a problem that the efficiency at the time of executing the program may be reduced.

Further, in the above-mentioned method, a target processor and a parallel computer are predetermined, and a binary program is generated from a source program by using a compiler or a library corresponding to the processor or the parallel computer. However, when generating binary programs for a plurality of types of processors, it is necessary to use a language processing system corresponding to each processor, and there has been a problem that a device and an operation for generating a binary program are complicated.

SUMMARY OF THE INVENTION The present invention has been made to solve the above problems, and is a programming language for parallel processing in which a programming language such as C language is expanded by adding a syntax used in a processor having a parallel processing function. To convert a statement or expression based on a syntax relating to a vector or a matrix in the source program into a statement or expression based on, for example, a C language syntax for calling a parallel processing routine of the library. Makes it possible to easily create source programs for processors with parallel processing functions without requiring detailed knowledge of library routines, and to implement relatively small-scale parallel processing within processors. A programming language processor that enables efficient use of functions, Programming language processing method, and an object of the present invention to provide a recording medium.

Further, according to the present invention, a compiler and a library corresponding to a predetermined number of processors are stored in a predetermined recording medium in advance, and the compiler and the library corresponding to the specified processor are used for the processor. An object of the present invention is to provide a programming language processing device, a programming language processing method, and a recording medium that can easily generate a binary file for a plurality of types of processors by generating a binary file.

[0012]

A programming language processing apparatus according to the present invention comprises a reading means for reading a source program described in a parallel processing programming language obtained by extending a predetermined programming language for parallel processing; From a predetermined number of libraries each having a routine describing processing in a different predetermined number of processors with parallel processing functions, and from a source program written in a predetermined programming language, a predetermined number of processors with parallel processing functions A storage medium storing a predetermined number of compiler programs describing a process of generating a corresponding binary program, and a statement or expression based on a syntax related to a vector or a matrix of a source program, a library parallel processing routine A predetermined program for calling Means for converting into a statement or an expression based on the syntax of the coding language, and a compiler program corresponding to any one of a predetermined number of processors with a parallel processing function from a recording medium, and converting means according to the compiler program Generating a binary program corresponding to the processor with the parallel processing function from the source program converted by the above.

In the programming language processing apparatus according to the present invention, the conversion means converts an expression based on a syntax describing a dot product of a vector, a product of a vector and a matrix, and a product of a matrix and a matrix, into a vector dot product, a vector In this case, the expression is converted into an expression based on the syntax of a predetermined programming language that calls a routine of a library corresponding to one of the product of the matrix and the matrix and the product of the matrix and the matrix.

[0014] In the programming language processing apparatus according to the present invention, the conversion means converts the expression based on the syntax describing the transposition of the matrix into the syntax of a predetermined programming language that calls a library routine corresponding to the transposition of the matrix. It is converted into an expression.

In the programming language processing apparatus according to the present invention, the conversion means uses, for each element of the matrix, an expression based on a syntax that describes a process of performing a predetermined operation on a predetermined range of elements including the element. Is converted into an expression based on a syntax of a predetermined programming language for calling a routine of a library corresponding to a process of performing a predetermined operation on a predetermined range of elements including the element for each element of the matrix. Things.

The programming language processing apparatus according to the present invention comprises four arithmetic operations "+",
When an expression in which the operator of “+” or “−” appears at least twice among “−”, “*”, and “/” is described in the source program, the conversion unit converts the expression into a vector. Alternatively, the matrix is converted into a formula of a predetermined programming language corresponding to a process of executing the operation of the formula for each predetermined number of elements.

In a programming language processing apparatus according to the present invention, when a declaration statement of an object-type variable representing a vector or a matrix is described in a source program, the conversion statement converts the declaration statement into an array of a predetermined programming language. Or a statement or expression having a memory allocation function.

In the programming language processing device according to the present invention, the conversion means converts the where statement of the DPCE language into w
Based on the conditional expression of the here statement, it is converted into a conditional statement in a predetermined programming language for each predetermined element of a vector or matrix.

A method for processing a programming language according to the present invention comprises the steps of: reading a source program described in a parallel processing programming language obtained by extending a predetermined programming language for parallel processing; A predetermined programming language for calling a statement or expression based on a parallel processing routine of a library corresponding to any one of a predetermined number of different parallel processors with different types of parallel processors And a predetermined number of parallel processing functions from a predetermined number of libraries and a source program written in a predetermined programming language corresponding to a predetermined number of processors with parallel processing functions. Corresponding to each processor with Reading a compiler program corresponding to the processor with a parallel processing function from a recording medium on which a predetermined number of compiler programs describing a process of generating an inital program are recorded; and a source program after conversion according to the compiler program. And generating a binary program corresponding to the processor with a parallel processing function.

A recording medium according to the present invention includes a predetermined number of libraries each having a routine describing a predetermined number of different types of processors with parallel processing functions, and a source program described in a predetermined programming language. And a predetermined number of compiler programs in which a process for generating a binary program corresponding to each of a predetermined number of processors having a parallel processing function is recorded, and the computer is expanded to a predetermined programming language for parallel processing. Reading means for reading a source program described in a programming language for parallel processing, a statement or expression based on a syntax relating to a vector or a matrix of the source program, and a statement of a predetermined programming language for calling a parallel processing routine of a library; Based on syntax Or a conversion means for converting into an expression, a compiler program corresponding to any one of a predetermined number of processors with parallel processing functions, and a source program converted by the conversion means according to the compiler program, and A program for causing a processor to function as generating means for generating a binary program corresponding to the processor is recorded.

[0021]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS One embodiment of the present invention will be described below. Embodiment 1 FIG. FIG. 1 is a block diagram illustrating a configuration of a programming language processing device according to a first embodiment of the present invention, and FIG. 2 is a diagram illustrating a configuration of an sDPCE language described later. In FIG. 1, reference numeral 1 denotes a control program 11 in which a control procedure of the programming language processing device is described.
A parallel processing routine 2 of a library 14-i corresponding to a processor specified by a user converts a statement or expression based on a syntax related to a vector or a matrix in a source program in the sDPCE language described below, which is an extension of the C language.
1-a preprocessor program 12 in which a procedure for converting i into a statement or expression in C language is described, and a parallel processing routine 21- in which a predetermined number of different types of processors with parallel processing functions are described. A predetermined number n of libraries 14-i (i =
1, 2,..., N), a predetermined number n of Cs describing a process of generating binary programs corresponding to a predetermined number of processors with parallel processing functions from a source program described in the C language Compiler program (compiler program) 13-i (i = 1, 2,...,
n) is a recording medium connected to the bus 2 such as a hard disk device.

Reference numeral 3 denotes a ROM 4 or a recording medium 1 at startup.
In addition to executing a process of activating a predetermined operating system or the like based on the boot program recorded in the storage medium 1, the preprocessor program 12 and the C compiler programs 13-1 to 13- through the bus 2 from the recording medium 1 according to the control program 11. n into the RAM 5 and execute the processes described in those programs.
PU (reading means, converting means, generating means).

Reference numeral 4 denotes a ROM in which a start-up program and various data are stored in advance.
Is a RAM for temporarily storing a program or the like recorded in a program or the like at the time of execution, and for temporarily storing various data during the execution of the program.
This bus is connected to the CPU 3, the ROM 4, and the RAM 5, and is also connected to various interfaces (not shown).

Here, a programming language for parallel processing which is processed by the programming language processing device will be described. As shown in FIG. 2, the parallel processing programming language processed by this programming language processing device is, for the parallel processing syntax in the DPCE language, a syntax used for a processor with a parallel processing function and a predetermined object type. An extension of the C language with the syntax of parallel computation (hereinafter sDPCE (small DPCE))
Language).

Among the syntaxes for parallel processing in the DPCE language, the syntax used for a processor with a parallel processing function includes operators "+" for vectors and matrices defined by shape statements, where statements, and shape statements.
“−”, “*”, “/”, “+ =”, “− =”, “*
= ”,“ / = ”,“ ＾ = ”,“ | = ”,“ <? = ”,
There are “>? =”, “<?”, And “>?”. Where sD
Objects defined in the shape statement of the PCE language are limited to one-dimensional or two-dimensional objects. These syntaxes are described in the above literature.

The syntax of the parallel calculation for the shape type includes an operator "**", an expression "<< matrix >>",
"[[Matrix]]" has been added. The operator "**" is a binary operator. When both arguments are shape-type vectors, they represent the operation of the inner product of the vectors. When the argument is a shape-type vector and a matrix, the vector is a vector. Represents the product of the matrix and the matrix, and both arguments are shape
In the case of a matrix of a type, it represents the operation of the product of the matrix and the matrix.

The expression "<< matrix >>" is composed of "<<" and ">
> ”Represents a process of calculating the transpose of a shape-type matrix surrounded by“> ”, and the expression“ [[matrix]] ”is expressed as“ [[”and“]] ”
Represents an arithmetic process described later for a shape-type matrix surrounded by.

Next, the operation will be described. FIG. 3 is a flowchart illustrating the operation of the program language processing apparatus according to the first embodiment. FIG. 4 is a flowchart illustrating the detailed operation of the program language processing apparatus in step ST2 of FIG. , FIG.
9 is a flowchart for describing the detailed operation of the program language processing device in step ST24 of FIG. FIG. 6 is a diagram illustrating an example of an operation process on a matrix.

When the user instructs the operating system to execute the control program 11, the CP
U3 loads the control program 11 into the RAM 5 and executes it. At this time, the user specifies a source program described in the sDPCE language and a target processor. Hereinafter, the following processing is executed according to the control program 11.

First, in step ST1, the CPU 3
Reads the source program specified by the user from, for example, the recording medium 1 or an external hard disk device or a flexible disk device connected to an interface (not shown), and stores the read source program in the RAM 5.

Next, in step ST2, the CPU 3
Loads the preprocessor program 12 from the recording medium 1 via the bus 2 into the RAM 5 and executes it. At this time, if a statement or expression based on the syntax extended in the sDPCE language described above exists in the source program,
The CPU 3 converts the statement or expression into a statement or expression in C language that calls the parallel processing routine 21-i corresponding to the syntax among the routines of the library 14-i of the processor specified by the user.

Then, in step ST3, the CPU
3 is a C compiler program 13-i of the processor designated by the user from the recording medium 1 via the bus 2.
Is loaded into the RAM 5 and executed. At this time, CPU3
Converts the C language source program converted based on the preprocessor program 12 into a binary program for a processor specified by the user according to the C compiler program 13-i.

Finally, in step ST4, the CPU
3 stores the binary program in a recording medium such as the recording medium 1, for example.

Thus, the source program in the sDPCE language is converted into a binary program for the processor specified by the user. Next, details of the processing in step ST2 will be described with reference to the flowchart in FIG.

First, in step ST20, the CPU 3 executes the RAM processing in accordance with the preprocessor program 12.
5. The first step of the source program in the sDPCE language stored in step 5 is selected, and in step ST21,
It is determined whether or not a shape-type variable declaration statement in the sDPCE language exists in the step. If it is determined that a shape-type variable declaration statement exists, the process proceeds to step ST.
At 22, the statement of the shape type variable is converted into an array declaration statement in C language. On the other hand, if it is determined that the declaration statement of the shape type variable does not exist, step S
T22 is skipped.

For example, in the sDPCE language, a vector type, which is a shape type of a one-dimensional array having 100 elements, corresponding to a vector having 100 elements, and a row element having 100 row elements and 200 column elements Is a two-dimensional array of 100 × 200 elements corresponding to the matrix
The declaration statement of the matrix type, which is the pe type, is described as follows. shape [100] vector; shape [100] [200] matrix;

In this vector type, variables v1 and v2 are
When a variable m1 is defined in this matrix type,
The declaration statement is described as follows. unsigned short int: vector v1, v2; unsigned short int: matrix m1;

The declaration statement defining such a shape-type variable is converted into a C language array declaration statement as shown below according to the preprocessor program 12. The above statement is deleted. unsigned short int v1 [100]; unsigned short int v2 [100]; unsigned short int m1 [100] [200];

Next, in step ST23, the CPU
3 is sDP according to the preprocessor program 12.
It is determined whether or not a parallel processing instruction (the above-described operator, expression, or the like) in the CE language exists in the step. If it is determined that a parallel processing instruction exists, the process proceeds to step ST.
At 24, the statement or expression having the instruction for parallel processing is converted into a statement or expression in C language that calls the routine corresponding to the instruction among the parallel processing routines 21-i of the processor specified by the user. . On the other hand, if it is determined that there is no parallel processing instruction, step ST24 is skipped.

For example, in a source program in the sDPCE language, each element of the vector v2 and a scalar value (=
The process of calculating the sum of 3) and substituting the calculation result into each element of the vector v1 is described as follows. v1 = v2 + 3;

The arithmetic expressions of such vectors and matrices are expressed as follows in accordance with the preprocessor program 12 by a parallel processing routine 21- corresponding to the arithmetic operation.
It is converted to a C language expression that calls i. MMX_unsign_scalar_add (v1, v2,3,100);

In this equation, "100" indicates the number of elements of the vectors v1 and v2. Also, "MMX_unsi
"gn_scalar_add" is the name of the parallel processing routine 21-i that calculates the sum of each element of the vector and the scalar value using the parallel processing function of the processor.

Then, in step ST25, the CP
U3 determines whether the step of the source program currently being processed is the last step according to the preprocessor program 12, and if it determines that the step currently being processed is not the last step, After selecting the next step of the source program in ST26, the process returns to step ST21, and the processing of steps ST21 to ST24 is executed for that step.

On the other hand, if it is determined in step ST25 that the step of the source program currently being processed is the last step, the CPU 3 ends the processing based on the preprocessor program 12, and proceeds to step ST3 of FIG. move on.

As described above, the preprocessor program 1
According to 2, a sentence or expression based on the syntax extended in the sDPCE language is converted into a sentence or expression based on the syntax in the C language. Next, details of the processing in step ST24 will be described with reference to the flowchart in FIG.

First, in step ST41, the CPU
3 judges whether the instruction of the parallel processing is the operator "**" according to the preprocessor program 12, and if it is determined that the instruction of the parallel processing is the operator "**", in step ST42, It is determined whether or not both arguments of the operator “**” are shape type vectors.

If it is determined that both of the two arguments of the operator “**” are shape type vectors, the CPU 3 calculates the inner product of the instruction and the vector according to the preprocessor program 12 in step ST43. It is converted into a C language expression that calls the parallel processing routine 21-i.

For example, in a source program in the sDPCE language, a process of calculating an inner product of a vector v1 and a vector v2 and assigning a scalar value of the calculation result to a scalar variable s3 is described as follows. s3 = v1 ** v2;

The arithmetic expression is converted into a C language expression for calling the parallel processing routine 21-i corresponding to the arithmetic operation as shown below in accordance with the preprocessor program 12. MMX_vector_inner (s3, v1, v2, size_of_vector);

Note that “size_of_vector” in the above equation is the number of elements of the vectors v1 and v2, and this value is read in advance from the declaration statement of these vectors v1 and v2 and stored.

On the other hand, if the argument of the operator “**” determines that any of the two terms is not a shape-type vector, the CPU 3 proceeds to step ST44 according to the preprocessor program 12 to execute the operator “**”. It is determined whether or not the argument is a shape type vector and a shape type matrix.

If it is determined that the argument of the operator “**” is a shape-type vector and a shape-type matrix, in step ST45, the CPU 3 converts the instruction according to the preprocessor program 12 into a product of the vector and the matrix. Is converted to a C language expression that calls a parallel processing routine 21-i for calculating.

For example, in a source program in the sDPCE language, the process of calculating the product of the matrix m1 and the vector v3 and substituting the vector of the calculation result into the vector v4 is described as follows. v4 = m1 ** v3;

This operation expression is converted into a C language expression for calling the parallel processing routine 21-i corresponding to the operation, as shown below, according to the preprocessor program 12. MMX_matrix_vector (v4, m1, v
3, size_of_vector);

Note that “size_of_vector” in the above equation is the number of elements of the vector v3, and this value is read out in advance from the declaration statement of this vector and stored.

On the other hand, the argument of the operator “**” is shape
If it is determined that the two vectors are not a shape vector and a shape matrix, in step ST46, the CPU 3 determines whether the two arguments of the operator “**” are both a shape matrix according to the preprocessor program 12. I do.

All arguments of the operator "**" are "shap".
If it is determined that the matrix is an e-type matrix, in step ST47, the CPU 3 converts the instruction into a C language expression for calling the parallel processing routine 21-i for calculating the product of the matrix and the matrix according to the preprocessor program 12. I do.

For example, in a source program in the sDPCE language, the product of the matrix m2 and the matrix m3 is calculated,
The process of substituting the matrix of the calculation result into the matrix m4 is described as follows. m4 = m2 ** m3;

The arithmetic expression is converted into a C language expression for calling the parallel processing routine 21-i corresponding to the arithmetic operation, as shown below, in accordance with the preprocessor program 12. MMX_matrix_matrix (m4, m2, m
3, size_of_row);

In the above expression, “size_of_row”
Is the number of elements in the rows or columns of the matrices m2 and m3, and this value is read in advance from the declaration statements of these matrices and stored.

On the other hand, if it is determined that any of the arguments of the operator “**” is not a shape type matrix, the operator “**” is used for other than a vector and a matrix. In step ST48, the CPU
3 executes error processing such as displaying an error message according to the preprocessor program 12.

If it is determined in step ST41 that the instruction for the parallel processing is not the operator "**", the CPU 3 sends the above-mentioned instruction to the other parallel processing in accordance with the preprocessor program 12 in step ST49. The conversion is appropriately performed in the same manner as in the operator “**”.

For example, in a source program in the sDPCE language, the process of substituting the transposed matrix of the matrix m5 into the original matrix m5 is described as follows. m5 = << m5 >>;

This arithmetic expression is converted into a C language expression for calling the parallel processing routine 21-i corresponding to the arithmetic operation as follows, in accordance with the preprocessor program 12. MMX_matrix_transpose (m5, size_of_row, size_of_colum
n);

Note that “size_of_row” and “size_o”
“f_column” is the number of elements in the row and column of the matrix m5, and these values are read in advance from the declaration statement of this matrix and stored.

For example, in a source program in the sDPCE language, the arithmetic processing based on the matrix M applied to the matrix image is described as follows. image = M [[image]];

The matrix M is defined in the sDPCE language, for example, as follows. This arithmetic processing is performed by centering on each element of the matrix image and calculating the sum of products of peripheral elements and each element of the matrix M by: This is executed by setting the value of the element at the center. shape [3] [3] mask; mask M = [-1, -1, -1,0,0,0, -1, -1, -1];

The arithmetic expression is converted into a C language expression for calling the parallel processing routine 21-i corresponding to the arithmetic operation as shown below in accordance with the preprocessor program 12. MMX_Apply_mask (image, M, image, size_of_column_of_M, s
ize_of_column_of_image);

Note that “size_of_column_of_M” and “size_of_column_of_image” in the above expression are the numbers of elements in the columns of the matrix M and the columns of the matrix image, respectively, and these values are read in advance from the declaration statements of these matrices and stored. Is done.

For example, when the matrix M having the values shown in FIG. 6A is applied to an element having a value d5 in the matrix image having the values shown in FIG. Is the value obtained by the following equation. m1 × d1 + m2 × d2 + m3 × d3 +... + m9 ×
d9

Such arithmetic processing is often used particularly in image processing. In that case, the value of each pixel is calculated from the values of pixels around the pixel. For example, the matrix ima
When the image represented by “ge” is to be smoothed, the arithmetic expression is described in the sDPCE language, for example, as in the following expression. mask M = [1,1,1,1,1,1,1,1,1]; image = M [[image]] / 9;

When the sharpening of the image represented by the matrix image is executed, the operation formula is described in the sDPCE language, for example, as in the following formula. mask M = [-1, -1, -1, -1, -1,1, -1,
-1, -1, -1]; image = M [[image]] / 9;

Further, in the case of executing a process for converting the sum of the values of the upper, lower, left and right elements of each element of the image represented by the matrix image into the value of the element, for example, the operation formula is sDPCE as in the following equation. Written in language. mask M = [0,1,0,1,0,1,0,1,0]; image = M [[image]];

As described above, according to the first embodiment, a source program is described in the sDPCE language, which is an extension of the C language by adding a syntax used for a processor with a parallel processing function, and Since a statement or expression based on a syntax related to a vector or a matrix is converted into a statement or expression in C language for calling a routine for parallel processing of the library, a detailed description of the routine of the library corresponding to each processor is provided. A source program for a processor with a parallel processing function can be easily created without requiring knowledge, and a relatively small-scale parallel processing function provided in the processor can be efficiently used. The effect is obtained.

According to the first embodiment, the compiler and the library corresponding to the predetermined number of processors are stored in the predetermined recording medium in advance, and the compiler and the library corresponding to the specified processor are used. Thus, since a binary file for the processor is generated, an effect is obtained that binary files for a plurality of types of processors can be easily generated.

In the first embodiment, shape
Although the type variable declaration statement is converted to a C language array declaration statement, it may be converted to a C language memory allocation function.

Embodiment 2 The programming language processing device according to the second embodiment of the present invention operates the "+" or "-" of the operators "+", "-", "*", and "/" of the four arithmetic operations on a vector or a matrix. When an expression in which a child appears at least twice is described in the source program, the expression is converted into an expression corresponding to a process of executing the operation of the expression for each predetermined number of elements in a vector or matrix. It is something to convert. Other processes are the same as those in the first embodiment, and therefore, only the process in the above case will be described here.

For example, in a source program in the sDPCE language, vectors v1, v2, v3, v4, v
The process of calculating the sum of 5 and substituting the sum into the vector v6 is described as follows. v6 = v1 + v2 + v3 + v4 + v5;

The arithmetic expression is converted into a C language expression for calling the parallel processing routine 21-i corresponding to the arithmetic operation in accordance with the preprocessor program 12, as shown below. for (i = 0; i <size; i + = partition_size) {MMX_add (& (tmp1 [i]), & (v1 [i]), & (v2 [i]), partition_size); MMX_add (& (tmp2 [ i]), & (tmp1 [i]), & (v3 [i]), partition_size); MMX_add (& (tmp3 [i]), & (tmp2 [i]), & (v4 [i]), partition_size ); MMX_add (& (v6 [i]), & (tmp3 [i]), & (v5 [i]), partition_size);}

In the above equation, “tmp1”, “tmp1”
“2” and “tmp3” are variables for temporarily storing values during the operation, and “partition_size” is the number of elements for executing the operation at one time. Also, the function "MMX_add (A, B, C,
D) "is the sum of the elements in the range from the element indicated by the pointer B to the element D and the element in the range from the element indicated by the pointer C to the element D, and the sum of the elements indicated by the pointer A to the area D. The function to assign.

As described above, according to the second embodiment, a vector or a matrix is converted into an expression corresponding to a process executed for each of a predetermined number of elements.
When the processor specified by the user has a cache memory, the effect of increasing the probability of a cache hit can be obtained.

That is, by converting the expressions as in the above example, as shown in FIG. 7, the variables “tmp1” and “t
Since “mp2” and “tmp3” are used in the following formula before being cached out, the probability of a cache hit increases. On the other hand, when the expression in the sDPCE language of the above example is converted as follows, for example, a cache hit does not occur as shown in FIG. 8, and the conversion as shown in the second embodiment is more binary. The processing speed when executing the program is increased. MMX_add (tmp1, v1, v2, size_of_vector); MMX_add (tmp2, tmp1, v3, size_of_vector); MMX_add (tmp3, tmp2, v4, size_of_vector); MMX_add (v6, tmp3, v5, size_of_vector);

Embodiment 3 The programming language processing apparatus according to the third embodiment of the present invention outputs a C language source program in which unnecessary operations on a where statement are skipped by a conditional statement. Other parts are the same as those according to the second embodiment.
The description is omitted.

For example, in a source program in the sDPCE language, matrices m1, m2, m3, m4, m5
When m6 is of the same type, matrices m2, m3, m4 at the same positions as the elements of matrix m1 whose values are 0
The processing for executing the operation only on the elements m5 and m6 is as follows.
For example, it is described as follows.

The arithmetic expression is converted into a C language expression for calling the parallel processing routine 21-i corresponding to the arithmetic operation in accordance with the preprocessor program 12, as shown below. for (i = 0; i <size; i + = partition_size) {if (condition) {MMX_Add (& (tmp1 [i]), & (m3 [i]), & (m4 [i]), partition_size); MMX_Add (& (tmp2 [i]), & (tmp1 [i]), & (m5 [i]), partition_size); MMX_Sub (& (tmp3 [i]), & (tmp2 [i]), & (m6 [ i]), partition_size); MMX_cwrite_eq (& (m2 [i]), & (tmp3 [i]), & (m1 [i]), partition_size);}}

In the above equation, “tmp1”, “tmp1”
“2” and “tmp3” are variables for temporarily storing values during the operation, and “partition_size” is the number of elements for executing the operation at one time. Also, the function “MMX_Add (A, B, C,
D) "is the sum of the elements in the range from the element indicated by the pointer B to the element D and the element in the range from the element indicated by the pointer C to the element D, and the sum of the elements indicated by the pointer A to the area D. This is the function to be assigned, and the function "MMX_Sub (A, B, C, D)"
Are elements in the range from the element indicated by the pointer B to D,
This function substitutes the difference of each element between the element indicated by the pointer C and the element in the range of D from the element indicated by the pointer A into the range of D. Further, the function “MMX_cwrite_eq (A,
B, C, D) "is an element indicated by the pointer B only for an element in the range from the element indicated by the pointer C to the element D corresponding to the element corresponding to the element having a value of 0. This is a function for substituting elements in the range from to to D into the range from the element indicated by the pointer A to D. And "condition
Is a conditional expression of a where statement (in this case, “m1 == 0
) Is a conditional statement for determining whether or not to execute the operations of the four expressions within the range of the if statement in each iteration of the for statement.

As described above, according to the third embodiment, the source program is converted so as to skip unnecessary calculations in the “where” statement, so that the binary program generated from the converted source program is converted. The effect that the processing speed at the time of execution is improved is obtained.

For example, when the edge enhancement processing is performed on an image having a halftone as shown in FIG. 9, most element values (ie, pixel values) of a matrix corresponding to pixels are not changed. By dividing the operation within the range of the “where” statement for each predetermined number of elements, it is possible to skip the operation for the element whose value is not changed.

Embodiment 4 In the programming language processing apparatus according to Embodiment 4 of the present invention, a case where a C compiler of a processor specified by a user can convert a statement described in an assembler language into a source program in the same manner as a statement in a C language First, a predetermined sentence described in the sDPCE language is appropriately converted into an assembler language.

For example, in a source program in the sDPCE language, a process of calculating the sum of scalar variables s1, s2, s3, and s4 and assigning the sum to the scalar variable s5 is described as follows. s5 = s1 + s2 + s3 + s4;

Then, this operation expression is converted into an expression in an assembler language corresponding to the operation as shown below according to the preprocessor program 12.

The instruction “movq A, B” sets the value of B to A
The command “padddA, B” is a command for storing the value obtained by adding the value of B to the value of A in A. Also,
"_Asm" indicates that the program in the following parentheses is described in assembler language.

As described above, according to the fourth embodiment, the expressions in the sDPCE language are appropriately converted into the expressions in the assembler language. Therefore, when the binary program generated from the converted source program is executed, The effect of improving the processing speed is obtained.

In the first to fourth embodiments, the function is converted into a statement or an expression that calls a function in the C language. However, the function may be converted into an inline function or a macro definition as appropriate.

In the first to fourth embodiments, the source program in the sDPCE language is converted to the source program in the C language.
It is not limited to CE language and C language.

[0096]

As described above, according to the present invention, a statement based on a syntax related to a vector or a matrix in a source program described in a parallel processing programming language obtained by extending a predetermined programming language for parallel processing. Or, convert the expression into a statement or expression based on the syntax of a predetermined programming language for calling a parallel processing routine of a library corresponding to any of the processors with parallel processing functions, and convert the parallel processing from a recording medium. The compiler program corresponding to the processor with the function is read, and a binary program corresponding to the processor with the parallel processing function is generated from the converted source program according to the compiler program. Detailed knowledge of routines , It is possible to easily create a source program for a processor with a parallel processing function, and to efficiently use a relatively small-scale parallel processing function provided in the processor. effective.

Further, an effect is obtained that binary files for a plurality of types of processors can be easily generated.

According to the present invention, among the operators "+", "-", "*", and "/" for the four arithmetic operations on a vector or a matrix, the operator of "+" or "-" is at least twice. When an appearing expression is described in a source program, the expression is converted into an expression of a predetermined programming language corresponding to a process of executing the operation of the expression for each predetermined number of elements of a vector or a matrix. With such a configuration, when the processor has a cache memory, there is an effect that the probability of a cache hit can be increased.

[Brief description of the drawings]

FIG. 1 is a block diagram showing a configuration of a programming language processing device according to a first embodiment of the present invention.

FIG. 2 is a diagram illustrating a configuration of an sDPCE language.

FIG. 3 is a flowchart illustrating an operation of the program language processing apparatus according to the first embodiment;

FIG. 4 is a flowchart illustrating a detailed operation of the program language processing device in step ST2 of FIG. 3;

FIG. 5 is a flowchart illustrating a detailed operation of the program language processing device in step ST24 of FIG. 4;

FIG. 6 is a diagram illustrating an example of a calculation process on a matrix.

FIG. 7 is a diagram illustrating an example of the contents of a cache of a processor at the time of execution.

FIG. 8 is a diagram showing another example of the contents of the cache of the processor at the time of execution.

FIG. 9 is a photograph showing a halftone image as an example of an image having a halftone.

FIG. 10 is a diagram illustrating a 64-bit MMX register provided in a Pentium processor having an MMX function.

[Explanation of symbols]

Reference Signs List 1 recording medium, 3 CPU (reading means, converting means, generating means), 13-1 to 13-n C compiler program (compiler program), 14-1 to 14-n library, 21-1 to 21-n parallel processing Routine.

 ──────────────────────────────────────────────────続 き Continued on the front page (72) Inventor Kenichi Tanaka 2-3-2 Marunouchi, Chiyoda-ku, Tokyo Mitsubishi Electric Corporation

Claims (9)

[Claims] 1. A reading means for reading a source program described in a parallel processing programming language obtained by extending a predetermined programming language for parallel processing, and processing by a predetermined number of different types of processors with parallel processing functions. A process of generating binary programs respectively corresponding to the predetermined number of processors with parallel processing functions from a predetermined number of libraries each having the described routine and a source program described in the predetermined programming language is described. A recording medium on which a predetermined number of compiler programs are recorded; and a statement or expression based on a syntax relating to a vector or a matrix of the source program, the predetermined programming language for calling a parallel processing routine of the library. Into statements or expressions based on syntax Converting means for reading the compiler program corresponding to any of the predetermined number of processors with parallel processing functions from the recording medium, and converting the source program according to the compiler program by the converting means. And a generating means for generating a binary program corresponding to the processor with a parallel processing function from the above. 2. The programming language for parallel processing has a syntax for describing an inner product of a vector, a product of a vector and a matrix, and a product of a matrix and a matrix, and the conversion means converts an expression based on the syntax into: The method according to claim 1, further comprising: converting an expression based on the syntax of the predetermined programming language to call a routine of a library corresponding to one of an inner product of a vector, a product of a vector and a matrix, and a product of a matrix and a matrix. 2. The programming language processing device according to 1. 3. The programming language for parallel processing has a syntax for describing transposition of a matrix, and the conversion means converts an expression based on the syntax into a routine of a library corresponding to the transposition of the matrix. 2. The programming language processing device according to claim 1, wherein the expression is converted into an expression based on a language syntax. 4. A programming language for parallel processing has a syntax for describing, for each element of a matrix, a process of executing a predetermined operation on a predetermined range of elements including the element, and the conversion means includes: An expression based on the syntax is converted into a syntax of the predetermined programming language for calling, for each element of the matrix, a routine of a library corresponding to a process of performing a predetermined operation on a predetermined range of elements including the element. 2. The programming language processing device according to claim 1, wherein the expression is converted into an expression based on the expression. 5. The conversion means includes one of operators “+”, “−”, “*”, and “/” for four arithmetic operations on a vector or a matrix.
When an expression in which a “+” or “−” operator appears at least twice is described in a source program, the expression is calculated by performing an operation of the expression on the vector or matrix for each predetermined number of elements. 2. The programming language processing device according to claim 1, wherein the programming language is converted into an expression of the predetermined programming language corresponding to a process to be executed. 6. The conversion means, when a declaration statement of an object type variable representing a vector or a matrix is described in a source program, converts the declaration statement into an array declaration statement of the predetermined programming language or memory allocation. 2. The programming language processing device according to claim 1, wherein the language is converted into a statement or an expression having a function. 7. The programming language for parallel processing is DP
A conversion unit configured to convert the where sentence into a conditional sentence in the predetermined programming language for each predetermined element of a vector or a matrix, based on a conditional expression of the where sentence. The programming language processing device according to claim 1, wherein: 8. A step of reading a source program written in a parallel processing programming language obtained by extending a predetermined programming language for parallel processing, and a step of reading a statement or an expression based on a syntax related to a vector or a matrix in the source program. A statement based on the syntax of the predetermined programming language for calling a parallel processing routine of a library corresponding to any one of the predetermined number of different types of parallel processing processors. Or converting to an expression; a predetermined number of libraries corresponding to the predetermined number of processors with parallel processing functions; and a predetermined number of processors with parallel processing functions from a source program written in the predetermined programming language. Binary programs corresponding to Reading the compiler program corresponding to the processor with the parallel processing function from a recording medium on which a predetermined number of compiler programs in which processing to be performed are described are recorded; and reading out the source program after conversion according to the compiler program. Generating a binary program corresponding to the processor with a parallel processing function. 9. A predetermined number of libraries each having a routine describing processing of a predetermined number of different types of processors with a parallel processing function, and a predetermined number of routines from a source program described in a predetermined programming language. A predetermined number of compiler programs each describing a process of generating a binary program corresponding to a processor with a parallel processing function are recorded, and the computer is expanded by using a parallel processing programming language obtained by expanding the predetermined programming language for parallel processing. Reading means for reading a written source program, a statement or expression based on a syntax relating to a vector or a matrix of the source program, based on a syntax of the predetermined programming language for calling a parallel processing routine of the library; Convert to statement or expression Converting means for reading the compiler program corresponding to any one of the predetermined number of processors with parallel processing function, and converting the source program converted by the converting means according to the compiler program into a program having the parallel processing function. A computer-readable recording medium on which a program for causing a processor to function as a generation unit for generating a binary program corresponding to the processor is recorded.