JP2014142945A - Balanced consistent hashing for distributed resource management - Google Patents

Abstract

PROBLEM TO BE SOLVED: To make cluster resources to be used efficiently and scalable for balanced and consistent placement of resource management responsibilities within a multi-computer environment, such as a cluster.SOLUTION: When the number of available nodes 610-660 changes because of either removal or addition of a network, locations of a plurality of resource identifiers in a resource identification space are determined and the resource identification space is divided into a plurality of regions of responsibility so as to make it possible to find minimization of redistribution of resource management responsibility among the nodes 610-660. In addition, management responsibility for each region of responsibility is assigned to each of corresponding nodes 610-660, and the size of the range of responsibility is determined by the relative capability of each of the assigned nodes 610-660.

Description

  The present invention relates to computer resource management, and more particularly to a system and method for distributing resource management responsibilities in a network of multiple computers.

  Due to the growing reliance on information and computing systems that generate, distribute, and maintain information in various forms, there is a great demand for information resources and technologies for providing access to these information resources. continuing. Many companies and organizations need not only a significant amount of computing resources (computer resources), but also resources that are available with minimal downtime. One solution to such a requirement is that computing resources are clustered, thereby providing a flexible, high performance, highly available platform for accessing shared data in a storage area network environment. The environment. The cluster-wide volume and file system configuration allows for simplified and centralized management. An additional effect is that an integrated cluster volume manager is provided that provides the same logical view (virtual table) of the shared device configuration to all nodes in the cluster.

 An advantage of a cluster environment is the ability to eliminate or substantially reduce a single point of failure for information access. All computer nodes in the cluster are given the same view of shared data resources and can access these data resources in the same manner. Thus, when one or more of the computer resources suffers a failure, the tasks being performed by the failed system can be transferred to other computer nodes for further processing. In order to effectively achieve the elimination or reduction of single points of failure for cluster resource management, management is distributed among the cluster's member nodes.

 When a cluster member leaves the cluster, arrangements must be made to distribute the member's resource management responsibilities among the remaining cluster members. Such redistribution of resource management responsibilities is preferably performed in a manner that efficiently uses cluster resources, such as computation cycles and network bandwidth. Furthermore, such redistribution of resource management responsibilities should take into account the relative capabilities of the remaining cluster members. It is also desirable that the resource management responsibility variation among the remaining nodes be minimized in terms of the efficiency of redistribution of resource management responsibility among cluster members.

  The present invention provides a mechanism for a balanced and harmonious arrangement of resource management responsibilities in a multi-computer environment such as a cluster, which makes efficient use of cluster resources and makes them scalable (with scalability). ) Embodiments of the present invention reduce the amount of time that a cluster is unavailable for redistribution of resource management responsibilities by reducing the amount of resource management responsibilities redistribution among surviving cluster members. Embodiments of the present invention provide redistribution of resource management responsibilities based on the relative capabilities of multiple remaining cluster nodes.

  In an embodiment of the present invention, the arrangement (location: location) of a plurality of resource identifiers in a resource identification space is determined, the resource identification space is divided into a plurality of responsible areas, and the management responsibility of each responsible area corresponds. Assigned to a network node. In one aspect of the above embodiment, the resource identification space is a name space, and in a further aspect, the name of the resource is hashed to determine the storage location within the name space. In another aspect of the above embodiment, the network node to which responsibility for the region of the resource identification space is assigned is a member of a cluster of network nodes. In yet another aspect of the above embodiment, the size of the area of responsibility is determined by the relative capabilities of the assigned network node. In another aspect of the above embodiment, when the number of available nodes fluctuates due to network removal or addition, resource management responsibility is to minimize redistribution of resource management responsibility among network nodes. It is redistributed in a way that finds it.

  The present invention will be better understood and its objects, features, and advantages will become apparent to those skilled in the art by reference to the accompanying drawings.

1 is a simplified block diagram illustrating a multi-computer network cluster configuration suitable for implementing an embodiment of the present invention. FIG. 3 is a simplified block diagram of a two level lock manager environment that provides a distributed lock manager that can be used by embodiments of the present invention. The figure which shows how a lock master is distributed among the various nodes in 1 cluster. FIG. 3 is a simplified illustration of a two-level lock manager environment that provides a distributed lock manager that can be used in accordance with an embodiment of the present invention. FIG. 6 is a simplified flow diagram illustrating one embodiment of tasks performed by a cluster node during a mapping table rebuilding process in accordance with an embodiment of the present invention. FIG. 6 is a simplified flow diagram illustrating one embodiment of tasks performed by a cluster node during a mapping table rebuilding process in accordance with an embodiment of the present invention. FIG. 3 is a simplified block diagram illustrating the exchange of remaster messages between a proxy and a relocated master in a cluster environment in accordance with an embodiment of the present invention. FIG. 4 is a simplified flow diagram illustrating some tasks performed when setting up a new master for multiple cluster nodes during lock master redistribution in accordance with an embodiment of the present invention. 1 is a block diagram illustrating a computer system suitable for implementing an embodiment of the present invention. 1 is a block diagram illustrating a network architecture suitable for implementing embodiments of the present invention.

  The present invention provides a mechanism for balanced and consistent placement of resource management responsibilities in a multi-computer environment such as a cluster, and makes efficient use of cluster resources. , To be scalable (scalable). Embodiments of the present invention reduce the amount of time that a cluster is unavailable for redistribution of resource management responsibilities by reducing the amount of resource management responsibilities redistribution among surviving cluster members. Embodiments of the present invention provide redistribution of resource management responsibilities based on the relative capabilities of multiple remaining cluster nodes.

