KR20120079957A - Method and apparatus for searching parallelization point of array - Google Patents

Abstract

PURPOSE: A method and an apparatus for searching the parallelization point of an array are provided to divide calculation about the array by nodes based on a parallelization point. CONSTITUTION: A monitoring code is inserted into the loop of a source code(S130). When the implementation of the loop is completed, the result of a monitoring data structure is acquired(S150). N sections for the loop are determined(S160). Whether overlapped updating elements are in the elements of a first array is verified based on the result(S170). The source code is updated by dividing the loop into loops for the n sections(S180).

Description

METHOD AND APPARATUS FOR SEARCHING PARALLELIZATION POINT OF ARRAY}

The following embodiments are directed to a method and apparatus for searching for parallelization points of an array.

A method and apparatus for searching for parallelization points of an array and dividing operations on the array by node based on the parallelization point are disclosed.

The parallelization of software is to build parallel software that can be executed on a multi-core or a plurality of nodes by parallelizing existing sequential programs.

To parallelize software, various methodologies and libraries based on these methodologies are used. In general, distributed processing methodologies using sockets and thread programming methodologies are used for parallelism. These methodologies are distributed in the form of books, technical documents, papers, programming libraries, programming frameworks, and the like.

For example, in a Unix system, parallel programs can be implemented by using system calls related to pthreads.

Also, framework technologies for developers include an OpenMP Library, a Message Passing Interface, a Test Parallel Library, and the like.

These framework technologies create threads that can perform parallel processing when developers make explicit declarations.

Existing techniques are based on a very abstract methodology, or only if the developer already knows if it can be parallelized (ie, if the developer explicitly declares it for parallelism). Provide a way.

One embodiment of the present invention can provide an apparatus and method for searching for parallelization points in an array.

An embodiment of the present invention may provide an apparatus and method for parallelizing an operation on an array based on a found parallelization point.

According to one aspect of the invention, inserting a monitoring code inside a loop in source code, the loop assigning a value to a plurality of elements of a first array. The monitoring code comprises a monitoring data structure, the monitoring data structure recording which of the plurality of elements of the first array has been updated at each iteration of the loop. Obtaining a result value of the monitoring data structure after execution of the loop ends, determining n intervals for the loop, where n is an integer greater than or equal to 2, each iteration of the loop being the n number of loops Included in one of the sections. Determining, based on the result value, whether there is a duplicate update element among a plurality of elements of the first array, wherein the duplicate update element is updated in at least two of the n periods. being. And if the duplicate update element is not found, dividing the loop into loops for each of the n intervals executed in parallel to update the source code. A parallelization method of is provided.

The method of parallelizing the operation on the elements of the array may further include selecting the first array in the source code and selecting the loop in the source code.

The n may be 2, the first interval may be the front of the iterations performed by the loop, the second interval may be the rear of the iterations.

The first arrangement may be k-dimensional and the monitoring data structure may indicate at which iterations of the loop each of the k-dimensional elements has been updated.

The number of iterations of the loop may be L.

The monitoring data structure may comprise a second array for each of a plurality of elements of the first array, the second array being a one-dimensional array of size L, each of the elements of the second array being L It may be an array of four Boolean values.

The monitoring code is set to true if the i-th Boolean value of the i-th element of the second array corresponding to the updated element is updated when a particular element of the plurality of elements of the first array is updated in the i-th iteration of the loop. ture).

Whether the xth element of the plurality of elements of the first array is updated in the yth period of the k periods, the yth period of the elements of the second array corresponding to the xth element may be The values of the elements of the indices corresponding to the repetitions may be determined based on a logical OR.

Among the elements of the second array corresponding to the xth element, whether the xth element of the plurality of elements of the first array is duplicated and updated in the yth and zth periods of the k periods, Compute the first logical sum of the values of the elements of the index corresponding to the iterations included in the y th interval, and the second logical sum of the values of the elements of the index corresponding to the iterations included in the z th interval It may be determined by calculating and ANDing the first AND and the second AND.

The monitoring data structure may be an array of k + 1 dimensions corresponding to the second array for each of the first array and a plurality of elements of the first array.

