JP4409604B2 - Overlay network construction and maintenance method and program - Google Patents

Description

  The present invention relates to an overlay network construction / maintenance method and program suitable for constructing / maintaining an overlay network using a skip table.

  In recent years, research and development of a technique for constructing and maintaining an overlay network of a peer-to-peer system (P2P system) or a system using the technique has been increasing. There are various methods for constructing and maintaining an overlay network of this P2P system, and among them, Tapestry centered on University of California, Berkeley (UCB) (see Non-Patent Documents 1 and 2), Attention has been focused on Pastry (see Non-Patent Documents 3 and 4) centered on Microsoft Corporation and Chord (Code) (see Non-Patent Documents 5 and 6) centered on Massachusetts Institute of Technology (MIT).

  What is common to these methods is that an overlay network is constructed by using consistent hashing (consistent hashing) in which the proximity of IDs (identifiers) is managed by a ring.

What is Consistent Hashing?
1) All nodes (computers connected to the network) and objects (a group of data such as files to be stored in the computer) have unique identifiers on the network that they have (for example, a host name or IP address for nodes) (Internet Protocol) address, if it is an object, its name and data itself)
2) The hash value of the node identifier obtained from the node ID is the node ID, and the hash value of the object identifier is the object ID.
3) The object is stored in the node having the node ID closest to the object ID (the definition of proximity will be described later).
It is a technology. Each node bears a part of the hash space, and one hash space is formed by all the nodes constituting the overlay network, so this technique is generally called “distributed hash table (DHT)”.

  In order to store an object or to retrieve a stored object, it is necessary to search for a node having a node ID closest to the object ID. Hereinafter, the operation of obtaining the node ID and identifier of the node having the node ID closest to the ID (of the node or object) will be referred to as “reference”.

Hereinafter, an overlay network construction method using the algorithm “Cord” shown in Non-Patent Documents 5 and 6 will be mainly described.
In Chord, IP address hash value the node ID of the node, as an object ID to the hash value of the data itself of the object, 2 all can take the ID (0 to N = 2 ^m -1 ^m pieces of ID, m is hashed Each ID is fitted on a ring (m-bit ring) that can accommodate the number of output bits of the function (160 bits SHA1 is used in the literature). On the ring, the proximity of the two IDs is measured by how far the two IDs are clockwise. A ring that can accommodate 2 ^m IDs is called an m-bit ring.

  FIG. 15 shows a ring when m is 3 (so-called Chord ring), that is, a 3-bit ring. In FIG. 15, eight circles arranged on the ring indicate IDs, and binary numbers 000 to 111 described in the vicinity of the circles indicate corresponding IDs themselves. The arrangement of ID 000 to ID 111 in FIG. 15 indicates the positional relationship of IDs that can be taken on a 3-bit ring.

  In FIG. 15, for example, the ID closest to ID 000 is ID 000 itself, and the next closest ID is ID 001 (note that it is not ID 111). Similarly, the ID closest to ID 111 is ID 111 itself, and the next closest ID is ID 000 (note that it is not ID 110).

In the 3-bit ring (corresponding to the overlay network) shown in FIG.
Node ID 000 / IP address 10.0.1.1
Node ID 001 / IP address 192.168.3.1
Node ID 011 / IP address 10.0.0.1
Node ID 100 / IP address 192.168.1.5
Node ID 110 / IP address 192.168.100.3
Node ID 111 / IP address 192.168.0.1
Suppose a node with In this case, the ring (corresponding to the overlay network) is as shown in FIG. In FIG. 16, the IP address of the node having the ID is written in the vicinity of the ID (node ID).

  Here, for any ID, the node that first encounters on the ring in the clockwise direction (that is, the node that has the closest node ID except for itself) is the successor (succeeding adjacent node), and first encounters counterclockwise (that is, A node having the farthest node ID excluding itself is called a predecessor (preceding adjacent node).

  For example, the successor of the node with the node ID 000 is the node with the node ID 001, and the predecessor is the node with the node ID 111. Further, the successor of the node with the node ID 100 is the node with the node ID 110, and the predecessor is the node with the node ID 011.

  In Chord, a node participating in the overlay network forms a ring as shown in FIG. 16 by forming a link with its successor and predecessor. Each node holds and manages the node ID and address (IP address) of its successor and predecessor. The node IDs and addresses of these successors and predecessors are held and managed using a table called an adjacent table. For a method of forming and maintaining a ring as shown in FIG. 16 by each node knowing its own successor and predecessor ID and address and forming a link with them, see Non-Patent Document 5 or 6. .

  In Chord, an object is stored in a node having a node ID closest to the object ID of the object.

  FIG. 17 shows a range of object IDs of objects stored in the respective nodes in the example of FIG. In FIG. 17, the object ID is described in a rectangular frame. For example, the object with object ID 000 is stored in the node with node ID 000, and the object with object ID 010 is stored in the node with node ID 011.

Here, the reference will be described.
References are the following inputs and outputs Input: ID (of object or node)
Output: Refers to a series of operations for performing the node ID and address of the node having the node ID closest to the input ID.

As a method for realizing the reference in the overlay network (ring) shown in FIG. 16, the following two <First method>
How each node participating in the overlay network knows the addresses of all other nodes participating in the network (broadcast)
<Second method>
A method of relaying a search request by tracing an adjacent table (full-flooding)
It has been known.

Each of these two methods has the following advantages and disadvantages.
<Advantages and disadvantages of the first method>
Advantage: It takes no time to reach the target, and all searches are not interrupted by a failure on the route.
Disadvantages: It is necessary to monitor the participation status (join / leave / abnormal stop) of all nodes participating in the overlay network.

<Advantages and disadvantages of the second method>
Advantage: Each node does not need to monitor the participation status (join / leave / abnormal stop) of all nodes participating in the overlay network.
Disadvantages: It takes time to reach the target and is not reliable because full flooding fails due to a failure on the route.
Either method may not work as the overlay network grows in size.

  Therefore, in Chord, an algorithm is used in which each node prepares m shortcut paths, so that the reference is completed with a search request transfer of at most m hops. Information on the m shortcut paths is held and managed using a table called a skip table (finger table).

  In the skip table, m shortcut paths (information thereof) are described (held) where m is the number of bits of the ring as described above. Each of the m shortcut paths is generated based on the following generation rule, where each node ID (node ID) is represented by “id” and each address (IP address) is represented by “addr”.

That is, each of the m shortcut paths is related to i = {0 ... m−1}.
skip [i]. interval _start
= (Id + 2 ⁱ ) mod 2 ^m
skip [i]. interval _end
= Skip [(i + 1) mod m]. interval _start
skip [i]. successor. id
= ID skip [i]. ID of the node with the node ID closest to interval _start
However, skip [0]. successor. Note that id is the node ID of the node that will be its successor skip [i]. successor. addr
= ID skip [i]. The address (IP address) of the node with the node ID closest to the interval _start
However, skip [0]. successor. The addr is generated based on attention that it is the address of the node that is the successor of itself.

In Chord, the reference using the skip table is realized as follows.
Process 1)
The node that starts the reference selects the shortcut path information to the node having the ID farthest from the input ID (that is, the node that becomes the predecessor) from the shortcut path information held in its own skip table. Then, a next inquiry destination is inquired to the node indicated by the selected information.

Process 2)
The node that received the inquiry selects the shortcut path information to the node having the ID farthest from the input ID from the shortcut path information held in its own skip table, and the selected information Is returned to the node that starts the reference. However, if the node ID of the node that is farthest from the input ID is farther than the node ID of the node that is farthest from the input ID, the node that starts the reference returns its own address along with the completion of arrival. To do.

Process 3)
The node that receives the answer, that is, the node that starts the reference makes an inquiry to the node indicated by the answer, that is, the next inquiry destination. Thereby, the process 2 is executed again. However, when the completion of arrival is answered, the following process 4) is executed.

Process 4)
The node that has started the reference acquires the node ID and address of the successor of the destination node from the destination node. The acquired node ID and address become a reference output (result).

  The skip table is used for speeding up the reference (that is, enabling a reference with a smaller number of hops compared to the search request forwarding using the adjacent table). However, the number of links to be managed in the skip table is larger than that in the adjacent table, and joining / leaving of nodes to be managed in the skip table occurs asynchronously. For this reason, it is difficult to maintain the skip table in a state where the node to be managed by the skip table is accurately pointed. Chord considers this point, and even if the skip table is not perfect (that is, when routing is not performed at the shortest distance), the reference is valid. The details are described in Non-Patent Documents 5 and 6.

  In order to construct and maintain the above skip table, Chord offers the following two methods.

