JPH11296487A - System and control method for distributed shaped memory - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a distributed shared system which can extended a data structure that counts a frequency of appearance of an item during counting the frequency of appearance of the item. SOLUTION: When a data structure is extended during counting by a process 11, a lock is first acquired by a distributed lock acquisition part 24, exclusive control of data structure extension operation is performed, and extension of the data structure is executed by a data structure expansion part 26 in a shared memory space. At this time, a data structure extension log 30 is recorded by a data structure expansion log recording part 28, and is transferred to another node 100 by a data structure extension log transfer part 31 at the time of lock release by a distributed lock release part 25. Then, this transferred data structure expansion log 30 is received by a data structure extension log reception part 29 in each node 100, and is reflected upon each data structure by a data structure extension log reflection part 27.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] The present invention relates to, for example, TB
The present invention relates to a distributed shared memory system and a distributed shared memory control method suitable for being applied to a distributed memory type multiprocessor system for executing large-scale data mining of (terabyte) order or the like.

[0002]

2. Description of the Related Art In recent years, with the development of barcode technology and the like, retailers such as supermarkets have accumulated a large amount of sales data. In addition, advanced retailers have increased the sales by analyzing the accumulated large amount of sales data and reflecting it in store layouts and the like. Such a technique is generally called data mining.

[0003] There are several types of information required by this data mining, but the most typical information is an association rule. Association rules are, for example, "50% of customers who buy disposable diapers
Will also buy canned beer together. "
This is an example of a supermarket in the United States, which shows that in the United States young fathers often buy paper diapers, so they often buy canned beer with paper diapers. Therefore, by utilizing such information, for example, by disposing disposable diapers and canned beer close to each other, the sales of canned beer can be increased. How to find this association rule is R.A.
grawal et al., “Mining Association Rules between
Sets of Items in Large Databases ”, Proceedings
of ACM SIGMOD, May 1993. This is briefly shown below.

A set of attributes (items) is defined as I = Ｉi1, i
2, ..., im}, the transaction database is D =
{T1, t2,..., Tn}. Here, ti
Consists of a set of items. The association rule is defined as X => Y. Here, X and Y are subsets of I, and a common set of X and Y is an empty set. Here, two evaluation values, a support value and a confidence value, are defined. The support value indicates a ratio of D including X, and the confidence value indicates a ratio of transactions including both X and Y among transactions including X in D.
The extraction of association rules is performed according to the following procedure. (1). Find an item set that satisfies the minimum support value (this is called a frequent item set). (2). From the frequent item set obtained in (1), find an association rule that satisfies the minimum confidence value. An example of association rule extraction is shown below. As a transaction, T1 = {1, 3, 4},
T2 = {1,2,3,5}, T3 = {2,4}, T4 =
It is assumed that {1, 2} and T5 = {1, 3, 5}. Then, the minimum support value of 60 from this transaction
Find association rules with%, minimum confidence value 60%. Then, the frequent itemset is
In {1}, {2}, {3}, {1, 3}, 1 => 3 is found as the association rule.

Apriori's algorithm is known as a method for efficiently processing the extraction of the frequent item set. This Apriori algorithm is based on R. Agraw
al et al., “Fast Algorithms for Mining Associati
on Rules ”, Proceedings of 20th VLDB, 1994. This is briefly described as follows: (1) Read the transaction database and count the number of occurrences of each item to obtain a support value. Counting the number of occurrences of an item refers to counting how many times each item has appeared in the transaction database.
This means this. (2). Those that satisfy the minimum support value are extracted and set as a frequent item set of length 1. (3). A combination of two items is created from a frequent item set of length 1. These are referred to as a length-2 candidate item set. (4). Search the transaction database for support values. (5). An item satisfying the minimum support value is extracted and set as a frequent item set of length 2. (6). Hereinafter, the processing in the case of the length k (> = 2) is as follows. (A). A candidate item set of length k is created from a frequent item set of length k-1. (B). Search the transaction database for support values. (C). An item satisfying the minimum support value is extracted and set as a frequent item set of length k. (7). The above processing is repeated until the frequently-used item set becomes empty.

As described above, in the conventional data mining, in order to find an association rule,
Basically, it used this Apriori algorithm. A data mining process based on Apriori's algorithm is processed in parallel on a distributed memory type multiprocessor computer having no shared memory, thereby enabling high-speed processing of TB order transactions. As Japanese Patent Application No. 9-341
No. 384 exists.