Acquiring a result value of the monitoring data structure after the execution of the loop ends, generating an execution code based on the source code, executing the execution code, and executing the result value after the execution of the loop ends. It may include the step of obtaining.

According to another aspect of the invention, a monitoring code inserter for inserting a monitoring code inside a loop in the source code-the loop assigns a value to a plurality of elements of the first array. The monitoring code comprises a monitoring data structure, the monitoring data structure recording which of the plurality of elements of the first array has been updated at each iteration of the loop. A result value obtaining unit obtaining a result value of the monitoring data structure after the execution of the loop is finished, an interval determining unit determining n sections for the loop, n being an integer of 2 or more, each of the loops Repetition is included in one of the n intervals. A duplicate update element determiner that determines whether there is a duplicate update element among a plurality of elements of the first array based on the result value, wherein the duplicate update element is two or more of the n periods; The element to update on. And a source code updater for dividing the loop into loops for each of the n intervals executed in parallel to update the source code if the duplicate update element is not found. Parallelism device for operation.

The apparatus for parallelizing operations on the elements of the array may further include a parallelization object selection unit that selects the first array in the source code and selects the loop in the source code.

The redundancy update element determiner is configured to OR the values of the elements of the indices corresponding to the repetitions included in the y th interval among the elements of the second array corresponding to the x th element among the plurality of elements of the first array. Based on a value, it may be determined whether the x th element is updated in the y th period among the k periods.

The redundancy update element determiner is configured to OR the values of the elements of the index corresponding to the repetitions included in the y th interval among the elements of the second array corresponding to the x th element among the plurality of elements of the first array. By calculating a first logical sum, calculating a second logical sum of the values of the elements of the index corresponding to the iterations included in the z interval, and ANDing the first logical sum and the second logical sum It may be determined whether the x th element is duplicated and updated in the y th section and the z th section among the k sections.

The result value obtaining unit may generate an execution code based on the source code and execute the execution code to obtain a result value of the monitoring data structure after the execution of the loop ends.

An apparatus and method for searching for parallelization points of an array are provided.

An apparatus and method are provided for parallelizing operations on arrays based on the retrieved parallelization points.

1 is a flow diagram of a method for parallelizing an operation on elements of an array in accordance with one embodiment of the present invention.
2 is a source arrangement that is subject to parallelism according to an example of the present invention.
3 is a pseudo code including a loop for updating an original arrangement according to an embodiment of the present invention.
4 illustrates a monitoring data structure according to an embodiment of the present invention.
5 shows a monitoring code according to an example of the present invention.
6 illustrates an update of the monitoring data structure during loop execution according to an example of the present invention.
7 illustrates a monitoring data structure after loop execution is completed according to an embodiment of the present invention.
8 illustrates a parallelized loop according to an example of the present invention.
9 is a structural diagram of an apparatus for parallelizing an operation on elements of an array according to an embodiment of the present invention.

Hereinafter, an embodiment of the present invention will be described in detail with reference to the accompanying drawings. However, the present invention is not limited to or limited by the embodiments. Like reference symbols in the drawings denote like elements.

1 is a flow diagram of a method for parallelizing an operation on elements of an array in accordance with one embodiment of the present invention.

In step S110, the original arrangement is selected in the source code.

The original array is the array to be parallelized.

In step S120, a loop to be parallelized in the source code is selected. The loop assigns values to multiple elements of the original array.

That is, as the loop is iterated, the value of a specific element of the plurality of elements of the original array is updated (or generated) in each iteration.

In step S130, a monitoring code is inserted inside the selected loop.

The monitoring code includes a monitoring data structure.

The monitoring data structure records which of the elements of the original array were updated at each iteration of the loop. That is, the monitoring data structure can identify which element of the original array has been updated at which iteration of the loop.

In step S140, the execution code based on the source code into which the monitoring code is inserted is generated.

In step S150, by executing the generated executable code, a result value of the monitoring data structure after the execution of the loop ends is obtained.

In step S160, n intervals for the loop are determined.

n is an integer of 2 or more. Each iteration of the loop is included in one of n intervals.

When n is 2, the first section may be the front of the repetitions performed by the loop, and the second section may be the rear of the repetitions performed by the loop.

In step S170, it is determined whether there is a duplicate update element among the plurality of elements of the original array based on the result value of the monitoring data structure.

