JPWO2009044486A1 - Method for sorting tabular data, multi-core type apparatus, and program - Google Patents

Abstract

In a multi-core processing device, a sorting method for rearranging the records of tabular data according to a predetermined item value is as follows. (I) In a block in which each arithmetic unit is in charge, multiple arithmetic units operate in parallel. Apply the sort to the item value access information using the item value information as a key, and (ii) sort the combination of the item value information and the record sequence number in a predetermined order between the blocks, and (iii) between the blocks A sorted block number array is created by repeating the sort (ii), and (iv) a sorted record sequence number array is created by distributing the elements in the block number array for each block.

Description

  The present invention relates to a sorting method for rearranging records of tabular data constructed in a global memory according to a predetermined item value, represented as an array of records including item values corresponding to data items in a multi-core processing apparatus. Involved.

  The present invention also relates to a multi-core processing device that is represented as an array of records including item values corresponding to data items and rearranges the records of tabular data constructed in the global memory according to predetermined item values.

  Furthermore, the present invention relates to a program for causing a computer having a multi-core processor to execute the sorting method, a computer program product, and a recording medium on which the computer program is recorded.

  Conventionally, it is required to process large-scale data at high speed in various industrial fields. For large-scale data processing, development of hardware technologies such as high-speed memory access by cache and prefetch, high-speed memory, and high-speed arithmetic processing such as parallel processing of processors, and data processing The development of algorithms continues to speed up.

  The inventor has proposed a basic data processing algorithm for processing large-scale data at high speed, for example, an “on-memory data processing algorithm” as described in Patent Document 1. This technique is based on the idea that the tabular data is decomposed into items (ie, columns) instead of records (ie, rows) as in the prior art. More specifically, the tabular data includes (1) an array representing the record order, (2) a value table in which unique item values belonging to the items are arranged in a predetermined order (for example, ascending order), and (3 ) The item value corresponding to each record is represented by a data structure including an array representing position information stored in the value table. By adopting such a data structure, processes such as retrieval, sorting, merging, and joining of tabular data are realized at high speed.

  Furthermore, the present inventor has proposed various on-memory data processing algorithms corresponding to the parallelization of processors such as a memory distributed multiprocessor system and a memory shared multiprocessor system. For example, Patent Literature 2 describes a search / sort algorithm corresponding to a memory distributed multiprocessor system, and Patent Literature 3 describes a tabulation algorithm. Furthermore, Patent Document 4 describes an efficient sorting algorithm corresponding to a memory-shared multiprocessor system.

  Processing that occurs frequently when processing large-scale data, especially large-scale tabular data, is sorting. As an efficient sorting algorithm, it is also called radix (RADIX) sorting and counting sorting (counting sorting, distribution counting sorting). Is known). The radix sort is performed for each digit using each digit of data to be sorted as a key. In the counting sort, the number of appearances of the data to be sorted and the cumulative frequency distribution are calculated, and the data to be sorted is rearranged according to the cumulative frequency distribution. The counting sort may be used for sorting each digit of the radix sort. Patent Document 4 proposes a method of sorting large-scale tabular data on a shared memory in parallel by a plurality of processors in a shared memory processor system.

On the other hand, in recent years, a processor architecture including a plurality of (or many) cores in one processor has been proposed. Cell Broadcast Engine ^TM is known as an example of a multi-core type processor (see Non-Patent Document 1). This type of processor is intended to be applied to, for example, high-speed processing of multimedia data and distributed computing. In this architecture, each core is not large-capacity, but has a dedicated local memory, and can perform calculations independently of other cores. Actually, since the memory capacity of the local memory is insufficient for processing multimedia data or the like, an external global memory is provided. The multi-core processor architecture has excellent extensibility because it increases parallelism and processing capacity by adding cores, rather than relying on clock speedup.

Therefore, it is desired that such a multi-core processor architecture is applied not only to multimedia data processing but also to various applications that require high speed, particularly to sort processing of large-scale tabular data. .
"Cell Broadband EngineArchitecture", Version 1.01, October 3, 2006, [Search on July 26, 2007], Internet (URL: http://cell.scei.co.jp/pdf/CBE_Architecture_v101.pdf) International Publication No. 00/10103 International Publication No. 2005/041066 International Publication No. 2005/041067 International Publication No. 2006/126467

  The present inventor has recognized the importance of the above-described technology that uses the multi-core processor architecture having excellent extensibility in order to sort large-scale tabular data at high speed.

  However, in an application using a large-scale memory such as a database, since all data to be sorted cannot be accommodated in the local memory attached to the core, the complexity of the sorting processing algorithm increases. For example, if data that is too large to be accommodated in the local memory associated with each core is randomly accessed, access to an external global memory frequently occurs and processing performance is significantly reduced. Therefore, a new sort processing algorithm that does not cause such a problem is required.

  Accordingly, in a computer equipped with a multi-core processor, a tabular data record representing an array of records including item values corresponding to one or more data items can be used for work with a small capacity without degrading parallel processing performance. It is preferable that a sorting method can be provided in which a memory is used for sorting according to item values relating to predetermined data items.

  In addition, a record of tabular data that represents an array of records including item values corresponding to one or more data items can be obtained by using predetermined working memory with a small capacity without reducing parallel processing performance. It is preferable to be able to provide a multi-core information processing apparatus that rearranges the items according to item values.

  Furthermore, in a computer having a multi-core type processor, a record of tabular data representing an array of records including item values corresponding to one or more data items can be used for work with a small capacity without degrading parallel processing performance. It is preferable that a program, a computer program product, and a recording medium on which the computer program is recorded can be provided by using a memory and rearranging according to the item values relating to the predetermined data item.

According to one embodiment of the present invention, in a multi-core processing apparatus including a plurality of arithmetic units including a dedicated local memory and a global memory connected to the plurality of arithmetic units, one or more data A sorting method for expressing an array of records including item values corresponding to items, and rearranging the records of tabular data constructed in the global memory according to item values related to a predetermined data item,
The above tabular data is
The block number corresponding to each record in the array of records divided into blocks having a size that can be accommodated in the local memory of each arithmetic unit is stored in the order of the record sequence number of the record in the tabular data. Block number array being
A record sequence number array in which the record sequence numbers of records in charge that are records belonging to each block are stored in the order of the record sequence numbers;
Field value access information array in which field value access information for accessing the field value included in the responsible record is stored in the order of the record sequence number;
Item value information describing the item value accessed using the item value access information for each data item;
Expressed by
The sorting method is related to the predetermined data item.
(i) The plurality of arithmetic units operate in parallel, and for each block including the record in charge, the item value information is used as a key to apply sorting to the item value access information array. Creating a sorted item value access information array, a work item value information array corresponding to the sorted item value access information array, and a work record sequence number array in the global memory;
(ii) The plurality of arithmetic units operate in parallel, and the first element from the work item value information array related to a pair of blocks and the second element from the corresponding work record sequence number array. An element set consisting of elements is merged in a predetermined order using the first element as the upper digit and the second element as the lower digit, and the element set is merged into the merged element set. Associating the included block numbers, thereby creating a new work item value information array, a new work record sequence number array, and a new block number array for the pair of blocks;
(iii) the plurality of arithmetic units operate in a parallel and hierarchical manner, repeatedly performing the step (ii), thereby creating a final block number array in the global memory;
(iv) The plurality of arithmetic units operate in parallel, and the record sequence numbers in which the elements in the final block number array are stored are distributed for each block number designated by the elements. Arranging in order, thereby creating a sorted record sequence number array in the global memory;
A sorting method is provided.

  Two types of tabular data built on the global memory of a computer equipped with a multi-core processor are available so that records can be rearranged using a small-capacity working memory without degrading parallel processing performance. It is described by the data format. The first type of data is a group of arrays that are divided into small pieces so that they can be accommodated in the local memory and are held in the global memory (or disk). Since the first type of data can be transferred from the global memory to the local memory at once, no delay occurs even if random access is performed. The second type of data is guaranteed to be accessed continuously in a predetermined order (eg, ascending or descending order) when accessing a large amount of data, and is held in global memory (or disk). Sequence group. Since the second type of data cannot be accommodated in the local memory as it is, it is transferred by sequential access from the global memory to the local memory in units of a size that can be accommodated in the local memory. Of course, the first type of data may be directly accessed by an element partially stored in the global memory without being sequentially accessed.

  In this document, tabular data means data represented as an array of records including item values corresponding to data items.

  In addition, in this document, the multi-core processing device or processor means a plurality of arithmetic units including a dedicated local memory, a global memory connected to the plurality of arithmetic units, and the plurality of arithmetic units. Means at least one control unit connected to the global memory and the plurality of arithmetic units.

  Further, in this document, “applying sorting (processing) to an array” means “sorting elements of the array”.

  According to the present embodiment, a combination of the above-described concept of component decomposition and the above-described two types of data formats is used to generate (a plurality or a large number of tabular data) constructed on the global memory of the multi-core processing apparatus. ) The record is divided into blocks identified by block numbers. This block corresponds to the arithmetic unit in charge of processing the records included in this block. The record that each arithmetic unit is responsible for is referred to as the charge record in this document. A block number array in which the block numbers are stored in the order of the record sequence numbers is created on the global memory. The block number array has a second type of data. The record sequence number corresponds to a position where each record is accommodated in the tabular data, for example, a row number. Since the sorting process according to the present embodiment rearranges the records of the tabular data, the record sequence number assigned to each record is changed by the sorting process.

  Each arithmetic unit can access the record sequence number array in which the record sequence numbers of the assigned records are stored in the order of the record sequence numbers in order to recognize the assigned records. This record sequence number array has the first type of data, and is transferred from the global memory to the local memory in each arithmetic unit as necessary.

  Furthermore, since each arithmetic unit accesses the item value included in the assigned record, it can access the item value access information array in which the item value access information is stored in the order of the record sequence numbers. This item value access information array has the first type of data, and is transferred from the global memory to the local memory in each arithmetic unit as necessary.

  The item value included in the record in charge of each arithmetic unit is held in the global memory as item value information so that each arithmetic unit can access for each data item using the item value access information array. , And transferred from the global memory to the local memory in each arithmetic unit.

According to one embodiment of the present invention,
Step (i) above is
The plurality of arithmetic units operate in parallel to correspond to the block including the record in charge, the record sequence number array and the item value access information array, and the item value information array relating to the predetermined item Transferring from the global memory to the local memory;
The plurality of arithmetic units operate in parallel, and the sorted item value access information array created in the local memory, the work item value information array, and the work record sequence number array are Transferring to global memory;
Further including
Step (ii) above is
Transferring the work item value information array for the pair of blocks and the work record sequence number array from the global memory to the local memory by operating the plurality of arithmetic units in parallel;
The plurality of arithmetic units operate in parallel, the new work item value information array created in the local memory, the new work record sequence number array, and the new block number array Transferring to the global memory or computing unit for further processing;
Further included.

According to an embodiment of the present invention, the item value information is
For each data item, a global item value array in which unique item values are stored in a predetermined order;
For each data item, a local field value number array in which local field value numbers that specify field values included in the record in charge are stored in the order of the record order numbers;
An item value designation pointer array in which an item value designation pointer for designating a position where the item value represented by the local item value number is stored in the global item value array is stored in a predetermined order for each data item When,
With
The sort applied in step (i) is a distribution counting sort, and the work item value information array is a work item value designation pointer array.

  According to this embodiment, the item value information of tabular data is constructed on a global memory as a global item value array in which unique item values are stored in a predetermined order (ascending or descending order) for each data item. ing. This global item value array has a second type of data. Further, since each arithmetic unit uses the field value access information array to access the field value included in the assigned record, for each data item, a local field value number that identifies the field value included in the assigned record is, for example, a primitive The local item value number array stored in the order of the record position number (that is, the initial record sequence number) and the position where the item value represented by the local item value number is stored in the global item value array An item value specification pointer array in which item value specification pointers to be specified are stored in a predetermined order (ascending or descending order) is constructed on the global memory, and from the global memory to the local memory in each arithmetic unit as necessary. Transferred. The local item value number array and the item value designation pointer array have the first type of data. As described above, the item values of the tabular data are expanded in the form of a global item value array, a local item value number array, and an item value designation pointer array for each data item.