In Japanese Patent Application No. 9-341384, a distributed shared memory is provided so that a distributed memory type multiprocessor computer does not require a distributed memory type programming model involving communication, and a serial processing is performed. It allows programs to be developed using the shared memory model, which is a natural extension from.

In the Apriori algorithm, transaction data is sequentially read and the appearance frequency of each item is counted. The transaction data referred to here is, for example, a single shopping receipt such as a disposable diaper or a canned beer in POS data of a supermarket.

FIG. 8 is a diagram showing an example of transaction data processed in Japanese Patent Application No. 9-341384. In FIG. 8, the first transaction data is a, b, c
It contains three items. The second transaction data includes five items a, b, d, e, and x. The items a and b correspond to disposable diapers, canned beers, and the like in POS data of a supermarket.

FIG. 9 is a flowchart showing a processing flow of a program for executing Apriori's algorithm which is a technique for efficiently extracting a frequently-used item set.

First, a candidate item set of length 1 is created (step A1). Here, the item set having a length of 1 indicates a set of items including only one element such as {a} or {b}. Next, the transaction data 17 is read, the appearance frequency of each item is counted,
A support value is obtained (step A2). Then, an item satisfying the minimum support value is extracted, and a frequently-used item set having a length of 1 is created (step A3).

Next, from the frequent item set of length 1, 2
A combination of two items is made (step A4). This is a candidate item set of length 2. That is, length 2
Is a set of items consisting of two elements such as {a, b} and {a, c}. Then, the transaction data 17 is read, the appearance frequency of each item is counted, and the support value is obtained (step A).
5) Take out the item that satisfies the minimum support value,
A frequent item set of length 2 is created (step A6).

Here, it is checked whether or not the frequent item set of length k (> = 2) is empty (step A7). If it is empty (YES in step A7), the process is terminated. on the other hand,
If it is not empty (NO in step A7), 1 is added to k (step A8), and a candidate item set of length k is created from the frequently-used item set of length k-1 (step A).
9). Then, the transaction data 17 is read, the appearance frequency of each item is counted, a support value is obtained (step A10), an item that satisfies the minimum support value is extracted, and a frequent item set of length k is created (step A11). The above-described processing is repeated from step A7.

FIG. 10 shows a hash table 16 that manages the path 1 that is counted in the frequent item set extraction process shown in FIG. 9, that is, the statistical information 15 that includes the type and appearance frequency of an item having a length of 1. It is shown. {A}, {b}, and {c} in FIG. 10 indicate the type of item, and a blank portion thereafter indicates a region for counting the appearance frequency of the item.

FIG. 11 shows a hash table which manages the path 2 to be counted in the frequent item set extraction process shown in FIG. 9, that is, the statistical information 15 including the type and the appearance frequency of the item of length 2. 16 is shown. {A, b}, {a, c} in FIG.
And {a, d}, etc., indicate the type of item composed of two elements, and the blank portion thereafter indicates an area for counting the appearance frequency of the item.

FIG. 12 shows the structure of the counting log, in which the address of an area for counting the frequency of appearance of the counted items is recorded every time counting is performed. And Japanese Patent Application No. 9-3413
In No. 84, this counted log is transferred to another node,
By reflecting this on other nodes, the consistency of the distributed shared memory of each node is maintained. Since the area for counting the appearance frequency is located on the distributed shared memory, any node has the same address.
Therefore, the counting log may be such address information.

[0017]

By the way, the aforementioned Ap
In the processing of the riori algorithm, it is not assumed that the data structure that counts the appearance frequency changes during counting. For this reason, Japanese Patent Application No. 9-341384 mentioned above does not include any means for expanding a data structure for counting the frequency of occurrence during counting.

However, for example, up to a certain point in time, eight items a, b, c, d, e, f, g, and h are counted, but while the results of these counting are retained, From then on, it is sufficiently conceivable that it is desired to newly count the item j. In such a case, for example, it is necessary to extend the data structure as shown in FIG. The data structure shown in FIG. 13 is a hash structure (hash link)
It is. As shown in FIG. 13A, before expansion, a, b,
Although there were only eight entries of c, d, e, f, g, and h, as shown in FIG. 13B, after expansion, j is added to nine entries. As a result, if any of the eight entries a, b, c, d, e, f, g, and h has been counted before the expansion,
Any one of the nine entries obtained by adding j to this can be counted.

On the other hand, as described above, Japanese Patent Application No. 9-341
No. 384 has a problem that such a request cannot be satisfied because there is no means for expanding a data structure for counting the frequency of appearance during counting.

