Application independent storage array performance optimizer

A system comprising a performance module and an application. The performance module may be configured to (i) monitor a LUN for a predetermined amount of time, (ii) capture information relating to the LUN, and (iii) store the information. The application may be configured to (i) retrieve the information, (ii) analyze the information, (iii) generate a configuration based on the analysis of the information and (iv) send the configuration to the performance module. The performance module may reconfigure the LUN based on the configuration.

FIELD OF THE INVENTION

The present invention relates to storage arrays generally and, more particularly, to a method and/or apparatus for implementing an application independent storage array performance optimizer.

BACKGROUND OF THE INVENTION

Conventional approaches for determining if a LUN is properly configured for a particular environment are challenging. An application and the environment each have different input/output (IO) profiles. The LUN needs to be custom configured to achieve an optimal performance with different IO profiles. With conventional approaches, to determine if the LUN is configured correctly, an information technology (IT) administrator figures out how to provision a storage array. For example, an IT administrator (or a performance engineer) manually tunes the LUN. Currently available utilities make limited recommendations based on a very limited list of applications (i.e., SQL, Exchange) running on a server.

While creating the LUN, a user decides several parameters. These parameters include (i) LUN segment size, (ii) RAID level, (iii) the number of spindles/drives to use for the LUN, and/or (iv) LUN size. In conventional systems, in order to achieve optimal performance, these LUN parameters are determined by (i) IO size, (ii) sequential versus random IO, (iv) IO segment boundary, (v) performance (i.e., throughput, bandwidth, etc.), (vi) data availability (i.e., how fast data is needed), (vii) data reliability (i.e., how critical the data is), (viii) IO volume and/or (ix) IO ratio (i.e., % read versus % write).

The main disadvantages of conventional solutions are the cost and time involved in performance optimization. The IT administrator doing the fine tuning of the LUN needs to understand the IO profile of each application and/or how a RAID works. The IT administrator will also need to have the knowledge of the expected performance of the storage array network (SAN). Once the IT administrator determines what the appropriate settings should be, the LUNs need to be reconfigured and the performance measured. If the performance statistics do not match up with the expected performance numbers, the IT administrator will have to adjust the LUNs again. This process can take several iterations. Conventional solutions are lengthy and rely on an individual with the appropriate level of expertise. As a result, many installed storage arrays do not run at optimal performance levels.

It would be desirable to implement an application independent storage performance optimizer.

SUMMARY OF THE INVENTION

The present invention concerns a system comprising a performance module and an application. The performance module may be configured to (i) monitor a LUN for a predetermined amount of time, (ii) capture information relating to the LUN, and (iii) store the information. The application may be configured to (i) retrieve the information, (ii) analyze the information, (iii) generate a configuration based on the analysis of the information and (iv) send the configuration to the performance module. The performance module may reconfigure the LUN based on the configuration.

The objects, features and advantages of the present invention include providing an application independent storage array performance optimizer that may (i) be application independent, (ii) be generic and useable in a variety of environments, (iii) save money by eliminating the need to have an expert in Performance Tuning manually tune the storage array, (iv) be performed by any IT engineer, (v) reduce time by implementing software that may be finalized on the first attempt, (vi) provide a user confidence that the SAN has been configured for optimum performance, (vii) be non-disruptive by implementing a software tool that does not modify data and/or a LUN configuration during analysis, (viii) be run by any user against an installed SAN to ensure the SAN is configured for optimal performance, and/or (ix) allow end users to periodically reconfigure a SAN for optimal performance as certain parameters (e.g., IO profile) change.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

Referring toFIG. 1, a block diagram of a system100is shown in accordance with a preferred embodiment of the present invention. The system100generally comprises a module102, a module104, a connection106, a module108, a module110, a set of modules112a-112n, and a set of connections114a-114n. The module102may be implemented as a host. The module104may be implemented as a storage array. For example, the module104may represent an array of disk drives or other storage devices (e.g., solid state storage, etc.). The host102may include the module108. In one example, the module108may be implemented as an application (e.g., software). The storage array104may include the module110and the set of modules112a-112n. The module110may be implemented as an input/output (IO) performance module.

The set of modules112a-112nmay be implemented as LUNs. The particular number of LUNs112a-112nmay be varied (e.g., increased and/or decreased) to meet the design criteria of a particular implementation (e.g., up to 2048 or more). IO requests are normally sent to the LUNs112a-112n, which translate such requests to storage devices in the storage array104. The connection106may be a network connection, such as a fiber channel connection or other type of network connection. The connections114a-114nmay be implemented as one or more logical connections within the storage array104. The connection106and/or the connections114a-114nmay each be implemented as one or more network segments. In one example, the system100may be application independent.