<Method by exact model>
When a node participates in an overlay network, it constructs its own skip table and notifies the node that it is necessary to modify the skip table as a result of its participation.

<Method by non-strict model>
After joining the overlay network, the node periodically selects one of the m shortcut paths described in its skip table and updates the skip table with respect to the selected shortcut path. .

The prior art relating to the reference using the skip table and the configuration / maintenance of the skip table has been described above using the Chord described in Non-Patent Documents 5 and 6 as an example.
Japanese Patent Application Laid-Open No. 2004-266796 http: // p2p. cs. ucsb. edu / chimera / Ben Y. Zhao, Ling Huang, Jeremy Striving, Sean C. Rhea, Anthony D. Joseph, and John D. Kubiatoicz. “Tapestry: A Resilient Global-Scale Over for Service Deployment”, IEEE Journal on Selected Areas in Communications, Vol. 1, (2004) http: // research. Microsoft. com / ~ antr / PAST / default. htm A. Rowstron and P.M. Druschel, “Storage management and caching in PAST, a large-scale, persistent peer-to-peer storage utility”, 18th ACM SOSP'01, Lake Louise, Alberta, Alberta, Alberta, Alberta, Alberta, Alberta, Alberta, Alberta, Alberta, Alberta, Alberta, Alberta, Alberta http: // pdos. csail. mit. edu / chord / Ion Stoica, Robert Morris, David Karger, M .; Trans Kaashhoek, and Hari Balakrishnan, “Cord: A Scalable Peer-to-peer Lookup Service for Internet Applications”, ACM SIGCOMM 2001, (2001).

  In the method of constructing an overlay network by using the adjacency table and the skip table as in the above-described Chord, when the configuration of the overlay network changes due to joining / leaving a node, the adjacency table and the skip table are reconstructed. There is a need. That is, to maintain the overlay network itself, it is necessary to maintain the adjacency table correctly. Also, it is desirable to maintain the skip table correctly in order to perform the reference faster.

  From this point of view, the skip table construction / maintenance method using the strict model and the non-strict model such as Chord has the following problems.

<Method by exact model>
When a node joins, the skip table must be completed, and the node that needs to update the skip table as a node joins / leaves is notified of the update and must wait for the completion of all update processes. Don't be. For this reason, it takes time to join / leave the node to / from the overlay network.

<Method by non-strict model>
The skip table managed by each node is periodically updated. Accordingly, even when a node joins / leaves the overlay network after the skip table is updated, the skip table is not updated until the next update. Therefore, it is necessary to continue using the skip table before update until the update time of the skip table comes. Even when the skip table is not required to be updated, it is necessary to periodically check whether the update is necessary. That is, the update process is wastefully performed even when the skip table is not used. In Chord, since the shortcut path to be updated in the skip table is selected at random, the update interval for each shortcut path is not constant.

  The present invention has been made in view of the above circumstances, and an object thereof is to provide an overlay network construction / maintenance method and program capable of reducing the cost required for update processing of a skip table used for managing an overlay network. There is to do.

  According to one aspect of the present invention, there is an overlay network composed of a plurality of nodes, each of the plurality of nodes including an m-bit node ID that is an identifier on the overlay network and an underlay network. And the node IDs and addresses of the adjacent nodes following itself when the node IDs of the plurality of nodes are arranged in a ring shape in the order of the node IDs. The adjacent table holding the node ID and address of the adjacent node preceding the node and the target node ID or object ID as inputs, and the address of the node having the node ID closest to the input node ID or object ID Shortcut path information to obtain by sequential inquiry An overlay for constructing and maintaining an overlay network including a node ID and addresses of m nodes other than itself selected according to a predetermined rule among the plurality of nodes. A network construction and maintenance method is provided. In this overlay network construction / maintenance method, when a first node participates in the overlay network, the first node is a second node that is an arbitrary node of the plurality of nodes. Performing a first inquiry for obtaining a node ID and address of a third node that is a node adjacent to the first node in the first direction on the ring; and responding to the first inquiry When the first node obtains the node ID and address of the third node, the first node sends the first node to the third node on the ring with respect to the third node. Performing a second inquiry to obtain a node ID and address of a fourth node that is an adjacent node in a second direction opposite to the direction of When the first node acquires the node ID and address of the fourth node in response to the inquiry, the first node receives the node ID and address of the third node and the node of the fourth node. Building an adjacency table of the first node based on the ID and address; and when the first node joins the overlay network, the first node Initializing the skip table and the target node ID or object ID as input, the first node obtains the address of the node having the node ID closest to the input node ID or object ID by sequential inquiry A reference process for the first node to send the inquiry to the first node. Performing a reference process including a step of updating the shortcut path in a process of transferring to a fifth node which is a node other than the node among the plurality of nodes according to the shortcut path indicated by the skip table. .

  According to the present invention, since the skip table is used in the process of reference (sequential inquiry), it is not necessary to update the skip table if the reference is not performed. By skipping the update of the skip table and updating the skip table in the process of using (referring to) the skip table, it takes less time to join the node to the overlay network than in the prior art. Costs required for table update processing can be reduced. Further, according to the present invention, by updating the skip table when using the skip table, it is possible to prevent unnecessary update processing from occurring, and immediately when the skip table needs to be updated, the skip table is immediately updated. Is updated.

Embodiments of the present invention will be described below with reference to the drawings.
FIG. 1 shows a system configuration of an overlay network system according to an embodiment of the present invention. The overlay network system of FIG. 1 includes an overlay network 10. The overlay network 10 corresponds to a 3-bit ring (Cord ring) and can accommodate a maximum of eight nodes. A node accommodated in the overlay network 10 may be expressed as a node participating in the overlay network 10. The IDs (node IDs) of eight nodes that can be accommodated (participated) in the overlay network 10 are 000,001,010,011,100,101,110,111 in binary notation (0,1,2 in decimal notation). , 3, 4, 5, 6, 7). This set of IDs is expressed as ID = {000,001,010,011,100,101,110,111}. This ID may be expressed as id (or ID id).

  In the example of the overlay network system of FIG. 1, the overlay network 10 includes six nodes 20-0, 20-1, 20-3, 20-4, ID = {000,001,011,100,110,111}. 20-6, 20-7 are participating. These nodes 20-0, 20-1, 20-3, 20-4, 20-6 and 20-7 are indicated by solid circles. Also, in the vicinity of these circles, an address (IP address) is written together with the ID of the corresponding node.

  In FIG. 1, the two nodes 20-2 and 20-5 with ID = {010, 101} indicated by a broken-line circle are not currently participating in the overlay network 10 but can participate in the overlay network 10. Node.

<Hardware configuration of node>
FIG. 2 shows a hardware configuration of the node 20-t. The node 20-t includes not only the nodes 20-0, 20-1, 20-3, 20-4, 20-6, 20-7 participating in the overlay network 10 shown in FIG. It also refers to other nodes that can participate (nodes 20-2 and 20-5).

  In the present embodiment, the node 20-t is a computer. The node 20-t includes a processing unit 21, a main storage device 22, an auxiliary storage device 23, a communication mechanism 24, and an input / output mechanism 25. The auxiliary storage device 23 is configured using, for example, a hard disk drive. The auxiliary storage device 23 stores a program 230 for constructing and maintaining the overlay network 10 in cooperation with each node 20-t. The communication mechanism 24 communicates with a node designated by the control unit 26 in order to construct and maintain the overlay network 10 by the control unit 26 to be described later using an IP address (an underlay network address).