The present invention has been made in view of the above circumstances, and has a distributed shared memory system capable of expanding a data structure for counting the frequency of appearance even during counting. An object of the present invention is to provide a control method of a distributed shared memory applied to the system.

[0021]

The present invention is a distributed shared memory system applied to a distributed memory type multiprocessor system in which a plurality of computers are loosely coupled, wherein each of the plurality of computers is connected to another computer. A shared memory space providing means for providing a shared memory space commonly accessible at the same address as a process operating on the same computer to a process operating on the same computer; and a process operating on the same computer is extracted from input data. Data structure creating means for creating, in the shared memory space, a data structure holding the frequency of appearance for each set of specific items to be executed, and operating on the same computer for the frequency of appearance held in the data structure A counting history acquisition means for acquiring a counting history of the process; Counting history transfer means for transferring the counting history acquired by the counting history acquisition means to the other computer, counting history receiving means for receiving the counting history transferred from the other computer, and reception by the counting history receiving means. In a distributed shared memory system comprising counting history reflecting means for reflecting the counted counting history in the appearance frequency held in the data structure, a data structure extension for extending the data structure to each of the plurality of computers. Means, an extension history acquisition means for acquiring a history of extension of the data structure by the data structure extension means, and an extension history transfer means for transferring the extension history acquired by the extension history acquisition means to the other computer And receive the extended history transferred from the other computer Extended history receiving means, extended history reflecting means for reflecting the extended history received by the extended history receiving means in the data structure, and the data structure operating on the same computer for extending the data structure Extended exclusive control means for performing exclusive control between the extended means and the extended history reflecting means and the data structure extending means and the extended history reflecting means operating on the other computer; and The data structure can be extended during counting of the number of operating processes.

Also, the present invention is characterized in that the extended history transferred by the extended history transferring means and the counting history transferred by the counting history transferring means are temporarily stored in each of the plurality of computers, and the other computers are temporarily stored. A log batch transfer means for batch transfer to a computer is further provided.

Further, the present invention is characterized in that the history batch transfer means has means for rearranging the accumulated extension history and counting history so that the extension history is transferred before the counting history. And

Further, the present invention is characterized in that an arbitrary operation that satisfies the exchange rule (a + b = b + a) is performed on the data held in the data structure. Further, the invention is characterized in that the data structure is configured in an arbitrary format.

[0025]

Embodiments of the present invention will be described below with reference to the drawings. FIG. 1 is a diagram showing a schematic configuration of a distributed memory multiprocessor system according to an embodiment of the present invention and functional blocks of a distributed shared memory system applied to the distributed memory multiprocessor system.

Each of the nodes 100 includes one or more processors, memories, and I / O devices, and these nodes 100 are connected to each other via a network 200.

On each of these nodes 100, process 1
1 operates, and in the address space of each process 11, as shown in FIG. 2, there is a shared memory space 12 that is common to all processes 10 (at the same address).
This shared memory space 12 includes a shared memory space providing unit 13
Provided by

In the shared memory space 12, a hash table 16 having a hash structure is created by the data structure creating unit 14 in the shared memory space, and statistical information 15 including the type of item and the frequency of appearance is stored. Here, the item is, for example, P of a supermarket.
In terms of OS data, it indicates a product item such as a disposable diaper or canned beer.

When the process 11 reads the transaction data 17, the statistical information 15
The item appearance frequency counting unit 18 counts the appearance frequency of the item. The transaction data referred to here is, for example, a single shopping receipt such as a disposable diaper or a canned beer in POS data of a supermarket.

FIG. 1 shows that each node has only one disk device, and all transaction data 17 is stored therein.
Many disk devices exist in each node 100, and the transaction data 17 is divided and held. For example, since 1 TB of transaction data requires 500 units of a 2 GB disk unit, for example, in a 10-node system, 50 disk units are connected to each node. Then, 1 TB of transaction data is divided and stored in 500 disk devices of 10 nodes.

When the item appearance frequency counting unit 18 of the process 11 counts the item appearance frequency, the counting log recording unit 19 of the process 11 simultaneously records a counting log 20 which is a history of the counting. Then, the recorded counting log 20 is transferred to another node 100 by the counting log transfer unit 21.

The transferred counting log 20 is received by the counting log receiving unit 22 in each node 100, and is reflected in the shared memory space 12 of each node 100 by the counting log reflecting unit 23.