Step (i) above is
The plurality of arithmetic units operate in parallel to correspond to the block including the record in charge, the record sequence number array and the item value access information array, and the local item value number related to the predetermined item Transferring the array and the item value designation pointer array from the global memory to the local memory;
The plurality of arithmetic units operate in parallel, the sorted item value access information array created in the local memory, the work item value designation pointer array, and the work record sequence number array. Transferring to the global memory;
Further including
The above step (ii)
The plurality of arithmetic units operating in parallel, transferring the work item value designation pointer array and the work record sequence number array for a pair of blocks from the global memory to the local memory;
The plurality of operation units operate in parallel, the new work item value designation pointer array created in the local memory, the new work record sequence number array, and the new block number array Transferring to the global memory or computing unit for further processing;
Further included.

According to another embodiment of the present invention, the item value information includes an item value array in which item values included in the charge record are stored for each data item,
The sort applied in step (i) above is a stable sort,
The work item value information array is a work item value array.

  In this embodiment, the item value information of the tabular data stores the item values included in the assigned record for each data item, for example, in the order of the original record position number (that is, the initial record sequence number). It is constructed in global memory as an item value array. In step (i), using the item value as a key, a stable sort is applied to the item value designation pointer array, that is, a sort that does not cause reordering before and after the sort is applied when the key value is the same value.

In addition, the above step (i)
The plurality of arithmetic units operate in parallel to correspond to the block including the record in charge, the record sequence number array and the item value access information array, and the item value related to the predetermined item. Transferring from the global memory to the local memory;
The plurality of arithmetic units operate in parallel, and the sorted item value access information array created in the local memory, the work item value array, and the work record sequence number array are stored in the global memory. Transferring to
Further including
The above step (ii)
Transferring the work item value array and the work record sequence number array for a pair of blocks from the global memory to the local memory, wherein the plurality of arithmetic units operate in parallel;
The plurality of arithmetic units operate in parallel, and the new work item value array, the new work record sequence number array, and the new block number array created in the local memory are Transferring to global memory or a computing unit for further processing;
Further included.

According to an embodiment of the present invention, since the sorting is performed in a multistage manner with respect to two or more data items, the sorting method includes:
(v) using the sorted record sequence number array and the sorted item value access information array as the record sequence number array and the item value access information array, respectively, with respect to another data item, the step (i) , (Ii), (iii) and (iv) are further included.

According to one embodiment of the present invention, a multi-core processing apparatus for performing the method of the present invention is provided. The multi-core processing apparatus according to the present embodiment includes a plurality of arithmetic units including a dedicated local memory, and a global memory connected to the plurality of arithmetic units, and corresponds to one or more data items. An array of records including values is expressed, and the records of the tabular data constructed in the global memory are rearranged in accordance with item values relating to predetermined data items. In this multi-core processing apparatus, the tabular data is
The block number corresponding to each record in the array of records divided into blocks having a size that can be accommodated in the local memory of each arithmetic unit is stored in the order of the record sequence number of the record in the tabular data. Block number array being
A record sequence number array in which the record sequence numbers of records in charge that are records belonging to each block are stored in the order of the record sequence numbers;
Field value access information array in which field value access information for accessing the field value included in the responsible record is stored in the order of the record sequence number;
Item value information describing the item value accessed using the item value access information for each data item;
It is expressed by.

Each arithmetic unit of the multi-core processor is
(a) Operates in parallel with other arithmetic units, and applies sorting to the item value access information array using the item value information relating to the predetermined data item as a key for each block including the assigned record And means for creating the sorted item value access information array, the working item value information array and the working record sequence number array corresponding to the sorted item value access information array in the global memory,
(b) An element composed of a first element of the work item value information array related to a pair of blocks and a corresponding second element of the work record sequence number array, operating in parallel with another arithmetic unit. The above blocks are merged in a predetermined order using the first element as the upper digit and the second element as the lower digit, and the merged element set includes the element set. Means for associating numbers, thereby creating a new work item value information array for the pair of blocks, a new work record sequence number array, and a new block number array;
(c) operating in parallel and hierarchically with other arithmetic units, repeatedly operating the means (b), thereby creating a final block number array in the global memory;
(d) Operates in parallel with other arithmetic units, and distributes the record sequence numbers in which the elements in the final block number array are stored for each block number specified by the elements in a predetermined order. Arranging, thereby creating a sorted record sequence number array in the global memory;
Is provided.

  According to a preferred embodiment of the present invention, each arithmetic unit in the multi-core processing apparatus further includes a dedicated memory interface for data transfer between the dedicated local memory and the global memory. The means (a), via the dedicated memory interface, corresponds to the block including the record in charge, the record sequence number array and the item value access information array, and the item value relating to the predetermined item. An information array is transferred from the global memory to the local memory, the sorted item value access information array created in the local memory, the work item value information array, and the work record sequence number array; Are transferred to the global memory. The means (b) transfers the work item value information array and the work record sequence number array for a pair of blocks from the global memory to the local memory via the dedicated memory interface, and The new work item value information array, the new work record sequence number array, and the new block number array created in the local memory are transferred to the global memory or the arithmetic unit for further processing. The means (c) transfers the final block number array created in the local memory to the global memory via the dedicated memory interface.

Furthermore, according to one embodiment of the present invention, the computer is loaded with a plurality of arithmetic units including a dedicated local memory, and a global memory connected to the plurality of arithmetic units. Expresses an array of records including item values corresponding to data items, and causes the computer to execute code for rearranging the records of tabular data constructed in the global memory according to the item values relating to a predetermined data item A computer-readable program,
In the computer, the tabular data is
The block number corresponding to each record in the array of records divided into blocks having a size that can be accommodated in the local memory of each arithmetic unit is stored in the order of the record sequence number of the record in the tabular data. Block number array being
A record sequence number array in which the record sequence numbers of records in charge that are records belonging to each block are stored in the order of the record sequence numbers;
Field value access information array in which field value access information for accessing the field value included in the responsible record is stored in the order of the record sequence number;
Item value information describing the item value accessed using the item value access information for each data item;
Expressed by
(a) Each arithmetic unit operates in parallel with other arithmetic units, and for each block including the record in charge, the item value access information array using the item value information relating to the predetermined data item as a key Sort is applied to the sorted item value access information array, and a work item value information array and a work record sequence number array corresponding to the sorted item value access information array are created in the global memory. Code to
(b) Each arithmetic unit operates in parallel with other arithmetic units, and the first element from the work item value information array relating to a pair of blocks and the corresponding first number from the work record sequence number array. The element set of two elements is merged in a predetermined order using the first element as the upper digit and the second element as the lower digit, and the merged element set A code for creating a new work item value information array, a new work record sequence number array, and a new block number array related to the pair of blocks, by associating the block numbers included in the set;
(c) Each arithmetic unit operates in parallel and hierarchically with other arithmetic units and repeatedly executes the code (b), thereby generating a final block number array in the global memory; ,
(d) Each arithmetic unit operates in parallel with other arithmetic units and distributes the record sequence numbers in which the elements in the final block number array are stored for each block number specified by the element. A code for arranging in a predetermined order, thereby creating a sorted record sequence number array in the global memory,
Is provided.

  Furthermore, according to one embodiment of the present invention, the computer is loaded with a plurality of arithmetic units including a dedicated local memory, and a global memory connected to the plurality of arithmetic units. The computer according to the present invention expresses an array of records including item values corresponding to data items, and rearranges the records of the tabular data constructed in the global memory according to the item values relating to a predetermined data item. There is provided a computer program product for causing a program to execute.

  Furthermore, according to one embodiment of the present invention, the computer is loaded with a plurality of arithmetic units including a dedicated local memory, and a global memory connected to the plurality of arithmetic units. The computer according to the present invention expresses an array of records including item values corresponding to data items, and rearranges the records of the tabular data constructed in the global memory according to the item values relating to a predetermined data item. A recording medium on which a computer program to be executed is recorded is provided.

  According to at least one embodiment of the present invention, the sort processing by the multi-core processing device can be applied to the tabular data record, so that the large-scale tabular data sort processing and various applications including the sort processing can be performed at high speed. Can be realized.

It is the schematic of the multi-core type processing apparatus by one Embodiment of this invention. 1 is a schematic diagram of a computer system according to an embodiment of the present invention. It is a figure showing an example of the tabular data for demonstrating the data management mechanism used as the foundation of this invention. It is explanatory drawing of the basic data management mechanism used as the foundation of this invention. It is explanatory drawing of the data structure for multi-core type processing apparatuses by one Embodiment of this invention. It is explanatory drawing of the data structure for multi-core type processing apparatuses by one Embodiment of this invention. It is explanatory drawing of the data structure for multi-core type processing apparatuses by one Embodiment of this invention. It is explanatory drawing of the data structure for multi-core type processing apparatuses by one Embodiment of this invention. It is explanatory drawing of the tabular data before applying the sort process by one Embodiment of this invention. It is explanatory drawing of the tabular data after applying the sort process by one Embodiment of this invention. It is explanatory drawing of the tabular data obtained by applying the sort process by one Embodiment of this invention to the tabular data of FIG. 5A. It is explanatory drawing of the tabular data obtained by applying the sort process by one Embodiment of this invention to the tabular data of FIG. 5A. It is explanatory drawing of the tabular data obtained by applying the sort process by one Embodiment of this invention to the tabular data of FIG. 5A. It is explanatory drawing of the tabular data obtained by applying the sort process by one Embodiment of this invention to the tabular data of FIG. 5A. It is a flowchart of the item value acquisition process by one Embodiment of this invention. It is a schematic flowchart of the sort processing of tabular data (first type item value information) according to an embodiment of the present invention. It is explanatory drawing of the sort process in a block in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the sort process in a block in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the sort process in a block in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the result of the sort process in a block in the sort process of the tabular data by one Embodiment of this invention. It is a figure explaining the hierarchical structure of the sort processing 1 between blocks in the sort processing of the tabular data by one Embodiment of this invention. It is a figure explaining the hierarchical structure of the sort processing 1 between blocks in the sort processing of the tabular data by one Embodiment of this invention. It is a figure explaining the hierarchical structure of the sort processing 1 between blocks in the sort processing of the tabular data by one Embodiment of this invention. It is explanatory drawing of the 1st stage merge process in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the 1st stage merge process in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the 1st stage merge process in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the 2nd merge process in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the 2nd merge process in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the merge process of the 3rd step | paragraph in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the tabular data showing the result of the block-to-block sort process 1 (merge process) in the tabular data sort process by one Embodiment of this invention. It is explanatory drawing of the tabular data showing the result of the block-to-block sort process 1 (merge process) in the tabular data sort process by one Embodiment of this invention. It is explanatory drawing of the tabular data showing the result of the block-to-block sort process 1 (merge process) in the tabular data sort process by one Embodiment of this invention. It is explanatory drawing of the inter-block sort process 2 (distribution process) in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the inter-block sort process 2 (distribution process) in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the inter-block sort process 2 (distribution process) in the sort process of the tabular data by one Embodiment of this invention. It is a figure explaining the result of the sort processing of the tabular data by one Embodiment of this invention. It is a flowchart of the sort processing of tabular data by one Embodiment of this invention. It is explanatory drawing of the separation process of the block number arrangement | sequence by alternative embodiment of this invention. It is explanatory drawing of the example of application of the multistage sort process by one Embodiment of this invention. It is explanatory drawing of the example of application of the multistage sort process by one Embodiment of this invention. It is explanatory drawing of the data structure of the tabular data by one Embodiment of this invention. It is explanatory drawing of the data structure of the tabular data by one Embodiment of this invention. It is explanatory drawing of the data structure of the tabular data by one Embodiment of this invention. It is explanatory drawing of the data structure of the tabular data by one Embodiment of this invention. It is a schematic flowchart of the sort processing of the tabular data (2nd type item value information) by one Embodiment of this invention. It is explanatory drawing of the sort process in a block in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the sort process in a block in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the sort process in a block in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the sort process in a block in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the sort process in a block in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the sort process in a block in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the sort process in a block in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the sort process in a block in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the result of the sort process in a block in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the 1st stage merge process in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the 1st stage merge process in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the 1st stage merge process in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the 2nd merge process in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the 2nd merge process in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the merge process of the 3rd step | paragraph in the sort process of the tabular data by one Embodiment of this invention. It is explanatory drawing of the tabular data showing the result of the block-to-block sort process 1 (merge process) in the tabular data sort process by one Embodiment of this invention. It is explanatory drawing of the tabular data showing the result of the block-to-block sort process 1 (merge process) in the tabular data sort process by one Embodiment of this invention. It is explanatory drawing of the tabular data showing the result of the block-to-block sort process 1 (merge process) in the tabular data sort process by one Embodiment of this invention.

Explanation of symbols