<Functional configuration of node>
FIG. 3 mainly shows a functional configuration of the node 20-t. In the present embodiment, the node 20-t cooperates with other nodes (node 20-t) to configure the overlay network 10 of FIG. 1, for example, and stores / retrieves, for example, objects from the client (client terminal) 40 Process the instruction to direct. An object refers to a group of data stored in a computer.

  The client 40 is connected to the node 20-t by a communication line, for example. The command from the client 40 includes, for example, a command that instructs to store / retrieve an object. That is, the client 40 instructs the node 20-t to store / retrieve the object. In the case of storing an object, the client 40 passes an object including an object ID and data to be described later to a command receiving unit 31 to be described later of the node 20-t, and obtains the result of the object storage success / failure from the command receiving unit 31. . The client 40 also passes the object ID to the command accepting unit 31 of the node 20-t in the case of retrieving an object, and if the node 20-t succeeds in retrieving the object, the command accepting unit of the node 20-t. An object is obtained from 31. In addition, when the node 20-t fails to extract the object, the client 40 receives a notification that the node 20-t has failed from the instruction receiving unit 31 of the node 20-t.

  The node 20-t includes a communication mechanism 24, a control unit 26, a command receiving unit 31, and an object storage unit 32. The control unit 26 processes a command passed from the command receiving unit 31, a command from another node received by the communication mechanism 24, and the like. The control unit 26 includes a configuration information storage unit 27, a table management unit 28, a search unit 29, and an object access unit 30, which are necessary for processing these instructions.

  The command receiving unit 31 receives a command from the client 40. The command receiving unit 31 passes the received command to the control unit 26. The command receiving unit 31 also receives a response to the command (request) passed to the control unit 26 from the control unit 26 and returns it to the client 40.

  The configuration information storage unit 27 is configured using a predetermined storage area of the main storage device 22 shown in FIG. 3, and is used to store configuration information 50-t described later.

  The table management unit 28 manages configuration information 50-t (an adjacent table 52-t and a skip table 53-t described later included in the configuration information 50-t) stored in the configuration information storage unit 27. When the node 20-t including the table management unit 28 participates in the overlay network 10 in FIG. 1, the table management unit 28 constructs the adjacent table 52-t in the configuration information 50-t managed by itself. The table management unit 28 also skips, when a node 20-t including the table management unit 28 participates in the overlay network 10 in FIG. 1, the adjacent nodes on the ring (Cord ring) of the overlay network 10 manage. Using the table, the skip table 53-t in the configuration information 50-t managed by itself is initialized.

  The table management unit 28 further includes a process in which the node 20-t including the table management unit 28 (the search unit 29 therein) performs a reference process (to be described later). In the process of transferring the inquiry to (1), the skip table 53-t in the configuration information 50-t managed by itself is sequentially updated.

  The search unit 29 receives, as an input, the ID of a certain object or node, and performs a reference process for acquiring the node ID and address (IP address) of the node having the node ID closest to the input ID in the configuration information storage unit 27. This is done using the stored configuration information 50-t. For example, when an instruction to store / retrieve an object is passed, the search unit 29 acquires (searches) a node ID and an address (IP address) of a node where the object is to be stored / stored. That is, the search unit 29 searches for a node where an object is to be stored / stored via another node 20-t as indicated by an arrow A1 in FIG. The control unit 26 (search unit 29) requests the searched node to store / retrieve the object, and receives a response from the searched node as indicated by an arrow A2 in FIG.

  The object storage unit 32 is a storage unit that stores objects. The object storage unit 32 is realized using a storage area of an auxiliary storage device corresponding to the auxiliary storage device 23 in the node 20-t shown in FIG. The object access unit 30 of the control unit 26 performs processing for storing an object in the object storage unit 32 and processing for extracting an object from the object storage unit 32.

  In this embodiment, the control unit 26 reads the program 230 stored in the auxiliary storage device 23 into the main storage device 22 in the node 20-t by the processing unit 21 in the node 20-t shown in FIG. It is realized by executing the above.

<Configuration information held by the node>
4 shows an example of the data structure of the configuration information 50-t stored in the configuration information storage unit 27 of the node 20-t shown in FIG. 3, where the node 20-t is a node 20-7 (t = 7). Show about. The configuration information 50-t includes node information 51-t, an adjacent table 52-t, and a skip table 53-t.

The node information 51-t includes an ID id bit number m, an ID id, and an address (IP address) addr.
The ID id bit number m indicates the bit number of the node ID (ID id) of the node 20-t. In other words, the ID id bit number m indicates the space of the overlay network 10 (overlay network space, overlay network hash space). The number of bits. The value of m is common to all nodes. In this embodiment, m = 3.

ID id (id) indicates the node ID of the node 20-t. The number of bits of ID id is indicated by the number of ID id bits m. ID id is a unique ID in the overlay network 10 in which the node 20-t participates. As the ID id, a hash value of the IP address of the node 20-t is used.
The address addr is the IP address of the node 20-t.

  The adjacency table 52-t includes an entry (successive adjacent node information entry) successor that holds information of the subsequent adjacent node of the node 20-t (subsequent adjacent node information) and information of the previous adjacent node of the node 20-t (advanced adjacent). Node (node information) (preceding adjacent node information entry) predecessor. The subsequent adjacent node (successor node) and the preceding adjacent node (predecessor node) of the node 20-t are arranged in ascending order of ids (ID ids) of all the nodes participating in (including) the overlay network 10. When the nodes are arranged in a ring shape, they indicate a node having an id adjacent in the clockwise direction and a node having an id adjacent in the counterclockwise direction from the id of the node 20-t itself. In other words, the subsequent adjacent node of the node 20-t indicates the node that first encounters clockwise from the node 20-t on the ring (having the closest node ID except for the node 20-t itself). The preceding adjacent node refers to a node that first encounters counterclockwise from the node 20-t on the ring (having a node ID farthest from the node 20-t itself).

  The subsequent adjacent node information held in the entry successor of the adjacent table 52-t includes the ID id and IP address addr of the subsequent adjacent node (successor node). On the other hand, the preceding adjacent node information held in the entry predecessor of the adjacent table 52-t includes the ID id and the IP address addr of the preceding adjacent node (precessor node).

  In the following description, the subsequent adjacent node may be called a successor or successor node, and the preceding adjacent node may be called a predecessor or predecessor node. Also, id and addr held in the entry successor are respectively set to successor. id and successor. It is written as addr, and id and addr held in the entry predecessor are respectively predecessor. id and predecessor. Sometimes referred to as addr. Further, the entire information (following adjacent node information) held in the entry successor may be expressed as successor, and the entire information (previous adjacent node information) held in the entry predecessor may be expressed as predecessor.

  The skip table 53-t is a table describing a shortcut path for enabling routing by inquiry transfer with a smaller number of hops. The skip table 53-t corresponds to a finger table described in Non-Patent Documents 5 and 6.

The skip table 53-t holds shortcut path information for each i (i = {0,... M−1}) from i = 0 to i = m−1, where i is a variable. The shortcut path information is skip [i]. interval _start , skip [i]. interval _end , skip [i]. successor. id and skip [i]. successor. It is composed of addr.

skip [i]. interval _start , skip [i]. interval _end , skip [i]. successor. id and skip [i]. successor. Each information of addr is generated based on the following generation rules.

skip [i]. interval _start
= (Id + 2 ⁱ ) mod 2 ^m
skip [i]. interval _end
= Skip [(i + 1) mod m]. interval _start
skip [i]. successor. id
= ID skip [i] .id when the ids of all the nodes participating in the overlay network 10 are arranged in an ascending order and arranged in a ring shape. interval _start the ID clockwise from skip [i]. id of the node having the ID closest to the interval _start (node ID) (see FIG. 5 described later)
However, skip [0]. successor. Note that id is the node ID (successor.id) of the node that is the successor (subsequent adjacent node) of the node 20-t itself. Therefore, if the adjacent table 52-t is correctly maintained, at least the shortcut path (skip [0] .successor.id) of the skip table 53-t is correctly maintained.

skip [i]. successor. addr
= Id (node ID) is skip [i]. successor. id node address (IP address)
However, skip [0]. successor. Note that addr is the address of the node that is the successor of the node 20-t itself. Therefore, if the adjacent table 52-t is correctly maintained, at least the shortcut path (skip [0]. Successor.addr) of the skip table 53-t is correctly maintained.

FIG. 5 shows skip [i]. interval _start and skip [i]. successor. Indicates the relationship with id. skip [i]. The interval _start is skip [i]. successor. This is reference position information indicating a reference position on the ring when id is determined.

  Referring to FIG. 1 again, FIG. 1 shows an example of configuration information 50-7 (t = 7) held by the node 20-7 (t = 7) of the node ID 111 participating in the overlay network 10. It is shown.