The "counting" here means, for example,
That is, the transaction data 17 is read, and the appearance frequency of the item included therein is incremented. Therefore, the “counting log” is an address of an area for recording the appearance frequency of the item. An area for recording the appearance frequency of this item is secured in the shared memory space 12, so that the process 11 on any node 100 can access the same address. Therefore, if the address of the area for recording the appearance frequency of the item is sent as the counting log 20, the node 100 that has received the address increments the value of the area indicated by the address, and the other node 100
Can be reflected in its own node 100, so that it is possible to maintain consistency of data in the shared memory space 12, which appears to be common among the nodes 100.

Further, in the distributed shared memory system in this embodiment, the distributed lock acquisition unit 24, the distributed lock release unit 25, the data structure extension unit 26 in the shared memory space,
The provision of the data structure extension log reflection unit 27, the data structure extension log recording unit 28, the data structure extension log reception unit 29, and the data structure extension log transfer unit 31 enables the hash table 16 to be extended during counting. . This is the feature of the present invention. Hereinafter, expansion of the hash table 16 during the counting is described.

In order to extend the hash table 16 while the process 11 is enumerating in each node 100, first, the distributed lock acquisition unit 24 acquires a lock related to the extension of the hash table 16 and extends the data structure. Performs exclusive control of operations.

Next, the hash table 16 in the shared memory space 12 is expanded by the data structure expansion unit 26 in the shared memory space. At this time, the data structure extension log recording unit 28 records the data structure extension log 30.

When the lock is released by the distributed lock release unit 25, the recorded data structure extension log 30 is transferred to another node 100 by the data structure extension log transfer unit 31.

The transferred data structure extension log 30 is received by the data structure extension log reception unit 29 at each node 100 and is reflected on the hash table 16 of the node 100 by the data structure extension log reflection unit 27. .

FIG. 3 shows the above-mentioned Japanese Patent Application No. 9-341384.
FIG. 11 is a diagram showing a state where nodes (0) and (1) are counted in parallel by the distributed shared memory system indicated by a symbol. Here, for convenience of explanation,
It is assumed that the log recording buffer can store only a maximum of four logs, but in practice, it is usually set to a size that can store thousands or more logs.

At node (0), a, b, c, and d are counted and stored in a buffer. When the buffer becomes full, it is transferred to node (1).
It is also reflected on node (1). Similarly, at this time, 1, 2, 3, and 4 are counted at node (1).
It is stored in the buffer, and when the buffer is full, it is transferred to node (0) and reflected on node (0). This is an example in which the data structure, that is, the hash table 16 is not expanded.

On the other hand, FIG. 4 is a diagram showing a state in which the nodes (0) and (1) count up in parallel by the distributed shared memory system of this embodiment. At the node (0), the lock is acquired at time t1, and the data structure, that is, the hash table 15 is extended.
At 3, the lock is released.

The data structure extension log x indicating the extension of the hash table 15 is stored (a, b, x, c) in the buffer together with the enumeration logs a, b, c, and transferred to the node (1). Reflected on node (1).

On the other hand, the node (1) also issues a lock acquisition request at time t2. However, at that time, since the lock has already been acquired by the node (0), the lock cannot be acquired immediately, and the process waits until time t4.

Thereafter, at time t4, node (0)
Is released, the lock can be acquired by the node (1), the hash table 16 is extended, and the lock is released at time t5. Then, the data structure extended log Y at this time is stored in the buffer together with the counted logs 1, 2, 3 (1, 2, Y,
3) is transferred to the node (0) and reflected on the node (0).

Then, at time t6, the lock acquired by the node (1) is released. As described above, the distributed shared memory system of this embodiment has a mechanism for exclusively controlling the expansion of the hash table 15 between the nodes 100, thereby enabling the expansion of the hash table 15 during the counting operation.

FIG. 5 shows an example in which the method shown in FIG. 4 is modified. The log in the buffer is transferred before transferring the counted log and the data structure extension log stored in the buffer to another node. The arrangement order is rearranged such that the data structure extension log comes first, and the counted log comes later.

In this example, although the number of logs stored in the buffer is small (4), since a large number of logs are actually stored, the data structure extension log is arranged first. On the node that receives it, the data structure is expanded first, so that the lock can be released before all the logs in the buffer are reflected.

FIG. 6 shows an example in which the method shown in FIG. 5 is further modified. When the data structure extension log is stored in the buffer, even if the buffer is not full, the data is stored in the buffer at that time. The stored data structure extension log and the counted log are immediately transferred to another node 100.

