US20140215148A1 - Limiting the execution of background management operations in a drive array - Google Patents
Limiting the execution of background management operations in a drive array Download PDFInfo
- Publication number
- US20140215148A1 US20140215148A1 US13/755,280 US201313755280A US2014215148A1 US 20140215148 A1 US20140215148 A1 US 20140215148A1 US 201313755280 A US201313755280 A US 201313755280A US 2014215148 A1 US2014215148 A1 US 2014215148A1
- Authority
- US
- United States
- Prior art keywords
- drive
- write instruction
- memory
- instruction
- drive array
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Abandoned
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/07—Responding to the occurrence of a fault, e.g. fault tolerance
- G06F11/08—Error detection or correction by redundancy in data representation, e.g. by using checking codes
- G06F11/10—Adding special bits or symbols to the coded information, e.g. parity check, casting out 9's or 11's
- G06F11/1076—Parity data used in redundant arrays of independent storages, e.g. in RAID systems
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F12/00—Accessing, addressing or allocating within memory systems or architectures
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
- G06F3/0601—Interfaces specially adapted for storage systems
- G06F3/0602—Interfaces specially adapted for storage systems specifically adapted to achieve a particular effect
- G06F3/061—Improving I/O performance
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
- G06F3/0601—Interfaces specially adapted for storage systems
- G06F3/0628—Interfaces specially adapted for storage systems making use of a particular technique
- G06F3/0655—Vertical data movement, i.e. input-output transfer; data movement between one or more hosts and one or more storage devices
- G06F3/0659—Command handling arrangements, e.g. command buffers, queues, command scheduling
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
- G06F3/0601—Interfaces specially adapted for storage systems
- G06F3/0668—Interfaces specially adapted for storage systems adopting a particular infrastructure
- G06F3/0671—In-line storage system
- G06F3/0683—Plurality of storage devices
- G06F3/0689—Disk arrays, e.g. RAID, JBOD
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2211/00—Indexing scheme relating to details of data-processing equipment not covered by groups G06F3/00 - G06F13/00
- G06F2211/10—Indexing scheme relating to G06F11/10
- G06F2211/1002—Indexing scheme relating to G06F11/1076
- G06F2211/104—Metadata, i.e. metadata associated with RAID systems with parity
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2211/00—Indexing scheme relating to details of data-processing equipment not covered by groups G06F3/00 - G06F13/00
- G06F2211/10—Indexing scheme relating to G06F11/10
- G06F2211/1002—Indexing scheme relating to G06F11/1076
- G06F2211/1059—Parity-single bit-RAID5, i.e. RAID 5 implementations
Definitions
- the field of the invention is data processing, or, more specifically, methods, apparatus, and products for limiting the execution of background management operations in a drive array.
- Storage systems can be embodied as a redundant array of independent disks (‘RAID’) that are controlled by a RAID controller.
- RAID controllers protect data by adding parity protection over a group of independent storage devices. Parity calculations require the RAID controller to use a number of reads and writes that are in some cases dependent on one another to keep the drive group coherent. The parity calculations on a RAID array require data from multiple sources and writes will have to wait for a series of reads and these parity calculations to complete. Individual devices can interpret the pause in activity as an opportunity to perform background tasks such as data scrubbing or consistency checking, which can hurt write performance on the storage array.
- Methods, apparatus, and products for limiting the execution of background management operations in a drive array including: receiving, by a drive array controller, a read instruction to read data from a memory drive in the drive array; determining, by the drive array controller, whether the read instruction is associated with a write instruction to write data to a memory drive in the drive array; responsive to determining, by the drive array controller, that the read instruction is associated with the write instruction, restricting, by the drive array controller, performance of background management operations on the memory drive targeted by the write instruction; determining, by the drive array controller, whether the write instruction has completed; and responsive to determining, by the drive array controller, that the write instruction has completed, removing, by the drive array controller, restrictions associated with the performance of background management operations on the memory drive targeted by the write instruction.
- FIG. 1 sets forth a block diagram of automated computing machinery comprising an example computer useful in limiting the execution of background management operations in a drive array according to embodiments of the present invention.
- FIG. 2 sets forth a flow chart illustrating an example method for limiting the execution of background management operations in a drive array according to embodiments of the present invention.
- FIG. 3 sets forth a flow chart illustrating an additional example method for limiting the execution of background management operations in a drive array according to embodiments of the present invention.
- FIG. 1 sets forth a block diagram of automated computing machinery comprising an example computer ( 152 ) useful in limiting the execution of background management operations in a drive array according to embodiments of the present invention.
- the computer ( 152 ) of FIG. 1 includes at least one computer processor ( 156 ) or ‘CPU’ as well as random access memory ( 168 ) (RAM') which is connected through a high speed memory bus ( 166 ) and bus adapter ( 158 ) to processor ( 156 ) and to other components of the computer ( 152 ).
- RAM Stored in RAM ( 168 ) is an application program ( 126 ), a module of user-level computer program instructions for carrying out particular data processing tasks on the computer ( 152 ). Examples of such application programs include spreadsheets, word processing programs, email clients, web browsers, database management programs, and so on. Also stored in RAM is a drive controller interface ( 130 ), a module of computer program instructions that provides an application programming interface or ‘API’ through which the application program ( 126 ) can communicate with a drive array controller ( 204 ), such as a redundant array of independent disks (‘RAID’) controller, for writing and reading data to and from one or more memory drives ( 224 , 226 , 228 ) in a drive array ( 222 ).
- a drive controller such as a redundant array of independent disks (‘RAID’) controller
- RAM ( 168 ) Also stored in RAM ( 168 ) is an operating system ( 154 ).
- Operating systems useful limiting the execution of background management operations in a drive array according to embodiments of the present invention include UNIX TM , Linux TM , Microsoft XPTM, AIXTM, IBM's i5/OSTM, and others as will occur to those of skill in the art.
- the operating system ( 154 ), application program ( 126 ), and drive controller interface ( 130 ) in the example of FIG. 1 are shown in RAM ( 168 ), but many components of such software typically are stored in non-volatile memory also, such as, for example, on a memory drive.
- the example computer ( 152 ) of FIG. 1 includes one or more input/output (‘I/O’) adapters ( 178 ).
- I/O adapters implement user-oriented input/output through, for example, software drivers and computer hardware for controlling output to display devices such as computer display screens, as well as user input from user input devices ( 181 ) such as keyboards and mice.
- the example computer ( 152 ) of FIG. 1 includes a video adapter ( 209 ), which is an example of an I/O adapter specially designed for graphic output to a display device ( 180 ) such as a display screen or computer monitor.
- Video adapter ( 209 ) is connected to processor ( 156 ) through a high speed video bus ( 164 ), bus adapter ( 158 ), and the front side bus ( 162 ), which is also a high speed bus.
- the example computer ( 152 ) of FIG. 1 includes a communications adapter ( 167 ) for data communications with other computers ( 182 ) and for data communications with a data communications network ( 100 ).
- a communications adapter for data communications with other computers ( 182 ) and for data communications with a data communications network ( 100 ).
- data communications may be carried out serially through RS- 232 connections, through external buses such as a Universal Serial Bus (‘USB’), through data communications networks such as IP data communications networks, and in other ways as will occur to those of skill in the art.
- Communications adapters implement the hardware level of data communications through which one computer sends data communications to another computer, directly or through a data communications network.
- Examples of communications adapters useful for limiting the execution of background management operations in a drive array according to embodiments of the present invention include modems for wired dial-up communications, Ethernet (IEEE 802.3) adapters for wired data communications network communications, and 802.11 adapters for wireless data communications network communications.
- the example computer of FIG. 1 also includes a drive array controller ( 204 ) coupled through an expansion bus ( 160 ) and a bus adapter ( 158 ) to a processor ( 156 ) and other components of the computer ( 152 ).
- the drive array controller ( 204 ) is a computer input/output adapter that connects non-volatile data storage to the computer ( 152 ) in the form of memory drives ( 224 , 226 , 228 ).
- the drive array controller ( 204 ) of FIG. 1 administers read and write requests to and from memory drives ( 224 , 226 , 228 ).
- the drive array controller ( 204 ) can carry out limiting the execution of background management operations in a drive array ( 222 ) by receiving a read instruction to read data from a first memory drive ( 224 ) in a drive array ( 222 ).
- the read instruction may be received from the computer processor ( 156 ) that sends the read instruction to the drive array controller ( 204 ) over a memory bus.
- Such a read instruction may be part of a larger memory management operation such as, for example, performing parity calculations for memory drives ( 224 , 226 , 228 ) in the drive array ( 222 ).
- the drive array controller ( 204 ) can further carry out limiting the execution of background management operations in a drive array ( 222 ) by determining whether the read instruction is associated with a write instruction to write data to a second memory drive ( 226 ) in the drive array ( 222 ). Determining whether the read instruction is associated with a write instruction to write data to a second memory drive ( 226 ) in the drive array ( 222 ) may be carried out, for example, through the use of flags that are contained in the read instruction ( 202 ), through the use of flags that are contained in the data that is to be read as a result of the read instruction ( 202 ), and so on.
- performing parity calculations for the drive array ( 222 ) can include reading data from a plurality of memory drives ( 224 , 228 ), using the data that was read from the memory drives ( 224 , 228 ) as input to an exclusive OR operation, and subsequently writing the result of the exclusive OR operation to another memory drive ( 226 ) that is responsible for maintaining parity information for a particular portion of the memory drives ( 224 , 228 ).
- a read instruction would be issued to memory drive ( 224 ) and another read instruction would be issued to memory drive ( 228 ).
- Each read instruction would be associated with a write instruction that will be issued to memory drive ( 226 ) upon the completion of the exclusive OR operation. As such, even though memory drive ( 226 ) may not be actively servicing any memory access requests, the issuance of a read instruction to memory drive ( 224 ) and another read instruction to memory drive ( 228 ) as part of parity calculations would serve as an indication that memory drive ( 226 ) will be servicing a memory access request—writing the result of the exclusive OR operation to the memory drive ( 226 )—in the near future.
- the drive array controller ( 204 ) can further carry out limiting the execution of background management operations in a drive array ( 222 ) by restricting performance of background management operations on the second memory drive ( 226 ) in the drive array ( 222 ). Restricting performance of background management operations on the second memory drive ( 226 ) in the drive array ( 222 ) is carried out in response to affirmatively determining that the read instruction is associated with the write instruction.
- Background management operations can include data scrubbing operations, consistency checking, and other management operations that are frequently run as background tasks to ensure proper operation of the memory drives ( 224 , 226 , 228 ).
- a particular operation may be identified as being a background management operation, for example, as part of configuring a computing system, as the result of input from a system administrator, and so on.
- Such background operations are typically executed through the use of a background process that is running in the background without user intervention.
- the memory drive ( 224 , 226 , 228 ) When a particular memory drive ( 224 , 226 , 228 ) is servicing memory access requests that are performed as part of background management operations, the memory drive ( 224 , 226 , 228 ) will have less capacity to service memory access requests that are performed as the result of normal computing operations.
- the memory drive ( 224 , 226 , 228 ) may have less capacity to service memory access requests that are performed as the result of normal computing operations because resources required to service memory access requests that are performed as part of background management operations are being dedicated to the execution of the background management operations. As such, the performance of background management operations on the second memory drive ( 226 ) in the drive array ( 222 ) may be restricted in anticipation of servicing the write instruction that is related to the read instruction.
- Restricting the performance of background management operations on the second memory drive ( 226 ) in the drive array ( 222 ) can include, for example, limiting the percentage of memory access requests that the second memory drive ( 226 ) may service as part of performing background management operations to a predetermined threshold.
- the drive array controller ( 204 ) can further carry out limiting the execution of background management operations in a drive array ( 222 ) by receiving the write instruction.
- the write instruction may be issued to the drive array controller ( 204 ), for example, by the computer processor ( 156 ) over a memory bus.
- Such a write instruction may be part of a larger memory management operation such as, for example, performing parity calculations for memory drives ( 224 , 226 , 228 ) in the drive array ( 222 ).
- Such metadata may include, for example, an identifier that includes a unique value that is included in metadata associated with the read instruction and also included in metadata associated with the write instruction.
- the drive array controller ( 204 ) may store the unique identifier contained in the read instruction. This value may be compared against values contained in metadata associated with incoming write instructions to identify the write instruction that includes a matching unique identifier.
- the drive array ( 222 ) is a RAID 5 compliant array.
- Performing parity calculations for the drive array ( 222 ) can therefore include reading data from a plurality of memory drives ( 224 , 228 ), using the data that was read from the memory drives ( 224 , 228 ) as input to an exclusive OR operation, and subsequently writing the result of the exclusive OR operation to another memory drive ( 226 ) that is responsible for maintaining parity information for a particular portion of the memory drives ( 224 , 228 ).
- the read instruction that is issued to memory drive ( 224 ) and read instruction that is issued to memory drive ( 228 ) may include metadata identifying these read instructions as being related to a write instruction that has not yet been issued.
- Each read instruction can also include a particular value that is to be used as an identifier of the group of instructions. This value can be stored in memory used by the drive array controller ( 204 ).
- the drive array controller ( 204 ) may examine the metadata associated with the incoming write instruction to determine whether the metadata associated with the incoming write instruction includes a value that matches the value that was that includes in the read instruction that is issued to memory drive ( 224 ) and read instruction that is issued to memory drive ( 228 ). If the values match, the incoming write instruction represents that related write instruction that was identified in the read instruction that is issued to memory drive ( 224 ) and read instruction that is issued to memory drive ( 228 ). Once the related write instruction is executed, there is no longer a need to restrict the performance of background management operations on the memory drive ( 226 ) targeted by the write operation.
- the drive array controller ( 204 ) can further carry out limiting the execution of background management operations in a drive array ( 222 ) by removing the restrictions associated with the performance of background management operations on the second memory drive ( 226 ) in the drive array ( 222 ). Removing the restrictions associated with the performance of background management operations on the second memory drive ( 226 ) in the drive array ( 222 ) is carried out in response to affirmatively determining that the write instruction has completed.
- Removing the restrictions associated with the performance of background management operations on the second memory drive ( 226 ) in the drive array ( 222 ) may be carried out, for example, by removing any limitations as to the percentage of memory access requests that the second memory drive ( 226 ) may service as part of performing background management operations, by increasing the percentage of memory access requests that the second memory drive ( 226 ) may service as part of performing background management operations, and so on.
- FIG. 2 sets forth a flow chart illustrating an example method for limiting the execution of background management operations in a drive array ( 222 ) according to embodiments of the present invention.
- the drive array ( 222 ) of FIG. 2 includes a plurality of memory drives ( 224 , 226 , 228 ).
- Each memory drive ( 224 , 226 , 228 ) may be embodied as a distinct computer storage device such as, for example, a disk drive, a solid state drive, and so on.
- the memory drives ( 224 , 226 , 228 ) are pooled together to create a drive array ( 222 ) which is a storage system that contains multiple memory drives to provide increased availability and resiliency through the use of redundant components.
- the drive array ( 222 ) of FIG. 2 may be embodied, for example, as a redundant array of independent disks (‘RAID’). Such a RAID may adhere to standard RAID levels such as RAID 5 in which parity and data are distributed amongst the memory drives ( 224 , 226 , 228 ).
- RAID redundant array of independent disks
- the example method of FIG. 2 is carried out by a drive array controller ( 204 ).
- the drive array controller ( 204 ) of FIG. 2 may be embodied as a device to manage the drive array ( 222 ), including the memory drives ( 224 , 226 , 228 ) that form the drive array ( 222 ).
- the drive array controller ( 204 ) of FIG. 2 may be embodied as a RAID controller which manages the physical memory drives ( 224 , 226 , 228 ) of a RAID and presents them to a computing device as logical units.
- the example method of FIG. 2 includes receiving ( 206 ), by the drive array controller ( 204 ), a read instruction ( 202 ) to read data from a first memory drive ( 224 ) in a drive array ( 222 ).
- the read instruction ( 202 ) may be received from a computer processor (not shown) that sends the read instruction ( 202 ) to the drive array controller ( 204 ) over a memory bus.
- Such a read instruction ( 202 ) may be part of a larger memory management operation such as, for example, performing parity calculations for memory drives ( 224 , 226 , 228 ) in the drive array ( 222 ).
- the example method of FIG. 2 also includes determining ( 208 ), by the drive array controller ( 204 ), whether the read instruction ( 202 ) is associated with a write instruction ( 200 ) to write data to a second memory drive ( 226 ) in the drive array ( 222 ).
- determining ( 208 ) whether the read instruction ( 202 ) is associated with a write instruction ( 200 ) to write data to a second memory drive ( 226 ) in the drive array ( 222 ) may be carried out, for example, through the use of flags that are contained in the read instruction ( 202 ), through the use of flags that are contained in the data that is to be read as a result of the read instruction ( 202 ), and so on.
- the read instruction ( 202 ) may include metadata that is associated with the read instruction ( 202 ).
- metadata may include, for example, an integer value that is set by the issuer of the read instruction ( 202 ) to identify whether the read instruction ( 202 ) is associated with a write instruction ( 200 ) to write data to a second memory drive ( 226 ) in the drive array ( 222 ).
- a value of 0 may indicate that the read instruction ( 202 ) is not associated with a write instruction ( 200 ) to write data to a second memory drive ( 226 ) in the drive array ( 222 ), while a value of 1 may indicate that the read instruction ( 202 ) is associated with a write instruction ( 200 ) to write data to a second memory drive ( 226 ) in the drive array ( 222 ).
- the drive array controller ( 204 ) may read the values contained in such flags to determine ( 208 ) whether the read instruction ( 202 ) is associated with a write instruction ( 200 ) to write data to a second memory drive ( 226 ) in the drive array ( 222 ).
- the write instruction ( 200 ) that is associated with the read instruction ( 202 ) may not yet have been issued at the time it was determined ( 208 ) that the read instruction ( 202 ) is associated with a write instruction ( 200 ) to write data to a second memory drive ( 226 ) in the drive array ( 222 ). That is, the issuer of the read instruction ( 202 ) may know, at the time that the read instruction ( 202 ) is issued, that the read instruction ( 202 ) is just one memory access request in a series of memory access requests that will involve issuing a write instruction ( 200 ) to write data to a second memory drive ( 226 ) in the drive array ( 222 ) at a later time.
- performing parity calculations for the drive array ( 222 ) can include reading data from a plurality of memory drives ( 224 , 228 ), using the data that was read from the memory drives ( 224 , 228 ) as input to an exclusive OR operation, and subsequently writing the result of the exclusive OR operation to another memory drive ( 226 ) that is responsible for maintaining parity information for a particular portion of the memory drives ( 224 , 228 ).
- a read instruction would be issued to memory drive ( 224 ) and another read instruction would be issued to memory drive ( 228 ).
- Each read instruction would be associated with a write instruction that will be issued to memory drive ( 226 ) upon the completion of the exclusive OR operation. As such, even though memory drive ( 226 ) may not be actively servicing any memory access requests, the issuance of a read instruction to memory drive ( 224 ) and another read instruction to memory drive ( 228 ) as part of parity calculations would serve as an indication that memory drive ( 226 ) will be servicing a memory access request—writing the result of the exclusive OR operation to the memory drive ( 226 )—in the near future.
- the example method of FIG. 2 also includes restricting ( 212 ), by the drive array controller ( 204 ), performance of background management operations on the second memory drive ( 226 ) in the drive array ( 222 ).
- restricting ( 212 ) performance of background management operations on the second memory drive ( 226 ) in the drive array ( 222 ) is carried out in response to affirmatively ( 210 ) determining that the read instruction ( 202 ) is associated with the write instruction ( 200 ).
- background management operations can include data scrubbing operations, consistency checking, and other management operations that are frequently run as background tasks to ensure proper operation of the memory drives ( 224 , 226 , 228 ).
- a particular operation may be identified as being a background management operation, for example, as part of configuring a computing system, as the result of input from a system administrator, and so on.
- Such background operations are typically executed through the use of a background process that is running in the background without user intervention.
- the memory drive ( 224 , 226 , 228 ) When a particular memory drive ( 224 , 226 , 228 ) is servicing memory access requests that are performed as part of background management operations, the memory drive ( 224 , 226 , 228 ) will have less capacity to service memory access requests that are performed as the result of normal computing operations.
- the memory drive ( 224 , 226 , 228 ) may have less capacity to service memory access requests that are performed as the result of normal computing operations because resources required to service memory access requests that are performed as part of background management operations are being dedicated to the execution of the background management operations.
- the performance of background management operations on the second memory drive ( 226 ) in the drive array ( 222 ) may be restricted ( 212 ) in anticipation of servicing the write instruction ( 200 ) that is related to the read instruction ( 202 ).
- Restricting ( 212 ) the performance of background management operations on the second memory drive ( 226 ) in the drive array ( 222 ) can include, for example, limiting the percentage of memory access requests that the second memory drive ( 226 ) may service as part of performing background management operations to a predetermined threshold.
- the example method of FIG. 2 also includes receiving ( 214 ), by the drive array controller ( 204 ), the write instruction ( 200 ).
- the write instruction ( 200 ) may be issued to the drive array controller ( 204 ), for example, by a computer processor (not shown) over a memory bus.
- Such a write instruction ( 200 ) may be part of a larger memory management operation such as, for example, performing parity calculations for memory drives ( 224 , 226 , 228 ) in the drive array ( 222 ).
- the example method of FIG. 2 also includes determining ( 216 ), by the drive array controller ( 204 ), whether the write instruction ( 200 ) has completed.
- determining ( 216 ) whether the write instruction ( 200 ) has completed may be carried out, for example, by inspecting each completed write instruction that the drive array controller ( 204 ) causes to execute.
- each completed write instruction may be examined to determine whether the executed write instruction is the same write instruction ( 200 ) that is related to the read instruction ( 202 ).
- the read instruction ( 202 ) and the write instruction ( 200 ) may include metadata that identifies the two instructions as being related.
- metadata may include, for example, an identifier that includes a unique value that is included in metadata associated with the read instruction ( 202 ) and also included in metadata associated with the write instruction ( 202 ).
- the drive array controller ( 204 ) may store the unique identifier contained in the read instruction ( 202 ). This value may be compared against values contained in metadata associated with incoming write instructions to identify the write instruction ( 202 ) that includes a matching unique identifier.
- the drive array ( 222 ) is a RAID 5 compliant array.
- Performing parity calculations for the drive array ( 222 ) can therefore include reading data from a plurality of memory drives ( 224 , 228 ), using the data that was read from the memory drives ( 224 , 228 ) as input to an exclusive OR operation, and subsequently writing the result of the exclusive OR operation to another memory drive ( 226 ) that is responsible for maintaining parity information for a particular portion of the memory drives ( 224 , 228 ).
- the read instruction that is issued to memory drive ( 224 ) and read instruction that is issued to memory drive ( 228 ) may include metadata identifying these read instructions as being related to a write instruction that has not yet been issued.
- Each read instruction can also include a particular value that is to be used as an identifier of the group of instructions. This value can be stored in memory used by the drive array controller ( 204 ).
- the drive array controller ( 204 ) may examine the metadata associated with the incoming write instruction to determine whether the metadata associated with the incoming write instruction includes a value that matches the value that was that includes in the read instruction that is issued to memory drive ( 224 ) and read instruction that is issued to memory drive ( 228 ). If the values match, the incoming write instruction represents that related write instruction that was identified in the read instruction that is issued to memory drive ( 224 ) and read instruction that is issued to memory drive ( 228 ). Once the related write instruction is executed, there is no longer a need to restrict the performance of background management operations on the memory drive ( 226 ) targeted by the write operation.
- the example method of FIG. 2 also includes removing ( 220 ), by the drive array controller ( 204 ), the restrictions associated with the performance of background management operations on the second memory drive ( 226 ) in the drive array ( 222 ).
- removing ( 220 ) the restrictions associated with the performance of background management operations on the second memory drive ( 226 ) in the drive array ( 222 ) is carried out in response to affirmatively ( 218 ) determining that the write instruction ( 200 ) has completed.
- Removing ( 220 ) the restrictions associated with the performance of background management operations on the second memory drive ( 226 ) in the drive array ( 222 ) may be carried out, for example, by removing any limitations as to the percentage of memory access requests that the second memory drive ( 226 ) may service as part of performing background management operations, by increasing the percentage of memory access requests that the second memory drive ( 226 ) may service as part of performing background management operations, and so on.
- FIG. 3 sets forth a flow chart illustrating an additional example method for limiting the execution of background management operations in a memory device according to embodiments of the present invention.
- the example method of FIG. 3 is similar to the example method of FIG. 2 , as it also includes receiving ( 206 ) a read instruction ( 202 ) to read data from a first memory drive ( 224 ) in a drive array ( 222 ), determining ( 208 ) whether the read instruction ( 202 ) is associated with a write instruction ( 200 ) to write data to a second memory drive ( 226 ) in the drive array ( 222 ), restricting ( 212 ) performance of background management operations on the second memory drive ( 226 ) in the drive array ( 222 ), receiving ( 214 ) the write instruction ( 200 ), determining ( 216 ) whether the write instruction ( 200 ) has completed, and removing ( 220 ) the restrictions associated with the performance of background management operations on the second memory drive ( 226 ) in the drive array ( 222 ).
- the read instruction ( 202 ) includes metadata ( 302 ) identifying whether the read instruction ( 302 ) is related to a write instruction ( 200 ) to write data to the second memory drive ( 226 ) in the drive array ( 222 ).
- the metadata ( 302 ) of FIG. 3 may include, for example, a value indicating that the read instruction ( 302 ) has an associated dependent write instruction ( 200 ), an identifier with a value that identifies the related set of instructions such that the same value will be included in metadata included in the dependent write instruction ( 200 ), and so on.
- determining ( 208 ) whether the read instruction ( 202 ) is associated with a write instruction ( 200 ) to write data to the memory device ( 222 ) can therefore include examining ( 304 ), by the drive array controller ( 204 ), the metadata ( 302 ) identifying whether the read instruction ( 202 ) is related to a write instruction ( 200 ) to write data to the memory device ( 222 ).
- restricting ( 212 ) performance of background management operations on the memory device ( 222 ) includes limiting ( 306 ), to a predetermined threshold, an amount of memory accesses requests from background management operations that may be serviced by the second memory drive ( 226 ).
- the predetermined threshold may be specified in terms of an amount of memory accesses requests from background management operations that the second memory drive ( 226 ) may service in a predetermined period of time, a maximum percentage of all memory accesses requests that are serviced by the second memory drive ( 226 ) that can originate from background management operations, and so on.
- the drive array controller ( 204 ) may simply ignore or reject any memory access requests that are directed to the second memory drive ( 226 ) that exceed the predetermined threshold. In such a way, the drive array controller ( 204 ) may ensure that the second memory drive ( 226 ) is not servicing background management operations to an extent that will cause an unnecessary delay in processing the write instruction ( 200 ).
- the write instruction ( 200 ) includes metadata ( 300 ) identifying a group of related instructions that includes the write instruction ( 200 ).
- the metadata ( 300 ) of FIG. 3 may include, for example, a value indicating that the write instruction ( 300 ) is part of a group of instructions that includes one or more associated read instructions ( 202 ) that the write instruction ( 300 ) is dependent upon, an identifier with a value that identifies a specific group of related instructions such that the same value will be included in metadata included in the one or more related read instructions ( 202 ), and so on.
- determining ( 216 ) whether the write instruction ( 200 ) has completed can include examining ( 308 ), by the drive array controller ( 204 ), the metadata ( 300 ) identifying a group of related instructions that includes the write instruction ( 200 ).
- examining ( 308 ) the metadata ( 300 ) identifying a group of related instructions that includes the write instruction ( 200 ) may be carried out, for example, by inspecting each completed write instruction that the drive array controller ( 204 ) causes to execute.
- each completed write instruction may be examined ( 308 ) to determine whether the write instruction ( 200 ) is part of a group of related instructions that includes the read instruction ( 202 ).
- the metadata ( 300 ) contained in the write instruction ( 200 ) may be compared to the metadata ( 302 ) contained in the read instruction ( 202 ) to identify a match.
- the drive array controller ( 204 ) may store the unique identifier contained in the read instruction ( 202 ). This value may be compared against values contained in metadata associated with incoming write instructions to identify the write instruction ( 202 ) that includes a matching unique identifier.
- aspects of the present invention may be embodied as a system, method or computer program product. Accordingly, aspects of the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment (including firmware, resident software, micro-code, etc.) or an embodiment combining software and hardware aspects that may all generally be referred to herein as a “circuit,” “module” or “system.” Furthermore, aspects of the present invention may take the form of a computer program product embodied in one or more computer readable medium(s) having computer readable program code embodied thereon.
- the computer readable medium may be a computer readable signal medium or a computer readable storage medium.
- a computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing.
- a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device.
- a computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof.
- a computer readable signal medium may be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device.
- Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.
- Computer program code for carrying out operations for aspects of the present invention may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, Smalltalk, C++ or the like and conventional procedural programming languages, such as the “C” programming language or similar programming languages.
- the program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server.
- the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider).
- LAN local area network
- WAN wide area network
- Internet Service Provider for example, AT&T, MCI, Sprint, EarthLink, MSN, GTE, etc.
- These computer program instructions may also be stored in a computer readable medium that can direct a computer, other programmable data processing apparatus, or other devices to function in a particular manner, such that the instructions stored in the computer readable medium produce an article of manufacture including instructions which implement the function/act specified in the flowchart and/or block diagram block or blocks.
- the computer program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other devices to cause a series of operational steps to be performed on the computer, other programmable apparatus or other devices to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide processes for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks.
- each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s).
- the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved.
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Human Computer Interaction (AREA)
- Quality & Reliability (AREA)
- Techniques For Improving Reliability Of Storages (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
- Read Only Memory (AREA)
- Debugging And Monitoring (AREA)
Abstract
Description
- 1. Field of the Invention
- The field of the invention is data processing, or, more specifically, methods, apparatus, and products for limiting the execution of background management operations in a drive array.
- 2. Description of Related Art
- Storage systems can be embodied as a redundant array of independent disks (‘RAID’) that are controlled by a RAID controller. RAID controllers protect data by adding parity protection over a group of independent storage devices. Parity calculations require the RAID controller to use a number of reads and writes that are in some cases dependent on one another to keep the drive group coherent. The parity calculations on a RAID array require data from multiple sources and writes will have to wait for a series of reads and these parity calculations to complete. Individual devices can interpret the pause in activity as an opportunity to perform background tasks such as data scrubbing or consistency checking, which can hurt write performance on the storage array.
- Methods, apparatus, and products for limiting the execution of background management operations in a drive array, including: receiving, by a drive array controller, a read instruction to read data from a memory drive in the drive array; determining, by the drive array controller, whether the read instruction is associated with a write instruction to write data to a memory drive in the drive array; responsive to determining, by the drive array controller, that the read instruction is associated with the write instruction, restricting, by the drive array controller, performance of background management operations on the memory drive targeted by the write instruction; determining, by the drive array controller, whether the write instruction has completed; and responsive to determining, by the drive array controller, that the write instruction has completed, removing, by the drive array controller, restrictions associated with the performance of background management operations on the memory drive targeted by the write instruction.
- The foregoing and other objects, features and advantages of the invention will be apparent from the following more particular descriptions of example embodiments of the invention as illustrated in the accompanying drawings wherein like reference numbers generally represent like parts of example embodiments of the invention.
-
FIG. 1 sets forth a block diagram of automated computing machinery comprising an example computer useful in limiting the execution of background management operations in a drive array according to embodiments of the present invention. -
FIG. 2 sets forth a flow chart illustrating an example method for limiting the execution of background management operations in a drive array according to embodiments of the present invention. -
FIG. 3 sets forth a flow chart illustrating an additional example method for limiting the execution of background management operations in a drive array according to embodiments of the present invention. - Example methods, apparatus, and products for limiting the execution of background management operations in a drive array in accordance with the present invention are described with reference to the accompanying drawings, beginning with
FIG. 1 .FIG. 1 sets forth a block diagram of automated computing machinery comprising an example computer (152) useful in limiting the execution of background management operations in a drive array according to embodiments of the present invention. The computer (152) ofFIG. 1 includes at least one computer processor (156) or ‘CPU’ as well as random access memory (168) (RAM') which is connected through a high speed memory bus (166) and bus adapter (158) to processor (156) and to other components of the computer (152). - Stored in RAM (168) is an application program (126), a module of user-level computer program instructions for carrying out particular data processing tasks on the computer (152). Examples of such application programs include spreadsheets, word processing programs, email clients, web browsers, database management programs, and so on. Also stored in RAM is a drive controller interface (130), a module of computer program instructions that provides an application programming interface or ‘API’ through which the application program (126) can communicate with a drive array controller (204), such as a redundant array of independent disks (‘RAID’) controller, for writing and reading data to and from one or more memory drives (224, 226, 228) in a drive array (222).
- Also stored in RAM (168) is an operating system (154). Operating systems useful limiting the execution of background management operations in a drive array according to embodiments of the present invention include UNIXTM, LinuxTM, Microsoft XP™, AIX™, IBM's i5/OS™, and others as will occur to those of skill in the art. The operating system (154), application program (126), and drive controller interface (130) in the example of
FIG. 1 are shown in RAM (168), but many components of such software typically are stored in non-volatile memory also, such as, for example, on a memory drive. - The example computer (152) of
FIG. 1 includes one or more input/output (‘I/O’) adapters (178). I/O adapters implement user-oriented input/output through, for example, software drivers and computer hardware for controlling output to display devices such as computer display screens, as well as user input from user input devices (181) such as keyboards and mice. The example computer (152) ofFIG. 1 includes a video adapter (209), which is an example of an I/O adapter specially designed for graphic output to a display device (180) such as a display screen or computer monitor. Video adapter (209) is connected to processor (156) through a high speed video bus (164), bus adapter (158), and the front side bus (162), which is also a high speed bus. - The example computer (152) of
FIG. 1 includes a communications adapter (167) for data communications with other computers (182) and for data communications with a data communications network (100). Such data communications may be carried out serially through RS-232 connections, through external buses such as a Universal Serial Bus (‘USB’), through data communications networks such as IP data communications networks, and in other ways as will occur to those of skill in the art. Communications adapters implement the hardware level of data communications through which one computer sends data communications to another computer, directly or through a data communications network. Examples of communications adapters useful for limiting the execution of background management operations in a drive array according to embodiments of the present invention include modems for wired dial-up communications, Ethernet (IEEE 802.3) adapters for wired data communications network communications, and 802.11 adapters for wireless data communications network communications. - The example computer of
FIG. 1 also includes a drive array controller (204) coupled through an expansion bus (160) and a bus adapter (158) to a processor (156) and other components of the computer (152). The drive array controller (204) is a computer input/output adapter that connects non-volatile data storage to the computer (152) in the form of memory drives (224, 226, 228). The drive array controller (204) ofFIG. 1 administers read and write requests to and from memory drives (224, 226, 228). - In the example of
FIG. 1 , the drive array controller (204) can carry out limiting the execution of background management operations in a drive array (222) by receiving a read instruction to read data from a first memory drive (224) in a drive array (222). The read instruction may be received from the computer processor (156) that sends the read instruction to the drive array controller (204) over a memory bus. Such a read instruction may be part of a larger memory management operation such as, for example, performing parity calculations for memory drives (224, 226, 228) in the drive array (222). - In the example of
FIG. 1 , the drive array controller (204) can further carry out limiting the execution of background management operations in a drive array (222) by determining whether the read instruction is associated with a write instruction to write data to a second memory drive (226) in the drive array (222). Determining whether the read instruction is associated with a write instruction to write data to a second memory drive (226) in the drive array (222) may be carried out, for example, through the use of flags that are contained in the read instruction (202), through the use of flags that are contained in the data that is to be read as a result of the read instruction (202), and so on. - Consider an example in which the drive array (222) is a RAID 5 compliant array. In such an example, performing parity calculations for the drive array (222) can include reading data from a plurality of memory drives (224, 228), using the data that was read from the memory drives (224, 228) as input to an exclusive OR operation, and subsequently writing the result of the exclusive OR operation to another memory drive (226) that is responsible for maintaining parity information for a particular portion of the memory drives (224, 228). In such an example, a read instruction would be issued to memory drive (224) and another read instruction would be issued to memory drive (228). Each read instruction would be associated with a write instruction that will be issued to memory drive (226) upon the completion of the exclusive OR operation. As such, even though memory drive (226) may not be actively servicing any memory access requests, the issuance of a read instruction to memory drive (224) and another read instruction to memory drive (228) as part of parity calculations would serve as an indication that memory drive (226) will be servicing a memory access request—writing the result of the exclusive OR operation to the memory drive (226)—in the near future.
- In the example of
FIG. 1 , the drive array controller (204) can further carry out limiting the execution of background management operations in a drive array (222) by restricting performance of background management operations on the second memory drive (226) in the drive array (222). Restricting performance of background management operations on the second memory drive (226) in the drive array (222) is carried out in response to affirmatively determining that the read instruction is associated with the write instruction. Background management operations can include data scrubbing operations, consistency checking, and other management operations that are frequently run as background tasks to ensure proper operation of the memory drives (224, 226, 228). A particular operation may be identified as being a background management operation, for example, as part of configuring a computing system, as the result of input from a system administrator, and so on. Such background operations are typically executed through the use of a background process that is running in the background without user intervention. - When a particular memory drive (224, 226, 228) is servicing memory access requests that are performed as part of background management operations, the memory drive (224, 226, 228) will have less capacity to service memory access requests that are performed as the result of normal computing operations. The memory drive (224, 226, 228) may have less capacity to service memory access requests that are performed as the result of normal computing operations because resources required to service memory access requests that are performed as part of background management operations are being dedicated to the execution of the background management operations. As such, the performance of background management operations on the second memory drive (226) in the drive array (222) may be restricted in anticipation of servicing the write instruction that is related to the read instruction. Restricting the performance of background management operations on the second memory drive (226) in the drive array (222) can include, for example, limiting the percentage of memory access requests that the second memory drive (226) may service as part of performing background management operations to a predetermined threshold.
- In the example of
FIG. 1 , the drive array controller (204) can further carry out limiting the execution of background management operations in a drive array (222) by receiving the write instruction. The write instruction may be issued to the drive array controller (204), for example, by the computer processor (156) over a memory bus. Such a write instruction may be part of a larger memory management operation such as, for example, performing parity calculations for memory drives (224, 226, 228) in the drive array (222). - In the example of
FIG. 1 , the drive array controller (204) can further carry out limiting the execution of background management operations in a drive array (222) by determining whether the write instruction has completed. Determining whether the write instruction has completed may be carried out, for example, by inspecting each completed write instruction that the drive array controller (204) causes to execute. In such an example, each completed write instruction may be examined to determine whether the executed write instruction is the same write instruction that is related to the read instruction. In order to determine whether a particular executed write instruction is the same write instruction that is related to the read instruction, the read instruction and the write instruction may include metadata that identifies the two instructions as being related. Such metadata may include, for example, an identifier that includes a unique value that is included in metadata associated with the read instruction and also included in metadata associated with the write instruction. In such an example, when the drive array controller (204) receives a read instruction that has a related write instruction, the drive array controller (204) may store the unique identifier contained in the read instruction. This value may be compared against values contained in metadata associated with incoming write instructions to identify the write instruction that includes a matching unique identifier. - Consider the example described above in which the drive array (222) is a RAID 5 compliant array. Performing parity calculations for the drive array (222) can therefore include reading data from a plurality of memory drives (224, 228), using the data that was read from the memory drives (224, 228) as input to an exclusive OR operation, and subsequently writing the result of the exclusive OR operation to another memory drive (226) that is responsible for maintaining parity information for a particular portion of the memory drives (224, 228). In such an example, the read instruction that is issued to memory drive (224) and read instruction that is issued to memory drive (228) may include metadata identifying these read instructions as being related to a write instruction that has not yet been issued. Each read instruction can also include a particular value that is to be used as an identifier of the group of instructions. This value can be stored in memory used by the drive array controller (204). When the drive array controller (204) subsequently receives an incoming write instruction, the drive array controller (204) may examine the metadata associated with the incoming write instruction to determine whether the metadata associated with the incoming write instruction includes a value that matches the value that was that includes in the read instruction that is issued to memory drive (224) and read instruction that is issued to memory drive (228). If the values match, the incoming write instruction represents that related write instruction that was identified in the read instruction that is issued to memory drive (224) and read instruction that is issued to memory drive (228). Once the related write instruction is executed, there is no longer a need to restrict the performance of background management operations on the memory drive (226) targeted by the write operation.
- In the example of
FIG. 1 , the drive array controller (204) can further carry out limiting the execution of background management operations in a drive array (222) by removing the restrictions associated with the performance of background management operations on the second memory drive (226) in the drive array (222). Removing the restrictions associated with the performance of background management operations on the second memory drive (226) in the drive array (222) is carried out in response to affirmatively determining that the write instruction has completed. Removing the restrictions associated with the performance of background management operations on the second memory drive (226) in the drive array (222) may be carried out, for example, by removing any limitations as to the percentage of memory access requests that the second memory drive (226) may service as part of performing background management operations, by increasing the percentage of memory access requests that the second memory drive (226) may service as part of performing background management operations, and so on. - For further explanation,
FIG. 2 sets forth a flow chart illustrating an example method for limiting the execution of background management operations in a drive array (222) according to embodiments of the present invention. The drive array (222) ofFIG. 2 includes a plurality of memory drives (224, 226, 228). Each memory drive (224, 226, 228) may be embodied as a distinct computer storage device such as, for example, a disk drive, a solid state drive, and so on. The memory drives (224, 226, 228) are pooled together to create a drive array (222) which is a storage system that contains multiple memory drives to provide increased availability and resiliency through the use of redundant components. The drive array (222) ofFIG. 2 may be embodied, for example, as a redundant array of independent disks (‘RAID’). Such a RAID may adhere to standard RAID levels such as RAID 5 in which parity and data are distributed amongst the memory drives (224, 226, 228). - The example method of
FIG. 2 is carried out by a drive array controller (204). The drive array controller (204) ofFIG. 2 may be embodied as a device to manage the drive array (222), including the memory drives (224, 226, 228) that form the drive array (222). For example, the drive array controller (204) ofFIG. 2 may be embodied as a RAID controller which manages the physical memory drives (224, 226, 228) of a RAID and presents them to a computing device as logical units. - The example method of
FIG. 2 includes receiving (206), by the drive array controller (204), a read instruction (202) to read data from a first memory drive (224) in a drive array (222). In the example method ofFIG. 2 , the read instruction (202) may be received from a computer processor (not shown) that sends the read instruction (202) to the drive array controller (204) over a memory bus. Such a read instruction (202) may be part of a larger memory management operation such as, for example, performing parity calculations for memory drives (224, 226, 228) in the drive array (222). - The example method of
FIG. 2 also includes determining (208), by the drive array controller (204), whether the read instruction (202) is associated with a write instruction (200) to write data to a second memory drive (226) in the drive array (222). In the example method ofFIG. 2 , determining (208) whether the read instruction (202) is associated with a write instruction (200) to write data to a second memory drive (226) in the drive array (222) may be carried out, for example, through the use of flags that are contained in the read instruction (202), through the use of flags that are contained in the data that is to be read as a result of the read instruction (202), and so on. For example, the read instruction (202) may include metadata that is associated with the read instruction (202). Such metadata may include, for example, an integer value that is set by the issuer of the read instruction (202) to identify whether the read instruction (202) is associated with a write instruction (200) to write data to a second memory drive (226) in the drive array (222). A value of 0 may indicate that the read instruction (202) is not associated with a write instruction (200) to write data to a second memory drive (226) in the drive array (222), while a value of 1 may indicate that the read instruction (202) is associated with a write instruction (200) to write data to a second memory drive (226) in the drive array (222). In such an example, the drive array controller (204) may read the values contained in such flags to determine (208) whether the read instruction (202) is associated with a write instruction (200) to write data to a second memory drive (226) in the drive array (222). - Readers will appreciate in the example method of
FIG. 2 , the write instruction (200) that is associated with the read instruction (202) may not yet have been issued at the time it was determined (208) that the read instruction (202) is associated with a write instruction (200) to write data to a second memory drive (226) in the drive array (222). That is, the issuer of the read instruction (202) may know, at the time that the read instruction (202) is issued, that the read instruction (202) is just one memory access request in a series of memory access requests that will involve issuing a write instruction (200) to write data to a second memory drive (226) in the drive array (222) at a later time. - Consider the example described above in which the drive array (222) is a RAID 5 compliant array. In such an example, performing parity calculations for the drive array (222) can include reading data from a plurality of memory drives (224, 228), using the data that was read from the memory drives (224, 228) as input to an exclusive OR operation, and subsequently writing the result of the exclusive OR operation to another memory drive (226) that is responsible for maintaining parity information for a particular portion of the memory drives (224, 228). In such an example, a read instruction would be issued to memory drive (224) and another read instruction would be issued to memory drive (228). Each read instruction would be associated with a write instruction that will be issued to memory drive (226) upon the completion of the exclusive OR operation. As such, even though memory drive (226) may not be actively servicing any memory access requests, the issuance of a read instruction to memory drive (224) and another read instruction to memory drive (228) as part of parity calculations would serve as an indication that memory drive (226) will be servicing a memory access request—writing the result of the exclusive OR operation to the memory drive (226)—in the near future.
- The example method of
FIG. 2 also includes restricting (212), by the drive array controller (204), performance of background management operations on the second memory drive (226) in the drive array (222). In the example method ofFIG. 2 , restricting (212) performance of background management operations on the second memory drive (226) in the drive array (222) is carried out in response to affirmatively (210) determining that the read instruction (202) is associated with the write instruction (200). In the example method ofFIG. 2 , background management operations can include data scrubbing operations, consistency checking, and other management operations that are frequently run as background tasks to ensure proper operation of the memory drives (224, 226, 228). A particular operation may be identified as being a background management operation, for example, as part of configuring a computing system, as the result of input from a system administrator, and so on. Such background operations are typically executed through the use of a background process that is running in the background without user intervention. - When a particular memory drive (224, 226, 228) is servicing memory access requests that are performed as part of background management operations, the memory drive (224, 226, 228) will have less capacity to service memory access requests that are performed as the result of normal computing operations. The memory drive (224, 226, 228) may have less capacity to service memory access requests that are performed as the result of normal computing operations because resources required to service memory access requests that are performed as part of background management operations are being dedicated to the execution of the background management operations. As such, the performance of background management operations on the second memory drive (226) in the drive array (222) may be restricted (212) in anticipation of servicing the write instruction (200) that is related to the read instruction (202). Restricting (212) the performance of background management operations on the second memory drive (226) in the drive array (222) can include, for example, limiting the percentage of memory access requests that the second memory drive (226) may service as part of performing background management operations to a predetermined threshold.
- The example method of
FIG. 2 also includes receiving (214), by the drive array controller (204), the write instruction (200). In the example method ofFIG. 2 , the write instruction (200) may be issued to the drive array controller (204), for example, by a computer processor (not shown) over a memory bus. Such a write instruction (200) may be part of a larger memory management operation such as, for example, performing parity calculations for memory drives (224, 226, 228) in the drive array (222). - The example method of
FIG. 2 also includes determining (216), by the drive array controller (204), whether the write instruction (200) has completed. In the example method ofFIG. 2 , determining (216) whether the write instruction (200) has completed may be carried out, for example, by inspecting each completed write instruction that the drive array controller (204) causes to execute. In such an example, each completed write instruction may be examined to determine whether the executed write instruction is the same write instruction (200) that is related to the read instruction (202). In order to determine whether a particular executed write instruction is the same write instruction (200) that is related to the read instruction (202), the read instruction (202) and the write instruction (200) may include metadata that identifies the two instructions as being related. Such metadata may include, for example, an identifier that includes a unique value that is included in metadata associated with the read instruction (202) and also included in metadata associated with the write instruction (202). In such an example, when the drive array controller (204) receives a read instruction (202) that has a related write instruction (200), the drive array controller (204) may store the unique identifier contained in the read instruction (202). This value may be compared against values contained in metadata associated with incoming write instructions to identify the write instruction (202) that includes a matching unique identifier. - Consider the example described above in which the drive array (222) is a RAID 5 compliant array. Performing parity calculations for the drive array (222) can therefore include reading data from a plurality of memory drives (224, 228), using the data that was read from the memory drives (224, 228) as input to an exclusive OR operation, and subsequently writing the result of the exclusive OR operation to another memory drive (226) that is responsible for maintaining parity information for a particular portion of the memory drives (224, 228). In such an example, the read instruction that is issued to memory drive (224) and read instruction that is issued to memory drive (228) may include metadata identifying these read instructions as being related to a write instruction that has not yet been issued. Each read instruction can also include a particular value that is to be used as an identifier of the group of instructions. This value can be stored in memory used by the drive array controller (204). When the drive array controller (204) subsequently receives an incoming write instruction, the drive array controller (204) may examine the metadata associated with the incoming write instruction to determine whether the metadata associated with the incoming write instruction includes a value that matches the value that was that includes in the read instruction that is issued to memory drive (224) and read instruction that is issued to memory drive (228). If the values match, the incoming write instruction represents that related write instruction that was identified in the read instruction that is issued to memory drive (224) and read instruction that is issued to memory drive (228). Once the related write instruction is executed, there is no longer a need to restrict the performance of background management operations on the memory drive (226) targeted by the write operation.
- The example method of
FIG. 2 also includes removing (220), by the drive array controller (204), the restrictions associated with the performance of background management operations on the second memory drive (226) in the drive array (222). In the example method ofFIG. 2 , removing (220) the restrictions associated with the performance of background management operations on the second memory drive (226) in the drive array (222) is carried out in response to affirmatively (218) determining that the write instruction (200) has completed. Removing (220) the restrictions associated with the performance of background management operations on the second memory drive (226) in the drive array (222) may be carried out, for example, by removing any limitations as to the percentage of memory access requests that the second memory drive (226) may service as part of performing background management operations, by increasing the percentage of memory access requests that the second memory drive (226) may service as part of performing background management operations, and so on. - For further explanation,
FIG. 3 sets forth a flow chart illustrating an additional example method for limiting the execution of background management operations in a memory device according to embodiments of the present invention. The example method ofFIG. 3 is similar to the example method ofFIG. 2 , as it also includes receiving (206) a read instruction (202) to read data from a first memory drive (224) in a drive array (222), determining (208) whether the read instruction (202) is associated with a write instruction (200) to write data to a second memory drive (226) in the drive array (222), restricting (212) performance of background management operations on the second memory drive (226) in the drive array (222), receiving (214) the write instruction (200), determining (216) whether the write instruction (200) has completed, and removing (220) the restrictions associated with the performance of background management operations on the second memory drive (226) in the drive array (222). - In the example method of
FIG. 3 , the read instruction (202) includes metadata (302) identifying whether the read instruction (302) is related to a write instruction (200) to write data to the second memory drive (226) in the drive array (222). The metadata (302) ofFIG. 3 may include, for example, a value indicating that the read instruction (302) has an associated dependent write instruction (200), an identifier with a value that identifies the related set of instructions such that the same value will be included in metadata included in the dependent write instruction (200), and so on. In the example method ofFIG. 3 , determining (208) whether the read instruction (202) is associated with a write instruction (200) to write data to the memory device (222) can therefore include examining (304), by the drive array controller (204), the metadata (302) identifying whether the read instruction (202) is related to a write instruction (200) to write data to the memory device (222). - In the example method of
FIG. 3 , restricting (212) performance of background management operations on the memory device (222) includes limiting (306), to a predetermined threshold, an amount of memory accesses requests from background management operations that may be serviced by the second memory drive (226). In the method ofFIG. 3 , the predetermined threshold may be specified in terms of an amount of memory accesses requests from background management operations that the second memory drive (226) may service in a predetermined period of time, a maximum percentage of all memory accesses requests that are serviced by the second memory drive (226) that can originate from background management operations, and so on. In the example method ofFIG. 3 , the drive array controller (204) may simply ignore or reject any memory access requests that are directed to the second memory drive (226) that exceed the predetermined threshold. In such a way, the drive array controller (204) may ensure that the second memory drive (226) is not servicing background management operations to an extent that will cause an unnecessary delay in processing the write instruction (200). - In the example method of
FIG. 3 , the write instruction (200) includes metadata (300) identifying a group of related instructions that includes the write instruction (200). The metadata (300) ofFIG. 3 may include, for example, a value indicating that the write instruction (300) is part of a group of instructions that includes one or more associated read instructions (202) that the write instruction (300) is dependent upon, an identifier with a value that identifies a specific group of related instructions such that the same value will be included in metadata included in the one or more related read instructions (202), and so on. - In the example method of
FIG. 3 , determining (216) whether the write instruction (200) has completed can include examining (308), by the drive array controller (204), the metadata (300) identifying a group of related instructions that includes the write instruction (200). In the example method ofFIG. 3 , examining (308) the metadata (300) identifying a group of related instructions that includes the write instruction (200) may be carried out, for example, by inspecting each completed write instruction that the drive array controller (204) causes to execute. In such an example, each completed write instruction may be examined (308) to determine whether the write instruction (200) is part of a group of related instructions that includes the read instruction (202). In order to determine the write instruction (200) is part of a group of related instructions that includes the read instruction (202), the metadata (300) contained in the write instruction (200) may be compared to the metadata (302) contained in the read instruction (202) to identify a match. In such an example, when the drive array controller (204) receives a read instruction (202) that has a related write instruction (200), the drive array controller (204) may store the unique identifier contained in the read instruction (202). This value may be compared against values contained in metadata associated with incoming write instructions to identify the write instruction (202) that includes a matching unique identifier. - Although the examples described above describe embodiments in which data is read from a first memory drive and written to a second memory drive, readers will appreciate data may be read from and written to the same memory drive according to embodiments of the present invention. The description of embodiments in which data is read from a first memory drive and written to a second memory drive is included for ease of explanation and should not be read to limit the scope of the present claims.
- As will be appreciated by one skilled in the art, aspects of the present invention may be embodied as a system, method or computer program product. Accordingly, aspects of the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment (including firmware, resident software, micro-code, etc.) or an embodiment combining software and hardware aspects that may all generally be referred to herein as a “circuit,” “module” or “system.” Furthermore, aspects of the present invention may take the form of a computer program product embodied in one or more computer readable medium(s) having computer readable program code embodied thereon.
- Any combination of one or more computer readable medium(s) may be utilized. The computer readable medium may be a computer readable signal medium or a computer readable storage medium. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples (a non-exhaustive list) of the computer readable storage medium would include the following: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this document, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device.
- A computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device.
- Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.
- Computer program code for carrying out operations for aspects of the present invention may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, Smalltalk, C++ or the like and conventional procedural programming languages, such as the “C” programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider).
- Aspects of the present invention are described above with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks.
- These computer program instructions may also be stored in a computer readable medium that can direct a computer, other programmable data processing apparatus, or other devices to function in a particular manner, such that the instructions stored in the computer readable medium produce an article of manufacture including instructions which implement the function/act specified in the flowchart and/or block diagram block or blocks.
- The computer program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other devices to cause a series of operational steps to be performed on the computer, other programmable apparatus or other devices to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide processes for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks.
- The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.
- It will be understood from the foregoing description that modifications and changes may be made in various embodiments of the present invention without departing from its true spirit. The descriptions in this specification are for purposes of illustration only and are not to be construed in a limiting sense. The scope of the present invention is limited only by the language of the following claims.
Claims (15)
Priority Applications (6)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US13/755,280 US20140215148A1 (en) | 2013-01-31 | 2013-01-31 | Limiting the execution of background management operations in a drive array |
US13/795,309 US10185517B2 (en) | 2013-01-31 | 2013-03-12 | Limiting the execution of background management operations in a drive array |
CN201480006746.1A CN105431832B (en) | 2013-01-31 | 2014-01-08 | Apparatus for limiting execution of background management operations in a drive array |
PCT/IB2014/058113 WO2014118651A1 (en) | 2013-01-31 | 2014-01-08 | Method and apparatus for limiting the execution of background management operations in drive array |
DE112014000627.0T DE112014000627B4 (en) | 2013-01-31 | 2014-01-08 | Method, apparatus, computer program product and computer program for limiting execution of background management functions in a drive array |
GB1513613.8A GB2524700B (en) | 2013-01-31 | 2014-01-08 | Method and apparatus for limiting the execution of background management operations in drive array |
Applications Claiming Priority (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US13/755,280 US20140215148A1 (en) | 2013-01-31 | 2013-01-31 | Limiting the execution of background management operations in a drive array |
Related Child Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US13/795,309 Continuation US10185517B2 (en) | 2013-01-31 | 2013-03-12 | Limiting the execution of background management operations in a drive array |
Publications (1)
Publication Number | Publication Date |
---|---|
US20140215148A1 true US20140215148A1 (en) | 2014-07-31 |
Family
ID=51224318
Family Applications (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US13/755,280 Abandoned US20140215148A1 (en) | 2013-01-31 | 2013-01-31 | Limiting the execution of background management operations in a drive array |
US13/795,309 Active 2033-07-25 US10185517B2 (en) | 2013-01-31 | 2013-03-12 | Limiting the execution of background management operations in a drive array |
Family Applications After (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US13/795,309 Active 2033-07-25 US10185517B2 (en) | 2013-01-31 | 2013-03-12 | Limiting the execution of background management operations in a drive array |
Country Status (5)
Country | Link |
---|---|
US (2) | US20140215148A1 (en) |
CN (1) | CN105431832B (en) |
DE (1) | DE112014000627B4 (en) |
GB (1) | GB2524700B (en) |
WO (1) | WO2014118651A1 (en) |
Citations (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5720025A (en) * | 1996-01-18 | 1998-02-17 | Hewlett-Packard Company | Frequently-redundant array of independent disks |
Family Cites Families (18)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6553511B1 (en) * | 2000-05-17 | 2003-04-22 | Lsi Logic Corporation | Mass storage data integrity-assuring technique utilizing sequence and revision number metadata |
US8275951B2 (en) | 2004-06-10 | 2012-09-25 | Hewlett-Packard Development Company, L.P. | Local bitmaps for an array of redundant storage devices |
US8219745B2 (en) | 2004-12-02 | 2012-07-10 | International Business Machines Corporation | Memory controller to utilize DRAM write buffers |
US7373444B2 (en) | 2005-04-15 | 2008-05-13 | Kabushiki Kaisha Toshiba | Systems and methods for manipulating entries in a command buffer using tag information |
US8200887B2 (en) | 2007-03-29 | 2012-06-12 | Violin Memory, Inc. | Memory management system and method |
US7668810B2 (en) | 2006-01-27 | 2010-02-23 | International Business Machines Corporation | Controlling consistency of data storage copies |
GB2440968B (en) * | 2006-08-16 | 2011-02-02 | Advanced Risc Mach Ltd | Protecting system control registers in a data processing apparatus |
CN101513027A (en) * | 2006-08-28 | 2009-08-19 | 索尼爱立信移动通讯股份有限公司 | Differentiated access to a data item store |
JP4640451B2 (en) * | 2008-06-06 | 2011-03-02 | ソニー株式会社 | Contact / non-contact composite IC card, communication method, program, and communication system |
US10725877B2 (en) * | 2008-06-30 | 2020-07-28 | International Business Machines Corporation | System, method and computer program product for performing a data protection operation |
US8250283B1 (en) | 2009-05-22 | 2012-08-21 | Google Inc. | Write-distribute command for RAID mirroring |
JP5655344B2 (en) | 2010-03-31 | 2015-01-21 | 富士通株式会社 | Storage device, storage device control program, and storage device control method |
US8359438B2 (en) | 2010-05-18 | 2013-01-22 | Avago Technologies Enterprise IP (Singapore) Pte. Ltd. | Memory banking system and method to increase memory bandwidth via parallel read and write operations |
US8874853B2 (en) | 2010-06-04 | 2014-10-28 | International Business Machines Corporation | Local and global memory request predictor |
US8688660B1 (en) * | 2010-09-28 | 2014-04-01 | Amazon Technologies, Inc. | System and method for providing enhancements of block-level storage |
US8755271B2 (en) | 2011-01-28 | 2014-06-17 | Broadcom Corporation | Dynamic memory bandwidth allocation |
JP2012185687A (en) | 2011-03-07 | 2012-09-27 | Fujitsu Ltd | Control device, control method, and storage device |
CN102122236B (en) | 2011-03-21 | 2013-08-28 | 华为数字技术(成都)有限公司 | Write request processing method and device |
-
2013
- 2013-01-31 US US13/755,280 patent/US20140215148A1/en not_active Abandoned
- 2013-03-12 US US13/795,309 patent/US10185517B2/en active Active
-
2014
- 2014-01-08 WO PCT/IB2014/058113 patent/WO2014118651A1/en active Application Filing
- 2014-01-08 DE DE112014000627.0T patent/DE112014000627B4/en active Active
- 2014-01-08 CN CN201480006746.1A patent/CN105431832B/en active Active
- 2014-01-08 GB GB1513613.8A patent/GB2524700B/en active Active
Patent Citations (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5720025A (en) * | 1996-01-18 | 1998-02-17 | Hewlett-Packard Company | Frequently-redundant array of independent disks |
Non-Patent Citations (1)
Title |
---|
M.M. Islam Chisty, "Java Annotations: An Introduction," Developer.com, Oct. 14, 2005, http://www.developer.com/java/other/article.php/3556176/An-Introduction-to-Java-Annotations.htm * |
Also Published As
Publication number | Publication date |
---|---|
CN105431832B (en) | 2019-03-22 |
GB2524700A (en) | 2015-09-30 |
DE112014000627B4 (en) | 2023-06-01 |
CN105431832A (en) | 2016-03-23 |
US10185517B2 (en) | 2019-01-22 |
WO2014118651A1 (en) | 2014-08-07 |
GB201513613D0 (en) | 2015-09-16 |
US20140215150A1 (en) | 2014-07-31 |
DE112014000627T5 (en) | 2015-11-05 |
GB2524700B (en) | 2021-01-13 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US9164840B2 (en) | Managing a solid state drive (‘SSD’) in a redundant array of inexpensive drives (‘RAID’) | |
US9043776B2 (en) | Transferring files to a baseboard management controller (‘BMC’) in a computing system | |
US8607003B2 (en) | Memory access to a dual in-line memory module form factor flash memory | |
US20150143054A1 (en) | Managing Faulty Memory Pages In A Computing System | |
US20130166672A1 (en) | Physically Remote Shared Computer Memory | |
US10310937B2 (en) | Dynamically restoring disks based on array properties | |
US10212844B2 (en) | System and method for improving fan life in an information handling system | |
US9454485B2 (en) | Sharing local cache from a failover node | |
US9411695B2 (en) | Provisioning memory in a memory system for mirroring | |
US9411666B2 (en) | Anticipatory protection of critical jobs in a computing system | |
US9223703B2 (en) | Allocating enclosure cache in a computing system | |
US9471433B2 (en) | Optimizing computer hardware usage in a computing system that includes a plurality of populated central processing unit (‘CPU’) sockets | |
US10585622B2 (en) | Data writing device and method | |
US8566538B2 (en) | Administering thermal distribution among memory modules with call stack frame size management | |
US10185517B2 (en) | Limiting the execution of background management operations in a drive array | |
US20130117493A1 (en) | Reliable Memory Mapping In A Computing System | |
US9256539B2 (en) | Sharing cache in a computing system | |
US8645774B2 (en) | Expedited memory drive self test | |
US9158669B2 (en) | Presenting enclosure cache as local cache in an enclosure attached server |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: INTERNATIONAL BUSINESS MACHINES CORPORATION, NEW Y Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:CUDAK, GARY D.;DO, LYDIA M.;HARDEE, CHRISTOPHER J.;AND OTHERS;SIGNING DATES FROM 20130130 TO 20130131;REEL/FRAME:029732/0182 |
|
AS | Assignment |
Owner name: LENOVO ENTERPRISE SOLUTIONS (SINGAPORE) PTE. LTD., SINGAPORE Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:INTERNATIONAL BUSINESS MACHINES CORPORATION;REEL/FRAME:034194/0111 Effective date: 20140926 Owner name: LENOVO ENTERPRISE SOLUTIONS (SINGAPORE) PTE. LTD., Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:INTERNATIONAL BUSINESS MACHINES CORPORATION;REEL/FRAME:034194/0111 Effective date: 20140926 |
|
STCB | Information on status: application discontinuation |
Free format text: ABANDONED -- FAILURE TO RESPOND TO AN OFFICE ACTION |