Cluster Environment and Distributed Locking FIG. 1 is a simplified block diagram illustrating a multi-computer network cluster configuration suitable for implementing an embodiment of the present invention. The cluster 120 includes a plurality of computer nodes (compute nodes) 110 (1) to 110 (n) that are members of the cluster. Computer nodes 110 (1)-110 (n) are coupled by a network 120. As shown, computer nodes 110 (1) -110 (n) are also connected to a storage area network (SAN) 130 that provides access to storage volume resources 140 (1) -140 (n). As another example, storage resources can be coupled directly to various computer nodes via a bus-based controller, or can be coupled, for example, as a network accessible storage device. Each computer node 110 (1)-110 (n) has simultaneous access to the SAN 130 storage pool. Given concurrent access to this storage resource, read / write access to the storage pool needs to be coordinated to ensure data integrity.

  In a cluster environment as shown in FIG. 1, various resources are shared by member nodes of the cluster. Such resources may include storage resources within the SAN 130, applications may run on various member nodes of the cluster, and so on. The distribution of management of such resources among the cluster's member nodes eliminates or reduces the presence of a single point that cannot benefit from access to those resources.

  One example of managing access to resources within a cluster is the file lock architecture associated with the cluster file system provided by the storage resources of the SAN 130. A cluster file system provides a single version of all files in a cluster, which is visible to all nodes in the cluster. Assuming that each member node has its own version for a particular file, what is owned by any one node may be incorrect information, especially during write access to that file. In order to ensure that only a single version of the data exists during any write access to specific data, a file locking process is performed in the clusterwide file system.

  Within a single computer system, multiple threads executing a given software application may access or update the same data. The term “thread” is used to describe the context in which a computer program is executing. Coordination between threads prevents another thread from reading shared data because when one thread is updating data, it can lead to data inconsistencies that depend on the timing of the two operations. It is necessary to guarantee that In a cluster environment such as that shown in FIG. 1, if the processing of a given software application can be load balanced across various member nodes, multiple threads sharing data may continue to run on different nodes in the cluster. .

  Coordination between multiple threads accessing shared data can be achieved using lock processing. Typically, a lock is to protect a piece of shared data, such as a file or a disk block. In a distributed system such as a cluster, locks can also protect shared “state” information distributed in the memory of each node of the system, such as the online or offline status of a given software application. . All shared data is protected by locks, which are typically managed by a lock manager. The lock manager provides an interface to be used by another application program that accesses the data.

  A lock on the data is requested before the calling application program can access the data protected by the lock. The calling application program typically requests an “exclusive” lock to write or update data protected by the lock, or a “shared” lock to read data protected by the lock. . If the calling application allows an exclusive lock, the lock manager ensures that the calling program is only one thread holding the lock. If the calling application allows a shared lock, another thread may hold a shared lock on the data, but cannot hold an exclusive lock on the data.

  The lock manager cannot immediately grant a lock request. As an example, consider one thread having an exclusive lock L for a given data set and a second thread requesting shared access to the given data set. The request for the second thread cannot be granted until the first thread has released an exclusive lock on the given data set.

  Locks are placed on data stored on a shared disk, such as a volume accessible through the SAN 130. Locks can also be placed on shared data stored in memory for each node if the data must be matched for all nodes in the cluster. For example, the nodes in the cluster can share information indicating that the file system is installed. A lock is placed in shared state information when the state of a file system changes from mounted to unmounted or vice versa.