FIG. 7 is an example showing still another method. Here, the buffer of the enumerated log and the buffer of the data structure extension log are separated, and when releasing the lock, the data structure extension log is sent prior to the enumeration log and reflected on other nodes. That is, at the node (0), first, a and b are counted up, then the lock is acquired at time t1, the data structure is extended, and the lock is released at time t3. Then, only the data structure extension log x is transferred from the node (0) to the node (1), and is also reflected on the node (1).

Thereafter, at the node (0), c,
Counting of d is performed. At this time, since the buffer becomes full, the counting log is sent from the node (0) to the node (1), and is reflected on the node (1).

On the other hand, at node (1), a lock acquisition request is issued at time t2.
Waited because node (0) has acquired the lock,
Acquired when the node (0) releases the lock at time t3.

Then, the data structure is extended at the node (1), and the lock is released at time t4. At this time, the data structure extension log Y is transferred from the node (1) to the node (0), and is also reflected on the node (0).

Thereafter, at node (1),
4 is counted. At this time, since the buffer becomes full, the counting log is sent from the node (1) to the node (0) and is reflected on the node (0).

As described above, in the examples shown in FIGS. 5 to 7, "counting" and "data structure extension" executed at a certain node are performed.
By changing the order of the operations with the other nodes, the execution efficiency is enhanced by changing the order.

Further, since the "data structure expansion" operation is merely moved before the "enumeration" operation, there is no inconsistency in the processing. In the above-described embodiment, the process of counting the number of occurrences of a data item in the Apriori algorithm is described as an example. However, the scope of the present invention is not limited to this.

That is, the present invention can be applied to all processes such as the tabulation process that satisfy the exchange rule (a + b = b + a). Further, the data structure stored in the distributed shared memory is not limited to the hash table, but can be widely applied to arrays, queues, networks, and the like.

[0057]

As described above in detail, according to the present invention, the expansion of the data structure constructed in the distributed shared memory can be exclusively controlled between a plurality of computers, so that during the counting operation, The data structure can be expanded, and it is possible to flexibly cope with the addition of items to be counted.

[Brief description of the drawings]

FIG. 1 is a diagram showing a schematic configuration of a distributed memory type multiprocessor system according to an embodiment of the present invention and functional blocks of a distributed shared memory system applied to the distributed memory type multiprocessor system.

FIG. 2 is a view showing an internal configuration of a process according to the embodiment.

FIG. 3 is a diagram showing a state in which counting is performed in parallel at a node (0) and a node (1) by a conventional distributed shared memory system.

FIG. 4 is an exemplary view showing a case where nodes (0) and (1) are counted in parallel by the distributed shared memory system according to the embodiment;

FIG. 5 shows the arrangement order of the logs in the buffer before transferring the counted log and the data structure extended log stored in the buffer to another node, so that the data structure extended log comes first and the counted log comes later. FIG. 5 is a diagram showing an example of a case where the method shown in FIG.

FIG. 6 is a diagram showing a configuration in which, when a data structure extension log is stored in a buffer, even if the buffer is not full, the data structure extension log and the counting log stored in the buffer at that time are immediately transferred to another node. FIG. 6 is a diagram showing an example when the method shown in FIG. 5 is further modified.

FIG. 7 is a diagram showing an example of separating the counted log buffer and the data structure extended log buffer according to the embodiment, sending the data structure extended log prior to the counted log, and reflecting it on another node when releasing a lock; .

FIG. 8 is a diagram showing an example of transaction data in a conventional distributed shared memory system.

FIG. 9 is a flowchart showing a processing flow of a program for executing Apriori's algorithm, which is a technique for efficiently processing the extraction of a frequent item set.

FIG. 10 is a diagram showing a hash table for managing statistical information including the type and appearance frequency of an item having a length of 1, which is counted in the frequent item set extraction process shown in FIG. 9;

FIG. 11 is a diagram showing a hash table for managing statistical information including the type and appearance frequency of an item having a length of 2, which is counted in the frequent item set extraction process shown in FIG. 9;

FIG. 12 is a diagram showing the structure of a counting log of a conventional distributed shared memory system.

FIG. 13 is a diagram showing an extension of a data structure of a conventional distributed shared memory system.

[Explanation of symbols]