The duplicate update element refers to an element that is updated in at least two sections of k sections.

That is, when a specific element of the elements of the original arrangement is updated in the first section and the second section, the specific element is a duplicate update element.

If there are duplicate update elements among the elements of the original array, k intervals cannot be parallelized.

For example, assume a case where the first redundant update element is updated at the a iteration and the b iteration of the loop. Where a <b. The a th iteration is a repetition belonging to the c section of the k sections, and the b th iteration is a iteration belonging to the d section of the k sections.

When the original loop is executed, since a <b, the value of the first redundant update element is the value updated (or generated) by the b th iteration.

However, if k intervals are all executed in parallel, then the a iteration is executed in the loop divided for the interval c, and the b iteration is executed in the loop divided for the interval d, so that the a iteration and the b iteration It is not guaranteed that the b th iteration is executed finally.

On the other hand, if there are no duplicate update elements among the elements of the original array, k intervals may be parallelized.

Suppose that one of the elements of the original array is updated at the a 'and b' iterations of the loop. Where a '<b'. The a 'th iteration and the b' th iteration are both iterations belonging to the 'c' section of k intervals.

When the original loop is executed, since a '<b', the value of the element is the value updated (or generated) by the b 'th iteration.

Although the k intervals are all executed in parallel, the a'th iteration and the b'th iteration are executed in the divided loop for the mode c 'interval. Thus, it can be ensured that the b 'th iteration of the a' th iteration and the b 'th iteration is finally executed.

That is, for a plurality of elements of the original arrangement, the k intervals can be parallelized if each element is updated in only one of the k intervals or in no interval.

If no duplicate update element is found, step S180 is performed.

In step S180, the loop is divided into loops for each of the n intervals.

The divided loops run in parallel. The divided loops may be executed in parallel by a plurality of nodes in the system.

The source code is updated by dividing the loop into loops for each of the n intervals.

2 is a source arrangement that is subject to parallelism according to an example of the present invention.

The original arrangement 200 shown is an array of two dimensions. The size of the first dimension x of the original array 200 is size_X, and the size of the second dimension y of the original array 200 is size_Y.

That is, the original array 200 may be declared by the pseudo code of Table 1 below.

element_type matrix (size_X, size_Y);

Here, matrix is a name of the original array 200, and element_type indicates that the original array 200 is an array of elements of the element_type type.

In this embodiment, it is merely exemplary that the original arrangement 200 is two-dimensional. The text array can be k dimension. k is an integer of 1 or more.

3 is a pseudo code including a loop for updating an original arrangement according to an embodiment of the present invention.

The loop 300 is repeated L times from 1 to LOOP_MAX_INDEX 310 (hereinafter, denoted by L 310).

In each iteration of the loop 300, the result value of the function ex_function () 330 is assigned to the element matrix (x, y) of the original array 200 "matrix". That is, the value of matrix (x, y) is updated.

ex_function () 330 may be any function.

Variable x and variable y specify one element of one or more elements of original array 200. In other words, the variables x and y are indexes 320 that specify the elements of the original array 200.

The value of the index 320, that is, the value of x and the value of y, may change continuously as the loop 300 repeats. Thus, as the loop 300 repeats, certain elements of the original array 200, which are specified by indexes, gradually change.

That is, as the loop 300 repeats, one element of the elements of the original array 200 is selected and the value of the selected element is updated.

A particular element e of the elements in the original arrangement 200 may not be updated during the iterations of the loop 300 (ie, the first to Lth iterations). On the other hand, a particular element f of the elements of the original array 200 may be updated two or more times as the loop 300 repeats.

4 illustrates a monitoring data structure according to an embodiment of the present invention.

As described above, in order to divide the loop 300 into loops for each of the n sections, it may be determined whether there are overlapping elements among the elements of the original array 200.

In order to determine whether a particular element of the original array 200 is redundant, it must be recorded at which iteration of the loop 300 each element of the original array 200 has been updated. For example, if the elements of original array 200 are k-dimensional arrays, the monitoring data structure may indicate at which iterations of loop 200 each of the k-dimensional elements has been updated.