In FIG. 1, node information 51-7 (t = 7) included in the configuration information 50-7 of the node 20-7 is
addr: address of the node 20-7 (IPv4 address 192.168.0.1)
id: Node ID of the node 20-7 (111)
m: Number of bits representing the hash space of the overlay network 10 (3)
Consists of

In FIG. 1, the adjacent table 52-7 (t = 7) included in the configuration information 50-7 of the node 20-7 is
successor. {Id, addr}: Node ID and address (000 and 10.0.1.1) of the subsequent adjacent node (successor) of the node 20-7
precessor. {Id, addr}: Node ID and address (110 and 192.168.100.3) of the preceding adjacent node (predecessor) of the node 20-7
Hold.

In FIG. 1, the skip table 53--7 (t = 7) included in the configuration information 50-7 of the node 20-7 is i = {0 ... m-1} = {0 ... 2 }
skip [i]. interval _start : (id + 2 ⁱ ) mod 2 ^m
skip [i]. interval _end : skip [(i + 1) mod m]. interval _start
skip [i]. successor. {Id, addr}: skip [i]. The node ID and address of the node having the node ID closest to the interval _start are held.

  Further, in FIG. 1, the node IDs from the node 20-7 to the skip [0].., Indicated by the shortcut path information held in the skip table 53-7 included in the configuration information 50-7, respectively. successor. id = 000, skip [1]. successor. id = 001 and skip [2]. successor. Also shown are shortcut paths 101, 102 and 103 to nodes with id = 011 (ie nodes 20-0, 20-1 and 20-3).

<Construction and maintenance of overlay network>
Next, a method for constructing and maintaining the overlay network 10 will be described.
First, an outline of processing (mainly construction of an adjacent table and initialization of a skip table) executed by a node Joiner when a node Joiner joins the overlay network 10 will be described. Here, it is assumed that the node Joiner is a node having a node ID of 010 or 101 (that is, the node 20-2 or 20-5).

1. Adjacency table construction process 1a)
The node Joiner (the search unit 29), for any node Introducer already participating in the overlay network 10, uses the address of the node Introducer (Introducer.addr) and uses the Joiner on the Ring (Cord ring). It inquires about the node ID (Successor.id) and address (Successor.addr) of the node Successor that is the successor (subsequent adjacent node). Here, the node Introducer is assumed to be the node 20-0, 20-1, 20-3, 20-4, 20-6 or 20-7.

  In the following description, if the node is A, the node ID of node A is A.D. id, address A. The node ID (A.id) and address (A.addr) of node A are represented as A.addr. {Id, addr} may also be written. Therefore, for example, the node ID and address of the node Successor are the successor. It can be expressed as {id, addr}.

  The node introducer receives the node ID (Joiner.id) of the node Joiner as an input, and sequentially inquires (recursively) with the update process of its own skip table 53-t (hereinafter referred to as the skip table 53-t (J)). A successor (subsequent adjacent node) reference process in routing: Recursive Routing is performed. The successor reference process will be described later. Node Introducer then joiner. The node ID (Successor.id) and the address (Successor.addr) of the node having the node ID closest to the id (hereinafter referred to as node successor) are output (notified) to the node Joiner. The node Introducer that performs the successor reference process corresponds to a node Node described later. Also, Joiner. id and Successor. {Id, addr} is a Target. id and Target Successor. It corresponds to {id, addr}.

  It is assumed that the address of the node Introducer (Introducer.addr) is given in advance to the node Joiner. Here, the address of the node introducer is given to the node joiner when the user operates the input / output mechanism 25 of the node joiner.

Process 1b)
The node Joiner (the search unit 29) uses the address of the node successor (Successor.addr) for the node Successor and becomes a predecessor (preceding adjacent node) of the node Successor in a state before the node joins itself. Queries the node ID (Predecessor.id) and address (Predecessor.addr) of the Precessor.

Process 1c)
The node Joiner (the table management unit 28) requests the node Successor to connect to the node Joiner (connection on the ring).
The node successor (the table management unit 28) performs switching from the node Predecessor to the node Joiner on its own adjacent table 52-t (adjacent table 52-t (S)) as its own predecessor. In addition, the node Successor displays the contents (node ID and address) of the entry affected by the addition of the node Joiner in its own skip table 53-t (hereinafter, skip table 53-t (S)). Node ID and address).

Process 1d)
The node Joiner (its table management unit 28) requests the node Predecessor to connect to the node Joiner (connection on the ring).

  The node Predecessor (the table management unit 28) performs switching from the node Successor to the node Joiner on its own adjacent table 52-t (adjacent table 52-t (P)) as its own successor. Also, the node Predecessor indicates the contents (node ID and address) of the entry affected by the addition of the node Joiner in its own skip table 53-t (skip table 53-t (P)) as Joiner (node ID of the node Joiner). And address).

Process 1e)
The node Joiner (the table management unit 28) requests the node Successor to notify the skip table 53-t (S) of the node Successor.

Process 1f)
The node Joiner (the table management unit 28) requests the node Predecessor to notify the skip table 53-t (P) of the node Predecessor.

2. Initialization of Skip Table The node Joiner (its table management unit 28) constructs (initializes) its own skip table 53-t (J). At this time, the node Joiner does not use the skip table 53-t (J). For this reason, note that the skip table 53-t (J) need not be complete at this point. Here, the skip table 53-t (J) is complete means that skip [i... M−1] .m indicated by m entries of the table 53-t (J). The successor skip [i... m−1]... of all nodes participating in the overlay network 10. It means the node closest to the interval _start .

In the present embodiment, the node Joiner (the table management unit 28) determines skip [i... M−1] .m that holds m entries of the skip table 53-t (J). As the node ID and address of the successor, skip [] is selected from the node IDs and addresses of the nodes held in the skip tables 53-t (S) and 53-t (P) respectively received from the node Successor and Predecessor. i ... m-1]. Select the node ID and address of the node closest to interval _start .

  After the node Joiner joins the overlay network 10, the node Joiner maintains a link (connection) on the ring with its successor (following adjacent node) and predecessor (preceding adjacent node).

  If the node Joiner's successor leaves the overlay network 10 for some reason, the node Joiner immediately forms a link with the node that will be the new successor due to the departure. Similarly, if the node Joiner's predecessor leaves the overlay network 10 for some reason, the node Joiner immediately forms a link with the node that will become the new predecessor due to the departure. Since the method for realizing this is shown in Non-Patent Documents 5 and 6, description thereof will be omitted.