The system100may be implemented with the application108configured to run on the host102. The IO performance module110may be configured to run on the storage array104. The application108and the IO performance module110may implement a storage performance optimizer. The application108on the host102may have several capabilities. The application108may initiate the storage array104to start capturing data relating to an IO profile (or profiles) and a LUN profile (or profiles) for a predetermined amount of time (e.g., 24 hours, however other amounts of time may be implemented) on the LUNs112a-112n. In one example, a user may select the predetermined amount of time via the application108.

The application108may retrieve the IO profile data and LUN profile data from the storage array104. The application108may process the IO profile data and LUN profile data. The application108may be configured to uncompress the IO profile data and/or LUN profile data on an as needed basis. The application108may make a recommendation on the characteristics of the LUNs112a-112nbased on the IO profile data and the LUN profile data. The recommendation may provide an optimum performance (e.g., configuration) based on a set of rules. In one example, the set of rules may be defined by a user. The application108may store and/or create new rules as needed.

The IO performance module110running on the storage array104may have several capabilities. The IO performance module110may create the IO profile data (e.g., as a file) and store the IO profile data (e.g., refer to TABLE 1 below). The IO performance module110may create the LUN profile data (or file) and store the LUN profile data (e.g., refer to TABLE 2 below). The IO performance module110may keep track of the LUNs112a-112nfor a predetermined amount of time (e.g., with a timer, such as a software timer module). In one example, the IO performance module110may compress (e.g., zip) the files (e.g., the IO profile data and the LUN profile data). Such compression may be optional and may be implemented on an as needed basis to reduce the size of the files.

The IO performance module110may store the files (e.g., in either compressed or uncompressed form). The IO performance module110may monitor a current performance including bandwidth (e.g., IO requests per second), throughput (e.g., MBs per second), and a number of IO requests received from the application108. For example, the IO performance module110may monitor the number of IO requests and an amount of data sent to and from the host102. The IO performance module110may keep track of the IO profile (e.g., read/write ratio, address range, IO request size, random vs. sequential addressing, performance, etc.).

A sample IO profile file may be shown in the following TABLE 1:

A sample LUN profile file may be shown in the following TABLE 2:

TABLE 2File ID: 10182008-1058LUN Segment# ofLUNRAID LevelSizeDrives/SpindlesIO/sMB/s0x0250x1053,7455.34
TABLE 2 may be implemented to keep track of the LUN profile. Each of the LUNs112a-112nmay have a corresponding LUN profile similar to the LUN profile in TABLE 2. The application108may make a recommendation for a configuration of the LUNs112a-112n. The configuration may improve performance (e.g., bandwidth, throughput, etc.) based on the IO profile that was captured for each of the LUNs112a-112n.

The system100may operate in a multi-step approach. In one step, the system100may store information (e.g., the IO profile data and the LUN profile data) on the storage array104on request (e.g., by the IO performance module110). In another step, the system100may retrieve the information (e.g., by the application108) on request. In another step, the system100may process the information collected (e.g., via the application108) and may make a recommendation (e.g., of a LUN configuration) based on the set of rules. In one example, the set of rules may be defined by the user. The recommendation may be a set of values used to configure the storage array104. For example, the set of values may be used to configure a particular one of the LUNs112a-112n. The recommended configuration may include a segment size, number of drives, and/or a RAID level for the particular one of the LUNs112a-112n.

Referring toFIG. 2, a flow diagram of a process200is shown. The process (or method)200generally comprises a state202, a state204, a decision state206, and a state208. In the state202, the IO performance module110may start to capture data (e.g., the IO profile and the LUN profile) for the LUNs112a-112nfor a predetermined amount of time. In the state204, the IO performance module110may store a command descriptor block (CDB) and information about the LUNs112a-112nin two files. The state206may determine if the predetermined amount of time has elapsed (or completed) or if data capture has been stopped by the user. If so, the process200may move to the state208. In the state208, the IO performance module110may save (and optionally compress, zip, etc.) the two files (e.g., CDB and information). If not, the process200may move back to the state204.

The process200may illustrate the complete process on how the system100(e.g., the application108) may initiate the IO performance module110. The IO performance module110may be initiated on the storage array104(or controller) to start capturing and storing the IO command descriptor block (CDB) and LUN profile data (e.g., the information) relating to the LUNs112a-112n. The process200may require a minimum configuration of the storage array104and the host102. The IO performance module110may run on the storage array104and the application108may run on the host102. In one example, the storage array104may be a commercial array (e.g., a 7900 by LSI Corporation, although other arrays may be implemented). Any host which has the application108installed and has access to the storage array104(e.g., implemented with the IO performance module110) over the network connection106may be used.