Or, it should be recorded which of the elements of the original array 200 has been updated in a particular section of the loop 300. For example, if the original array 200 is repeated L times, the monitoring data structure may indicate which elements of the original array 200 have been updated at each iteration.

For example, the monitoring data structure may assign a repeating arrangement to each of a plurality of elements of the original arrangement 200. The length of the repeat array is L. As mentioned above, L is the number of iterations of the loop 300. That is, a one-dimensional repetitive array of length L is assigned to each of the plurality of elements of the original array 200.

Each element of the repeating array may be an array of L Boolean values. Alternatively, the elements of the repeating array may be bit strings of length L.

If one of the elements of the original array 200 is updated in the i th iteration of the loop 300, the monitoring code in the loop 300 updates the value of the i th element of the iterative array of the updated element. . That is, among the L boolean values (or bit strings), the i th Boolean value (or i th bit), which is the value of the i th element of the iterative array of updated elements, is true (or 1). Set to). Thus, a repeating arrangement corresponding to a particular element of the original array 200 may record at which iteration the element was updated.

In addition, if a logical sum is generated by ORing all the values of the repeating array, the elements of the ORed array are true that the specific element of the 1 to L iterations is updated. Are listed in false order.

The monitoring data structure may be configured as one array. The monitoring data structure may comprise a single array including the original array 200 and repeating arrays for each element of the original array 200. That is, the monitoring data structure may be a single array k + 1 dimension array corresponding to the original array 200 and a repeating array for each of the plurality of elements of the original array 200.

For example, if the original array is an array of k dimensions, the monitoring data structure may be an array of k + 1 dimensions.

Monitoring data structure 400 of FIG. 4 shows an example of monitoring data structure 400 that includes a single arrangement.

When the original array 200 is a two dimensional array, the monitoring data structure 400 may be a three dimensional array.

The range of the first dimension 410 of the monitoring data structure 400 is the same as the range of the first dimension of the original arrangement. Also, the range of the second dimension 420 of the monitoring data structure 400 is the same as the range of the second dimension of the original arrangement.

That is, when the original array 200 is a k-dimensional array, the ranges of the first through k-th dimensions of the monitoring data structure 400 are each the same as the range of the corresponding dimension of the original array 200.

The third dimension 430 of the monitoring data structure 400 corresponds to the iterative arrangement described above. The third dimension of the monitoring data structure 400 ranges from 1 to L. FIG. In FIG. 4, L = 4.

In FIG. 4, the size of the first dimension 410 of the monitoring data structure 400 is two, the size of the second dimension 420 is two, and the size of the third dimension 430 is four. The element of monitoring data structure 400 is four Boolean values.

Among them, the elements of the monitoring data structure 400 corresponding to the matrix (1, 1) of the original array 200 have four elements 440, 442, 444 having a first dimension of 1 and a second dimension of 2. And 446).

Each element of the monitoring data structure 400 is an element of the repeating arrangement described above. That is, each element of the monitoring data structure 400 is an array of L Boolean values (or a bit string of length L).

That is, the monitoring data structure 400 may be declared by the pseudo code of Table 2 below.

bool [L] matrix_monitor (index 1, index 2, ..., index k, L);

Here, matrix_monitor is the name of the monitoring data structure 400.

index 1 to index k represent the range of each dimension of the original array that is k-dimensional.

L is the number of iterations of the loop 300, as described above.

Here, the monitoring structure 400 can be declared as an array of k + 2 dimensions with bool values as elements. An array of k + 2 dimensions may be declared by the pseudo code of Table 3 below.

bool matrix_monitor (index 1, index 2, ..., index k, L, L);

5 shows a monitoring code according to an example of the present invention.

In FIG. 5, the loop 500 with the monitoring code 510 inserted is shown.

Within the monitoring code 510, the value of matrix_monitor (x, y, i) 520 is updated.

That is, the element 320 specified by the indexes x and y of the elements of the original array 200 is updated by the "ex_function ()" 330, and the indexes x and y of the elements of the monitoring data structure 400. And the element 520 specified by i is updated by " mark (i) "

"mark (i)" 530 is a function that changes the value of the i th element of a Boolean array of length L to true. That is, by the " mark (i) " function 530, the i &lt; th &gt; Boolean value of the element 520 specified by the indexes x, y, and i of the elements of the monitoring data structure 400 is updated to true.