DESCRIPTION OF SYMBOLS 100 Multi-core type processing apparatus 101 Multi-core type processor chip 110,120,130,140 Arithmetic unit 111,121,131,141 Core 112,122,132,142 Local memory 150 In-chip bus 160,161,162,163 Bus 170, 171, 172, 173 Global memory 200 Computer system 202 Multi-core processor 210 CPU
212 RAM
214 ROM
216 Fixed storage device 218 CD-ROM
220 CD-ROM driver 222 I / F
224 Input device 226 Display device 228 Bus 500 Tabular data 501 Data item “School”
502 Data item “Age”
510 records 0
511 Record 14
520, 521, ..., 527 Block 530 Order information 531 Item information "School"
532 Item information "Age"
540 Block number array 551-0, 551-1, ..., 551-7 Record sequence number array 552-0, 552-1, ..., 552-7 Item value access information array 560-0, 560-1 , ..., 560-7 Block information "School"
561-0, 561-1, ..., 561-7 Local item value number array "School"
562-0, 562-1, ..., 562-7 Item value designation pointer array "School"
570 Global Item Value Array “School”
580-0, 580-1,..., 580-7 Block information “Age”
581-0, 581-1,..., 581-7 Local item value number array “Age”
582-0, 582-1, ..., 582-7 Item value designation pointer array "Age"
590 Global Item Value Array “Age”

  Hereinafter, various embodiments for carrying out the present invention will be described in detail with reference to the drawings.

[Multi-core processing equipment]
First, a multi-core type processing apparatus that implements data processing according to an embodiment of the present invention will be described. FIG. 1 is a schematic view of an embodiment of a multi-core processing apparatus. The multi-core processing apparatus 100 is provided with a plurality of (for example, two, four, eight, etc., four in this example) arithmetic units 110, 120, 130, 140 on a multi-core processor chip 101. . Each arithmetic unit 110, 120, 130, 140 includes a core 111, 121, 131, 141 for data processing and a local memory 112, 122, 132, 142 dedicated to the core. Each arithmetic unit 110, 120, 130, 140 is connected by a bus 150 in the chip. This bus 150 is preferably a ring bus. Since the arithmetic units are connected by a bus 150 in the chip, data communication can be performed at high speed. Furthermore, each arithmetic unit 110, 120, 130, 140 is connected to global memory 170, 171, 172, 173 externally attached to the chip 101 via buses 160, 161, 162, 163 that support DMA transfer. ing.

  The storage capacity of the local memories 112, 122, 132, 142 in the chip is about 256 KB (kilobytes), for example, while the global memories 170, 171, 172, 173 are large-capacity memories of several tens GB (gigabytes). is there. In the figure, the global memories 170, 171, 172, and 173 are distinguished from each other. This is because when each core accesses the global memory with a single bus, the communication performance of the bus becomes a bottleneck. Therefore, a dedicated memory interface (not shown) is provided for each core. It shows access through this memory interface. Of course, even with such a configuration, it is possible to manage the global memory so that it appears as one logically continuous memory as a whole, as in the NUMA (non-uniform memory access) system. In an alternative embodiment, each computing unit is connected to a physically integrated external global memory via one bus.

Furthermore, in a processor such as the above-mentioned Cell Broadband Engine ^™ , a general-purpose processor core and an arithmetic processor core are mounted in one chip. The general-purpose processor core can control operations of a plurality of arithmetic processor cores. Therefore, the multi-core type processor preferably includes a control unit such as a general-purpose processor core, but the control unit does not need to be mounted in the chip and may be provided outside the chip.

  The control unit and the arithmetic unit, or the arithmetic units can communicate with each other using, for example, a mailbox or a signal mechanism.

[Computer system configuration]
FIG. 2 is a schematic diagram of a computer system 200 for manipulating tabular data according to one embodiment of the present invention. The computer system 200 performs multi-core processing as shown in FIG. 1 in which tabular data represented as an array of records including item values corresponding to data items is shared and operated by a plurality of arithmetic units. A device 202 is provided. As shown in FIG. 2, the computer system 200 further stores a CPU 210 that controls the entire system and individual components by executing a program, work data, and the like, for example, a RAM (Random Access Memory). ), A ROM (Read Only Memory) 214 that stores programs, a fixed storage medium 216 such as a hard disk, a CD-ROM driver 220 for accessing the CD-ROM 218, and a CD-ROM driver 220 and an interface (I / F) 222 connected to an external terminal connected to an external network or the like (not shown), an input device 224 such as a keyboard and a mouse, and a display device 226 such as a computer monitor. And. The multi-core processing device 210, the RAM 212, the ROM 214, the external storage medium 216, the I / F 222, the input device 224, and the display device 226 are connected to each other via a bus 228.

  A program for causing the multi-core processing device 202 and the CPU 210 of the computer system 200 to operate the tabular data is stored in the CD-ROM 218 and may be read by the CD-ROM driver 220 or stored in the ROM 214 in advance. Also good. Further, what is once read from the CD-ROM 218 may be stored in a predetermined area of the external storage medium 216. Alternatively, the program may be supplied from the outside via a network (not shown), an external terminal, and the I / F 220.

  The multi-core processor system according to an embodiment of the present invention is realized by causing the computer system 200 to execute a program for manipulating tabular data.

  In the computer system 200 shown in FIG. 2, a CPU 210 is provided in addition to the multi-core processing device 202, and controls the entire system and individual components. However, the present invention is not limited to such an embodiment, and in an alternative embodiment, a control unit included in the multi-core processing apparatus 202 controls the entire system and individual components.

[Data management mechanism based on information blocks]
FIG. 3 is a diagram showing an example of tabular data for explaining the data management mechanism which is the basis of the present invention. This tabular data is stored as a data structure as shown in FIG. 4 in the computer by using the data management mechanism proposed in the above-mentioned International Publication No. WO00 / 10103. This data structure has been proposed to realize retrieval, sorting, aggregation, etc. of large-scale tabular data using hardware resources of commercially available computers, for example, personal computers, in particular, processors and memories. It should be noted that the data structure of tabular data placed on the computer memory.

  In this document, “information indicating the position where a record is stored in the original tabular data (ie, the original record position number)” and “information indicating the order of the record (ie, record order number)” And are distinguished. The source record position number is virtual information used for specifying individual records including item values corresponding to data items. For example, when normal tabular data is converted into tabular data based on an information block, the position where a record is accommodated in the original normal tabular data is represented by a source record position number. In general, in tabular data based on information blocks, records are not always arranged in the order of the original record position numbers. For example, when the tabular data is sorted in ascending order with respect to the item value of a certain item, the sort order of the tabular data records after sorting is different from the sort order of the original tabular data records. However, records in tabular data based on information blocks immediately after conversion from normal tabular data may be arranged in the order of the source record position number. In this case, the source record position The number and the record sequence number initially match.

  As shown in FIG. 4, the order number (record order number) of each record of the tabular data and the original record position number are abbreviated as a record order designation array 401 (hereinafter, this array is abbreviated as “OrdSet”). .). The record order specification array 401 stores the original record position numbers in the order of the record order numbers. In the example of FIG. 4, the records are arranged in the order of the original record position numbers.

  Here, the notation of the arrangement | sequence in this specification is demonstrated. In general, an array element A can be expressed as A [i], where i is a subscript. However, in the drawing, an array element A [i] is within a region surrounded by a solid line. The boundary between the element A [i] and the element A [i + 1] is indicated by a dotted line. The subscript i of element A [i] is shown on the left side of element A [i]. Further, the subscript i of the array is represented by an integer starting from 0.

  Returning to FIG. 4 again, regarding the gender, it can be seen that the original record position number corresponding to the record order number = 0 of the tabular data is “0” from the array OrdSet [0]. The actual gender value for the record whose source record position number is “0”, ie, “male” or “female” is a value list in which the actual values are sorted according to a predetermined order (eg, ascending or descending order). Item value number array 402 (hereinafter, item value number array, that is, pointer array) that is a pointer array to a certain item value array 403 (hereinafter, item value array, that is, a value list is abbreviated as “VL”). Is abbreviated as “VNo.”). The pointer array 402 stores pointers that point to elements in the actual value list 403 according to the order of the source record position numbers stored in the array OrdSet 401. As a result, the item value of the gender corresponding to the record “0” in the tabular data is (1) the original record position number = 0 corresponding to the record sequence number = 0 is extracted from the array OrdSet 401, and (2) is stored in the value list. The element “1” corresponding to the original record position number = 0 is extracted from the pointer array 402, and (3) the element “female” indicated by the element “1” extracted from the value array 403 from the pointer array 302 to the value list is extracted. Can be obtained by taking out "".

  The item values can be acquired in the same manner for other records and also for age and height.

  In this way, the tabular data is expressed by a combination of the value list VL and the pointer array VNo to the value list, and this combination is particularly referred to as an “information block”. In FIG. 4, information blocks regarding gender, age, and height are shown as information blocks 408, 409, and 410, respectively.

  If a single computer has a single memory (physically multiple, but a single memory in the sense that it is located and accessed in a single address space) May store the ordered set array OrdSet, the value list VL constituting each information block, and the pointer array VNo in the memory. However, in various embodiments of the present invention, the manipulation of tabular data is performed by a multi-core processing device configured by a plurality of arithmetic units with a small capacity dedicated local memory. Therefore, a new mechanism for holding tabular data has been proposed in order to achieve efficient parallel processing.

[Data structure for multi-core processors]
Next, a data structure for a multi-core processing apparatus according to an embodiment of the present invention will be described. 5A to 5B are explanatory diagrams of a data structure according to an embodiment of the present invention. FIG. 5A shows an example of tabular data. The tabular data 500 shown in FIG. 5A5A includes item values corresponding to the data item 501 “School” (for example, “West”, “South”, “North”, “East”, and data items “Age”). It is represented as an array of records including item values (for example, “12”, “8”, “11”, “10”, etc.) corresponding to 502. The records of this tabular data 500 are in order from the top. , Record sequence number = 0, 1, 2, ..., 31. Record 510 at the head of the array is a record to which record sequence number 0 is assigned. The item value of “School” is “West”, and the item value of the data item “Age” is “12.” The data item “School” of the record 511 is displayed. The item value of “” is “North”, and the item value of the data item “Age” is “9.” Here, when the records of this tabular data are rearranged by the sort processing, they are given to each record. Note that the record sequence number changes.

  In the data structure for a multi-core processing device according to an embodiment of the present invention, this tabular data record includes blocks 520, 521, identified by a block number (in this example, eight block numbers from 0 to 7). ... divided into 527. Initially, this block corresponds to an arithmetic unit of a multi-core type processing apparatus that is responsible for processing the records included in this block.

  The data structure for a multi-core type processing apparatus relates to information (order information) relating to the order in which records are arranged (that is, record order numbers) and storage locations of item values in the data structure, and item values for each data item. Information (item value information). The order information functionally corresponds to the record order designation array OrdSet in the data management mechanism that is the basis of the present invention, and the item value information similarly corresponds to the information block. Both the order information and the item value information are held in the global memory, and a part of them is transferred to the local memory of each arithmetic unit as necessary. FIG. 5B shows the order information 530, and FIGS. 5C and 5B5C5D show the item value information 531 and 532 of the data item “School” and the data item “Age”, respectively.

  The order information 530 includes a block number array 540 in which the block numbers are stored in the order of the record order numbers. In the data structure of this embodiment, an arithmetic unit responsible for the operation of the record is determined for each record. Therefore, the record (s) is divided into records that each arithmetic unit is in charge of, that is, the records in charge, and a block number is assigned to each record in charge. If the block number array is BlkNo and the record order number is i, BlkNo [i] indicates that the block number of the block to which the record having the record order number i belongs is BlkNo [i]. The block number array 540 is an integer type array having a size equal to the number of records. The block number array 540 is the second type of data. For example, in the example of FIG. 5, records with record sequence numbers 0 to 3 are included in the block with block number 0, records with record sequence numbers 4 to 7 are included in the block with block number 1, and so on.

  According to the data structure of the present embodiment, all records are divided into assigned records corresponding to the blocks. Therefore, information for associating each assigned record with the original tabular data record is required for each block. Therefore, the order information 530 includes a record order number array 551-1, 551-2, ..., 551-7 in which the record order numbers of the records in charge are stored in the order of the record order numbers for each block. The record order number array may be referred to as GOrd below. For example, in the example of FIG. 5, the record sequence numbers of the assigned records belonging to the block of block number 0 are 0, 1, 2, and 3, and the record sequence numbers of the assigned records belonging to the block of block number 1 are 4, 5, 6, 7 and so on. The record sequence number array has the same size as the number of records in charge belonging to each block, and is an integer type array. The record sequence number array is divided into sizes that can be accommodated in the local memory of each arithmetic unit, and is therefore the first type of data. Therefore, the record sequence number array is transferred from the global memory to the local memory in each arithmetic unit as necessary.

