|Numéro de publication||US7934056 B2|
|Type de publication||Octroi|
|Numéro de demande||US 12/014,302|
|Date de publication||26 avr. 2011|
|Date de dépôt||15 janv. 2008|
|Date de priorité||18 juil. 2000|
|État de paiement des frais||Caduc|
|Autre référence de publication||US6829678, US7325120, US20050102481, US20080126451|
|Numéro de publication||014302, 12014302, US 7934056 B2, US 7934056B2, US-B2-7934056, US7934056 B2, US7934056B2|
|Inventeurs||Wayne A. Sawdon, Roger L. Haskin, Frank B. Schmuck, James C. Wyllie|
|Cessionnaire d'origine||International Business Machines Corporation|
|Exporter la citation||BiBTeX, EndNote, RefMan|
|Citations de brevets (60), Citations hors brevets (15), Classifications (15), Événements juridiques (3)|
|Liens externes: USPTO, Cession USPTO, Espacenet|
This application is a continuation of U.S. patent application Ser. No. 11/006,261, filed Dec. 6, 2004 U.S. Pat. No. 7,325,120, issued Jan. 29, 2008, entitled “ALLOCATING SPACE ON DATA STORAGE DEVICES IN PROPORTION TO WEIGHTS ASSOCIATED WITH THE DEVICES,” which is a continuation of U.S. patent application Ser. No. 09/618,332, filed Jul. 18, 2000, now U.S. Pat. No. 6,829,678, issued Dec. 7, 2004, entitled “SYSTEM FOR DETERMINING THE ORDER AND FREQUENCY IN WHICH SPACE IS ALLOCATED ON INDIVIDUAL DATA STORAGE DEVICES,” the entirety of each are hereby incorporated herein by reference.
This application contains subject matter which is related to the subject matter of the following issued patents, each of which is assigned to the same assignee as this application. Each of the below listed applications/patents is hereby incorporated herein by reference in its entirety:
This invention relates, in general, to allocating space on data storage devices, and in particular, to using weights to determine the order and frequency in which space is allocated on individual storage devices.
Many computing environments include file systems, which enable other application programs to store data on and retrieve data from storage devices. In particular, a file system allows application programs to create files and to give them names (a file is a named data object of arbitrary size), to store (or write) data into files, to read data from files, to delete files, and perform other operations on files.
A file structure is the organization of data on the storage devices. In addition to the file data itself, the file structure contains meta data, which includes, for instance, the following: a directory that maps file names to the corresponding files; file meta data that contains information about the file, including the location of the file data on the storage device (i.e., which device blocks hold the file data); an allocation map that records which device blocks are currently in use to store meta data and file data; and a superblock that includes overall information about the file structure (e.g., the locations of the directory, allocation map, and other meta data structures).
In order to store successive data blocks of a file to distinct devices, such as disks or other storage devices, a technique known as striping is used. Striping may also be used to store the file system's meta data. The advantages of striping include high performance and load balancing. In striping, the file system writes successive blocks of a file, or the file's meta data, to distinct devices in a defined order. For example, the file system may use a round-robin allocation, in which successive blocks are placed according to a cyclic permutation of the devices. This permutation is called the stripe order. The stripe order defines the order and frequency of allocations (and thus, writes) to each device in the file system. For example, a system with four disks using a simple round-robin allocation scheme would allocate space on each disk in consecutive order, namely: 1, 2, 3, 4, 1, 2, 3, 4 . . . . Hereinafter, “data stripe” and “stripe”, as well as “data striping” and “striping” are used interchangeably.
This simple round-robin allocation is used by most striped file systems for allocation. Although, round-robin allocations may be sufficient in some circumstances for a system that includes homogeneous devices, it proves to be inadequate for a system with heterogeneous devices, and it proves to be inadequate for various circumstances in which homogeneous devices are used.
As one example, a round-robin allocation is inadequate for devices of different storage capacities or throughput. Under round-robin allocation, all devices are allocated equally. Consequently, subsequent access to the data is typically spread equally across the devices as well. For systems that include devices with different storage capacities, the small devices fill before the larger devices and then, must be excluded from the stripe order, thus reducing the parallelism and performance for all subsequent writes. Furthermore, the data striped across the reduced set of devices has reduced performance for all subsequent accesses.
Likewise, for systems that include devices with different throughput, round-robin allocation fails to maximize the throughput for allocation and all subsequent accesses to the data. Additionally, round-robin allocation has no capability for rebalancing a system that begins in an unbalanced state. An unbalanced state can occur for a variety of reasons including, for instance, when devices are partitioned between file or operating systems; when empty devices are added to an existing file system; or when the allocation policy changes. To rebalance such a system, extraordinary measures are required by the user, such as restriping of all the data in the file system.
Thus, a need still exists for an allocation technique that is general enough to be used in a wide variety of circumstances. Further, a need exists for a capability that enables rebalancing of the allocations to better match the current conditions and requirements of the system and/or devices.
The shortcomings of the prior art are overcome and additional advantages are provided through the provision of a system of managing the allocation of space on storage devices. The system includes, for instance, means for obtaining weights for at least a subset of a plurality of data storage devices, the subset including at least two data storage devices, and wherein the obtaining includes using a first weighting procedure based on a first parameter; means for allocating space on multiple data storage devices of the at least a subset of data storage devices in proportion to weights obtained for the multiple data storage devices, wherein the allocating is independent of access patterns of data to be accommodated by the allocated space in that the allocating is performed without a priori knowledge of the access patterns; means for subsequently dynamically adjusting one or more of the weights using at least one second weighting procedure different from the first weighting procedure, wherein the at least one second weighting procedure is based on at least one second parameter, wherein one or more parameters of the at least one second parameter differ from the first parameter; and means for allocating space on one or more data storage devices using the one or more dynamically adjusted weights.
Computer program products and methods corresponding to the above-summarized systems are also described and may be claimed herein.
The capabilities of one or more aspects of the present invention advantageously provide for the allocation of space across a plurality of storage devices, such that the space on each device is allocated and thus, consumed in proportion to some weight assigned to that device. The weight assigned to each device determines the allocation policy and allows the file system to balance the allocation across the devices. The weights and the allocation policy are independent of the technique used for allocation. This allows the policy to be changed dynamically to better match the current conditions and requirements.
Additional features and advantages are realized through the techniques of the present invention. Other embodiments and aspects of the invention are described in detail herein and are considered a part of the claimed invention.
The subject matter which is regarded as the invention is particularly pointed out and distinctly claimed in the claims at the conclusion of the specification. The foregoing and other objects, features, and advantages of the invention are apparent from the following detailed description taken in conjunction with the accompanying drawings in which:
In accordance with an aspect of the present invention, space is allocated on multiple storage devices in proportion to weights associated with those devices. In particular, weights obtained for the storage devices are used to generate a stripe order, which provides the order in which space on individual storage devices is to be allocated and the frequency of allocating space on those devices.
As used herein, the obtaining of weights can be accomplished in any manner including, but not limited to, receiving the weights, and assigning the weights. Further, as used herein, a weight is a relative value obtained for data storage devices to indicate how one data storage device compares to another. This obtained value (i.e., weight) indicates, for instance, characteristics or capabilities of one data storage device relative to another. As one example, relative capacities of data storage devices can be indicated by values (i.e., weights) assigned to the devices such that a data storage device having a greater capacity is assigned a higher value. Other examples are described further below.
One embodiment of a computing environment incorporating and/or using aspects of the present invention is described with reference to
As one example, a node 102 includes an operating system 200 (
In accordance with an aspect of the present invention, file system 202 allocates space on the various storage devices, such that the total allocation on each storage device is proportional to a weight obtained for (e.g., assigned to) that device. The weight obtained for each device is used in determining the allocation policy and allows the file system to balance the allocation across the devices to match individual device capacities and to better utilize the combined throughput of the devices. However, the weights and the allocation policy (i.e., the order and frequency of allocations on each device) are independent of the technique used for the allocation. That is, different allocation techniques can be used for the allocation. The allocation technique is not tied to the weights. This allows the weights to represent a variety of parameters (e.g., capacity weighting, throughput weighting, round-robin weighting, hybrid weighting, etc.), and allows the weights to dynamically change. Thus, the allocation policy can be changed at any time to better suit the current conditions or requirements. Further, any weighting technique used in obtaining the weights need not be known to the allocation technique.
Many different allocation techniques can be used to allocate space on the storage devices. One such technique, in accordance with an aspect of the present invention, is a deterministic technique, which is described with reference to
As shown in
Initialization step 300 includes providing each of a plurality of devices (either all or some subset of the storage devices associated with the file system) with a weight and an allocation distance. One embodiment of this initialization is described with reference to
Initially, from a given list of devices and associated weights, where the weights are greater than zero, the lowest weight in the list is determined, STEP 400. In one example, this includes a linear scan over the weights in the list to find the lowest weight. However, for other embodiments, a heap or priority queue could be used to improve the efficiency of the technique.
Subsequent to finding the minimum weight, the weights are normalized such that the lowest weight is 1.0 and the other weights are proportionally higher, STEP 402. This is accomplished by dividing each of the weights by the minimum weight. For example, given four devices with weights [1000, 1500, 2000, 2500], the normalized weights are [1, 1.5, 2.0, 2.5].
Thereafter, the normalized weights are summed to obtain a total weight, STEP 404. Thus, for the above example, the total weight is seven (1+1.5+2.0+2.5=7).
The total weight and normalized weights are then used to set the average distance between allocations for each device, STEP 406. In one example, the average distance between allocations for a device is computed by dividing the total weight of the devices (e.g., 7) by the normalized weight for that device. Thus, in the example described above, the average allocation distance for each of the four devices is 7, 4.3, 3.5 and 2.8, respectively.
Thereafter, the current position for each device is initialized to the average allocation distance for that device, STEP 408. That is, Device 1 is initialized to 7, Device 2 is initialized to 4.3, Device 3 is initialized to 3.5 and Device 4 is initialized to 2.8, in the example provided herein. This completes the initialization step of
One example of pseudocode used to initialize device weights and allocation distances is listed below:
Initialize the device weights and allocation distances:
// Find the minimum weight
minWeight = Weight[device#1]
If Weight[device] < minWeight
then minWeight = Weight[device]
// Normalize all weights
normalWeight[device] = Weight[device]/
//Sum the normalized weights
totalWeight = 0
totalWeight = totalWeight + normalWeight
//Set the average distance between allocations
for each device
allocDistance[device] = totalWeight/
//Finally, initialize the current position for
To generate the stripe order, each device is selected in turn. In one example, the next device to be selected for the stripe order is the device with the lowest current position. Thus, that device is located, STEP 500. For example, using the four devices above, with normalized weights of [1.0, 1.5, 2.0, 2.5] and an average allocation distance of [7, 4.3, 3.5, 2.8], the device with the lowest current position is Device 4 with a current position of 2.8.
Subsequent to finding the device with the minimum current position, the current position for that selected device is updated, STEP 502. In one example, the current position is updated by adding the average allocation distance of that device to its current position. Thus, for Device 4, 2.8 is added to its current position of 2.8, yielding 5.6. This selected device is then returned to the caller, STEP 504.
The above is repeated for the desired number of allocations in the stripe order. In one example, the first fourteen allocations in the stripe order for the above example would be 4, 3, 2, 4, 1, 3, 4, 2, 3, 4, 1, 2, 3, 4. Thus, Device 1 has two allocations, Device 2 has three allocations, Device 3 has four allocations, and Device 4 has five allocations, which is in proportion to the weights assigned to each device.
One embodiment of pseudocode associated with selecting the next device in the stripe order is depicted below.
Selecting the next device in the stripe order:
//Find the device with the minimum current position
minDevice = device#1
if currentPosition[device] < currentPosition [minDevice]
minDevice = device
// Update the current position for the selected device
currentPosition[minDevice] = currentPosition
[minDevice] + allocDistance[minDevice]
// Return the selected device to the caller
One embodiment of the logic associated with resetting the current positions is described with reference to
Resetting the current positions:
//Find the minimum current allocation position
minPosition = currentPosition[device#1]
if currentPosition[device] < minPosition
minPosition = currentPosition[device]
// Adjust the allocation distance for all devices
currentPosition[device] − minPosition
Described above is one allocation technique for allocating space across multiple storage devices based on weights associated with those storage devices. Another technique used for such allocation is referred to as a randomized technique. The randomized technique is an alternative implementation for weighted allocation based on a randomized selection of each device in the stripe order. The weight assigned to each device is used to bias the random selection so that the allocation is proportional to the weights.
In one example, randomized weighted allocation is performed in cycles. The weights of the devices are maintained as floating point numbers. The integer portion of each weight is used to determine the number of allocations to that device in each cycle. The sum of the integer portions determines the total number of allocations in the cycle. As each cycle completes, the initial normalized weights are added into the current weights and the next cycle of allocation can begin. The fractional portions of each weight accumulate across cycles to accurately maintain the weighted proportion.
One embodiment of the logic associated with a randomized allocation technique is described with reference to
Initially, the minimum weight of the list of weights is found, STEP 800. Thereafter, the weight of each device is divided by the minimum weight in order to obtain a normalized weight for that device, STEP 802. The normalized weights are saved, and are also used to set the original current weights for the devices, STEP 804. In particular, the current weight for each device is initialized to its normalized weight.
Thereafter, the integer portion of the current weights are summed to determine the number of allocations in the first allocation cycle, STEP 806. For example, given four devices with weights [1000, 1500, 2000, 2500], the normalized weights are [1, 1.5, 2.0, 2.5], and the total allocations on the first cycle is 6 (1+1+2+2=6).
One embodiment of pseudocode employed to initialize the device weights and total allocations is provided below:
floating minWeight, Weight[ ]
floating normalWeight[ ], currentWeight[ ]
int device, allocsRemaining
// Find the minimum weight
minWeight = Weight[device#1]
if Weight[device]< minWeight
then minWeight = Weight[device]
// Normalize all the device weights
normalWeight[device] = Weight[device]/minWeight
// Initialize the current weight for each device
currentWeight[device] = normalWeight[device]
// Count the number of allocations in the first
// Subroutine float2int will truncate the f
fractional portion of each floating number.
allocsRemaining = 0
allocsRemaining = allocsRemaining + float2int
Initially, a random integer number is generated, STEP 900. For example, a random number is selected within the range of 1 to the number of allocations remaining in the cycle (i.e., [1 . . . allocRemaining]). Thus, if the total allocations in this cycle is six, a random number from 1 to 6 is selected. This number is then used to select a device by counting the integer portions of the weights of each device until the number is reached, STEP 902. For example, for devices with current weights of [1, 1.5, 2.0, 2.5] and a random number of 4, a selection of Device 3 results (1(of Device 1)+1 (of Device 2)+2(of Device 3)=4). As a further example, a random number of 1 results in a selection of Device 1.
Once a device is selected, its current weight and the total allocations remaining in the cycle are both decremented by 1, STEP 904. When the total allocations remaining reaches 0, the cycle is complete. To start a new cycle, the initial normalized weights are added to the current weights and the number of allocations in the next cycle are counted, STEP 906.
Thereafter, the selected device is returned to the caller, STEP 908. The above procedure is repeated until each cycle is complete, in one example.
One embodiment of pseudocode used to select the next device in the data stripe order is depicted below:
integer device, selectCount
floating currentWeight[ ], normalWeight[ ]
// Generate an integer random number between 0 and
selectCount = random( ) mod allocsRemaining
// Scan the current device weights to locate the
if (currentWeight[device] >= 1.0) then
if (currentWeight[device] >= selectCount)
selectCount = selectCount − float2int
// Update the device's current weight
currentWeight[device] = currentWeight[device] − 1.0;
allocsRemaining = allocsRemaining − 1;
// Reset the weights to start a new cycle,
if (allocsRemaining == 0) then
// Update each device's current weight
currentWeight[device] = currentWeight[device]
allocsRemaining = allocsRemaining + float2int
// Return the selected device to the caller
Described in detail above are two implementations of weighted allocation. Although these particular techniques are described herein, the invention is not limited to such techniques. Any allocation technique, which can use weights to allocate, can be employed without departing from the spirit of the present invention.
Although weighted allocation depends on the weights to determine the allocation policy, the allocation techniques themselves are independent of the actual weights assigned to each device. The weights can be changed at any time, to adjust the load on each device as needed. Furthermore, the technique of assigning weights can be changed at any time. This allows the allocation policy to be set dynamically and adjusted to meet the current requirements of the system.
A variety of weighting techniques are available to assign the initial weights, including for instance, the following:
(1) Round-Robin Weighting—To implement a simple round-robin allocation, the weight of each device is set to 1. Using an equal weight for each device, the technique will allocate space on each device an equal number of times.
(2) Capacity Weighting—To better distribute the allocations across uneven sized devices, the weights can be assigned using the relative capacity of each device. This weighting technique causes the devices to fill in the same proportion (i.e., the percentage utilized on each device is the same, regardless of the capacity of the device). Consequently, the expected I/O load on each device is also in proportion the device's capacity.
(3) Free Space Weighting—The weights may be based upon the relative amount of free space on each device. Under this technique, devices with a higher percentage of free space receive proportionately more allocations. This serves to rebalance unevenly filled devices, which may have resulted from adding new devices to an existing system or previously using round-robin allocation on uneven sized devices. The weights can be adjusted dynamically to account for changes in the relative amount of free space. For devices that are evenly filled, the free space weighting technique is equivalent to capacity weighting.
(4) Throughput Weighting—The weights can also be assigned based on the relative performance of each device. Devices with higher throughput receive proportionately more allocations and consequently, more I/O requests on the average. This weighting attempts to maximize the total throughput of the combined devices.
There are a number of ways to determine the throughput weights during initialization, including, for instance, reading the device throughput from a table or by measuring the device throughput by measuring the actual throughput to each device while the system is under a maximal I/O load.
(5) Hybrid Weighting—Not only can the weights be changed dynamically, the technique for assigning the weights can also be changed. Furthermore, a combination of two or more weighting techniques to produce a hybrid weighting can be used. This may be accomplished by computing the normalized weight for each device under more than one technique, then adding the normalized weights for a device from each desired technique. This allows the system to tailor the allocation to the current requirements and to change the allocation as the system changes.
Described in detail above is an allocation capability in which a stripe order is generated and used such that the total allocation on each device is proportional to the weight assigned to that device. The weighted allocation allows the system to balance the allocation to match the device capacities and to better utilize the combined throughput to the devices.
In one example, one or more stripe orders can be generated and used to allocate space across the storage devices. As examples, one stripe order can be used for all allocations of a file system; in another example, the storage devices are partitioned into groups, and a stripe order is generated and used for each group; and in yet another embodiment, a stripe order is generated for each file that is going to have space allocated therefor. Thus, in the last example, one stripe order can be used to allocate space for one file, and another stripe order (the same or different) can be used to allocate space for another file. In any of the above scenarios, the stripe orders are generated, as described above.
Various allocation techniques can be used to perform the weighted allocation. The allocation technique selected is independent of the weight assigned to each device, thus allowing the weights to be dynamically changed. This allows the allocation policy to be changed at any time to better suit the current conditions or requirements.
The weights assigned to the devices can be dynamically changed to represent different values and/or to represent a different operating parameter (e.g., capacity, I/O throughput, round-robin, hybrid). Further, the weighting assigning technique need not be known to the allocation technique. Further, the allocation technique can accommodate various data streams, including video streams and general data streams. This is because the allocation technique does not know and need not know a priori the length of the data streams and/or the access patterns of those data streams.
The allocation capability of the present invention is able to stripe according to weight across a plurality of heterogeneous storage devices. That is, the storage devices may be of different sizes, different capacities and/or of different speeds. These heterogeneous devices can be utilized and that utilization can be maximized. For instance, storage usage can be maximized and/or throughput can be maximized.
Additionally, the allocation capability of the present invention can automatically compensate for an imbalance in the file system. Such an imbalance can be caused by adding devices to the system, removing devices from the system, or for any other reasons. The rebalancing of the system is performed without necessarily restriping space already striped. In one example, the rebalancing is accomplished by obtaining new, different and/or additional weights and using an allocation technique to allocate space based on those weights.
The above-described computing environment is offered as only one example. One or more aspects of the present invention can be incorporated and used with many types of computing units, computers, processors, nodes, systems, work stations and/or environments without departing from the spirit of the present invention. As one example, one or more aspects of the present invention can be incorporated and used in a computing environment having a single node coupled to a plurality of storage devices, in which that node may have either a traditional distributed file system or a parallel file system.
The present invention can be included in an article of manufacture (e.g., one or more computer program products) having, for instance, computer usable media. The media has embodied therein, for instance, computer readable program code means for providing and facilitating the capabilities of the present invention. The article of manufacture can be included as a part of a computer system or sold separately.
Additionally, at least one program storage device readable by a machine, tangibly embodying at least one program of instructions executable by the machine to perform the capabilities of the present invention can be provided.
The flow diagrams depicted herein are just examples. There may be many variations to these diagrams or the steps (or operations) described therein without departing from the spirit of the invention. For instance, the steps may be performed in a differing order, or steps may be added, deleted or modified. All of these variations are considered a part of the claimed invention.
Although preferred embodiments have been depicted and described in detail herein, it will be apparent to those skilled in the relevant art that various modifications, additions, substitutions and the like can be made without departing from the spirit of the invention and these are therefore considered to be within the scope of the invention as defined in the following claims.
|Brevet cité||Date de dépôt||Date de publication||Déposant||Titre|
|US3715730||1 juin 1970||6 févr. 1973||Texas Instruments Inc||Multi-criteria search procedure for trainable processors|
|US3715840||31 déc. 1970||13 févr. 1973||Grav I Flo Corp||Apparatus and method for finishing workpieces|
|US4274139||16 avr. 1979||16 juin 1981||International Business Machines Corporation||Digital telecommunication network having improved data processing systems|
|US4467421||2 juin 1982||21 août 1984||Storage Technology Corporation||Virtual storage system and method|
|US4779189||28 juin 1985||18 oct. 1988||International Business Machines Corporation||Peripheral subsystem initialization method and apparatus|
|US5014197 *||2 sept. 1988||7 mai 1991||International Business Machines Corporation||Assignment of files to storage device using macro and micro programming model which optimized performance of input/output subsystem|
|US5043876||27 mai 1988||27 août 1991||International Business Machines Corporation||N-level file shadowing and recovery in a shared file system|
|US5129088||3 juil. 1990||7 juil. 1992||International Business Machines Corporation||Data processing method to create virtual disks from non-contiguous groups of logically contiguous addressable blocks of direct access storage device|
|US5202971||17 déc. 1990||13 avr. 1993||International Business Machines Corporation||System for file and record locking between nodes in a distributed data processing environment maintaining one copy of each file lock|
|US5226159||4 juin 1992||6 juil. 1993||International Business Machines Corporation||File lock management in a distributed data processing system|
|US5301350||6 janv. 1993||5 avr. 1994||Unisys Corporation||Real time storage/retrieval subsystem for document processing in banking operations|
|US5375233||6 avr. 1992||20 déc. 1994||International Computers Limited||File system|
|US5394531||18 nov. 1991||28 févr. 1995||International Business Machines Corporation||Dynamic storage allocation system for a prioritized cache|
|US5423046||17 déc. 1992||6 juin 1995||International Business Machines Corporation||High capacity data storage system using disk array|
|US5454108||26 janv. 1994||26 sept. 1995||International Business Machines Corporation||Distributed lock manager using a passive, state-full control-server|
|US5463736||18 oct. 1994||31 oct. 1995||International Business Machines Corporation||Coupling facility for receiving commands from plurality of hosts for activating selected connection paths to I/O devices and maintaining status thereof|
|US5490270||16 juin 1994||6 févr. 1996||International Business Machines Corporation||Simultaneous updates to the modification time attribute of a shared file in a cluster having a server and client nodes|
|US5537588||11 mai 1994||16 juil. 1996||International Business Machines Corporation||Partitioned log-structured file system and methods for operating the same|
|US5566297||16 juin 1994||15 oct. 1996||International Business Machines Corporation||Non-disruptive recovery from file server failure in a highly available file system for clustered computing environments|
|US5572699||15 mars 1993||5 nov. 1996||Hitachi, Ltd.||Variable length data in a parallel disk array|
|US5583995||30 janv. 1995||10 déc. 1996||Mrj, Inc.||Apparatus and method for data storage and retrieval using bandwidth allocation|
|US5600820||1 déc. 1993||4 févr. 1997||Bell Communications Research, Inc.||Method for partitioning memory in a high speed network based on the type of service|
|US5657476||17 juin 1993||12 août 1997||Korg, Inc.||Signal processor with delay line management logic|
|US5659704||2 déc. 1994||19 août 1997||Hewlett-Packard Company||Methods and system for reserving storage space for data migration in a redundant hierarchic data storage system by dynamically computing maximum storage space for mirror redundancy|
|US5675769||23 févr. 1995||7 oct. 1997||Powerquest Corporation||Method for manipulating disk partitions|
|US5687363||26 juil. 1996||11 nov. 1997||Siemens Stromberg-Carlson||Distributed database architecture and distributed database management system for open network evolution|
|US5706472||7 nov. 1995||6 janv. 1998||Powerquest Corporation||Method for manipulating disk partitions|
|US5708660||4 mars 1996||13 janv. 1998||Siemens Aktiengesellschaft||Circuit arrangement for accepting and forwarding message cells with an ATM communication equipment|
|US5721909||7 nov. 1996||24 févr. 1998||Siemens Stromberg-Carlson||Distributed database architecture and distributed database management system for open network evolution|
|US5724539||5 avr. 1994||3 mars 1998||Digital Equipment Corporation||System for selectively storing stripes of data in tracks of disks so that sum of transfer rates of stripes match communication bandwidth to host|
|US5732239||19 mai 1994||24 mars 1998||Starlight Networks||Method for operating a disk storage system which stores video data so as to maintain the continuity of a plurality of video streams|
|US5754756||29 févr. 1996||19 mai 1998||Hitachi, Ltd.||Disk array system having adjustable parity group sizes based on storage unit capacities|
|US5774643||13 oct. 1995||30 juin 1998||Digital Equipment Corporation||Enhanced raid write hole protection and recovery|
|US5774715||27 mars 1996||30 juin 1998||Sun Microsystems, Inc.||File system level compression using holes|
|US5784646||25 avr. 1995||21 juil. 1998||Sony Corporation||Hierarchical data storage processing apparatus for partitioning resource across the storage hierarchy|
|US5845319||21 août 1996||1 déc. 1998||Fujitsu Limited||Disk array device which separates local and physical disks using striping and operation mode selection|
|US5937428||6 août 1997||10 août 1999||Lsi Logic Corporation||Method for host-based I/O workload balancing on redundant array controllers|
|US5943690||7 avr. 1997||24 août 1999||Sony Corporation||Data storage apparatus and method allocating sets of data|
|US5960446||11 juil. 1997||28 sept. 1999||International Business Machines Corporation||Parallel file system and method with allocation map|
|US5963963||11 juil. 1997||5 oct. 1999||International Business Machines Corporation||Parallel file system and buffer management arbitration|
|US6016552||6 juin 1997||18 janv. 2000||The Chinese University Of Hong Kong||Object striping focusing on data object|
|US6023706||11 juil. 1997||8 févr. 2000||International Business Machines Corporation||Parallel file system and method for multiple node file access|
|US6055354||11 avr. 1997||25 avr. 2000||Discreet Logic Inc.||Data storage apparatus|
|US6104962||26 mars 1998||15 août 2000||Rockwell Technologies, Llc||System for and method of allocating processing tasks of a control program configured to control a distributed control system|
|US6122646||18 oct. 1994||19 sept. 2000||Sony Corporation||Method and apparatus for management of information where sub directory information in a directory identifies the relative recording location of the sub directory|
|US6253296||5 janv. 1998||26 juin 2001||Intel Corporation||Disk block allocation optimization methodology and applications|
|US6275917||15 janv. 1999||14 août 2001||Fujitsu Limited||High-speed address translation system|
|US6279052||13 janv. 1998||21 août 2001||Intel Corporation||Dynamic sizing of FIFOs and packets in high speed serial bus applications|
|US6309822||23 déc. 1996||30 oct. 2001||Affymetrix, Inc.||Method for comparing copy number of nucleic acid sequences|
|US6314102||10 juil. 1997||6 nov. 2001||Alcatel||Telecommunications system for providing both narrowband and broadband services to subscribers|
|US6317808 *||26 mars 1999||13 nov. 2001||Adc Telecommunications, Inc.||Data storage system and method of routing or assigning disk write requests among a set of disks using weighted available disk space values|
|US6327638||30 juin 1998||4 déc. 2001||Lsi Logic Corporation||Disk striping method and storage subsystem using same|
|US6378039 *||31 août 2000||23 avr. 2002||Hitachi, Ltd.||Storage subsystem which balances loads across a plurality of disk controllers|
|US6425052||28 oct. 1999||23 juil. 2002||Sun Microsystems, Inc.||Load balancing configuration for storage arrays employing mirroring and striping|
|US6629201||2 mai 2001||30 sept. 2003||Superspeed Software, Inc.||System and method for high-speed substitute cache|
|US6829678 *||18 juil. 2000||7 déc. 2004||International Business Machines Corporation||System for determining the order and frequency in which space is allocated on individual storage devices|
|US6928459||18 juil. 2000||9 août 2005||International Business Machines Corporation||Plurality of file systems using weighted allocation to allocate space on one or more storage devices|
|US7325120||6 déc. 2004||29 janv. 2008||International Business Machines Corporation||Allocating space on data storage devices in proportion to weights associated with the devices|
|GB2312316A||Titre non disponible|
|JPH11203055A||Titre non disponible|
|1||*||"IBM Video Charger Server for AIX," International Business Machines Corporation, Mar. 1997.|
|2||Corbett et al., "Vesta Parallel File System," ACM Transactions on Computer Systems, vol. 14, No. 3, Aug. 1996, pp. 225-264 (Abstract Only).|
|3||*||Custer, H., "Inside the Window NT File System," Microsoft Press, 1994, pp. 49-52.|
|4||*||Eshel et al., "CMS Interactive File Sharing Prototype," IBM Research Division, T.J. Watson Research Center, Yorktown Heights, NY RC13371 (#50869), Dec. 18, 1987.|
|5||Final Office Action for U.S. Patent No. 6,829,678 dated Feb. 25, 2004.|
|6||Final Office Action for U.S. Patent No. 6,928,459 dated Aug. 12, 2003.|
|7||Fujiwara, Torn et al., "Performance Analysis of Disk Allocation Method Using Error-Correcting Codes," IEEE Transactions on Information Theory, vol. 37, No. 2, Mar. 1991, pp. 379-384.|
|8||*||Howard et al., "Supporting Fundamentals for Microsoft Windows NT," Microsoft Press, pp. 152- 163 and 449-451, 1995.|
|9||IEEE 100: The Authoritative Diction of IEEE Standards Terms, 7th ed. IEEE Press, 2000. p. 1277.|
|10||*||Joel Wolf. "The Placement Optimization Program: A Practical Solution to the Disk File Assignment Problem." 1989. ACM. Performance Evaluation Review. vol. 17. Iss. 1. pp. 1-10.|
|11||*||Office Action for U.S. Patent No. 5,960,446 dated Aug. 31, 1998.|
|12||Office Action for U.S. Patent No. 6,829,678 dated Jul. 30, 2003.|
|13||Office Action for U.S. Patent No. 6,928,459 dated Feb. 27, 2003.|
|14||Office Action for U.S. Patent No. 6,928,459 dated Jun. 17, 2004.|
|15||Office Action for U.S. Patent No. 7,325,120 dated Jun. 20, 2007.|
|Classification aux États-Unis||711/114, 711/E12.002, 711/170|
|Classification internationale||G06F12/02, G06F17/30, G06F12/00, G06F3/06|
|Classification coopérative||G06F3/061, G06F3/067, G06F17/30067, G06F3/0644|
|Classification européenne||G06F3/06A4F6, G06F3/06A6D, G06F3/06A2P, G06F17/30F|
|5 déc. 2014||REMI||Maintenance fee reminder mailed|
|26 avr. 2015||LAPS||Lapse for failure to pay maintenance fees|
|16 juin 2015||FP||Expired due to failure to pay maintenance fee|
Effective date: 20150426