3. Details of Processing in Node Joiner Next, table initialization processing (processing for building an adjacent table and initializing a skip table) in the node Joiner (that is, a node newly participating in the overlay network 10) will be described with reference to FIG. 6A. And 6B will be described.

  First, the node Joiner (the search unit 29) sets the node ID (Joiner.id) of the node Joiner itself as a node ID to be input for the following inquiry (Step S2) (Step S1).

  Next, the node Joiner (the search unit 29) determines that Joiner. With respect to an arbitrary node Introducer already participating in the overlay network 10 with the id as an input, the node ID and address (Successor. { id, addr}) (step S2). This step S2 corresponds to the process 1a.

  In response to the inquiry from the node Joiner, the node Introducer (the search unit 29) outputs the node ID and address (Successor. {Id, addr}) of the node Successor to the node Joiner as a response to the inquiry (Step S3). ). In this node introducer, a successor reference process in recursive routing is performed in order to respond to an inquiry from the node joiner. The successor reference process will be described later with reference to the flowcharts of FIGS. 10A and 10B.

  Next, the node Joiner (the search unit 29), with respect to the node Successor indicated by the response from the node Introducer, the node Predecessor node ID and the address (Predecessor. {Id, addr}) is inquired (step S4). This step S4 corresponds to the process 1b.

  In response to the inquiry from the node Joiner, the node Successor (the search unit 29) receives the node ID and address (Predecessor. {Id, addr}) of the node Precessor that is the predecessor of the node Successor as a response to the inquiry. It outputs to Joiner (step S5).

  Next, the node Joiner (the table management unit 28) sets the node ID and address (Joiner. {Id, addr}) of the node Joiner itself as an input for the following request (Step S7) (Step S6). ).

  The node Joiner (the table management unit 28 thereof) then joins Joiner. Using {id, addr} as an input, the node Successor is requested to connect to the node Joiner (step S7). This step S7 corresponds to the above process 1c). In response to the request from the node Joiner, the node Successor executes connection processing (see FIG. 7) described later.

  Next, the node Joiner (the table management unit 28) sets the node ID and address (Joiner. {Id, addr}) of the node Joiner as an input for the following request (Step S9) (Step S8). ).

  The node Joiner (the table management unit 28 thereof) then joins Joiner. Using {id, addr} as an input, the node Predecessor is requested to connect to the node Joiner (step S9). This step S9 corresponds to the above process 1d). In response to the request from the node Joiner, the node Predecessor executes connection processing (see FIG. 8) described later.

  Next, the node Joiner (the table management unit 28), on its own adjacent table 52-t (J), the node ID and address (Joiner. Successor. {Id, addr}) of its successor (Joiner. Successor) The node ID and address (Successor. {Id, addr}) of the node Successor are set (step S10). In step S10, the node Joiner uses the node ID and address (Joiner. Predecessor. {Id, addr}) of its predecessor (Joiner. Predecessor) on the adjacency table 52-t (J). ID and address (Predecessor. {Id, addr}) are set. In the following description, Joiner. successor. {Id, addr} to Joiner. Sometimes expressed as successor.

  Next, the node Joiner (the table management unit 28) requests the node Successor to notify the skip table 53-t (S) of the node Successor (step S11). That is, in step S11, the node Joiner inquires of the node Successor about the skip table 53-t (S) of the node Successor. This step S11 corresponds to the above process 1e). In the following description, the skip table 53-t (S) of the node Successor will be referred to as Successor. Sometimes expressed as skip.

  In response to an inquiry from the node Joiner, the node Successor (the table management unit 28 thereof) determines the successor of the node Successor. The skip is output to the node Joiner as a response to the inquiry (step S12). As a result, the node Joiner becomes the successor. Of the node Successor. A skip can be acquired.

  Next, the node Joiner (the table management unit 28) inquires of the node Predecessor about the skip table 53-t (P) of the node Predecessor (Step S13). This step S13 corresponds to the process 1f). In the following description, the skip table 53-t (P) of the node Predecessor is referred to as Predecessor. Sometimes expressed as skip.

  In response to the inquiry from the node Joiner, the node Predecessor (the table management unit 28 thereof) determines the Predecessor. The skip is output to the node Joiner as a response to the inquiry (step S14). As a result, the node Joiner makes a predecessor. Of the node Predecessor. A skip can be acquired.

  Next, the node Joiner (the table management unit 28) receives the node ID and address (Joiner. {Id, addr}) of the node Joiner as an input for the following skip table initialization process (step S16), Information on the entry of its own successor (Joiner. Successor) in the adjacency table 52-t (J) is set (step S15). In other words, the node Joiner receives the Joiner. {Id, addr, successor} is set. In step S15, the node Joiner receives the skip table 53-t (S) of the node successor and the skip table 53-t (P) of the node Predecessor acquired in steps S11 and S13 as inputs for the skip table initialization process. ) (That is, Successor.skip and Predecessor.skip).

  Then, the node Joiner (the table management unit 28) receives the input Joiner. {Id, addr, successor}, Successor. skip and Predecessor. Based on the skip, a process (skip table initialization process) for initializing its own skip table 53-t (J) (that is, Joiner.skip) is executed (step S16). This step S16 corresponds to the above process 2. Details of step S16 (skip table initialization processing) will be described later with reference to the flowchart of FIG.

<Connection process in node successor>
Next, a procedure of connection processing performed in the node successor (subsequent adjacent node) in response to a connection request from a node Joiner newly participating in the overlay network 10 will be described with reference to the flowchart of FIG.

  The connection request from the node Joiner includes the node ID and address (Joiner. {Id, addr}) of the node Joiner. The node Successor (the table management unit 28 of the node Successor) has the Joiner. With {id, addr} as an input, connection processing is executed according to the following procedure.

  First, the node Successor has a predecessor. Of its own adjacency table 52-t (S). id (ie Successor.predecessor.id) and predecessor. addr (that is, Successor.precessor.addr) is assigned to Joiner. id and Joiner. Rewrite to addr (step S21).

Next, the node Successor makes Joiner.com with respect to the variable i (i = {0... M−1}). id is in the range [Successor. skip [i]. interval _start , Successor. skip [i]. successor. id) is determined (step S22). Here, x = Joiner. id, y = Successor. skip [i]. interval _start , z = Successor. skip [i]. successor. When it is set as id, “[” in the range [y, z) represents that y is included in the range [y, z), and “)” does not include z in the range [y, z). Represents. For example, if y = 2 (010 in binary notation) and z = 5 (101 in binary notation), the value of x that falls within the range of [y, z) (that is, the range of [2, 5)] is {2, 3, 4} ({010, 011, 100} in binary notation).

If the determination in step S22 is Yes, the node Successor is the current Successor. skip [i]. successor. Joiner. id is the successor. skip [i]. Judged to be close to interval _start . That is, the node Successor has the entry Successor. Of the skip table 53-t (S) when the node Joiner participates in the overlay network 10. skip. Judge that [i] is affected. Therefore, the node Successor has the entry Successor. skip. Successor. In [i]. skip. [I]. successor. id and Successor. skip. [I]. successor. addr, Joiner. id and Joiner. Rewrite to addr (step S23).

On the other hand, if the determination in step S22 is No, the node Successor is the current Successor. skip [i]. successor. id is Joiner. Successor. on the ring than id. skip [i]. Judged to be close to interval _start . That is, even if the node Joiner participates in the overlay network 10, the node Successor has the entry Successor.com in the skip table 53-t (S). skip. [I] is determined not to be affected. In this case, the node Successor skips step S23 (that is, rewrite processing of the skip table 53-t (S)).

  The node Successor repeats step S22 for all i from i = 0 to i = m−1.

<Connection process at node Predecessor>
Next, connection processing performed in the node Predecessor (preceding adjacent node) in response to a connection request from a node Joiner newly participating in the overlay network 10 will be described with reference to the flowchart of FIG.

  The connection request from the node Joiner includes the node ID and address (Joiner. {Id, addr}) of the node Joiner. The node Predecessor (the table management unit 28 thereof) is the Joiner. With {id, addr} as an input, connection processing is executed according to the following procedure.

  First, the node Predecessor has a successor. Of its own adjacency table 52-t (P). id (ie Predecessor.successor.id) and predecessor. addr (that is, Predecessor.successor.addr) is assigned to Joiner. id and Joiner. Rewrite to addr (step S31).

Next, the node Predecessor sets Joiner. For the variable i (i = {0... M−1}). id is in the range [Predecessor. skip [i]. interval _start , Predecessor. skip [i]. successor. id) is determined (step S32).

If the determination in step S32 is Yes, the node Predecessor is the current Precessor. skip [i]. successor. Joiner. id is predecessor. skip [i]. Judged to be close to interval _start In other words, the node Predecessor has the entry Precessor. skip. Judge that [i] is affected. Thus, the node Predecessor has an entry Predecessor. skip. Predecessor. In [i]. skip. [I]. successor. id and Predecessor. skip. [I]. successor. addr, Joiner. id and Joiner. Rewrite to addr (step S33).

On the other hand, if the determination in step S32 is No, the node Predecessor is current Precessor. skip [i]. successor. id is Joiner. Predecessor. on the ring rather than id. skip [i]. Judged to be close to the interval _start . In this case, the node Predecessor skips Step S33 (that is, the rewriting process of the skip table 53-t (P)).

  The node Predecessor repeats the above step S32 for all i from i = 0 to i = m−1.

<Skip table initialization process in Node Joiner>
Next, the procedure of the skip table initialization process (that is, the details of step S16) in the node Joiner will be described with reference to the flowchart of FIG.

  Node Joiner (the table management unit 28 thereof) is the Joiner. {Id, addr, successor}, Successor. skip and Predecessor. With skip as an input, skip table initialization processing is executed in the following procedure.

First, the node Joiner relates to the variable i (i = {0... M−1}) in the entry skip [i] (that is, the entry Joiner.skip [i]) of its own skip table 53-t (J). Of successor. {Id, addr} (that is, Joiner.skip [i]. Successor. {Id, addr) is changed to Joiner. It is set to successor (that is, Joiner.successor. {id, addr}) (step S41). In step S41, the node Joiner enters the entry Joiner. Of the skip table 53-t (J). Interval _start (ie, Joiner.skip [i] .interval _start ) in skip [i]) is set to (Joiner.id + 2 ⁱ ) mod 2 ^m .

  The node Joiner repeats the above step S41 for all i (i = {0... M−1}) from i = 0 to i = m−1.