6 illustrates an update of the monitoring data structure during loop execution according to an example of the present invention.

When the executable code including the loop 300 is executed, the loop 300 is repeated.

When the loop 300 repeats a second time, the matrix (1, 1) of the elements of the original array 200 is updated. That is, when loop 300 is repeated a second time, x = 1 and y = 1.

At this time, the matrix_monitor (1, 1, 2) 442 of the monitoring data structure 400 is updated by the monitoring code 510. That is, the value of the second element 620 of the Boolean array 610 pointed to by matrix_monitor (1, 1, 2) is true updated. If the element of the monitoring data structure 400 is a bit string, the bit string pointed to by matrix_monitor (1, 1, 2) is updated to "0010".

7 illustrates a monitoring data structure after loop execution is completed according to an embodiment of the present invention.

In FIG. 7, matrix (2, 2) is updated at the first iteration of loop 300, matrix (1, 1) is updated at the second iteration, matrix (2, 1) is updated at the third iteration, and When the matrix (1, 2) is updated in the fourth iteration, the value of the monitoring data structure 400 is represented.

In the Boolean array that is an element of the monitoring data structure 400, the hatched portion represents the Boolean element whose value is true, and the blank portion represents the Boolean element whose value is false.

8 illustrates a parallelized loop according to an example of the present invention.

First, the parallelism of the loop will be described based on the parallelization point.

The parallelization point is the point at which loop 300 divides into two sub-loops 810 and 820.

In FIG. 7, by the parallelization point, the loop 300 is divided into a first sub-loop 810 in a range of 1 to 2 and a second sub-loop 820 in a range of 3 to 4.

Source code including the parallelized loops 810 and 820 may be converted into executable code through compilation or the like. The converted executable code is executed by a plurality of nodes in a multi-node environment.

By means of the upper "if" statement 830, the first sub-loop 810 is executed by the first node. Also, with an abort " else if " statement 840, the second sub-loop 820 is executed by the second node.

The last " merge () " function 850 merges the original matrix 200 updated by the first node and the original matrix 200 updated by the second node.

The parallelization point may be determined by a particular prediction method, and may be arbitrarily determined. That is, several parallelization points may be arbitrarily set, and the loop 300 may be divided based on the parallelization point that satisfies a specific condition.

Whether the loop 300 may be parallelized by a particular parallelization point may be determined based on the result value of the monitoring data structure 400.

That is, an OR operation on an element of the monitoring data structure 400 may determine which element is updated within the iterations included in the interval. In addition, it may be determined which elements are updated in each of the first section and the second section divided by the parallelization point.

If there is an overlap between the elements updated in the first section and the elements updated in the second section (that is, if a specific element is updated in both the first section and the second section), the first section and the second section It cannot be done in parallel.

On the other hand, if there is no overlap among the elements updated in the first section and the elements updated in the second section (that is, all elements in the original array 200 are at most one section (that is, among the first section and the second section). If only one section is updated, the first section and the second section may be performed in parallel, so that the loop 300 is divided into the first sub-loop 810 by the parallelization point that divides the first section and the second section. ) And the second sub-loop 820.

In FIG. 6, in the first iteration and the second iteration belonging to the first section, the matrix (2, 2) and the matrix (1, 1) have been updated. In the third and fourth iterations belonging to the second interval, the matrix (2, 1) and matrix (1, 2) were updated. Therefore, the first section and the second section may be performed in parallel.

Elements of the monitoring data structure 400 that are updated in the first iteration may be expressed as "matrix_monitor (*, *, 1)".

In addition, the elements of the monitoring data structure 400 that are updated in the first iteration or the second iteration may be represented as a logical sum. That is, elements of the monitoring data structure 400 updated in the first iteration and the second iteration corresponding to the first interval may be expressed as "matrix_monitor (*, *, 1) OR matrix_monitor (*, *, 2)". have. Elements of the monitoring data structure 400 updated in the third and fourth iterations corresponding to the second interval may be expressed as "matrix_monitor (*, *, 3) OR matrix_monitor (*, *, 4)".

Elements of the monitoring data structure 400 updated in the first and second intervals may be represented as a logical product. That is, elements of the monitoring data structure 400 updated in both the first section and the second section may be expressed as shown in Table 4 below.