Distributed Lock Management As described above, the lock manager responds to requests to access data protected by the lock process. In a cluster environment, resource managers such as lock managers are desired to be distributed among the cluster's member nodes in order to avoid or reduce single point of failure.

  FIG. 2 is a simplified block diagram illustrating a two-level lock manager environment that provides a distributed lock manager that can be used with embodiments of the present invention. For example, client thread 215 in node 210 requests lock A through proxy 220 (A). In such a system, there is one proxy per lock per node that holds or requests a lock. For example, there may be a proxy for the lock A on the node 240 (proxy 250 (A)) corresponding to the client 245 holding or requesting the lock A on the node 240. However, if node 240 does not already have access to lock A, proxy 250 (A) will request lock A from the master for lock A. As shown in FIG. 2, the master for lock A is the master 230 (A) located in the node 210. There is one master for each lock in the cluster. If the master is not located at the node executing the requesting thread, the master table at that node is the remote node that provides the master for the requested lock ( Referenced to find (identification). For example, if a client requests lock C from proxy 220 (C) on node 210, proxy 220 (C) will request lock C from lock C master 290 (C) on node 270. Let's go. If node 210 has been granted lock A for another different thread, proxy 220 (C) distributes lock C to the requesting client without further requesting from the lock master. Can be managed. Although the above example refers to one thread accessing a lock through a proxy, multiple threads may be able to access a node through a single proxy. Furthermore, a thread may be able to access multiple locks through multiple corresponding proxies on a single node.

  Multiple nodes in a cluster do not have to be homogeneous and are fairly loaded to master control these resources in the type or configuration of the computers that make up the nodes or in the processes that run on the nodes. Is distributed according to the relative capabilities of the multiple member nodes of the cluster. Factors for determining node capabilities may include, for example, processing speed, number of processors on the node, available memory size, desired load on the node, and the like. A node's capabilities may be automatically detected, or an administrator of the cluster may be able to define the capability, and the capability information is the lock master between the various nodes. It may be possible to use it in determining the decentralization.

  FIG. 3 is a diagram showing how the lock master is distributed among various nodes in one cluster. The original master map 310 illustrates how a plurality of lock masters 1 to c are associated with members of a cluster of four nodes. In the figure, lock masters are evenly distributed across nodes based on the name of the lock associated with the master. The name of each lock (namely, lock name) is uniquely determined from file system information such as inode, lock type, or volume.

  One approach to decentralizing lock masters uses lock name hashing. The node ID (node identifier) for the host master for locking is determined as a hash value (modulo n). Here, n is the number of nodes available to the host master in the cluster. If one node (eg, node 3) leaves the cluster, a new master map 320 is generated using the same algorithm. Therefore, since the master host ID is based on a hash value (modulo n), many of the lock masters are relocated between surviving nodes. The number of masters to be rearranged is “((n−1) / n) * number of lock masters”.

  In the system shown in FIG. 3, since many of the lock masters should be relocated, it is reasonable to invalidate the old master information and rebuild the new master table on each cluster node. When the new master is redistributed, the surviving proxy sends locks to the various new masters. One problem with such systems is that as the number of locks and the size of the cluster increase, the cluster becomes unavailable while waiting for the master to be redistributed and waiting for the proxy to send a lock state. The amount is to occur. Furthermore, the above algorithm for determining the master host ID for locking does not take into account the relative capabilities of multiple nodes when performing redistribution. In addition, after reconfiguration of the cluster, each lock ID needs to be re-hashed, and the master host ID needs to be recalculated against the number of surviving nodes in the cluster, which reduces processing costs. It takes quite a while.

Balanced Consistent Hash Method Embodiments of the present invention use a balanced consistent hash method mechanism to reduce the computation in determining the master host ID as well as the various survivors in the cluster. It also reduces the number of masters that should be redistributed between nodes. The resource identification “space” is defined by an identifier for each resource for which the master associated with it is to be distributed within the cluster. An embodiment of the present invention performs a hash calculation for various lock names in the cluster and determines the scope of the resource identification space therefrom. This resource identification space has a spread from the minimum value to the maximum value of the calculated hash value. This resource identification space is then balanced among multiple cluster member nodes according to the relative capabilities of the cluster member nodes. If a node leaves or joins the cluster, the resource identification space is rebalanced among the surviving cluster member nodes.

  FIG. 4 is a simplified illustration of a two level lock manager environment that provides a distributed lock manager that can be used in accordance with an embodiment of the present invention. The resource identification space 410 shows a distribution of hash values for lock identifiers from the minimum value to the maximum value of the calculated hash values. For the purposes of illustration, locks A through L are shown as being uniformly distributed throughout the resource identification space, but such uniform distribution is not required. In addition, an original mapping 420 of cluster member nodes 1 through 4 is shown. As an example, a four node cluster is used, and the relative capabilities of each node are considered the same. Accordingly, each responsibility area of the lock management hash space is assumed to be equal among the four nodes.

  The unbalanced map 430 illustrates the case where node 3 has left the cluster. In the illustrated example, the responsibility area of node 2 is simply extended into the responsibility area of node 3 so that node 2 is responsible for all lock management originally performed by node 3. . This case is considered unbalanced because node 2 needs to spend more resources than any other node 1 or 4 to perform the lock management task.

  The lock master rebalanced map 440 is more desirable to share the load evenly among the surviving nodes. As shown in the figure, even if node 2 remains in the cluster, the master for lock D moves from node 2 to node 1. The responsibility of the masters for locks G and H, originally performed by node 3, is now performed by node 2. The responsibility of the master for lock I originally performed by node 3 is transferred to node 4.

  When performing the rebalance process for the map 440, only 4 of the 12 lock masters are relocated after node 3 leaves the cluster. This is less than nine (= ((n-1) / n) * number of lock masters) masters in the system shown in FIG. Thus, through the balanced consistent hashing scheme shown at 440, a significant amount of resources can be consumed by the computational cycles required to recreate the lock master (which will be discussed in more detail later) and various proxies. It can be used with care both in the network resources required to send the state to the new lock master. Further, computer resources can be further saved because the lock identifier is not re-hashed.

  As the number of mastered nodes and resources increases, the number of resource masters that are redistributed asymptotically approaches approximately 1/3 of the total resource masters. The number of resource masters that are redistributed is also sensitive to the node responsible for one of the “edges” of the resource identification space as to whether the node responsible for the middle of the space becomes unavailable. . One embodiment of the present invention solves this edge sensitivity problem by modeling an edgeless resource identification space. That is, for example, a resource identification space without an edge is modeled by linking the “A” edge of the resource identification space 410 to the “L” edge of the resource identification space.

  Another balanced consistent hashing method can be implemented by simply moving the lock master from the node that left the cluster to the surviving nodes. Referring to an example in FIG. 4, when the node 3 leaves the cluster, the lock master corresponding to the lock G is moved to the node 1, H is moved to the node 2, and I is moved to the node 4. This will result in the number of masters being moved equal to 1 / n. Here, n is the number of nodes in the original cluster.

Selection of a master node from a set of cluster member nodes is performed using an array of available nodes and a resource identification space. The master node ID array (master_nid [idx]) includes a sorted list of cluster member node IDs that are replicated based on each node's scaled weight. The scaled weight of each node is based on the relative ability of one node with respect to other nodes in the array. For example, if nodes 1 and 3 have a weight of 1 and node 2 has a weight of 2, the master_nid array will contain entries {1, 2, 2, 3}.
The total weight (tot_weight) of the array is the number of entries in the master_nid array. Therefore, in the above example, tot_weight is 4. The master for the lock resource calculates a hash value of the name of the lock, divides the hash value by the maximum value (max_hash) in the hash value space, multiplies the quotient by the total weight, and multiplies the product by the master node. By using the ID value as an index (index) for retrieving from the master_nid array, it can be assigned to one node represented in the master_nid. Thus, the formula for reaching the index for the master_nid array is
idx = (hashval / max_hash) * tot_weight
It is. The above formula for the master_nid indicator is to calculate the normalized value for the lock name hash against the maximum hash value and multiply the normalized value by the total number of entries in the master_nid array I understand that.

In one embodiment of the invention, an integer calculation may be used as a modification to calculate the index of the master_nid array. In this embodiment, the index is calculated by the following formula.
idx = (hashval11 * tot_weight) >> 11
hashval 11 is the least significant 11 bits of the calculated hash value for the lock name. hashval 11 is multiplied by the total weight of the master_nid array. The calculation result is right shifted by 11 bits to yield the index value. In this embodiment, the 11-bit and 11-bit right shifts are selected in relation to some selected maximum value of the hash value that can be searched during relocation.

An alternative mechanism for balanced consistent hashing has already been described and only the lock master associated with the remaining nodes in the cluster has been relocated and associated with the remaining nodes in the cluster. Those lock masters continue to be held in their no. One such example is described here. As described above, the master_nid array contains entry groups based on the scale weighting of each node in the cluster. The master_nid array is stored as a level 1 mapping table for a new cluster or for a cluster that a node has joined. This alternative mechanism introduces a second level mapping table (eg, a level 2 mapping table) when a node leaves the cluster. When a node leaves a cluster, those entries in the master_nid array corresponding to nodes that are no longer in the cluster are replaced with a zero value, and this modified master_nid array is retained as a level 1 mapping table. A level 2 mapping table is then constructed based on the scale weights of the surviving nodes. The level 2 mapping table is used to redistribute masters from disjoint nodes to surviving nodes. During the master node ID lookup, the index for the level 1 mapping table is calculated by any of the methods described above. If the node ID in the level 1 mapping table is zero, a second index is calculated for the level 2 mapping table. The formula for calculating the level 2 index is as follows.
idx 2 = (((((hashval11) & 0x3f) << 5│ ((hashval 11) >> 6)) * tot_weight2) >> 11
In the above formula, hashval 11 is the least significant 11 bits of the hash value, and tot_weight2 is the size of the level 2 mapping table. Again, the use of the 11 least significant bits of the hash value and the 11 bit right shift are related to the table size used to search for the relocated master.

  Although the alternative embodiment of the present invention described above uses a two level mapping table, any number of mapping tables may be used, each level being the number of nodes in the cluster. It corresponds to the event that changes. Such a number of tables used requires the memory resources required to store the tables and the computer resources used when performing table lookups at multiple levels. Furthermore, as described above, when a new node joins the cluster, a level 1 mapping table is constructed. Thus, in the embodiment described above, only a level 1 mapping table is constructed when a new node enters the cluster in the same period as an existing node leaves the cluster.

  The example shown in FIG. 4 results in the removal of a node from the network environment, followed by a resource management redistribution process for the remaining nodes, the methodology includes the addition of nodes to the network environment, and the addition Allows decentralization of resource management responsibilities for nodes.

  FIG. 5a is a simplified flow diagram illustrating one embodiment of tasks performed by a cluster node during a mapping table reconstruction process in accordance with an embodiment of the present invention. Lockmaster distribution is initiated by a restart call (request) triggered by a change in cluster membership (510). Such a change in cluster membership is detected by the cluster membership monitor and the appearance of a new membership identifier that has joined the cluster or the absence of a node from the cluster after a period of time or Identified by an explicit leave statement from a node. In response to the restart call, each node in the cluster broadcasts information about the node to all other nodes (broadcast delivery) (515). Such node information is, for example, node capability information as described above and information (for example, node entry time stamp) indicating when the node has entered the cluster. The node then waits to receive node information from all other remaining nodes (520).

  In light of the information received from the other nodes, each node builds a level 1 mapping table or a level 2 mapping table as described above (525). The proxy table stored at each node is scanned, references the new mapping table using the balanced consistent hash method described above, and records the previous master for proxy (eg, remote master table) and the new By comparing the reference results against the correct mapping table, it is determined whether any proxy is associated with the relocated master (530). If there is no relocated master (535), the proxy on the node does not need to send information to its associated master. This is in contrast to the prior art where almost all masters are relocated in the prior art as described above and therefore the master table is completely rebuilt and all proxies have to send information to those masters. This is a prominent feature of the balanced consistent hash method. If the proxy has a relocated master associated with it (535), a remaster message is sent to the node that is now responsible for controlling the lock ID ( 540). This is done for each proxy with a relocated master. One node broadcasts to all nodes in the cluster that the node has completed sending a remaster message, for example, indicating that the node has finished sending a remaster message. (For example, “DONE_REMASTER” message).

  FIG. 6 is a simplified block diagram illustrating the exchange of remaster messages between a proxy and a relocated master in a cluster environment in accordance with an embodiment of the present invention. FIG. 6 illustrates that the members of the cluster are nodes 610-660. Node 610 is responsible for lock master A. Upon discovering that lock master A has been relocated to node 610, each node in the cluster with lock A proxy communicates a remaster message to node 610. Similarly, node 630 is responsible for lock master B, and the node with lock B proxy sends a remaster message to node 630. From this figure, the greater the number of relocated lock masters, the greater the network traffic for remaster messages. Further, as the number of nodes and proxies increases, the network traffic increases. Thus, a mechanism that keeps the lock master relocation to a minimum will keep network resources (eg, bandwidth) meaningful.

  Returning to FIG. 5a, the node deletes any of the masters relocated from the node from the node's master table (545). After the node has changed its own master table and has performed a housekeeping task on the queue associated with the changed master table (see, eg, in connection with FIG. 5b below) For each relocated master associated with the node proxy, any outstanding requests from the node proxy may be sent to the relocated master (550).

  FIG. 5b is a simplified flow diagram illustrating the tasks performed in the housekeeping task associated with the modified master table, in accordance with an embodiment of the present invention. A determination is made whether the node has received all remaster messages from all nodes (560). Such a determination can be made, for example, by determining whether or not the node has received the “DONE_REMASTER” message as described above from all other nodes. If not, the node can wait for additional remaster messages. If all remaster messages have been received, the node broadcasts information 565 that indicates that it is “ready” to handle the lock processing request that is governed by the node (565). The node can then wait to receive "prepare" assertion information from all other nodes in the cluster (570) and, when doing so, clean up the master table on the node. Tasks related to that. The node can, for example, scan the request queue and delete lock resource requests from nodes that have left the cluster (575). The node can scan the permission queue and delete the permissions granted to nodes that have left the cluster (580). If the grant is removed (585), the node may process the request queue to determine if any requested lock resource can now be granted in light of the grant removal. Yes (590). The invalid queue for requests to invalidate other locked resources (by other threads) can be scanned and allowed if the invalid request source has been removed from the cluster When all invalidations are terminated instead of being promoted to the queue, the entry can be deleted (595).

  Although they are performed sequentially in the figure, many of these tasks (e.g. proxy table scan (530), relocated master deletion (545), request and grant queue scan (575, 580), Master table updates (715 below) can be performed simultaneously by one node, thereby reducing the amount of time involved in relocating the master between member nodes.

  Part of the process for implementing a new master table involves removing old messages. Old messages originated from a relocated or discarded master to a node or vice versa. Old messages can also be discarded from sender nodes that are no longer members of the cluster. Furthermore, any message sent to the sender or receiver that entered the cluster can be discarded as well.

  FIG. 7 is a simplified flow diagram illustrating some of the tasks performed when setting up a new master for multiple cluster nodes during lock master redistribution in accordance with an embodiment of the present invention. The node starts processing when it receives a remaster message, such as that sent at 540 (710). The node then updates the node's master table to include an entry for the new master that the node should be responsible for (715).

  Redistribution of resource management in a network cluster environment has been described above using an example of lock resource management. However, it should be understood that the inventive concept can also be applied to the distributed management of other types of resources within a distributed computing environment where resources are shared. The principle of the present invention is not limited to lock management. For example, a plurality of applications that are responsible for managing applications in a distributed computing environment or each recipient's email address range for one network can be handled by each email server. It can also be applied to providing an e-mail server.

Exemplary Computer and Network Environments As noted above, the present invention can be implemented using a variety of computer systems and networks. An example of such a computer system and network environment is described below with reference to FIGS.

  FIG. 8 shows a block diagram of a computer system 810 suitable for implementing the invention. The network computer system 810 includes a bus 812 that interconnects the main subsystems of the computer system 810, which includes a central processor 814, system memory 817 (typically RAM, but ROM or flash RAM). In addition, an external audio device such as a speaker system 820 with an audio output interface 822 interposed therebetween, an external device such as a display screen 824 with a display adapter 826 interposed therebetween, serial Flexible operating to accept ports 828, 830, keyboard 832 (interfaced with keyboard controller 833), storage interface 834, flexible magnetic disk 838 Accepts magnetic disk drive 837, host bus adapter (HBA) interface card 835A operating to connect to optical fiber channel network 890, host bus adapter (HBA) interface card 835B operating to connect to SCSI bus 839, and optical disk 842 An optical disk drive 840 or the like that operates to Also, mouse 846 (or other point and click device connected to bus 812 via serial port 828), modem 847 (connected to bus 812 via serial port 830), network interface 848 (bus 812 Etc.).

  The bus 812 allows data communication between the central processor 814 and the system memory 817, and as already mentioned, the system memory 817 can be read only memory (ROM) or flash memory (both not shown), random access A memory (RAM) (not shown) is included. The RAM is generally a main memory into which an operating system and application programs are loaded. ROM or flash memory may include a basic input-output system (BIOS) that controls basic hardware operations, such as interactions with peripheral elements, among other code. Applications resident in computer system 810 are typically on a computer readable medium, such as a hard disk drive (eg, fixed disk 844), an optical disk drive (eg, optical disk drive 840), flexible magnetic disk unit 837, or other storage medium. Stored and accessed. In addition, an application may take the form of electronic signals that are modulated according to the application and data communication techniques when accessed through a network modem 847 or interface 848.

  The storage device interface 834 may be connected to a standard computer readable medium for storage and retrieval of information, such as a fixed disk drive 844, as is the case with other storage device interfaces of the computer system 810. . Fixed disk drive 844 may be part of computer system 810 or may be separate and accessible via other interface systems. Modem 847 may provide a direct connection to a remote server via a telephone link or to the Internet via an Internet service provider (ISP). The network interface 848 may provide a direct connection to a remote server via a direct network link or to the Internet via a point of presence (POP). Network interface 848 may provide these connections using wireless technologies such as digital cellular phone connections, cellular phone digital packet data (CDPD) connections, digital satellite data connections, and the like.

  Many other devices or subsystems (not shown) (document scanners, digital cameras, etc.) may be connected in a similar manner. Conversely, not all devices shown in FIG. 8 need be presented to practice the present invention. Devices or subsystems can be interconnected in different ways than in FIG. The operation of the computer system as shown in FIG. 8 is well known and will not be described in detail in this document. Code for implementing the invention may be stored in a computer readable storage medium such as one or more of system memory 817, fixed disk 844, optical disk 842, or flexible magnetic disk 838. The operating system provided on the computer system 810 is MS-DOS (registered trademark), MS-WINDOWS (registered trademark), OS / 2 (registered trademark), UNIX (registered trademark), Linux (registered trademark), or others. A known operating system may be used.

  Further, with respect to the signals described herein, those skilled in the art can transmit signals directly from the first block to the second block, or the signals can be transformed between blocks (eg, amplified). , Attenuation, delay, latch, buffer, invert transform, filter, or other changes). The signal in the above embodiment is transmitted from one block to the next, but in another embodiment of the present invention, transmission is performed between blocks as information of the signal and / or from a functional viewpoint. As far as possible, a modified signal may be included instead of such a direct transmission. In some extensions, the signal input in the second block is the first signal output from the first block due to physical limitations of the circuits involved (eg, attenuation and delay are inevitable). Can be conceptualized as a second signal derived from. Thus, as used herein, the second signal derived from the first signal is a circuit limit or changes the informational and / or functional aspects of the first signal. The first signal or some variation of the first signal is included, even though it passes through other circuit elements that do not.

  FIG. 9 is a block diagram illustrating a network architecture 900 in which client systems 910, 920, 930 and storage servers 940A, 940B (any of which can be implemented using the computer system 810) are coupled to a network 950. Is done. The storage server 940A directly attaches storage devices 960A (1) to 960A (N), and the storage server 940B directly attaches storage devices 960B (1) to 960B (N) directly. As shown. Although connection to a storage area network (SAN) is not essential to the operation of the present invention, storage servers 940A, 940B are also connected to a SAN organization 970. The SAN organization 970 supports access to the storage devices 980 (1) to 980 (N) by the storage servers 940A and 940B, and thus by the client systems 910, 920, and 930 via the network 950. An intelligent storage array 990 is shown as an example of a specific storage device accessible via the SAN organization 970.

  Computer system 810, modem 847, network interface 848, or some other technique may be used to provide connectivity from each of client computer systems 910, 920, 930 to network 950. The client systems 910, 920, 930 can access information on the storage servers 940A, 940B using, for example, a web browser or other client software (not shown). Such client software can be one of storage servers 940A or 940B, storage devices 960A (1) -960A (N), 960B (1) -960B (N), 980 (1) -980 (N), or It enables client systems 910, 920, 930 to access data hosted by intelligent storage array 990. Although FIG. 9 illustrates use in a network such as the Internet for exchanging data, the present invention is not limited to the Internet or any particular network-based environment.

Other Embodiments The present invention is suitable for providing the advantages described above and other advantages inherent therein. In the foregoing, the invention has been described, illustrated and defined with reference to specific embodiments of the invention, but such references are not meant to limit the invention, but such limitations. Is not implied. The present invention is capable of considerable variations and modifications and equivalents in form and function to those skilled in the art to which the invention pertains. The embodiments described and illustrated herein are only examples and do not cover the scope of the invention.

  The above-described embodiments include components that are included within other components (eg, various components shown as components of computer system 810). Such a design philosophy is merely an example, and in fact, many other design philosophies can be implemented to implement functions similar to those described above. Generally speaking, however, for the sake of clarity, any arrangement of components to achieve similar functionality is effectively “associated” to achieve the desired functionality. . Thus, any two components combined here to achieve a particular functionality are “associated” with each other so that the desired functionality is achieved, regardless of design philosophy or intermediate components. Can be seen as being associated (associated). Similarly, any two components so associated may be “operably connected” or “operably coupled” to each other to achieve the desired functionality. Can be considered.

  In the foregoing detailed description, various embodiments of the invention have been described using block diagrams, flow diagrams, and examples. The components described by use of each block diagram, each step, operation, and / or example of the flow diagram may be individually and / or collectively represented by a wide range of hardware, software, firmware, or any combination thereof. Those skilled in the art will appreciate that it can be implemented.

  Although the present invention has been described in the context of a fully functional computer system, those skilled in the art will recognize that the present invention can be distributed as various forms of computer program products and that the present invention actually performs the distribution. It will be understood that the present invention applies equally regardless of the particular type of signal-bearing medium used. Examples of signal bearing media include computer readable media, transmission-type media such as digital or analog communication links, as well as media storage and distribution systems that will evolve in the future.

  The embodiments described above can be implemented by software modules that perform specific tasks. The software modules described herein may include scripts or batches or other executable files. The software module is a machine readable, such as a flexible magnetic disk, hard disk, semiconductor memory (eg, RAM, ROM, flash media), optical disk (eg, CD-ROM, CD-R, DVD) or other type of memory module. It may be stored on a possible or computer readable storage medium. A storage device used to store firmware or hardware modules according to embodiments of the present invention may include a semiconductor-based memory that is permanently, removably or remotely. It may be coupled to a microprocessor / memory system. Thus, the module can be stored in a computer system memory for configuring the computer system such that the computer system performs the functions of the module. Other new and various types of computer readable storage media may be used to store the modules as described herein.

  The above description is intended to illustrate the present invention and should not be taken as limiting. Other embodiments within the scope of the present invention are possible. Those skilled in the art will readily implement the procedures necessary to provide the structures and methods described herein, and the processing parameters and order of the procedures are given for illustrative purposes only, and As with variations within the scope, it can be varied to achieve the desired structure. Variations and modifications of the embodiments described herein may be made based on the description provided herein without departing from the scope of the present invention.

  Accordingly, the invention is limited only by the following claims, which provide complete recognition of equivalents in all respects.

Claims (21)

Determining the placement of a plurality of resource identifiers in the resource identification space;
Dividing the resource identification space into a first plurality of individual responsible areas, wherein each of the responsible areas is associated with a unique network node, and the total of all responsible areas is the resource Encompasses all of the identification space,
Allocating management responsibility for one resource associated with one resource identifier located in the first responsibility area to the network node associated with the first responsibility area.   The method of claim 1, wherein the resource identification space is a namespace.   The method of claim 2, further comprising calculating a resource identifier of the plurality of resource identifiers by hashing a resource name.   4. The method further comprises deriving the name of the one resource using an i-node identifier, wherein the resource is one of a file and a storage location in a file system. The method described in 1.   Further comprising deriving the name of the one resource using an email address, wherein the resource is a mailbox, state information associated with the mailbox, metadata associated with the mailbox The method according to claim 3, wherein the management information is one of management information associated with the mailbox and mail data in an electronic mail system.   The method of claim 1, wherein each of the network nodes is a member in a cluster of network nodes.   The method of claim 1, wherein one resource identified by one of the plurality of resource identifiers is accessible to all members in a cluster of the network node.   The method of claim 1, further comprising determining a responsibility region for the associated network node based on the capability of the associated network node.   9. The method of claim 8, further comprising associating the associated network node capability with one or more of processor capability and memory capability.   9. The method of claim 8, further comprising defining the capability of the associated network node by user input.   The method of claim 8, wherein the capability of the associated network node is defined relative to each other network node.   When one network node enters or leaves the network, the current number of network nodes available to be associated with the responsibility area is used to define the dividing and assigning steps to a second plurality of responsibilities. The method of claim 1, further comprising performing in the region.   13. The method of claim 12, further comprising maximizing overlap of responsibility areas between the first plurality of responsibility areas and the second plurality of responsibility areas. A first instruction set, executable by a processor, configured to determine placement of a plurality of resource identifiers in a resource identification space;
A second instruction set executable by a processor, configured to divide the resource identification space into a first plurality of individual responsible areas, wherein each of the responsible areas is a unique network; Associated with the node, the total of all responsible areas includes all of the resource identification space,
A processor configured to assign management responsibility for one resource associated with one resource identifier arranged in the first responsibility area to the network node associated with the first responsibility area And a third instruction set executable by the computer.   The computer-readable storage medium of claim 14, wherein the resource identification space is a name space.   16. A fourth instruction set, executable by a processor, configured to compute a resource identifier of the plurality of resource identifiers by hashing a resource name. A computer-readable storage medium described in 1.   The method of claim 1, further comprising a fourth instruction set executable by a processor configured to determine a region of responsibility for the associated network node based on the capabilities of the associated network node. Computer-readable storage media. A plurality of network nodes, wherein each network node in the plurality of network nodes comprises a corresponding processor, a memory coupled to the processor, and a network interface coupled to the processor; And
A network configured to couple the plurality of network nodes to each other, the network coupled to the network interface of the network node;
The memory of each network node is
A first instruction set, executable by the processor of the network node, configured to determine placement of a plurality of resource identifiers in a resource identification space;
A second instruction set, executable by the processor of the network node, configured to divide the resource identification space into a first plurality of individual responsible areas, wherein each of the responsible areas is Associated with one unique network node, and the sum of all responsible areas encompasses all of the resource identification space;
Configured to assign management responsibility for one resource associated with one resource identifier arranged in a first responsibility area to the network node associated with the first responsibility area; And a third instruction set executable by the processor of the network node.   A fourth instruction set, executable by the processor of the network node, configured to calculate one resource identifier of the plurality of resource identifiers by hashing a name of one resource; 19. A system according to claim 18 comprising.   And further comprising a fourth instruction set executable by the processor of the network node configured to determine a responsibility area for the associated network node based on the capability of the associated network node. The system of claim 18. Means for determining the placement of a plurality of resource identifiers in the resource identification space;
Means for dividing the resource identification space into a first plurality of individual responsible areas, wherein each of the responsible areas is associated with a unique network node, and the total of all responsible areas is Encompasses all of the resource identification space;
Means for allocating management responsibility for one resource associated with one resource identifier arranged in the first responsibility area to the network node associated with the first responsibility area. apparatus.

Images