Next, the node Joiner makes an entry Joiner. Of the skip table 53-t (J) for i = {0 ... m−1}. Interval _end in skip [i]) (i.e., Joiner.skip [i] .interval _end ) is changed to Joiner. skip. [(I + 1) mod m]. The interval _start is set (step S42).

  The node Joiner repeats the above step S42 for all i from i = 0 to i = m−1.

Next, the node Joiner makes a successor.successor for variables i (i = {0 ... m-1}) and j (j = {0 ... m-1}). skip [j]. successor. id is a range on the ring [Joiner. skip [i]. interval _start , Joiner. skip [i]. successor. id) is determined (step S43).

If the determination in step S43 is Yes, the node Joiner is the current Joiner. skip [i]. successor. More than id, Successor. skip [j]. successor. id is Joiner. skip [i]. Judged to be close to interval _start . Therefore, the node Joiner has an entry Joiner. skip. Joiner. In [i]. skip. [I]. successor. {Id, addr} is assigned to Successor. skip [j]. successor. It is rewritten to {id, addr} (step S44).

On the other hand, if the determination in step S43 is No, the node Joiner is the current Joiner. skip [i]. successor. id is the successor. skip [j]. successor. Joiner. on the ring rather than id. skip [i]. Judged to be close to interval _start . In this case, the node Joiner skips step S44 (that is, rewrite processing of the skip table 53-t).

  The node Joiner repeats the above step S43 for all i combinations from i = 0 to i = m−1 and all j combinations from j = 0 to j = m−1. In the present embodiment, the operation of repeating step S43 from j = 0 to j = m−1 for a certain i is repeated for all of i = 0 to i = m−1.

<Reference process at node Node>
Next, in the present embodiment, the reference process executed by the node 20-t participating in the overlay network 10, that is, the ID of a certain object or node is input, and the node ID closest to the input ID is obtained. The reference process for acquiring the node ID and address of the node will be described with reference to the flowcharts of FIGS. 10A and 10B. This reference process is executed when it is necessary to obtain the node ID and address of the node having the node ID closest to the input ID of the node 20-t. Therefore, when the node Joiner is inquired of the node ID and address of the node successor from the node joiner in the step S2, the reference processing is executed in the node introducer. In the following description, the node 20-t that executes the reference process may be referred to as a node Node, and the skip table 53-t included in the node 20-t may be referred to as a skip table 53-t (N).

  In this embodiment, the input (ID) of the reference process is represented by Targetid, and the output of the reference process (the reference result, the node ID and address of the node having the node ID closest to the input ID) is indicated by Status, Target. Successor. id and Target. Successor. It is represented by addr.

  In Targetid, an arbitrary ID (object or node ID) is set. In Status, status information indicating a reference result, that is, whether the reference has succeeded or failed is set. Here, success is indicated when Status = “LOOKUP_REACHED”, and failure (that is, no route) is indicated when Status = “LOOKUP_NOPATH”.

  Target. Successor. In id, the node ID of the node having the node ID closest to Targetid is set. However, in the case of failure, Target. Successor. id is set to NULL. Target. Successor. In addr, the address (IP address) of the node having the node ID closest to Targetid is set. However, in the case of failure, Target. Successor. addr is set to NULL.

  In the case of the reference process in the above-described node introducer, the node Node, Targetid, Target. Successor. id and Target. Successor. addr is a node introduced by nodes Introducer, Joiner. id, Successor. id and Successor. It corresponds to addr.

  The Node (the search unit 29) determines whether or not the node Node itself has the closest node ID with respect to the input Targetid (Step S51). That is, the node Node determines whether its own node ID (that is, Node.id) is closest to the Targetid.

  When the determination in step S51 is Yes, the node Node (the search unit 29) outputs an output Target. Successor. {Id, addr} as its node ID and address, that is, Node. In addition to setting {id, addr}, “LOOKUP_REACHED” indicating success is set as the output status (step S52). In this case, the node Node (the search unit 29) completes the reference process on the assumption that the node has been reached.

  On the other hand, when the determination in step S51 is No, the node Node (the search unit 29) searches for a node that becomes a predecessor with respect to the input Targetid (that is, a node having a node ID farthest from the Targetid) TargetPredecessor. (Step S53).

  In the search in step S53, the node Node (the search unit 29) searches the shortest successor. On the ring within a range not exceeding Targetid from the shortcut paths of the skip table 53-t (N) of the node Node. This is done by selecting a shortcut path indicating id and transferring an inquiry to the link destination node of this shortcut path (that is, an inquiry about a node TargetPredecessor that is a predecessor for Targetid) (step S530). This search method is described in Non-Patent Documents 5 and 6. The successor. Indicating the shortcut path selected here. id is successor.x of the xth entry skip [x] of the skip table 53-t (N). It is assumed that it is id (that is, skip [x]. successor.id).

This embodiment differs from the search methods described in Non-Patent Documents 5 and 6 in that, in the process of searching for a TargetPredecessor, the node Node (the search unit 29) uses not only Targetid but also the target node. It is also to transfer the information of the shortcut path made. Here, the interval _start of the xth entry skip [x] of the skip table 53-t (N) (that is, skip [x] .interval _start ) is used as the information of the shortcut path used. Information on the shortcut path used skip [x]. It should be noted that the transfer of the interval _start from the node Node to the inquired node indicates the reason why the node Node has inquired the inquired node.

  Here, a processing procedure in the node (inquiry destination node) to which the inquiry is transferred from the node Node for the search of the Target Predecessor will be described with reference to the flowchart in FIG.

The inquiry destination node (the search unit 29) receives the shortcut path information skip [x] .x transferred from the node Node (inquiry source). The proximity of its own node ID with respect to the interval _start (proximity on the ring) and the skip [x]. A comparison is made with the proximity of the IDs of other nodes managed by itself for the interval _start (step S530a). Here, the IDs of the other nodes managed by the inquiry destination node are the node ID (predecessor.id) of the preceding adjacent node (predecessor node) indicated by the adjacent table 52-t managed by the inquiry destination node, and skip. This is the node ID (skip [i] .successor.id) of the node (skip [i] .successor) indicated by each entry skip [i] (i = {0 ... m-1}) of the table 53-t. . From the result of the comparison in step S530a, the inquiry destination node determines skip [x]. interval by either closer than the node ID of all other nodes towards their node ID to manage itself against _start, information skip shortcut path that is transferred from the node Node [x]. It is determined whether the interval _start is correct (step S530b).

The inquired node (the search unit 29) determines skip [x]. If the node ID is closer to the interval _start , it is determined that the shortcut path information transferred from the node Node is correct, that is, the skip table 53-t (N) of the node Node is correct (step S530c). In this case, the inquiry destination node (the search unit 29) determines that it is correct that the node Node inquires of itself. Therefore, the inquiry destination node (the search unit 29) searches for the node TargetPredecessor that becomes the predecessor for the Targetid, and notifies (responses) the result to the inquiry source node (node Node) (step S530d).

In contrast, skip [x]. If the node ID of a node other than itself is closer to the interval _start on the ring, the inquiry destination node (the search unit 29) has incorrect information on the shortcut path transferred from the node Node. It is determined that the skip table 53-t (N) of the node Node is not correct (step S530e). In this case, the inquiry destination node (the search unit 29) notifies the node Node that the node Node has inquired of itself, and that the skip table 53-t (N) needs to be updated (response). (Step S530f).

When the node Node (the search unit 29) makes the inquiry in step S530, the node Node waits for a response to the inquiry. When a response to the inquiry is returned from the inquiry destination, the node Node receives the response (step S531). Then, the node Node (the search unit 29) determines whether the received response notifies that the skip table 53-t (N) needs to be updated (step S532). When the determination in step S532 is Yes, the node Node (the search unit 29) suspends the search for the node TargetPredecessor and skips the correct link destination of the selected (transferred) shortcut path to the skip table 53-t (N). The search is performed by a method that does not involve updating (step S533). The search at this node Node is performed by using the shortcut path information skip [x]. Interval _start is performed as Targetid.

  Non-Patent Documents 5 and 6 describe a search using a method that does not involve updating the skip table 53-t (N). Here, the reference is performed using the skip table 53-t (N) that has not been updated. For this reason, as described in Non-Patent Documents 5 and 6, search request transfer may be required at m hops (m is the number of bits in the space of the overlay network 10) or more, but the reference is successful. Please note that. Note that the search request transfer at m hops or more is also necessary in the update by the non-strict model in Chord described in Non-Patent Documents 5 and 6.