(matrix_monitor (*, *, 1) OR matrix_monitor (*, *, 2)) AND (matrix_monitor (*, *, 3) OR matrix_monitor (*, *, 4))

The result of Equation 4 above being 0 (or empty set) means that none of the elements of the monitoring data structure 400 is updated in both intervals. Thus, in this case, both sections can be performed in parallel.

Next, consider the case where there is more than one parallelization point. That is, the case where the loop 200 is divided into k sections is considered.

It may be determined whether the x th element of the plurality of elements of the original array 200 is updated in the specific y th period among the k periods.

That is, among the elements of the repetition array corresponding to the x th element, it may be determined based on a logical OR of values of elements of the indices corresponding to the repetitions included in the y th interval.

For example, if the repetitions included in the first interval are the first repetition and the second repetition, the indexes corresponding to the two repetitions are “1” and “2”. By logical sum of the values of the first element of the repeating array (ie, the first Boolean array of the repeating array) and the second element (ie, the second Boolean array of the repeating array) corresponding to the xth element of the original array 200. (Ie, by generating an ORed Boolean array by ORing each element of the first Boolean array and each element of the second Boolean array), it may be determined whether the x th element is updated in the first interval.

Therefore, it may be determined whether the x-th element of the original array 200 is duplicated and updated in the y-th and z-th sections of the k sections using the above-described method. That is, the first ANDed Boolean array for the y-th interval is generated, the second ANDed Boolean array for the z-th interval is generated, and the AND is performed by ANDing the first ANDed Boolean array and the second ANDed Boolean array By generating the Boolean array, it may be determined whether the x-th element of the original array 200 is updated in the y-th and z-th periods.

If the ANDed Boolean array contains elements with true values, then certain elements are duplicates in the y-th and z-th periods.

The above description can also be applied when k is 3 or more. In this case, it may be determined whether the x-th element is duplicated and updated in two specific sections by performing an AND operation on all possible OR pairs of the paired Boolean array pairs among the first AND-Boolean Boolean arrays.

For all elements of the original array 200, it can be determined whether k intervals can be performed in parallel by calculating and checking the OR. That is, if all elements of the original array 200 are not duplicated and updated, k sections may be performed in parallel.

9 is a structural diagram of an apparatus for parallelizing an operation on elements of an array according to an embodiment of the present invention.

The parallelization apparatus 900 may include a parallelization object selection unit 910.

The parallelizing apparatus 910 includes a monitoring code inserting unit 920, a result value obtaining unit 930, a section determining unit 940, a duplicate update element determining unit 950, and a source code updating unit 960.

The parallelization object selection unit 910 selects a first array in the source code, and selects a loop in the source code. The first arrangement may be the original arrangement 200 described above. The loop may be a loop 300 that is subject to the parallelism described above.

The monitoring code inserter 920 inserts the monitoring code into a loop in the source code. The loop assigns values to a plurality of elements of the first array. The monitoring code includes a monitoring data structure, which records which element of the plurality of elements of the first array has been updated at each iteration of the loop.

If the first arrangement is k-dimensional, the monitoring data structure may indicate at which iterations of the loop each of the elements of k-dimensional were updated.

The number of iterations of the loop may be represented by L.

The monitoring data structure may comprise a second arrangement for each of the plurality of elements of the first arrangement. The second arrangement may be the repeating arrangement described above.

The monitoring data structure may be an array of k + 1 dimensions corresponding to the first array and the second array for each of the plurality of elements of the first array.

In this case, the second array may be a one-dimensional array having a size L, and each of the elements of the second array may be an array of L Boolean values.

The monitoring code sets the i-th Boolean value of the i-th element of the second array corresponding to the updated element to true when a particular one of the plurality of elements of the first array is updated in the i-th iteration of the loop. I can set it.

The result value obtaining unit 930 obtains a result value of the monitoring data structure after the execution of the loop ends.

The interval determiner 940 determines n intervals for the loop. n is an integer of 2 or more, and each repetition of the loop is included in one of n intervals.

n may be 2. In this case, the first section may be the front of the iterations performed by the loop, and the second section may be the back of the iterations.