A user may start the application108(or tool) on the host102. The application108may allow the user to select one or more of the LUNs112a-112n(e.g.,112a-112c) or create a new list of LUNs (e.g.,112d-112n) to optimize. The user may then select how long the application108will monitor the LUNs112a-112n. Once the user has selected the amount of time to monitor the LUNs112a-112n, a request may be sent down to the storage array104via the network connection106. The IO performance module110may create a data file and start to capture the CDB of the LUNs112a-112nbeing requested. A number representing each of the LUNs112a-112nmay also be stored with the CDB. The IO performance module110may start measuring a performance (e.g., bandwidth, throughput, etc.). When the duration to monitor the LUNs112a-112nhas expired, the IO performance module110may store the files. In one example, when the duration (e.g., predetermined time) to monitor the LUNs112a-112nhas expired, the IO performance module110may compress (e.g., zip, etc.) the files and then store the files in particular format (e.g., .zip, .rar, .mim, etc.). The files (either compressed or uncompressed) may then be ready for the application108to perform an analysis.

Referring toFIG. 3, a flow diagram of a process300is shown. The process (or method)300generally comprises a state302, a state304, a state306, and a state308. In the state302, the IO performance module110may stop monitoring (e.g., by the user) or the predetermined time for monitoring may have elapsed. In the state304, the IO performance module110may stop capturing information and compress (e.g., zip) the data. The compression in the state304may be implemented on an as needed basis. In the state306, the application108may request the data file (or files) from the IO performance module110. In the state308, the IO performance module110may send the data file (or files) to the application108.

After the completion of the first step, the required data (e.g., the IO profile data and the LUN profile data) may be stored in the storage array104. In one example, the user may stop the IO performance module110from monitoring prior to the initial predetermined time. Once the IO performance module110may stop capturing the data, the IO performance module110may optionally compress (e.g., zip, archive, etc.) the data files. When the application108requests the data files from the IO performance module110, the IO performance module110may transfer the data files to the host102via the network connection106.

Referring toFIG. 4, a flow diagram of a process400is shown. The process (or method)400generally comprises a state402, a state404, a state406, and a state408. In the state402, the application108may start processing the data files. In the state404, the application108may provide a list of recommended configurations (e.g., LUN segment size, number of drives, RAID level, etc.) based on the IO profile. In the state406, the user may fine tune the recommended configuration based on a priority (e.g., is the data critical?, is IO performance more important?, etc.). In the state408, the user may narrow down to one configuration. In one example, the application108may present the new LUN configuration to the user.

After the completion of the second step, the data files may be processed by the application108. The application108may analyze the IO profile and/or the LUN profile. The application108may calculate a (i) IO size (e.g., % large and % small), (ii) segment boundary (e.g., how often (%) does it cross the segment boundary based on small versus large IOs), (iii) IO mix (e.g., % read and % write), and/or (iv) IO randomness (e.g., versus sequential). The application108may make several recommendations (e.g., of a LUN configuration) to the user based on the set of rules. In one example, the set of rules may be stored by the application108. The application108may then send the recommended configuration to the IO performance module110. In one example, the IO performance module110may reconfigure a particular one of the LUNs112a-112nbased on the recommended configuration. In one example, the reconfiguration of the LUNs112a-112nmay be automatic. However, the reconfiguration of the LUNs112a-112nmay also be manual and/or based on a user confirmation.

Several different rules may be implemented based on the particular design implementation. For example, when there is a small number of random IO requests, a larger LUN segment size may be recommended to ensure that the segment size is large enough for the IO requests to stay within the segment boundary. For a large number of IO requests, a smaller LUN segment size may be recommended to ensure that the segment size is small so that the IO requests may be serviced by multiple drives within the LUN. In general, the more drives servicing the IO requests, the faster the response time.

Several different rules may be implemented based on the user data priority. The user may be given one or more options to select an appropriate RAID level. For example, the application108may recommend a RAID 1 LUN if the data reliability is more critical than performance. A RAID 5 LUN may be recommended instead if IO performance is more important than the data reliability. A RAID 6 LUN may be recommended if both are important. The decision may be determined by the set of rules stored by the application108.

The present invention may also be implemented by the preparation of ASICs (application specific integrated circuits), Platform ASICs, FPGAs (field programmable gate arrays), PLDs (programmable logic devices), CPLDs (complex programmable logic device), sea-of-gates, RFICs (radio frequency integrated circuits), ASSPs (application specific standard products) or by interconnecting an appropriate network of conventional component circuits, as is described herein, modifications of which will be readily apparent to those skilled in the art(s).

The elements of the invention may form part or all of one or more devices, units, components, systems, machines and/or apparatuses. The devices may include, but are not limited to, servers, workstations, storage array controllers, storage systems, personal computers, laptop computers, notebook computers, palm computers, personal digital assistants, portable electronic devices, battery powered devices, set-top boxes, encoders, decoders, transcoders, compressors, decompressors, pre-processors, post-processors, transmitters, receivers, transceivers, cipher circuits, cellular telephones, digital cameras, positioning and/or navigation systems, medical equipment, heads-up displays, wireless devices, audio recording, storage and/or playback devices, video recording, storage and/or playback devices, game platforms, peripherals and/or multi-chip modules. Those skilled in the relevant art(s) would understand that the elements of the invention may be implemented in other types of devices to meet the criteria of a particular application.