The node Node (the search unit 29) determines that the node ID and address of the correct link destination node of the transferred shortcut path, that is, the node ID is the highest in Targetid (that is, skip [x] .interval _start ) in the search in step S531. Get the node ID and address of a nearby node. Then, the node Node (the table management unit 28) updates the shortcut path (here, skip [x] .successor. {Id, sddr} of the entry skip [x]) with the acquired node ID and address. (Step S534).

  Next, the node Node (the search unit 29) uses the updated skip table 53-t (N) to restart the reference that was interrupted earlier (that is, the search for the node TargetPredecessor) (step S535). That is, the node Node (the search unit 29) searches for the most successful successor. On the ring within the range not exceeding the Targetid from the shortcut path of the updated skip table 53-t (N). The search for the node TargetPredecessor is resumed by selecting the shortcut path indicating the id and transferring the inquiry to the link destination node of the shortcut path. In this way, the search for the node TargetPredecessor (step S53) is performed recursively.

  Next, the node Node (the search unit 29) determines whether or not the node TargetPredecessor has been reached as a result of executing the search for the node TargetPredecessor (step S53) (step S54).

  When the determination in step S54 is No, the node Node (the search unit 29) outputs an output Target. Successor. NULL is set as {id, addr}, and “LOOKUP_NOPATH” indicating failure is set as output Status (step S55). In this case, the node Node (the search unit 29) completes the reference process assuming that the destination node cannot be reached (no route).

  On the other hand, when the determination in step S54 is Yes, the node Node (the search unit 29) inquires of the searched node TargetPredecessor about the node TargetSuccessor that is the successor node of the node TargetPredecessor (step S56).

As a result of the inquiry in step S56, the node Node (the search unit 29) obtains the node ID and address (TargetSuccessor. {Id, addr}) of the node TargetSuccessor. Then, the node Node (its table management unit 28) updates the shortcut path of its own skip table 53-t (N) using the node ID and address of each of the node TargetPredecessor and the node TargetSuccessor (step S57). That is, the node Node (its table management unit 28) makes each entry Node. Of the skip table 53-t (N). For the interval _start (i.e. Node.Node.skip [i] .interval _start ) of skip [i] (i = {0 ... m-1}), the node Node. skip [i]. If the node ID of the target TargetPrecessor or the target Successor (TargetPredecessor.id or TargetSuccessor.id) is closer to that on the ring than the node ID of the successor (Node.skip [i] .successor.id). skip [i]. successor. {Id, addr} is changed to Target Predecessor. id or Target Successor. Update to {id, addr}. Here, Node. skip [i]. successor. id and Node. skip [i]. successor. addr is a TargetPredecessor. id and Target Successor. id. Node. skip [i]. Updated to the id (node ID) closest to the interval _start and the address of the node having the id.

  Next, the node Node (the search unit 29) outputs the Target. Successor. The node ID and address (TargetSuccessor. {Id, addr}) of the node TargetSuccessor are set as {id, addr}, and “LOOKUP_REACHED” indicating success is set as the output Status (step S58). In this case, the node Node completes the reference process assuming that it has reached the target node.

As described above, in this embodiment, the node Node, in the process of searching for the TargetPredecessor, uses the shortcut path information skip [x]. By transferring (notifying) the interval _start , the inquiry destination node determines whether the information of the shortcut path is incorrect, that is, whether the skip table 53-t (N) of the node Node needs to be updated. ing. If the inquiry destination node determines that the skip table 53-t (N) needs to be updated, the inquiry destination is notified of the fact to the node Node. By searching for the correct link destination by a method that does not involve updating the skip table 53-t (N), the skip table 53-t (N) (correct link destination of the shortcut path) can be updated.

  That is, in the present embodiment, the skip table 53-t is not initialized (updated) when the node joins the overlay network 10, but the skip table 53-t is updated during the reference process at the node. . Similarly, in this embodiment, the skip table 53-t is not initialized (updated) even when the node leaves the overlay network 10.

As a result, in the present embodiment, the following effects are obtained: 1) When the node joins / leaves the overlay network 10, the skip table 53-t is not updated, so that it takes no time for the node to join / leave 2) Since the skip table 53-t is updated in the course of the reference process for acquiring the node ID and address (Target. Successor. {Id, addr}) of the node having the node ID closest to the Targetid, useless update processing Does not occur and can be updated immediately when it is needed.

  The overlay network system in this embodiment can be applied to, for example, a large-scale wide-area distributed storage system without a central control point (metadata server) that is a weak point of reliability and performance.

[First Modification]
Next, a first modification of the above embodiment will be described.
The feature of the first modification is that each node 20-t (the search unit 29) updates the skip table 53-t managed by itself, independently of the update performed in the process of routing to an arbitrary node, The point is to update regularly. Therefore, each node 20-t has a timer that counts a certain time. The node 20-t (the search unit 29) updates the skip table 53-t each time the timer counts a predetermined time.

Hereinafter, the skip table regular update process by the node 20-t (the search unit 29 thereof) will be described with reference to the flowchart of FIG.
The node 20-t starts a timer (step S61). Then, the node 20-t monitors that the timer counts a predetermined time (that is, the timer timeout) (step S62).

If the timer counts a certain time, the node 20-t determines that the update time (periodic update time) for periodically updating the skip table 53-t has come. Then, the node 20-t makes skip [i]... In the skip table 53-t indicated by each i (i = {0... M−1}) from i = 0 to i = m−1. By executing reference for interval _start , skip [i]. successor. {Id, addr} is updated (step S63).

  When the node 20-t has executed step S63 for all i, the node 20-t starts the timer again (step S61), and monitors that the timer counts a certain time (step S62).

  Instead of using a timer, a field holding periodic update time information indicating the latest periodic update time may be added to the skip table 53-t. Here, the node 20-t can determine the arrival of the next regular update time by monitoring the passage of a fixed time from the regular update time indicated by the regular update time information. When the node 20-t updates the skip table 53-t due to the arrival of the regular update time, the regular update time information held in the table 53-t indicates the current time (that is, the latest regular update time). Update to

  According to the first modification, the entry (shortcut path entry) in the skip table 53-t managed by each node 20-t is periodically updated. For this reason, the entry of the skip table 53-t is prevented from becoming stale in the node 20-t in which the reference process including the Target Predecessor inquiry (routing request), that is, the reference process involving the update process is performed less frequently. be able to.

[Second Modification]
Next, a second modification of the above embodiment will be described.
The feature of the second modification is that each node 20-t (the search unit 29) has an entry skip [i] (i = {0 ... m-1}) of the skip table 53-t managed by itself. Is updated after a predetermined time has elapsed from the latest update time of the entry skip [i]. Therefore, in the second modification, a skip table 530-t having the data structure shown in FIG. 13 is used instead of the skip table 53-t used in the above embodiment. Each entry skip [i] of the skip table 530-t includes an update time field 531. The update time field 531 is used to hold update time information indicating the latest update time.

Hereinafter, the skip table update processing by the node 20-t (the search unit 29) will be described with reference to the flowchart of FIG.
The node 20-t repeats the following processing for all i (i = {0... M−1}) from i = 0 to i = m−1.

  First, the node 20-t refers to the update time field 531 included in the entry skip [i] in the skip table 53-t (step S71). Next, the node 20-t compares the latest update time indicated by the referenced update time field 531 (that is, the previous update time) with the current time to determine whether a certain time has elapsed from the update time. (Step S72).

If a predetermined time has elapsed since the previous update time, the node 20-t determines that the update time for updating the entry skip [i] in the skip table 53-t has come. Then, the node 20-t transmits skip [i]. By executing a reference for the interval _start , skip [i]. successor. {Id, addr} is updated (step S73). At this time, the node 20-t updates the update time information set in the update time field 531 in the entry skip [i] so as to indicate the current time (step S74).

  When node 20-t executes step S74, it proceeds to step S75. If a certain time has not elapsed since the last update time, the node 20-t skips step S74 and proceeds to step S75. In step S75, the node 20-t waits for a predetermined time.