The duplicate update element determiner 950 determines whether there is a duplicate update element among a plurality of elements of the first array based on the result value. The duplicate update element is an element that is updated in at least two of the n periods.

The duplicate update element determiner 950 may determine values of elements of indices corresponding to repetitions included in the y th interval among the elements of the second array corresponding to the x th element of the plurality of elements of the first array. Based on the OR value, it may be determined whether the x th element is updated in the y th period among the k periods.

The duplicate update element determiner 950 may select values of elements of an index corresponding to repetitions included in the y th interval among the elements of the second array corresponding to the x th element of the plurality of elements of the first array. Computing the first logical OR, calculating the second logical OR of the values of the elements of the index corresponding to the repetitions included in the z-th interval, and ORing the first logical OR and the second logical OR, It is possible to determine whether the x element is duplicately updated in the y th section and the z th section among k sections.

If no duplicate update element is found, the source code updater 960 updates the source code by dividing the loop into loops for each of the n sections executed in parallel.

Technical contents according to an embodiment of the present invention described above with reference to FIGS. 1 to 8 may be applied to the present embodiment as it is. Therefore, more detailed description will be omitted below.

The functions of the components 910 through 960 may be performed by a single controller (not shown). In this case, the controller may represent a single or multi chip, a processor, or a core. Each of the components 910 to 960 may represent a function, a library, a service, a process, a thread, or a module that is performed by the controller.

Method according to an embodiment of the present invention is implemented in the form of program instructions that can be executed by various computer means may be recorded on a computer readable medium. The computer readable medium may include program instructions, data files, data structures, etc. alone or in combination. The program instructions recorded on the medium may be those specially designed and constructed for the present invention or may be available to those skilled in the art of computer software. Examples of computer-readable recording media include magnetic media such as hard disks, floppy disks, and magnetic tape, optical media such as CD-ROMs, DVDs, and magnetic disks, such as floppy disks. Hardware devices specially configured to store and execute program instructions, such as magneto-optical media, ROM, RAM and flash memory, are included. Examples of program instructions include not only machine code generated by a compiler, but also high-level language code that can be executed by a computer using an interpreter or the like. The hardware device described above may be configured to operate as one or more software modules to perform the operations of the present invention, and vice versa.

As described above, the present invention has been described by way of limited embodiments and drawings, but the present invention is not limited to the above embodiments, and those skilled in the art to which the present invention pertains various modifications and variations from such descriptions. This is possible.

Therefore, the scope of the present invention should not be limited to the described embodiments, but should be determined by the equivalents of the claims, as well as the claims.

900: device for parallelizing operations on elements of an array
920: monitoring code insertion unit
930: interval determination unit
960: update source code

Claims (20)