Here, it should be noted that the block number array 540 and the record sequence number arrays 551-1, 551-2, ..., 551-7 can be converted to each other. For example, the block number of the block to which the record having the record sequence number i belongs is expressed by BlkNo [i], and the element corresponding to the subscript k of the record sequence number array belonging to the block having the block number = j is GOrd [j] [ k]. At this time, assuming that the total number of records is Rmax, the conversion from the block number array to the record sequence number array is as follows.
For (i = 0; i ++; i <Rmax) {
GOrd [BlkNo [i]] [j [BlkNo [i]]] = i;
j [BlkNo [i]] ++;
}
Is expressed as Here, j [BlkNo [i]] represents a subscript that designates an element of the record sequence number array GOrd [BlkNo [i]] belonging to the block whose block number is BlkNo [i]. Note that all elements of the variable j [BlkNo [i]] are initialized to 0.

Conversely, the conversion from the record sequence number array to the block number array is described as follows, where the block number is represented by i, the total number of blocks is represented by Bmax, and the total number of records in each block is represented by BRmax. That is,
For (i = 0; i ++; i <Bmax) {
For (j = 0; j ++; j <BRmax) {
BlkNo [GOrd [i]] [j] = i;
}
}
It becomes.

  Thus, since the block number array and the record order number array can be converted into each other, it is sufficient if either one is prepared.

  In addition, since the item value included in each record is held in the form of item value information described later, each arithmetic unit can access address information included in the record in charge, that is, item value access. It is necessary to obtain information. Therefore, according to the data structure of the present embodiment, the order information 530 includes the item value access information arrays 552-1 and 552 in which the item value access information of the assigned record is stored in the order of the record order number for each block. 2, ..., 552-7. This item value access information array is an integer type array, and the size of the item value access information array matches the number of records in charge. The item value access information array is also a first type of data, and is transferred from the global memory to the local memory in each arithmetic unit as necessary. The item value access information array may be called by the name LOrd. For example, in the example of FIG. 5, the item value included in the record with the record sequence number 0 included in the block with the block number 0 can be accessed with the item value access information of 0 with respect to the block number 0. The item value included in the record having the record sequence number 5 included in the block 1 can be accessed by the item value access information 1 regarding the block number 1.

  Next, according to the present embodiment, the item value information is held as item value information for each data item. For example, in the example of FIG. 5, item value information 531 related to the data item “School” and item value information 532 related to the data item “Age” are constructed in the global memory. The item values included in the record in charge for each block are held in the global memory so that each arithmetic unit can access each data item using the item value access information array. To the local memory in each arithmetic unit. The item value itself is constructed on the global memory as a global item value array in which unique item values are stored in a predetermined order (ascending order or descending order) for each data item. For example, in the example of FIG. 5, the item value relating to the data item “School” is held in the global memory as the global item value array 570, and the item value relating to the data item “Age” is held in the global memory as the global item value array 590. Has been. This global item value array is the second type of data. The global item value array is an array for storing the item value itself, and thus has various data types such as an integer type, a floating point type, and a character string type.

  The item value information is configured so that the item value stored in the global item value array can be specified using the item value access information related to the record in charge. Therefore, the item value information includes, for each data item, a local item value number array in which local item value numbers that specify item values included in the assigned record are stored in the order of record sequence numbers (for example, ascending order or descending order). Including an item value specification pointer array in which an item value specification pointer for specifying a position where the item value represented by the local item value number is stored in the global item value array is stored in the order of the local item value number . A local item value number array and an item value designation pointer array are provided for each block. The local item value number array is an integer type array having a size that matches the number of records in charge, is the first type of data, and is sometimes referred to as VNo. The item value designation pointer array is an integer type array having the same size as the number of unique item values included in the record in charge, is a first type of data, and is sometimes called LVL. Since both the local item value number array and the item value designation pointer array are data of the first type, they are constructed on the global memory for each block, and from the global memory to the local memory in each arithmetic unit as necessary. Transferred.

  In the example of FIG. 5, regarding the data item “School”, the item value information 531 includes local item value number arrays 561-0, 561-1,... 561-7, an item value designation pointer array 562-0, 562-1,... 562-7 and a global item value array 590. The local item value number array and the item value designation pointer array are divided for each block. In the figure, for example, the value of the first element of the local item value number array VNo is “1”. This means that the item value number of the item value included in the record specified by the item value access information whose value is “0” is “1”. The item value whose item value number is “1” refers to the second element of the item value designation pointer array LVL, that is, the third element of the global item value array GVL, ie, LVL [1]. It turns out that it is GVL [2]. The same applies to other blocks and other data items.

  As described above, according to the data structure of the present embodiment, the item value included in the record belonging to each block includes the local item value number assigned to each item value in the block, the local item value number, and the global item. This is expressed by an item value designation pointer that associates an item value in the value array with a global item value array.

[Overview of sort processing of tabular data]
Next, sorting processing of tabular data by the multi-core processing apparatus according to an embodiment of the present invention will be described. FIG. 6 is an explanatory diagram of a tabular data sort process according to an embodiment of the present invention. FIG. 6A shows tabular data before sort processing, FIG. 6B shows tabular data after sort processing, and the tabular data before sort processing is the same as the tabular data shown in FIG. 5A. is there. In the example of the figure, in the tabular data, records are rearranged in the ascending order (more specifically, alphabetical order) of the item value of the data item using the data item “School” as a key. In the record (West, 12) corresponding to the record order number = 0 before sorting, the record order number is changed to 24 by the sorting process. In addition, the record (West, 11) corresponding to the record order number = 2 before sorting has the record order number changed to 25 after the sorting process. A sort process in which the order of two records having the same key value (that is, West) does not change before and after the sort process is called a “stable” sort process. Here, the notation of record (A, B) represents a record in which the item value of the data item “School” is A and the item value of the data item “Age” is B.

  The tabular data before sort processing shown in FIG. 6A is expressed by the data structures shown in FIGS. 5A to 5D when the data structure for multi-core processing devices is used. 7A to 7D are explanatory diagrams of tabular data obtained by applying the sort processing according to the embodiment of the present invention to the tabular data shown in FIGS. 5A to 5D. The result of the sorting process will be described with reference to FIGS. 7A to 7D. For example, the record (East, 6) corresponding to the record sequence number = 0 of the tabular data in FIG. 7A belongs to the block of block number = 2 from BlkNo [0] = 2 in the block number array of FIG. 7B. I understand that. Next, referring to the record sequence number array GOrd included in the block of block number = 2, it can be seen that the element of the record sequence number array GOrd that matches the record sequence number = 0 is GOrd [0]. The storage position of the element GOrd [0] in the record sequence number array GOrd in which this record sequence number = 0 is stored, that is, 0 is the rank (rank) of the target record in the record in charge of the arithmetic unit responsible for this block. ). In this embodiment, the record order number array is an ascending order array, so that this storage position can be found efficiently by a well-known two-division method or the like.

  Next, the item value access information array LOrd is referred to in order to acquire item value information included in the record with rank = 0 in the block of block number = 2. More specifically, LOrd [0] = 0 indicates that block No. 2 represents an item value designation pointer for accessing item value information included in a record to which rank = 0 in block 2 is assigned.