The node 20-t repeats the above processing for all i (i = {0... M−1}) from i = 0 to i = m−1.
In the second modification, Node. Is used in the reference process according to the flowcharts of FIGS. skip [i]. successor. When the update of {id, addr} is executed, the update time field 531 of the entry (Node.skip [i]) in which the update is performed is updated.

  According to the second modification, the entry (shortcut path entry) in the skip table 53-t managed by each node 20-t is updated after a certain time from the previous update. It is possible to prevent the entry of the skip table 53-t from becoming old in the node 20-t where the number of times the reference process involving the update process is executed is small.

  In addition, this invention is not limited to the said embodiment or its modification example as it is, A component can be deform | transformed and embodied in the range which does not deviate from the summary in an implementation stage. In addition, various inventions can be formed by appropriately combining a plurality of constituent elements disclosed in the embodiment or its modification. For example, you may delete a some component from all the components shown by embodiment or its modification.

1 is a diagram showing a system configuration of an overlay network system according to an embodiment of the present invention. The block diagram which shows the hardware constitutions of the node shown by FIG. The block diagram which mainly shows the function structure of the node shown by FIG. The figure which shows the data structure example of the structure information stored in the structure information storage part of the node shown by FIG. skip [i]. interval _start and skip [i]. successor. The figure which shows the relationship with id. 6 is an exemplary flowchart illustrating a procedure of table initialization processing which is executed in a node newly participating in the overlay network in the embodiment. 6 is an exemplary flowchart illustrating a procedure of table initialization processing which is executed in a node newly participating in the overlay network in the embodiment. 6 is a flowchart showing a procedure of connection processing executed in a subsequent adjacent node in response to a connection request from a node newly participating in the overlay network in the embodiment. 6 is a flowchart showing a procedure of connection processing executed in the preceding adjacent node in response to a connection request from a node newly participating in the overlay network in the embodiment. The flowchart which shows the procedure of the skip table initialization process in FIG. 6B. 6 is a flowchart showing a procedure of reference processing in the embodiment. 6 is a flowchart showing a procedure of reference processing in the embodiment. The flowchart which shows the procedure of the process in the inquiry destination for the node search in the embodiment. The flowchart which shows the procedure of the skip table regular update process in the 1st modification of the embodiment. The figure which shows the data structure example of the skip table applied in the 2nd modification of the embodiment. 14 is a flowchart showing a procedure of skip table update processing in a second modification of the embodiment. The figure for demonstrating a ring. The figure which shows an example of a ring. The figure which shows the range of object ID of the object which each node stores in the example of FIG.

Explanation of symbols

  DESCRIPTION OF SYMBOLS 10 ... Overlay network, 20-t, 20-0-20-7 ... Node, 26 ... Control part, 27 ... Configuration information storage part, 28 ... Table management part, 29 ... Search part, 30 ... Object access part, 32 ... Object storage unit, 40 ... client, 50-t, 50-7 ... configuration information, 51-t, 51-7 ... node information, 52-t, 52-7 ... adjacent table, 53-t, 53-7, 530 -t ... Skip table.

Claims (7)

An overlay network composed of a plurality of nodes, each of the plurality of nodes having an m-bit node ID that is an identifier on the overlay network and an address that is an identifier on the underlay network , When the node IDs of the plurality of nodes are arranged in a ring in the order of the node IDs, the node ID and address of the node adjacent to the node ID and the address of the node adjacent to the node ID and the node ID of the node adjacent to the node ID And an adjacent table holding addresses and a shortcut path for obtaining the address of a node having a node ID closest to the input node ID or object ID by sequential inquiry with the target node ID or object ID as input. As information, the plurality of nodes In an overlay network construction and maintenance method for constructing and maintaining the overlay network with a skip table for holding a node ID and address of the m nodes other than the selected itself according to a predetermined rule,
When the first node participates in the overlay network, the first node is connected to the second node, which is an arbitrary node of the plurality of nodes, on the ring. Performing a first inquiry to obtain a node ID and address of a third node that is a node adjacent to the first node in the first direction;
When the first node obtains the node ID and address of the third node in response to the first inquiry, the first node makes a connection to the third node on the ring. Performing a second inquiry to obtain a node ID and an address of a fourth node that is a node adjacent to the third node in a second direction opposite to the first direction;
When the first node acquires the node ID and address of the fourth node in response to the second inquiry, the first node receives the node ID and address of the third node and the fourth node. Building an adjacency table of the first node based on the node ID and address of the node;
When the first node joins the overlay network, the first node initializes a skip table of the first node;
A reference process in which the first node obtains the address of a node having a node ID closest to the inputted node ID or object ID by sequential inquiry by using a target node ID or object ID as an input, In the process in which the first node forwards the inquiry to a fifth node that is a node other than itself among the plurality of nodes according to a shortcut path indicated by the skip table of the first node, An overlay network construction / maintenance method comprising: performing a reference process including a step of updating. To the inquiry transferred from the first node to the fifth node, the information of the shortcut path used for transferring the inquiry is added,
When the inquiry is transferred from the first node to the fifth node, the fifth node transmits information on the shortcut path added to the inquiry and its neighbor table and skip table. Further comprising the step of determining whether the information of the shortcut path is correct by comparing the information,
The step of executing the reference process is a step of updating the information of the shortcut path in the skip table of the first node when the information of the shortcut path is determined to be incorrect at the fifth node. The overlay network construction / maintenance method according to claim 1, further comprising: The information of the shortcut path includes reference position information indicating a position on the ring which is a reference when setting the shortcut path,
In the determining step, with respect to the position indicated by the reference position information included in the shortcut path information, the node ID of the fifth node is the adjacent table and the skip of the fifth node. The overlay network construction / maintenance method according to claim 2, wherein whether or not the shortcut path information is correct is determined based on whether it is closer on the ring than all node IDs indicated in the table.   The overlay network construction / maintenance method according to claim 1, further comprising a step of executing an update process for the first node to periodically update its own skip table. .   The first node further comprises a step of updating the shortcut path information when a predetermined time has elapsed since the last update of the shortcut path information indicated by the skip table of the first node. 4. The overlay network construction / maintenance method according to claim 1, wherein the overlay network is constructed and maintained. The skip table is associated with the shortcut path information, and holds update time information indicating the time when the shortcut path information was most recently updated,
The overlay according to claim 5, wherein the first node updates the information of the shortcut path corresponding to the update time information when the predetermined time has elapsed from the time indicated by the update time information. Network construction and maintenance method. An overlay network composed of a plurality of nodes, each of the plurality of nodes having an m-bit node ID that is an identifier on the overlay network and an address that is an identifier on the underlay network , When the node IDs of the plurality of nodes are arranged in a ring in the order of the node IDs, the node ID and address of the node adjacent to the node ID and the address of the node adjacent to the node ID and the node ID of the node adjacent to the node ID And an adjacent table holding addresses and a shortcut path for obtaining the address of a node having a node ID closest to the input node ID or object ID by sequential inquiry with the target node ID or object ID as input. As information, the plurality of nodes , The first node participating in the overlay network with a skip table for holding a node ID and address of the m nodes other than the selected itself according to a predetermined rule,
When the first node joins the overlay network, the first node on the ring from the first node to a second node that is an arbitrary node of the plurality of nodes Performing a first inquiry to obtain a node ID and address of a third node that is a node adjacent to the first node in the first direction;
When the first node obtains the node ID and address of the third node in response to the first inquiry, the first node sends the third node to the third node on the ring. Performing a second inquiry to obtain a node ID and an address of a fourth node that is a node adjacent to the third node in a second direction opposite to the first direction;
When the first node acquires the node ID and address of the fourth node in response to the second inquiry, the node ID and address of the third node and the node ID and address of the fourth node And constructing an adjacency table of the first node based on:
Initializing a skip table of the first node when the first node joins the overlay network;
A reference process in which the first node obtains the address of a node having a node ID closest to the inputted node ID or object ID by sequential inquiry by using a target node ID or object ID as an input, Including a step of updating the shortcut path in a process of transferring the inquiry to a fifth node which is a node other than itself among the plurality of nodes according to a shortcut path indicated by the skip table of the first node. A program for executing the steps to execute the process.

Images