Inserting monitoring code inside a loop in the source code, the loop assigning values to the plurality of elements of the first array. The monitoring code comprises a monitoring data structure, the monitoring data structure recording which of the plurality of elements of the first array has been updated at each iteration of the loop. -;
Obtaining a result value of the monitoring data structure after execution of the loop ends;
Determining n sections for the loop, where n is an integer greater than or equal to 2, each iteration of the loop being included in one of the n sections. -;
Determining whether there is a duplicate update element among a plurality of elements of the first array based on the result value, wherein the duplicate update element is an element that is updated in at least two of the n periods. -; And
If the duplicate update element is not found, dividing the loop into loops for each of the n intervals executed in parallel to update the source code
And a method for parallelizing an operation on elements of an array. The method of claim 1,
Selecting the first arrangement in the source code; And
Selecting the loop within the source code
Further comprising a method of parallelism of the operation on the elements of the array. The method of claim 1,
N is 2,
And a first section is a front part of the iterations performed by the loop, and a second section is a later part of the iterations. The method of claim 1,
Wherein the first arrangement is of k dimension, and wherein the monitoring data structure indicates at which iterations of the loop each of the elements of the k dimension are updated. The method of claim 4, wherein
The number of iterations of the loop is L,
The monitoring data structure includes a second array for each of the plurality of elements of the first array, the second array is a one-dimensional array of size L, and each of the elements of the second array is L Booleans. (Boolean) A method of parallelizing an operation on the elements of an array that is an array of values. The method of claim 5,
The monitoring code is set to true if the i-th Boolean value of the i-th element of the second array corresponding to the updated element is updated when a particular element of the plurality of elements of the first array is updated in the i-th iteration of the loop. method of parallelizing an operation on the elements of an array. The method of claim 5,
Whether the xth element of the plurality of elements of the first array is updated in the yth period of the k periods, the yth period of the elements of the second array corresponding to the xth element may be A method of parallelizing an operation on elements of an array that is determined based on a value of the OR of the elements of the indices corresponding to the iterations that comprise. The method of claim 5,
Among the elements of the second array corresponding to the xth element, whether the xth element of the plurality of elements of the first array is duplicated and updated in the yth and zth periods of the k periods, Compute the first logical sum of the values of the elements of the index corresponding to the iterations included in the y th interval, and the second logical sum of the values of the elements of the index corresponding to the iterations included in the z th interval And determining by AND of the first AND and the second AND. The method of claim 5,
And said monitoring data structure is an array in k + 1 dimension corresponding to said second array for each of said first array and a plurality of elements of said first array. The method of claim 1,
Acquiring a result value of the monitoring data structure after execution of the loop ends,
Generating executable code based on the source code; And
Obtaining the result value after execution of the loop ends by executing the execution code
And a method for parallelizing an operation on elements of an array. Monitoring code insertion section for inserting monitoring code inside the loop in the source code-the loop assigns values to a plurality of elements of the first array. The monitoring code comprises a monitoring data structure, the monitoring data structure recording which of the plurality of elements of the first array has been updated at each iteration of the loop. -;
A result value obtaining unit obtaining a result value of the monitoring data structure after the execution of the loop ends;
An interval determining unit for determining n intervals for the loop, wherein n is an integer of 2 or more, each repetition of the loop is included in one of the n intervals. -;
A duplicate update element determiner that determines whether there is a duplicate update element among the plurality of elements of the first array based on the result value-the duplicate update element is updated in at least two of the n sections; It is a factor. -; And
A source code updater that updates the source code by dividing the loop into loops for each of the n intervals executed in parallel when the duplicate update element is not found
An apparatus for parallelizing an operation on elements of an array comprising a. The method of claim 11,
A parallelization target object selector that selects the first array in the source code and selects the loop in the source code.
Further comprising a device for parallelizing the operation on the elements of the array. The method of claim 11,
N is 2,
And a first section is a front part of the iterations performed by the loop, and a second section is a back part of the iterations. The method of claim 11,
Wherein the first arrangement is k-dimensional, and wherein the monitoring data structure indicates at which iterations of the loop each of the elements of the k-dimensional are updated. 15. The method of claim 14,
The number of iterations of the loop is L,
The monitoring data structure includes a second array for each of the plurality of elements of the first array, the second array is a one-dimensional array of size L, and each of the elements of the second array is L Booleans. (Boolean) A device for parallelizing an operation on elements of an array that is an array of values. 16. The method of claim 15,
The monitoring code is set to true if the i-th Boolean value of the i-th element of the second array corresponding to the updated element is updated when a particular element of the plurality of elements of the first array is updated in the i-th iteration of the loop. device for parallelizing operations on the elements of an array. 16. The method of claim 15,
The redundancy update element determiner is configured to OR the values of the elements of the indices corresponding to the repetitions included in the y th interval among the elements of the second array corresponding to the x th element among the plurality of elements of the first array. And determining whether the x-th element is updated in the y-th period of the k periods based on a value. 16. The method of claim 15,
The redundancy update element determiner is configured to OR the values of the elements of the index corresponding to the repetitions included in the y th interval among the elements of the second array corresponding to the x th element among the plurality of elements of the first array. By calculating a first logical sum, calculating a second logical sum of the values of the elements of the index corresponding to the iterations included in the z interval, and ANDing the first logical sum and the second logical sum And determining whether the x th element is duplicated and updated in the y th and z th periods of the k periods. 16. The method of claim 15,
And said monitoring data structure is an array in k + 1 dimension corresponding to said second array for each of said first array and a plurality of elements of said first array. The method of claim 11,
The result value obtaining unit generates an execution code based on the source code, and executes the execution code to obtain a result value of the monitoring data structure after execution of the loop is terminated. Parallelization unit.

Images