The item value information related to the data item “School” is shown in FIG. 7C. Block No. The item value included in the record with rank = 0 in the block of 2 is
GVL [LVL [VNo [LOrd [0]] = “East”
Obtained by. This item value is obtained according to the following procedure. First, in the local item value number array VNo regarding the block 2, the element specified by the item value access information = LOrd [0] = 0 VNo [LOrd [0]] = VNo [0] = 0
To get. Next, in the item value designation pointer array LVL, the element designated by VNo [0] = 0 LVL [VNo [0]] = LVL [0] = 0
To get. Finally, using the obtained item value designation pointer, the item value GVL [LVL [0]] = GVL [0] = “East” from the global item value array GVL
To get. This indicates that the item value relating to the data item “School” included in the record corresponding to the record sequence number = 0 of the tabular data in FIG. 7A is “East”. Similarly, it is also clear that the item value for the data item “Age” is “6”.

  As described above, in the sorting process according to the embodiment of the present invention, only the order information (that is, the block number array, the record order number array, and the item value access information array) changes before and after the sorting process. Information does not change before and after the sorting process.

  In the description of the present embodiment, the item value information is configured by the local item value number array VNo, the item value designation pointer array LVL, and the global item value array GVL, but the item value information is not processed. It is also possible to configure by an item value array including values. Therefore, in the following description, the former is referred to as first type item value information, and the latter is referred to as second type item value information.

[Overview of field value acquisition processing]
In the multi-core processing apparatus according to the embodiment of the present invention, the process for acquiring the item value uses the cooperation of the control unit and the arithmetic unit and the data transfer between the global memory and the local memory. Done. FIG. 8 is a flowchart of an item value acquisition method according to an embodiment of the present invention. As shown in FIG. 8, first, the control unit refers to the block number array in the global memory, and the block number of the block including the predetermined record from which the item value is to be acquired. Is determined (step 802). Next, the control unit notifies the record unit number of a predetermined record to the arithmetic unit identified by the determined block number (step 804). Thereafter, the arithmetic unit transfers the record sequence number array and the item value access information array relating to the record in charge of this arithmetic unit from the global memory to the local memory of this arithmetic unit (step 806). Subsequently, the arithmetic unit specifies the position where the notified record sequence number is stored in the record sequence number array transferred to the local memory (step 808). Thereafter, the arithmetic unit specifies item value access information specified by the specified position in the item value access information array transferred to the local memory (step 810). Finally, for each data item, the arithmetic unit acquires the item value specified by the item value access information specified from the global item value array held in the global memory, and stores the acquired item value in the global memory. (Step 812).

[Sort processing of tabular data (first type item value information)]
Sorting processing of tabular data including item value information of the first type includes the following three steps. FIG. 9 is a schematic flowchart of the sort processing of the tabular data including the first type item value information.

Step 901: Sorting within a block Each arithmetic unit operates in parallel, and within each block, sorting is performed by applying a distribution counting sort to the item value access information array LOrd using the local item value number array VNo as a key. An item value designation pointer array LVL ′ and a record sequence number array GOrd ′ are generated so as to conform to the item value access information array LOrd.

Step 902: Inter-block sort 1 (merge)
Each arithmetic unit operates in parallel and hierarchically to generate a block number array BlkNo from the item value designation pointer array LVL ′ and the record order number array GOrd ′. Here, the item value designation pointer array LVL ′, the record order number array GOrd ′, and the block number array BlkNo ′ from the respective blocks are merged in a predetermined order between the blocks.

Step 903: Sorting between blocks 2 (distribution)
Each arithmetic unit operates in parallel to generate a record order number array GOrd from the block number array BlkNo.

  As described above, the sort processing of the tabular data is realized by three steps of sort within block, sort 1 between blocks (merge), and sort 2 between blocks (distribution). Here, the inter-block sort 1 (merge) is a sort process in the sense that data from a pair of blocks is rearranged in a predetermined order, and the data from the pair of blocks is integrated into a set of data. It is also a merge process in meaning. In this document, “merge in a predetermined order” refers to processing in block-to-block sort 1 (merge).

  In the following, with reference to the examples shown in FIGS. 5A to 5D, FIGS. 6A and 6B, and FIGS. 7A to 7D, the tabular data sorting process according to the embodiment of the present invention (first type item value information) ) Will be described in more detail.

  10A to 10C are explanatory diagrams of the intra-block sorting process in the tabular data sorting process according to the embodiment of the present invention. In the figure, as an example, processing related to the block of block number = 1 (ie, block 1) is described, but it will be apparent to those skilled in the art that processing related to other blocks is performed in the same manner. The processing related to each block is executed by each arithmetic unit to which the block is assigned. In the following description, an array operation may be expressed by a pseudo instruction similar to the C language.

FIG. 10A is an explanatory diagram of the count-up process in the distribution counting sort process. FIG. 10A shows a record order number array GOrd, an item value access information array LOrd, a local item value number array VNo, an item value designation pointer array LVL, and a local item value number used as a distribution counting sort key. The transition of the count array Count that counts the number of occurrences of is shown. The count-up process is
for (i = 0; i <number of records in block; i ++) {
Count [VNo [LOrd [i]]] ++;
}
Can be described as In the example of FIG. 10A, the first stage corresponds to i = 0, the second stage corresponds to i = 1, the third stage corresponds to i = 2, and the fourth stage corresponds to i = 3.

FIG. 10B is an explanatory diagram of the cumulative number process in the distribution counting sort process. The count array Count obtained as a result of the count-up process is
Count [0] = 1
Count [1] = 2
Count [2] = 1
It is. When this number of appearances is converted into a cumulative frequency distribution (that is, converted into a cumulative number), a cumulative frequency distribution array Aggr is obtained. Note that the head element of the cumulative frequency distribution array Aggr generated by the cumulative number processing is 0, and the actual cumulative frequency is stored after Aggr [1]. For example, the cumulative number processing
Aggr [0] = 0;
for (i = 1; i <number of key values; i ++) {
Aggr [i] = Aggr [i-1] + Count [i-1];
}
Can be described as

Finally, the item value access information array LOrd ′ is obtained by copying the elements of the item value access information array LOrd using the elements of the cumulative frequency distribution array Aggr thus generated as pointers. . FIG. 10C is an explanatory diagram of the transfer process in the distribution counting sort process. In the transfer process, not only the elements of the array LOrd are copied to the array LOrd ′, but also the item value designation pointer array LVL ′ and the record sequence number array GOrd ′ corresponding to the newly generated array LOrd ′ are generated. For example, a process of copying LOrd [0] is shown at the top of FIG. 10C. LOrd [0] = 0 is copied to element LOrd ′ [1] of LOrd ′. This is because the local item value number VNo [0] of the item value included in the record that is LOrd [0] is 1, so that the element Aggr [1] = 1 in the cumulative frequency distribution array Aggr is used as a pointer. This is realized by copying LOrd [0] = 0 to the element LOrd ′ [1] of the item value access information array LOrd ′. This transfer process is typically performed, for example,
for (i = 0; i <number of records in block; i ++) {
LOrd ′ [Aggr [VNo [LOrd [i]]]] = LOrd [i];
LVL ′ [Aggr [VNo [LOrd [i]]]] = LVL [VNo [LOrd [i]]];
GOrd ′ [Aggr [VNo [LOrd [i]]]] = GOrd [i];
Aggr [VNo [LOrd [i]]] ++;
}
Can be described as

  The item value access information array LOrd 'obtained in this way matches the final item value access information array LOrd in the sorted block. Also, the newly generated item value designation pointer array LVL 'and record sequence number array GOrd' correspond to records sorted using item values as keys in the block.

  According to one embodiment of the present invention, the tabular data records sorted within the block by each arithmetic unit are then merged between the blocks. In merging between blocks, data sorted in each block is merged, and merged data sorted as a whole is generated. More specifically, a set of elements of the item value designation pointer array LVL 'and elements of the record sequence number array GOrd' is sorted. Since the element of the record sequence number array GOrd 'has a value uniquely determined for each record, the set of the element of the item value designation pointer array LVL' and the element of the record sequence number array GOrd 'is unique. The element of the item value designation pointer array LVL ′ relating to a certain data item indicates the element of the global item value array in which the item values relating to the data item are arranged in a predetermined order. Sorting in the order of the values is equivalent to sorting in the order of the item values. In addition, in the item value designation pointer array LVL ′ and the record sequence number array GOrd ′ obtained as a result of the intra-block sort process, a block number array BlkNo ′ representing the block number to which the record in each block belongs is used for the subsequent processing. Because it is added.

  FIG. 11 is an explanatory diagram of the result of the intra-block sorting process in the tabular data sorting process according to the embodiment of the present invention obtained as described above. At this time, the item value access information array LOrd in each block is consistent with the final result, and thus is indicated without a prime symbol (') like LOrd. On the other hand, the item value designation pointer array LVL 'and the record sequence number array GOrd' are not final results but represent working arrays in the middle of processing, and therefore are indicated with a prime symbol ('). Further, the block number array BlkNo and the record sequence number array GOrd, which are the final results, have not yet been determined at this point, and are left blank.

  12A to 12C are diagrams illustrating the hierarchical structure of the inter-block sort process 1 (merge process) in the tabular data sort process according to an embodiment of the present invention. In the example of the figure, for example, at least seven arithmetic units SPU-0, SPU-1,..., SPU-6 are executing 128 blocks of sort processing from Block0 to Block127.

  The first process of FIG. 12A includes a sort process from block Block-0 to block Block-7, a sort process from block Block-8 to Block Block-15, and so on. The sort process of 16 sorts up to -127, that is, the sort process between 8 blocks is sequentially executed 16 times. For example, in the first stage, SPU-0 applies a merging process in a predetermined order to block Block-0 and block Block-1, and outputs blocks 0 to 1, and SPU-1 outputs block Block-2 and block Block. Apply merge processing in a predetermined order to -3 to output blocks 2 to 3. Here, the notation of the blocks A to B such as the blocks 0 to 1 is the data regarding the block obtained as a result of applying the merge processing in a predetermined order from the block A to the block B (more specifically, for the work An item value designation pointer array, a work record sequence number array, and a work block number array). Next, in the second stage, SPU-4 is assigned to blocks 0 to 1 that have been merged in a predetermined order by SPU-0 and blocks 2 to 3 that have been merged in a predetermined order by SPU-1 The order merge process is applied and blocks 0 to 3 are output. Similarly, SPU-4 outputs blocks 4-7. The SPU-6 at the third stage applies merge processing in a predetermined order to the blocks 0 to 3 output by the SPU-4 and the blocks 4 to 7 output by the SPU-5, thereby performing the blocks 0 to 7 Is output. By repeating the third-stage merge process repeatedly, 16 blocks of blocks 0 to 7, blocks 8 to 15,..., And blocks 120 to 127 are output. In the figure, white arrows indicate input / output between the global memory and the local memory in the arithmetic unit, and black arrows indicate data transfer between the local memory in the arithmetic unit via the intra-chip bus. Represents.

  In the second process of FIG. 12B, a merge process in a predetermined order is performed on eight blocks of blocks 0 to 7,..., Blocks 56 to 63 among the 16 blocks output by the first process. Applying blocks 0 to 63, blocks 64 to 71,..., And blocks 120 to 127 are applied to a predetermined order of merge processing to output blocks 64 to 127.

  Further, in the third process of FIG. 12C, the SPU-0 applies a merge process in a predetermined order to the blocks 0 to 63 and the blocks 64 to 127, and outputs one final block 0 to 127. .

  In the inter-block sort process 1 (that is, the merge process), each arithmetic unit merges information related to a pair of blocks, and generates information related to one block of the merged higher layer. Therefore, the merge process is realized by a parallel operation of a plurality of arithmetic units. Each arithmetic unit also merges information about merged more block pairs belonging to the same layer and generates information about one block of the merged higher layer. In this way, by repeating the merge processing in parallel and hierarchically, information on one block at the top layer is finally generated. One block in the uppermost layer is a block including the entire record.

For example, ^assuming that there are 2 ⁿ -1 arithmetic units, each arithmetic unit inputs information about two blocks, merges them and outputs information about one block, each arithmetic unit has By executing the merge process once, an n-stage (layer) merge process is realized. In this case, of the total data communication amount by all the arithmetic processors, the ratio occupied by the communication performed by the arithmetic processor with the global memory is 1 / n. The communication amount between the arithmetic units is (n−1) / n of the total data communication amount.

  Next, the inter-block sort process 1 (inter-block merge process) in the tabular data sort process according to an embodiment of the present invention will be described in more detail. 13A to 13C are explanatory diagrams of the inter-block merge process at the first stage in the tabular data sort process according to the embodiment of the present invention. In this example, the SPU-0 executes a merge process in a predetermined order between the block Block-0 (hereinafter, block 0) and the block Block-1 (block 1). The inter-block merge process is an ascending list merge process in that one ascending list is generated from two ascending lists. First, the SPU-0 transfers the item value designation pointer array LVL ′, the record order number array GOrd ′, and the block number array BlkNo ′ regarding the block 0 and the block 1 from the global memory to the local memory. However, when the entire data cannot be transferred to the global memory at once, the data is transferred little by little from the global memory to the local memory.

FIG. 13A shows information on the first record in block 0 (represented as B0 (LVL ′, GOrd ′)) and information on the first record in block 1 (B1 (LVL ′, GOrd ′)). The process of comparing with the above is shown. At this time, both the read pointer on the block 0 side and the read pointer on the block 1 side are located at the head of the data. LVL ′ is regarded as an upper digit and GOrd ′ is regarded as a lower digit, and (LVL ′, GOrd ′) from the block 0 side and the block 1 side are arranged in a predetermined order (for example, ascending order). In this example,
B0 (LVL ′, GOrd ′) = (2, 1)> B1 (LVL ′, GOrd ′) = (1, 5)
Therefore, it is determined that B1 (LVL ′, GOrd ′) is the head (smallest) element. Therefore, the element set B1 (1, 5, 1) including the block number is extracted as a result of the merge process. The result of this merge process is
LVL '[0] = 1
GOrd ′ [0] = 5
BlkNo '[0] = 1
Can be described as follows. As a result, since the data on the block 1 side is extracted, the read pointer on the block 1 side is advanced by one.

FIG. 13B shows a process of comparing the first record in block 0 where the read pointer is positioned at the head with the second record in block 1 where the read pointer is advanced one step forward. Yes. Similarly, when B0 (2,1) and B1 (2,4) are compared, it is determined that B0 (2,1) is smaller, so the element set B0 (2,1) including the block number is determined. , 0) is the result of the merge process, ie
LVL '[1] = 2
GOrd '[1] = 1
BlkNo '[1] = 0
As taken out. As a result, since the data on the block 0 side is extracted, the read pointer on the block 0 side is advanced by one.

  In this way, by sequentially comparing the data on the block 0 side and the data on the block 1 side while advancing the pointer, finally, an ascending list in which the data on the block 0 side and the data on the block 1 side are merged is obtained. can get. FIG. 13C shows the item value designation pointer array LVL ′, the record sequence number array GOrd ′, and the block number array BlkNo ′ that are finally extracted.

  Note that the extracted item value designation pointer array LVL ′, record sequence number array GOrd ′, and block number array BlkNo ′ are sent to the SPU-4 in this example because of the second-stage merging process. The extracted data may be sent from the SPU-0 to the SPU-4 as necessary while proceeding with the comparison process between the block 0 side and the block 1 side, instead of sending the actual results all at once. .

  As can be seen from the above description, in the first stage of the inter-block sort process 1 (merge process) according to one embodiment of the present invention, data access is limited to sequential access and each SPU is blocked in parallel. Intersort processing 1 can be executed. Therefore, the performance of the multiprocessor type processing apparatus is fully utilized.