11: Process, 12: Shared memory space, 13: Shared memory space providing unit, 14: Data structure creating unit in shared memory space, 15: Statistical information consisting of item type and appearance frequency, 16: Hash table, 17 ... Transaction data, 18 ... Item appearance frequency counting unit, 19 ...
Counting log recording section, 20: Counting log, 21: Counting log transfer section, 22: Counting log receiving section, 23: Counting log reflecting section, 24: Distributed lock acquisition section, 25: Distributed lock release section, 26: Shared memory space Internal data structure extension unit, 27: Data structure extension log reflection unit, 28: Data structure extension log recording unit, 29: Data structure extension log receiving unit, 30: Data structure extension log, 31: Data structure extension log transfer unit, 100 ... node, 200 ... network.

Claims (10)

[Claims] 1. A distributed shared memory system applied to a distributed memory type multiprocessor system in which a plurality of computers are loosely coupled, wherein each of the plurality of computers has the same address as a process operating on another computer. A shared memory space providing means for providing a shared memory space that can be commonly accessed in the same computer to a process operating on the same computer; Data structure creating means for creating a data structure holding the appearance frequency in the shared memory space, and acquiring a history of counting of processes operating on the same computer with respect to the appearance frequency held in the data structure Counting history acquisition means, and counting history acquisition means A counting history transfer unit that transfers the obtained counting history to the other computer, a counting history receiving unit that receives the counting history transferred from the other computer, and a counting history received by the counting history receiving unit. In a distributed shared memory system including a counting history reflecting unit that reflects the appearance frequency held in the data structure, a data structure extending unit that extends the data structure to each of the plurality of computers; An extension history acquisition unit that acquires a history of extension of the data structure by a structure extension unit; an extension history transfer unit that transfers the extension history acquired by the extension history acquisition unit to the other computer; Extended history receiving means for receiving an extended history transferred from the computer, Extended history reflecting means for reflecting the extended history received by the extended history receiving means on the data structure; data structure extending means operating on the same computer for extending the data structure; and extended history reflecting Means and an extended exclusive control means for exclusive control between the data structure extending means and the extended history reflecting means operating on the other computer, wherein the number of processes operating on the plurality of computers is counted up. A distributed shared memory system, wherein the data structure can be expanded during the process. 2. The computer according to claim 1, wherein the extended history transferred by the extended history transferring unit and the counting history transferred by the counting history transferring unit are temporarily stored in each of the plurality of computers and are collectively stored in the other computers. 2. The distributed shared memory system according to claim 1, further comprising: a history batch transfer means for transferring the data. 3. The distributed sharing system according to claim 2, wherein the history batch transfer means includes means for rearranging the accumulated extension history and the count history so that the extension history is transferred before the count history. Memory system. 4. The distributed shared memory system according to claim 1, wherein an arbitrary operation that satisfies an exchange rule (a + b = b + a) is performed on the data held in the data structure. 5. The data structure according to claim 1, wherein the data structure can be constructed in any format.
A distributed shared memory system as described. 6. A distributed shared memory system applied to a distributed memory type multiprocessor system in which a plurality of computers are loosely coupled, wherein each of the plurality of computers has the same address as a process operating on another computer. A shared memory space providing means for providing a shared memory space that can be commonly accessed in the same computer to a process operating on the same computer; Data structure creating means for creating a data structure holding the appearance frequency in the shared memory space, and acquiring a history of counting of processes operating on the same computer with respect to the appearance frequency held in the data structure Counting history acquisition means, and counting history acquisition means A counting history transfer unit that transfers the obtained counting history to the other computer, a counting history receiving unit that receives the counting history transferred from the other computer, and a counting history received by the counting history receiving unit. A control method for a distributed shared memory applied to a distributed shared memory system including a counting history reflecting unit that reflects the frequency of appearance held in the data structure, wherein the expansion of the data structure is performed with the other computer. Executing while performing exclusive control between; acquiring the extension history of the executed data structure; transferring the acquired extension history to the other computer; and Receiving the extended history to be transferred; and Reflecting the data structure in the data structure while maintaining consistency with another computer, and expanding the data structure during counting of processes running on the plurality of computers. A method for controlling a distributed shared memory, the method comprising: 7. The distributed sharing according to claim 6, further comprising a step of temporarily storing the transferred extended history and the counted history and transferring the extended history and the counted history to the another computer at a time. How to control memory. 8. The distributed sharing according to claim 7, further comprising the step of rearranging the accumulated extension history and counting history so that the extension history is transferred before the counting history. How to control memory. 9. The distributed shared memory system according to claim 1, wherein the exchange rule (a +
9. The method according to claim 6, wherein any operation that satisfies b = b + a) is performed. 10. The method according to claim 6, wherein the data structure can be constructed in any format.