This time, the arithmetic unit SPU-4 applies a merge process in a predetermined order to the blocks 0 to 1 output from the SPU-0 and to the blocks 2 to 3 output from the SPU-11, thereby obtaining one block 0 to 0. The second block sorting process 1 for outputting 3 will be described. 14A and 14B are explanatory diagrams of the second-stage merge processing in the tabular data sort processing according to the embodiment of the present invention. The second-stage merge process is the same as the first-stage merge process, except that the input information is transferred from the local memory of another arithmetic unit. Briefly explaining this processing, as shown in FIG. 14A, first, for reading the item value designation pointer array LVL ′, the record sequence number array GOrd ′, and the block number array BlkNo ′ from the two blocks. The pointer is set to the beginning. Comparing the values of both (LVL ', GOrd') pairs,
B0-1 (LVL ', GOrd') = (1,5)> B2-3 (LVL ', GOrd') = (0,8)
Therefore, it can be seen that the element on the B2-3 side is smaller. Therefore, B2-3 (0, 8, 2), which is the set of the leading elements on the B2-3 side, is extracted. Then, the read pointer on the B2-3 side from which the element set has been extracted is advanced by one. Here, the notation Ba to b represents data obtained as a result of the merge processing in a predetermined order between block a and block b.

  By repeating the size comparison of such element sets and reading out the smaller element set, as shown in FIG. 14B, finally, B2-3 ( 3, 13, 3) are taken out, and the second-stage merge processing ends.

  Note that the extracted item value designation pointer array LVL ′, record sequence number array GOrd ′, and block number array BlkNo ′ are sent to the SPU-6 in this example because of the third-stage merge process. The extracted data may be sent from the SPU-4 to the SPU-6 as necessary while proceeding with the comparison process between the block 0 side and the block 1 side, instead of sending the actual results all at once. . As can be seen from the above description, in the second stage of the inter-block sort process 1 (merge process) according to an embodiment of the present invention, data access is limited to sequential access and each SPU is parallel. In addition, the inter-block sort process 1 can be executed. Therefore, the performance of the multiprocessor type processing apparatus is fully utilized.

  In the present example, the second-stage merge processing is executed in parallel by SPU-4 and SPU-5. The SPU-4 outputs the result of the inter-block merge process from the block 0 to the block 3 to the SPU-6 as the blocks 0 to 3, and the SPU-5 displays the result of the inter-block merge process from the block 4 to the block 7 It outputs to SPU-6 as blocks 4-7. In this example, since the total number of blocks is 8 blocks from block 0 to block 7, merging of data from all the blocks is completed by the third-stage merge processing by SPU-6, that is, all blocks The sort process considering the block ends. As will be appreciated by those skilled in the art, if there are more than nine blocks, for example, as shown in FIGS. It is possible to obtain a sort processing result in which data is merged.

  FIG. 15 is an explanatory diagram of the third merging process in the tabular data sorting process according to the embodiment of the present invention. Similarly to the first-stage merge process and the second-stage merge process, the third-stage merge process also includes data B0-3 on the B0-3 side (LVL ′, GOrd ′) and data B0 on the B4-7 side. -4 (LVL ', GOrd') are compared in order from the top, the smaller element set is extracted, and the operation of advancing the read pointer of the data on the side from which the element has been extracted is repeated. As a result, a set of arrays as shown on the right side of FIG. 15, that is, a set of an item value designation pointer array LVL ', a record sequence number array GOrd', and a block number array BlkNo 'is obtained. This set of arrays represents the sorting result of all records. For example, referring to the item value designation pointer array LVL ′, since the values including the same value are arranged in ascending order from the beginning, the records may be sorted in the order of the item values in the global item value array. Recognize. It can also be seen that records having the same element value in the item value designation pointer array LVL 'are arranged in ascending order of the record order numbers before sorting by referring to the record order number array GOrd'. As described above, the reason why a stable sorting result with respect to the record sequence number is obtained is that when sorting between blocks, the records are rearranged based on the magnitude relation regarding the combination of the item value designation pointer and the record sequence number. Because it was broken.

The following can be understood from the three arrays obtained by the inter-block sort process 1 (merge process) in the tabular data sort process according to the embodiment of the present invention. For example, referring to the data in the first row of the array set = (0, 8, 2), the record to which the record sequence number 0 is given after sorting is
(1) The value of the item value designation pointer that designates the item value related to the data item that is the key for sorting is 0,
(2) The record sequence number assigned before sorting is 8,
(3) Belonging to block 2

  In order to help the understanding of the invention, the result of the inter-block sort process 1 (merge process) is expressed in a data structure for a multi-core type processing apparatus. 16A to 16C are explanatory diagrams of the result of the inter-block sort process 1 (merge process) in the tabular data sort process according to the embodiment of the present invention. The tabular data shown in FIGS. 16A to 16C are similar to the tabular data shown in FIGS. 7B to 7D, but at this point, they are stored in the record sequence number array GOrd shown in FIG. 16A. The power value is undecided. On the other hand, the item value information shown in FIGS. 16B and 16C is not affected by the sort process, and is naturally the same.

In the sort processing of tabular data according to an embodiment of the present invention, the record sequence number of the record belonging to each block is finally determined. The process for determining the record sequence number is called an inter-block sort process 2 (distribution process). In the distribution process, a plurality of arithmetic units operate in parallel, and the record order number corresponding to the subscript i of the block number array BlkNo is distributed to each block represented by the block number BlkNo [i]. Record order numbers are arranged in a predetermined order (for example, ascending order) within a block. In this process, for example, the k-th element of the record sequence number array of block j is GOrd [j] [k], and the write pointer k for setting the record sequence number in the record sequence number array GOrd [j] is set. If index [j], it can be described as follows.
Initialize the index array index;
for (i = 0; i <total number of records; i ++) {
GOrd [BlkNo [i]] [index [BlkNo [i]] = i;
index [BlkNo [i]] ++;
}
In practice, however, a plurality of arithmetic units share part of the block number array BlkNo and perform distribution processing. Therefore, the record sequence number array GOrd [j] relating to a certain block is processed by being shared by a plurality of arithmetic units. Then, the record sequence number arrays created by sharing by a plurality of arithmetic units are integrated into one record sequence number array for each block. If the block number array BlkNo is continuously assigned to a plurality of arithmetic units, that is, if a part of the block number array BlkNo assigned to each arithmetic unit is continuous, this integration process is very To be simplified. This is because it is not necessary to change the order of elements between record sequence number arrays created by different arithmetic units for the same block. That is, the integration process of the record sequence number arrays is achieved by simply concatenating the record sequence number arrays created separately.

  17A to 17C are explanatory diagrams of the inter-block sort process 2 (distribution process) in the tabular data sort process according to the embodiment of the present invention. Referring to FIG. 17A, in the block number array BlkNo, four elements are assigned to eight arithmetic units SPU-0, SPU-1,..., SPU-7 in order from the top. In FIG. 17A, each arithmetic unit sets the record sequence number in parallel according to the subscript i (= record sequence number) and the element BlkNo [i] (= block number) of its own block number array BlkNo. It is distributed for each block number. For example, the SPU-0 writes the record sequence number = 0 at the head of the record sequence number array GOrd-2 for the block number 2 in accordance with the data BlkNo [0] = 2 in charge. That is, GOrd-2 [0] = 0. Each arithmetic unit creates the data in its own range in the block number array and the record sequence number arrays GOrd-0, GOrd-1,..., GOrd-7 on the local memory and distributes them. Process.

  Each arithmetic unit sequentially performs distribution processing on four data within the range that it is in charge of. FIG. 17B shows a state in which each arithmetic unit distributes the fourth data within the range that it is in charge of. For example, SPU-7 sets 31 to GOrd-7 [1] according to BlkNo [31] = 7.

  In this example, an array GOrd-0 to GOrd-7 from block 0 to block 7 is used for each arithmetic unit. In this case, a work area equal to the number of arithmetic units (= 8) is secured in the local memory and the global memory. In order to make this work area compact, a linked list may be used. The important thing is that as long as the work area can be stored in local memory, the work area is accommodated in local memory, and when the work area cannot be accommodated in local memory, the entire work area in local memory is Alternatively, memory access to the global memory can be unified by transferring a part of the data to the global memory.

  Finally, a final record order number array is created by integrating the record order number arrays for each block created by each arithmetic unit. Specifically, the values stored in each of GOrd-0, GOrd-1,..., GOrd-7 are extracted in ascending order of record order numbers, that is, in the order of SPU-0 to SPU-7. The values may be stored in order from the top of the final GOrd-0, GOrd-1,..., GOrd-7. For example, this operation can be executed by any one of the arithmetic units or the control unit, but for each block number, a plurality of arithmetic units take out values from GOrd-0 etc. in parallel. You may make it write in general GOrd-0 grade | etc.,.

  GOrd-0 obtained in this way is a record sequence number assigned to records belonging to block 0, GOrd-1 is a record sequence number assigned to records belonging to block 1, and so on. FIG. 18 is an explanatory diagram of the result of the sort processing of tabular data according to an embodiment of the present invention. It can be seen that the record sequence number array obtained in FIG. 17C matches the record sequence number array of each block.

[Summary of sort processing of tabular data]
The tabular data sorting method according to the above-described embodiment of the present invention will be described once more generally with reference to the flowchart shown in FIG.

How to sort tabular data
The plurality of arithmetic units operate in parallel and apply the sort to the item value access information array using the item value information as a key for each block including the record in charge. A step 1902 for creating an item value access information array, a work item value information array corresponding to the sorted item value access information array, and a work record sequence number array in the global memory;
The plurality of arithmetic units operate in parallel, and are composed of a first element from the work item value information array relating to a pair of blocks and a second element from the corresponding work record sequence number array. The element set is merged in a predetermined order using the first element as the upper digit and the second element as the lower digit, and the element set is included in the merged element set Associating block numbers, thereby creating a new work item value information array, a new work record sequence number array, and a new block number array for the pair of blocks, 1904;
The plurality of arithmetic units operate in a parallel and hierarchical manner, and the above step (ii) is repeatedly executed, whereby a set of final work item value information array, final work record order Creating a number array and a final block number array in the global memory 1906;
The plurality of arithmetic units operate in parallel, and the record sequence numbers storing the elements in the final block number array are distributed for each block number designated by the elements and arranged in a predetermined order. Thereby creating a sorted record sequence number array in the global memory 1908;
It has.

  The item value information includes a global item value array in which unique item values are stored in a predetermined order for each data item, and a local item for specifying an item value included in the assigned record for each data item. The local item value number array in which the value numbers are stored in the order of the record sequence numbers, and the position where the item value represented by the local item value number is stored in the global item value array for each data item If the item value specifying pointer that specifies the item value specifying pointer array is stored in a predetermined order, the sort applied in step (i) is the distribution counting sort, and the work item value The information array is a work item value designation pointer array.

Further, the above step 1902 includes
The plurality of arithmetic units operate in parallel to correspond to the block including the record in charge, the record sequence number array and the item value access information array, and the local item value number related to the predetermined item Transferring the array and the item value designation pointer array from the global memory to the local memory;
The plurality of arithmetic units operate in parallel, the sorted item value access information array created in the local memory, the work item value designation pointer array, and the work record sequence number array. Transferring to the global memory;
Further included. Also, the above step 1904 includes
The plurality of arithmetic units operating in parallel, transferring the work item value designation pointer array and the work record sequence number array for a pair of blocks from the global memory to the local memory;
The plurality of arithmetic units operate in parallel, and the work item value designation pointer array created in the local memory, the work record sequence number array, and the new block number array are stored in the global memory. Or transferring to an arithmetic unit for further processing;
including. Further, the step 1906 includes a step of transferring the final block number array created in the local memory to the global memory.

[Alternative distribution process]
In the example of the distribution process shown in FIGS. 17A to 17C, when the number of blocks increases, the work area on the local memory also increases. Therefore, in an alternative embodiment of the present invention, particularly when the number of blocks is large, a distribution process is performed for each group after a plurality of blocks are grouped in order to improve the processing efficiency. For example, the block number is divided by 4 to separate the upper block number and the lower block number (grouping), and the distribution process is separately applied to the upper block number and the lower block number. Specifically, the block number array BlkNo ′ for the lower block number and the block number work array BlkNo ′ for the upper block number are generated from the block number array BlkNo ′ obtained by the merge process in the inter-block sort process 2. . This generation process can also be executed by a plurality of arithmetic units operating in parallel.

  For example, when the block number array BlkNo shown in FIGS. 16A to 16C is separated into a lower block number (ie, 0 to 3) and an upper block number (ie, 4 to 7), two block number arrays are generated. The FIG. 20 is an explanatory diagram of block number array separation processing according to an alternative embodiment of the present invention. The BlkNo ′ and LVL ′ for the lower block number and the BlkNo ′ and LVL ′ for the upper block number obtained in this way are according to the embodiment of the present invention described with reference to FIGS. 17A to 17C. A distribution process in the inter-block sort process is applied, and a record sequence number is obtained for each block number.

[Multi-item sort processing for tabular data]
The sort processing of tabular data according to an embodiment of the present invention is a sort processing related to a predetermined data item. What is changed by this sort processing is the block number array, the record sequence number array, and the item value access information array. On the other hand, records belonging to each block and item value information do not change. Therefore, the sorting process for a plurality of data items is realized by repeating the sorting process for the predetermined data item. According to a preferred embodiment of the multi-core processing apparatus of the present invention, the multi-item sort process is realized by the control unit controlling the arithmetic unit to repeat the sort process for a plurality of data items.

  Thus, for example, when the tabular data shown in FIG. 5A is first subjected to sort processing for data item = “School” and then to sort processing for data item = “Age” ( Multi-stage sort processing), the sort processing described with reference to FIGS. 10A to 10C to FIG. 18 is performed to sort the data item = “School”, and then the record sequence number array shown in FIG. Starting with the item value access information array, the sort processing for data item = “Age” may be executed. Note that when the sort process is sequentially applied to a plurality of data items, the sort process for the data item having a high priority is applied later.

  FIG. 21 is a diagram showing a result of applying the multi-stage sorting process according to the embodiment of the present invention to the tabular data shown in FIG. 5A. In FIG. 21A, the sorting process for data item = “School” is first applied, and then the sorting process for data item = “Age” is applied. On the other hand, in FIG. 21B, the sort related to the data item = “Age” is applied first, and then the sort related to the data item = “School” is applied. As described above, the result of the sort process varies depending on the order of the data items to which the sort is applied. It can also be seen that the multi-stage sort process according to an embodiment of the present invention is a stable sort.

Alternatively, in an alternative embodiment, the multi-item sort process can be realized in one stage. This is realized by executing the distribution counting sort process executed in the intra-block sort process in the above embodiment by combining a plurality of data items. For example, in the example of the tabular data in FIG. 5A, when the multi-item sort process is performed with the data item = “School” as the data item with low priority and the data item = “Age” as the data item with high priority. think of. Sorting is executed by regarding the value Z generated by combining the value X of the item value designation pointer of data item = “School” and the value Y of the item value designation pointer of data item = “Age” as a new item value. do it. In this example, there are four possible ranges of X values, 0 ≦ X ≦ 3, and seven possible ranges of Y values are 0 ≦ Y ≦ 6. A value of 4 × 7 = 28, that is, a value from 0 to 27 is assigned to the combination. More specifically, since data item = “Age” is a high priority data item,
Z = 4 × Y + X
The sort process may be executed by regarding the value Z as a new item value.

  Actually, it is not necessary to create new tabular data having new item values, and the value X of the item value designation pointer of data item = “School” and the data item are used as the key value Z for the distribution counting sorting process. = The value Z = 4 × Y + X, which is a combination of the values of the item value designation pointer Y of “Age”, may be used. Then, using this new item value designation pointer Z, sorting is performed for each data item by executing intra-block sort processing, inter-block sort processing 1 (merge processing), and inter-block sort processing 2 (distribution processing). The same result can be obtained as when processing is executed.

[Another data structure of tabular data]
In the description so far, the sort processing of the tabular data according to the present invention has been described for the case where the item value information of the first type is used. As already described, the tabular data according to the present invention is described. This sort processing can also be applied when the data structure of the tabular data holds the item type information of the second type. 22A to 22D are explanatory diagrams of the data structure of tabular data according to an embodiment of the present invention, which describes the same tabular data as the tabular data of FIG. 5A. FIG. 22A is a diagram for conceptually explaining tabular data, and FIG. 22B is a diagram showing order information in the data structure of tabular data. FIG. 22C shows item value information related to data item = “School”, and FIG. 22D shows item value information related to data item = “Age”. In the present embodiment, the item value information is the item value itself. Also in this embodiment, the item value information does not change before and after the sorting process. Hereinafter, with respect to such tabular data, a sorting process using an item value of “data item =“ School ”as a key value will be described.

[Sort processing of tabular data (second type item value information)]
The differences between the tabular data sort process using the first type item value information and the tabular data sort process using the second type item value information are as follows. In the sort processing using the first type of item value information, the item value access information is sorted by executing the distribution counting sort processing in the block using the local item value number as the key value, and then the value of the item value designation pointer And the record sequence number pair as a key value. On the other hand, in the sort process using the second type item value information, the item value access information is sorted by executing a stable sort process in the block using the item value as a key value, Perform block-to-block sort using a set of value and record sequence number as key value.

  FIG. 23 is a schematic flowchart of sorting processing of tabular data including item value information of the second type.

Step 2301: In-block sorting Each arithmetic unit operates in parallel, and in each block, the item value in the item value array RV is used as a key value, and the item value access information array LOrd has a stable sort (for example, , Merge sort, bubble sort, etc.) are applied to generate the item value array RV ′ and the record sequence number array GOrd ′ so as to match the sorted item value access information array LOrd ′.

Step 2302: Inter-block sort 1 (merge)
Each arithmetic unit operates in parallel and hierarchically to generate a block number array BlkNo from the item value array RV ′ and the record order number array GOrd ′. Here, the item value array RV ′, the record order number array GOrd ′, and the block number array BlkNo ′ from each block are merged in a tournament manner between the blocks.

Step 2303: Inter-block sort 2 (distribution)
Each arithmetic unit operates in parallel to generate a record order number array GOrd from the block number array BlkNo.

  24A to 24H are explanatory diagrams of the intra-block sort process in the tabular data sort process according to the embodiment of the present invention. FIG. 24A to FIG. 24H show the state of the intra-block sorting process in block 0 to block 7, respectively. In this example, seven arithmetic units from SPU-0 to SPU-7 are in charge of the intra-block sort processing in each block from block 0 to block 7, respectively. Also in this embodiment, each arithmetic unit transfers data necessary for processing from the global memory to a dedicated local memory, and manipulates the data in the local memory. When all the data cannot be accommodated in the local memory at the same time, the data is transferred between the global memory and the local memory for processing to some extent.

  For example, referring to FIG. 24A, in this example, since the value of the element of RV is a character string, LOrd is sorted in alphabetical order of the key value using the value of RV as the key value. Further, since a stable sort algorithm such as merge sort or bubble sort is used, the array LOrd = (0, 1, 2, 3) has the array LOrd ′ = (1, 3, 0, 2). Sorted as follows. The array A = (a, b, c, d) represents that the elements of the array A are a, b, c, d in order from the top. Since the elements “West”, “South”, “West”, “South” of the item value array RV correspond to the element values 0, 1, 2, 3 of the array LOrd, respectively, It is clear that the array LOrd ′ is obtained by rearranging the elements of the array LOrd as key values. Here, when the elements of the corresponding item value array RV and the elements of the record order number array GOrd are extracted in the order of the elements of LOrd ', the item value array RV' and the record order number array GOrd 'are obtained. The item value array RV 'is, of course, an array in which the item values are sorted in ascending order (alphabetical order). The elements of the record sequence number array GOrd 'are sorted in such an order that the LOrd value that appears first is given priority when the item values are the same value. That is, the combination of the item value and the record sequence number is rearranged by stable sorting. The same processing is performed for the other blocks 1 to 7.

  FIG. 25 is an explanatory diagram of the result of the intra-block sorting process in the tabular data sorting process according to the embodiment of the present invention obtained as described above. At this time, the item value access information array LOrd in each block is consistent with the final result, and thus is indicated without a prime symbol (') like LOrd. On the other hand, the item value array RV 'and the record sequence number array GOrd' are not final results, but represent working arrays in the middle of processing, and therefore are indicated with a prime symbol ('). Further, the block number array BlkNo and the record sequence number array GOrd, which are the final results, have not yet been determined at this point, and are left blank. Further, the block number BlkNo ′ is added to the array RV ′ and the array GOrd ′ that are the results of the intra-block sort.

  As described with reference to FIGS. 12A to 12C, the inter-block sort process 1 (merge process) in the tabular data sort process according to an embodiment of the present invention is executed in parallel and hierarchically.

  Next, the inter-block sort process 1 (inter-block merge process) in the tabular data sort process according to an embodiment of the present invention will be described in more detail. FIGS. 26A to 26C are explanatory diagrams of the inter-block merging process in the first stage in the tabular data sort process according to the embodiment of the present invention. In this example, the SPU-0 executes a merge process in a predetermined order between the block Block-0 (hereinafter, block 0) and the block Block-1 (block 1). The inter-block sorting process is an ascending list merging process in that one ascending list is generated from two ascending lists. First, the SPU-0 transfers the item value array RV ′, the record order number array GOrd ′, and the block number array BlkNo ′ regarding the block 0 and the block 1 from the global memory to the local memory. However, when the entire data cannot be transferred to the global memory at once, the data is transferred little by little from the global memory to the local memory.

26A shows information on the first record in block 0 (represented as B0 (RV ′, GOrd ′)) and information on the first record in block 1 (B1 (RV ′, GOrd ′)). The process of comparing with the above is shown. At this time, both the read pointer on the block 0 side and the read pointer on the block 1 side are located at the head of the data. RV ′ is regarded as an upper digit and GOrd ′ is regarded as a lower digit, and (RV ′, GOrd ′) from the block 0 side and the block 1 side are arranged in a predetermined order (for example, ascending order). In this example,
B0 (RV ′, GOrd ′) = (“South”, 1)> B1 (LVL ′, GOrd ′) = (“North”, 5)
Therefore, it is determined that B1 (RV ′, GOrd ′) is the head (smallest) element. Therefore, the element set B1 (“North”, 5, 1) including the block number is extracted as a result of the merge process. The result of this merge process is
RV ′ [0] = “North”
GOrd ′ [0] = 5
BlkNo '[0] = 1
Can be described as follows. As a result, since the data on the block 1 side is extracted, the read pointer on the block 1 side is advanced by one.

FIG. 26B shows a process of comparing the first record in block 0 where the read pointer is positioned at the head with the second record in block 1 where the read pointer is advanced one step forward. Yes. Similarly, when B0 (“South”, 1) is compared with B1 (“South”, 4), it is determined that B0 (“South”, 1) is smaller, so the element including the block number The set B0 (“South”, 1, 0) is the result of the merge process, ie,
RV ′ [1] = “South”
GOrd '[1] = 1
BlkNo '[1] = 0
As taken out. As a result, since the data on the block 0 side is extracted, the read pointer on the block 0 side is advanced by one.

  In this way, by sequentially comparing the data on the block 0 side and the data on the block 1 side while advancing the pointer, finally, an ascending list in which the data on the block 0 side and the data on the block 1 side are merged is obtained. can get. FIG. 26C shows the item value array RV ′, the record order number array GOrd ′, and the block number array BlkNo ′ that are finally extracted.

  Note that the extracted item value array RV ′, record order number array GOrd ′, and block number array BlkNo ′ are sent to the SPU-4 in this example because of the second-stage merge process. Instead of sending the results all at once, the extracted data may be sent from the SPU-0 to the SPU-4 as necessary while proceeding with the comparison process between the block 0 side and the block 1 side.

  As can be seen from the above description, in the first stage of the inter-block sort process 1 (merge process) according to one embodiment of the present invention, data access is limited to sequential access and each SPU is blocked in parallel. Intersort processing 1 can be executed. Therefore, the performance of the multiprocessor type processing apparatus is fully utilized.

This time, the arithmetic unit SPU-4 applies a merge process in a predetermined order to the blocks 0 to 1 output from the SPU-0 and to the blocks 2 to 3 output from the SPU-11, thereby obtaining one block 0 to 0. The second block sorting process 1 for outputting 3 will be described. 27A and 27B are explanatory diagrams of the second-stage merge process in the tabular data sort process according to an embodiment of the present invention. The second-stage merge process is the same as the first-stage merge process, except that the input information is transferred from the local memory of another arithmetic unit. Briefly describing this processing, as shown in FIG. 27A, first, the reading pointers of the item value array RV ′, the record sequence number array GOrd ′, and the block number array BlkNo ′ from the two blocks are displayed. Set to the beginning. Comparing the values of both (RV ′, GOrd ′) pairs,
B0-1 (RV ′, GOrd ′) = (“North”, 5)> B2-3 (RV ′, GOrd ′) = (“East”, 8)
Therefore, it can be seen that the element on the B2-3 side is smaller. Therefore, B2-3 ("East", 8, 2), which is the set of the leading elements on the B2-3 side, are extracted. Then, the read pointer on the B2-3 side from which the element set has been extracted is advanced by one. Here, the notation Ba to b represents data obtained as a result of the sorting process from block a to block b.

  By repeating the size comparison of such element sets and reading out the smaller element set, finally, as shown in FIG. 27B, B2-3 ( “West”, 13, 3) is taken out, and the second-stage merge processing ends.

  Note that the extracted item value array RV ′, record order number array GOrd ′, and block number array BlkNo ′ are sent to the SPU-6 in this example because of the third-stage merge process, Rather than sending the results all at once, the extracted data may be sent from the SPU-4 to the SPU-6 as necessary while proceeding with the comparison process between the block 0 side and the block 1 side. As can be seen from the above description, in the second stage of the inter-block sort process 1 (merge process) according to an embodiment of the present invention, data access is limited to sequential access and each SPU is parallel. In addition, the inter-block sort process 1 can be executed. Therefore, the performance of the multiprocessor type processing apparatus is fully utilized.

  In the present example, the second-stage merge processing is executed in parallel by SPU-4 and SPU-5. The SPU-4 outputs the result of the inter-block merge process from the block 0 to the block 3 to the SPU-6 as the blocks 0 to 3, and the SPU-5 displays the result of the inter-block merge process from the block 4 to the block 7 It outputs to SPU-6 as blocks 4-7. In this example, since the total number of blocks is 8 blocks from block 0 to block 7, merging of data from all the blocks is completed by the third-stage merge processing by SPU-6, that is, all blocks The sort process considering the block ends. As will be appreciated by those skilled in the art, if there are more than nine blocks, for example, as shown in FIGS. It is possible to obtain a sort processing result in which data is merged.

  FIG. 28 is an explanatory diagram of the third merging process in the tabular data sorting process according to an embodiment of the present invention. Similarly to the first-stage merge process and the second-stage merge process, the third-stage merge process also includes data B0-3 on the B0-3 side (RV ′, GOrd ′) and data B0 on the B4-7 side. -4 (RV ′, GOrd ′) are compared in order from the beginning, the smaller element set is extracted, and the operation of advancing the read pointer of the data from which the element has been extracted is repeated. As a result, a set of arrays as shown on the right side of FIG. 28, that is, a set of an item value array RV ′, a record order number array GOrd ′, and a block number array BlkNo ′ is obtained. This set of arrays represents the sorting result of all records. For example, referring to the item value array RV ', it can be seen that since the values are arranged in ascending order including the same value from the top, the records are sorted in the order of the item values in the global item value array. It can also be seen that records having the same element value in the item value array RV 'are arranged in ascending order of the record order numbers before sorting by referring to the record order number array GOrd'. As described above, the reason why a stable sorting result with respect to the record sequence number is obtained is that when sorting between blocks, the records are rearranged based on the magnitude relation regarding the combination of the item value designation pointer and the record sequence number. Because it was broken.

The following can be understood from the three arrays obtained by the inter-block sort process 1 (merge process) in the tabular data sort process according to the embodiment of the present invention. For example, referring to the data in the first row of the array set = (“East”, 8, 2), the record assigned the record sequence number 0 after sorting is
(1) The value of the item value related to the data item that is the key for sorting is “East”.
(2) The record sequence number assigned before sorting is 8,
(3) Belonging to block 2

  In order to help the understanding of the invention, the result of the inter-block sort process 1 (merge process) is expressed in a data structure for a multi-core type processing apparatus. FIG. 29A thru | or 29C are explanatory drawings of the result of the inter-block sort process 1 (merge process) in the sort processing of the tabular data by one Embodiment of this invention. The tabular data shown in FIG. 29A is similar to the tabular data shown in FIG. 7B, but at this point, the values to be stored in the record sequence number array GOrd shown in FIG. 29A are undecided. It is. On the other hand, the item value information shown in FIGS. 29B and 29C, that is, the item value array RV, is not affected by the sort process, and is naturally the same as the item value information shown in FIGS. 22A to 22D. is there.

  In the sort processing of tabular data according to an embodiment of the present invention, the record sequence number of the record belonging to each block is finally determined. The process for determining the record sequence number is called an inter-block sort process 2 (distribution process). Since the inter-block sort process 2 (distribution process) is exactly the same as the process described with reference to FIGS. 17A, 17B, 17C and FIG. 18, no further description will be given.

  Furthermore, it is possible to apply multi-item sort processing to tabular data including item value information of the first type. The multi-item sort process used in this case is a multi-stage sort process. That is, it is realized by repeating the sorting process for a predetermined data item described with reference to FIGS. 22A to 22D to FIGS. 29A to 29C for a plurality of data items.

  Therefore, for example, when the tabular data shown in FIG. 22A is first subjected to sort processing for data item = “School” and then to sort processing for data item = “Age” ( (Multi-stage sort process), the sort for the data item = “School” is performed by the above sort process, and similarly, starting from the block number array, record sequence number array, and item value access information array shown in FIG. , Sort processing relating to data item = “Age” may be executed. Note that when the sort process is sequentially applied to a plurality of data items, the sort process for the data item having a high priority is applied later. Note that the result of the sort process varies depending on the order of the data items to which the sort is applied.

  The present invention is not limited to the above embodiments, and various modifications can be made within the scope of the invention described in the claims, and these are also included in the scope of the present invention. Needless to say.

Claims (10)

In a multi-core processing apparatus including a plurality of arithmetic units including a dedicated local memory and a global memory connected to the plurality of arithmetic units, a record including item values corresponding to one or more data items A sorting method for representing an array and rearranging the records of tabular data constructed in the global memory according to item values relating to a predetermined data item,
The above tabular data is
The block number corresponding to each record in the array of records divided into blocks having a size that can be accommodated in the local memory of each arithmetic unit is stored in the order of the record sequence number of the record in the tabular data. Block number array being
A record sequence number array in which the record sequence numbers of records in charge that are records belonging to each block are stored in the order of the record sequence numbers;
Field value access information array in which field value access information for accessing the field value included in the responsible record is stored in the order of the record sequence number;
Item value information describing the item value accessed using the item value access information for each data item;
Expressed by
The sorting method is related to the predetermined data item.
(i) The plurality of arithmetic units operate in parallel, and for each block including the responsible record, the item value information is used as a key to apply sorting to the item value access information array, Creating a sorted item value access information array, a work item value information array corresponding to the sorted item value access information array, and a work record sequence number array in the global memory;
(ii) The plurality of arithmetic units operate in parallel, and the first element from the work item value information array related to a pair of blocks and the second element from the corresponding work record sequence number array. An element set consisting of elements is merged in a predetermined order using the first element as the upper digit and the second element as the lower digit, and the element set is merged into the merged element set. Associating the included block numbers, thereby creating a new work item value information array, a new work record sequence number array, and a new block number array for the pair of blocks;
(iii) the plurality of arithmetic units operate in a parallel and hierarchical manner, repeatedly performing the step (ii), thereby creating a final block number array in the global memory;
(iv) The plurality of arithmetic units operate in parallel, and the record sequence numbers in which the elements in the final block number array are stored are distributed for each block number designated by the elements. Arranging in order, thereby creating a sorted record sequence number array in the global memory;
A sorting method comprising: Step (i) above is
The plurality of arithmetic units operate in parallel to correspond to the block including the record in charge, the record sequence number array and the item value access information array, and the item value information array relating to the predetermined item Transferring from the global memory to the local memory;
The plurality of arithmetic units operate in parallel, and the sorted item value access information array created in the local memory, the work item value information array, and the work record sequence number array are Transferring to global memory;
Further including
Step (ii) above is
Transferring the work item value information array for the pair of blocks and the work record sequence number array from the global memory to the local memory by operating the plurality of arithmetic units in parallel;
The plurality of arithmetic units operate in parallel, the new work item value information array created in the local memory, the new work record sequence number array, and the new block number array Transferring to the global memory or computing unit for further processing;
Further including
The sorting method according to claim 1. The above field value information
For each data item, a global item value array in which unique item values are stored in a predetermined order;
For each data item, a local field value number array in which local field value numbers that specify field values included in the record in charge are stored in the order of the record order numbers;
An item value designation pointer array in which an item value designation pointer for designating a position where the item value represented by the local item value number is stored in the global item value array is stored in a predetermined order for each data item When,
With
The sort applied in step (i) above is a distribution counting sort,
The work item value information array is a work item value designation pointer array.
The sorting method according to claim 1 or 2. The item value information includes an item value array in which item values included in the charge record are stored for each data item,
The sort applied in step (i) above is a stable sort,
The work item value information array is a work item value array.
The sorting method according to claim 1 or 2.   (v) using the sorted record sequence number array and the sorted item value access information array as the record sequence number array and the item value access information array, respectively, with respect to another data item, the step (i) 5. The sorting method according to claim 1, further comprising a step of executing (ii), (iii), and (iv). Comprising a plurality of arithmetic units including a dedicated local memory and a global memory connected to the plurality of arithmetic units, and representing an array of records including item values corresponding to one or more data items; A multi-core processing device for rearranging the records of tabular data constructed in the global memory according to item values relating to predetermined data items,
The above tabular data is
The block number corresponding to each record in the array of records divided into blocks having a size that can be accommodated in the local memory of each arithmetic unit is stored in the order of the record sequence number of the record in the tabular data. Block number array being
A record sequence number array in which the record sequence numbers of records in charge that are records belonging to each block are stored in the order of the record sequence numbers;
Field value access information array in which field value access information for accessing the field value included in the responsible record is stored in the order of the record sequence number;
Item value information describing the item value accessed using the item value access information for each data item;
Expressed by
Each arithmetic unit of the multi-core processing device
(a) Operates in parallel with other arithmetic units, and applies sorting to the item value access information array using the item value information relating to the predetermined data item as a key for each block including the assigned record And means for creating the sorted item value access information array, the working item value information array and the working record sequence number array corresponding to the sorted item value access information array in the global memory,
(b) Operate in parallel with other arithmetic units, from the first element from the work item value information array relating to a pair of blocks and the second element from the corresponding work record sequence number array Are merged in a predetermined order using the first element as the upper digit and the second element as the lower digit, and the merged element set includes the element set. Means for associating the block numbers, thereby creating a new work item value information array for the pair of blocks, a new work record sequence number array, and a new block number array;
(c) operating in parallel and hierarchically with other arithmetic units, repeatedly operating the means (b), thereby creating a final block number array in the global memory;
(d) Operates in parallel with other arithmetic units, and distributes the record sequence numbers in which the elements in the final block number array are stored for each block number specified by the elements in a predetermined order. Arranging, thereby creating a sorted record sequence number array in the global memory;
A multi-core processing apparatus. Each arithmetic unit further comprises a dedicated memory interface for data transfer between the dedicated local memory and the global memory,
The means (a) corresponds to the block including the record in charge through the dedicated memory interface, the record sequence number array and the item value access information array, and the item value relating to the predetermined item. An information array is transferred from the global memory to the local memory, the sorted item value access information array created in the local memory, the work item value information array, and the work record sequence number array; To the above global memory,
The means (b) transfers the work item value information array and the work record sequence number array related to a pair of blocks from the global memory to the local memory via the dedicated memory interface, and Transfer the new work item value information array created in the local memory, the new work record sequence number array, and the new block number array to the global memory or the arithmetic unit for further processing,
The means (c) transfers the final block number array created in the local memory to the global memory via the dedicated memory interface.
The multi-core type processing apparatus according to claim 6. An array of records loaded into a computer comprising a plurality of arithmetic units including a dedicated local memory and a global memory connected to the plurality of arithmetic units and including item values corresponding to one or more data items A computer-readable program that causes the computer to execute a code that rearranges the records of the tabular data constructed in the global memory according to the item values relating to a predetermined data item,
In the computer, the tabular data is
The block number corresponding to each record in the array of records divided into blocks having a size that can be accommodated in the local memory of each arithmetic unit is stored in the order of the record sequence number of the record in the tabular data. Block number array being
A record sequence number array in which the record sequence numbers of records in charge that are records belonging to each block are stored in the order of the record sequence numbers;
Field value access information array in which field value access information for accessing the field value included in the responsible record is stored in the order of the record sequence number;
Item value information describing the item value accessed using the item value access information for each data item;
Expressed by
The above program is
(a) Each arithmetic unit operates in parallel with other arithmetic units, and for each block including the record in charge, the item value access information array using the item value information relating to the predetermined data item as a key Sort is applied to the sorted item value access information array, and a work item value information array and a work record sequence number array corresponding to the sorted item value access information array are created in the global memory. Code to
(b) Each arithmetic unit operates in parallel with other arithmetic units, and the first element from the work item value information array relating to a pair of blocks and the corresponding first number from the work record sequence number array. The element set of two elements is merged in a predetermined order using the first element as the upper digit and the second element as the lower digit, and the merged element set A code for creating a new work item value information array, a new work record sequence number array, and a new block number array related to the pair of blocks, by associating the block numbers included in the set;
(c) Each arithmetic unit operates in parallel and hierarchically with other arithmetic units and repeatedly executes the code (b), thereby generating a final block number array in the global memory; ,
(d) Each arithmetic unit operates in parallel with other arithmetic units and distributes the record sequence numbers in which the elements in the final block number array are stored for each block number specified by the element. A code for arranging in a predetermined order, thereby creating a sorted record sequence number array in the global memory,
Including the program.   An array of records loaded into a computer comprising a plurality of arithmetic units including a dedicated local memory and a global memory connected to the plurality of arithmetic units and including item values corresponding to one or more data items 7. The sorting method according to claim 1, wherein the record of the tabular data constructed in the global memory is rearranged according to an item value relating to a predetermined data item. A computer program product that causes a computer to execute.   An array of records loaded into a computer comprising a plurality of arithmetic units including a dedicated local memory and a global memory connected to the plurality of arithmetic units and including item values corresponding to one or more data items 7. The sorting method according to claim 1, wherein the record of the tabular data constructed in the global memory is rearranged according to an item value relating to a predetermined data item. A recording medium on which a computer program to be executed is recorded.

Images