DETECTING AND DIAGNOSING MISBEHAVING APPLICATIONS IN VIRTUALIZED COMPUTING SYSTEMS

Abstract

Misbehaving applications may be detected by monitoring system resource utilization in a virtualized computer system. Utilization may be forecasted based on historical utilization data for the system resources when the application is known to be behaving normally. When the monitored utilization of system resources deviates from the forecasted utilization, an alert may be generated. When the alert is generated, system resources allocated to the application may be increased or decreased to prevent abnormal behavior in the virtualized computer system executing to misbehaving application.

Description

TECHNICAL FIELD

The instant disclosure relates to virtualized computer systems. More specifically, the instant disclosure relates to monitoring application performance on virtualized computer systems.

BACKGROUND

On-demand computing infrastructures such as the Unisys Stealth, the Amazon EC2, and the Microsoft Azure platforms built using x86 virtualization technologies allow applications hosted on these infrastructures to acquire and release computing resources based on conditions within the hosted applications. The allocation of computing resources such as processor, memory, network input/output (I/O), and disk I/O to virtualized applications hosted on such platforms is varied in proportion to the workloads experienced by the applications. For example, certain applications may have higher workload during the day as opposed to at night. These applications may receive increased computing resources during the day and fewer at night. The workloads generally exhibit repetitive behavior, and the resource allocations to the applications change as the workload changes.

Commercial applications are available for monitoring application performance such as Netuitive and AppDynamics. These conventional applications incorporate statistical and machine learning algorithms for forecasting application misbehavior and for determining root-causes of such misbehaviors. These tools are designed for non-virtualized environments and clusters, where applications run on a set of homogenous machines in a dedicated manner.

However, the usefulness of these conventional applications in virtualized data-centers is limited due to the long latency associated with data collection. Conventional monitoring applications spend a significant amount of their time at the beginning of their lifecycle learning application behavior and the learning pattern of resource consumption. Only after sufficient data on various metrics have been collected can these tools differentiate normal behavior from abnormal behavior and generate meaningful predictions. For example, Netuitive typically requires two weeks of data before it can forecast abnormal behavior and initiate alarm generation.

In a virtualized scenario, where applications encapsulated within respective virtual machines share a common host and all virtual machine have the capability to migrate during their lifetime onto different machines with different resources, the statistics collected from different physical machines must be re-used appropriately for conclusions to be meaningful and predictions to be accurate. For example, assume that at time t1, a virtual machine is hosted on machine ‘A’ and at time t2, the virtual machine migrates to machine ‘B’. Further, assume that machine ‘A’ and machine ‘B’ belong to two different server classes (with different hardware architectures). If the CPU utilization by an application on machine ‘A’ is 50% at certain workload, the CPU utilization on machine ‘B’ could be 20% for the application at the same workload. In such scenarios, the existing commercial application performance management tools will fail to generate meaningful predictions. The data collected by Netuitive on machine A is irrelevant for predicting application misbehavior on machine B. Additionally, many of the commercial tools work with only a limited set of variables and, thus, do not scale well to virtualized machines.

SUMMARY

According to one embodiment, a method includes measuring current utilization of at least one system resource by an application. The method also includes generating a forecasted utilization for the at least one system resource by the application. The method further includes calculating an error between the current utilization and forecasted utilization. The method also includes determining when the application is misbehaving based, in part, on the error.

According to another embodiment, a computer program product includes a non-transitory computer storage medium having code to measure current utilization of at least one system resource by an application. The medium also includes code to generate a forecasted utilization for the at least one system resource by the application. The medium further includes code to calculate an error between the current utilization and forecasted utilization. The medium also includes code to determine when the application is misbehaving based, in part, on the error.

According to a further embodiment, an apparatus includes a virtualized computer system. The apparatus also includes a monitoring system. The apparatus further includes a database of historical utilization data of the virtualized computer system for at least one application. The apparatus also includes a forecasting system. The apparatus further includes a fault detection system.

The foregoing has outlined rather broadly the features and technical advantages of the present invention in order that the detailed description of the invention that follows may be better understood. Additional features and advantages of the invention will be described hereinafter which form the subject of the claims of the invention. It should be appreciated by those skilled in the art that the conception and specific embodiment disclosed may be readily utilized as a basis for modifying or designing other structures for carrying out the same purposes of the present invention. It should also be realized by those skilled in the art that such equivalent constructions do not depart from the spirit and scope of the invention as set forth in the appended claims. The novel features which are believed to be characteristic of the invention, both as to its organization and method of operation, together with further objects and advantages will be better understood from the following description when considered in connection with the accompanying figures. It is to be expressly understood, however, that each of the figures is provided for the purpose of illustration and description only and is not intended as a definition of the limits of the present invention.

BRIEF DESCRIPTION OF THE DRAWINGS

For a more complete understanding of the disclosed system and methods, reference is now made to the following descriptions taken in conjunction with the accompanying drawings.

FIG. 1 is a block diagram illustrating a system for detecting application misbehaviors according to one embodiment of the disclosure.

FIG. 2 is a flow chart illustrating a method for detecting application misbehaviors according to one embodiment of the disclosure.

FIG. 3 is a graph illustrating an error calculation between a forecast and measured processor utilization during normal operation according to one embodiment of the disclosure.

FIG. 4 is a graph illustrating an error calculation between a forecast and measured memory utilization during normal operation according to one embodiment of the disclosure

FIG. 5 is a table illustrating error values for processor and memory utilization during normal operation according to one embodiment of the disclosure.

FIG. 6 is a graph illustrating an error calculation between a forecast and measured processor utilization during misbehavior according to one embodiment of the disclosure.

FIG. 7 is a graph illustrating an error calculation between a forecast and measured memory utilization during misbehavior according to one embodiment of the disclosure.

FIG. 8 is a table illustrating error values for processor and memory utilization during misbehavior according to one embodiment of the disclosure.

FIG. 9 is a block diagram illustrating an information system according to one embodiment of the disclosure.

FIG. 10 is block diagram illustrating a data management system configured to store databases, tables, and/or records according to one embodiment of the disclosure.

FIG. 11 is a block diagram illustrating a server according to one embodiment of the disclosure.

DETAILED DESCRIPTION

Misbehaving applications may be detected and corrective action taken by monitoring system resource usage in a virtualized computing system and comparing the monitored resource utilization to forecast utilization derived from historical utilization data for an application. When the monitored resource utilization deviates from the forecast utilization an alarm may be generated to alert a user or a fault diagnosis component to the potential fault and allow corrective procedures applied to the application. The corrective behavior may include, for example, increasing or decreasing resources of the virtualized computing system allocated to the application.

FIG. 1 is a block diagram illustrating a system for detecting application misbehaviors according to one embodiment of the disclosure. A virtualized computing system 110, such as a cloud computing system, includes one or more computer systems. A monitoring system 112 is coupled to the virtualized computing system 110 for monitoring system resources such as processor utilization, memory utilization, network input/output (I/O), and disk I/O. The monitoring system 112 may perform monitoring at the web-tier, the application-tier, and/or the database-tier level. Historical measurement data may be stored by the monitoring system 112 in a database 114 coupled to the monitoring system 112. The database 114 may be stored in an information system as described below with respect to FIGS. 9, 10, and 11, and include time stamps with the recorded monitoring data. According to one embodiment, the database 114 only stores monitoring data for time periods during which applications are not misbehaving in the virtualized computing system 110. The monitoring system 112 is coupled to a fault detection system 120 through a number of error computation modules 122. The modules 122 receive data from the monitoring system 112 and a forecasting component 118 and calculates an error between the measured and forecasted data. For example, a processor error module 122a may compute the difference between a measured processor utilization by the monitoring system 112 and a forecasted processor utilization by the forecasting component 118. Likewise, a memory error module 122b and a network error module 122c may compute errors for memory utilization and network I/O. The fault detection system 120 may include additional error modules 122 such as a disk I/O error module (not shown).

The errors calculated by the modules 122 are reported to a fault detection component 124, which determines if an application executing on the virtualized computing system 110 is misbehaving. When an application is misbehaving an alarm may be generated by the fault detection component 124 and transmitted to a fault diagnosis component 126. Detecting misbehavior may allow correction of a misbehaving application before performance of the virtualized computing system 110 is negatively impacted. The fault diagnosis component 126 may determine a cause of the misbehaving application and transmit one or more instructions to a policy-based management system 130 for curing the misbehaving application. When no alarm is generated by the fault detection component 124 a no alarm signal may be transmitted to the policy-based management system 130. The policy-based management system 130 is coupled to a provisioning system 132, which is coupled to the virtualized computing system 110. The provisioning system 132 may perform tasks such as allocating system resources within the virtualized computing system 110 according to policy decisions received from the policy-based management system 130. For example, when the virtualized computing system 110 includes multiple computing systems each with multiple processors, the provisioning system 132 may allocate individual processors or individual computing systems to applications executing on the virtualized computing system 110. The policy-based management system 130 may provide instructions to allocate additional or fewer system resources to a misbehaving application in accordance with instructions received from the fault diagnosis component 126. According to one embodiment, when no applications are misbehaving the provisioning system 132 receives instructions from timer-based policies in the policy-based management system 130.

FIG. 2 is a flow chart illustrating a method for detecting application misbehaviors according to one embodiment of the disclosure. A method 200 begins at block 202 with measuring current utilization of a system resource within the virtualized computing system 110. At block 204 the measured utilization is compared with historical utilization data stored in the database 114. At block 206 an error is calculated (by a fault detection system 120) between the current utilization and this historical utilization. The fault detection system 120 then determines at block 208 when an application is misbehaving based, in part, on the calculated error. If an application is misbehaving corrective action may be taken such as, for example, the provisioning system 132 allocating more or less system resources in the virtualized computing system 110 to the misbehaving application.

Referring back to FIG. 1, according to one embodiment, a calibration system 116 is coupled to the forecasting component 118 for adjusting forecasts generated by the forecasting component 118 in accordance with different system capabilities and/or resources within the virtualized computing system 110. Because the virtualized computing system 110 may be a heterogeneous combination of computers with different capabilities and resources, the historical data in the database 114 may include data measured from different computing systems. The historical data may be adjusted by the calibration system 116 to a base configuration. For example, assume that an application is executing on a dual-core computing system (machine A) and that the configuration of the base machine has one core (machine B). The processing requirement of the application may first be calculated on machine B. This measurement may then be adjusted proportionately by an amount that depends on the relative strength of machine A and machine B, which generates a processor forecast for the application on machine A. According to one embodiment, the calibration system 116 may be, for example, a look-up table based on Standard Performance Evaluation Corporation (SPEC) benchmarks. According to another embodiment, the calibration system 116 may perform estimates based on support-vector machines and statistical learning theory.

According to one embodiment, the forecasting component 118 may decompose historical data in the database 114 for at least one computing resource such as memory, processor, network I/O, and disk I/O into individual components. The individual components may include trend (T_t), seasonal (S_t), cyclical (C_t) and error components (E_t). A multiplicative model may be formed for the error to decompose the data as:

X _t=(T_t*S_t*C_t)*E_t,

where X_t is a data-point at period t, T_t is the trend component at period t, S_t is the seasonal component at period t, C_t is the cyclical component at period t, and E_t is the error component at period t. For the historical data in the database 114 regarding each of the computing resources in the virtualized computing system 110 the following steps may be performed with L as the length of the seasonality. First, calculate the L-period total, L-period moving average, and the L-period centered moving average (CMA). Second, separate the L-period CMA computed in the first step from the original data to isolate the trend and the cyclical components. Third, determine seasonal factors by averaging them for each of the slots that make up the length of the seasonality. Seasonal indexes may be calculated as the average of the CMA percentage of the actual values observed in that slot. Fourth, the seasonal pattern may be removed by multiplicative seasonal adjustment, which is computed by dividing each value of the time series by the seasonal index calculated in the third step. Fifth, the de-seasonalized data of the fourth step may then be analyzed for the trend (represented as {circumflex over (X)}_t). Sixth, determine the cyclical component by separating the difference of actual and the trend as a fraction of the trend

$\left(\frac{X_t-{\hat{X}}_{\mathrm{tt}}}{{\hat{X}}_t}\right)$

from the results of the fifth step. Seventh, calculate the random error component after separating the trend, cyclical, and seasonal components from the actual data.

To forecast resource utilization for future time periods, a series of computations may be performed opposite to the decomposition approach described above. First, the cyclical component may be forecasted. Then, the trend component may be forecasted. Finally, the seasonal component may be forecasted. Forecasts of the individual components may be aggregated using the multiplicative model to compute the final forecast.

The forecasted values generated by the forecasting component 118 may be compared against the measured values by the monitoring system 112 and a difference between the two values calculated as an error by the fault detection system 120. According to one embodiment, the fault detection component 124 embodies a fault detection method based on the Hotelling's multi-variate T² statistic. The fault detection component 124 may monitor the error component for forecasting abnormal application behavior. Hotelling's multi-variate T² statistic has been successfully applied in the past to various chemical process industries and manufacturing operations to detect and diagnose faults. T² may be calculated as:

T ²=(X− X)′S⁻¹(X− X),

where X=(x₁, x₂, . . . , x_p) denotes the vector of variate (e.g., computational resources), X denotes the mean vector and S is the variance-covariance matrix. If the computed T² values for consecutive observations is greater than a threshold (δ), the fault detection component 124 may determine that the monitored application is behaving in an anomalous manner and more or less system resources in the virtualized computing system 110 should be provisioned to the application.

According to one embodiment, the fault diagnosis component 126 may employ an MYT decomposition method to interpret the signals associated with the T² value. A vector (X− X) may be partitioned as:

(X= X)′=[(X^(p−1)− X^(p−1)), (x_p− x_p)]′.

where X^(p−1)′=(x₁, x₂, . . . , x_p−1) represents the (p−1) dimensional variable vector, and X^(p−1) represents the corresponding (p−1) elements of the mean vector. A matrix S may be defined as:

$S=\left[\begin{array}{cc}{S}_{X^{\left(p-1\right)}X^{\left(p-1\right)}}& S_{x_pX^{\left(p-1\right)}}\\ s_{x_pX^{\left(p-1\right)}}^{\prime }& s_{x_p^2}\end{array}\right],$

where, S_{X(p−1)X(p−1)} is the covariance matrix of the (p−1), s_xp2 is the variance of x_p, s_xpX(p−1) is the covariance matrix between x_p and (x₁, x₂, . . . , x_p−1). The T² component may be partitioned into two components:

T ² =T _{p 1} ² +T _{p.1, 2, . . . , p 1},

where

$T_{p-1}^2=\frac{{\left(x_{p-1}-{\stackrel{\_}{x}}_{p-1}\right)}^2}{s_{p-1}^2},$ T _{p.1, 2, . . . , p−1}=(X^(p−1)− X^(p−1))′S_{X(p−1)X(p−1)}(X^(p−1)− X^(p−1)), and

T²≡T_{(x1, x2, . . . , xp)}², T_{(x1, x2, . . . , xp)}², T_{(x1, x2, . . . , xp−1)}², . . . , T_(xi)² are calculated according to:

T _{(x 1 , x 2 , . . . , x j )}=(X^(j)− X^(j))′S_X(j)X(j)⁻¹(X^(j)− X^(j)).

The terms of the MYT decomposition may be calculated as:

$T_{p\mathrm{.1},2,\dots ,p-1}^2=T_{\left(x_1,x_2,\dots ,x_p\right)}^2-T_{\left(x_1,x_2,\dots ,x_{p-1}\right)}^2,T_{p-1.1,2,\dots ,p-2}^2=T_{\left(x_1,x_2,\dots ,x_{p-1}\right)}^2-T_{\left(x_1,x_2,\dots ,x_{p-2}\right)}^2,T_{2,1}^2=T_{\left(x_1,x_2\right)}^2-T_{\left(x_1\right)}^2,\mathrm{and}$ $T_{\left(x_1\right)}^2=\frac{\left(x_1-{\stackrel{\_}{x}}_1\right)}{s_1^2}.$

p! partitions of T² statistic are possible in the above calculations. According to one embodiment, the calculations may be parallelized to operate on a cluster or grid infrastructure or specialized hardware such as a General Purpose Computation on Graphics Processing Units (GPGPU) machine.

According to another embodiment, the computational overhead may be reduced through the following iterative process. First, from the correlation matrix of all the variables, all variables with weak correlation may be deleted. Second, for the remaining variables compute T_xi² for i ∈ (1, 2, . . . , p). Variables with T_xi² values greater than their respective thresholds may be amongst the root-cause variables. Further analysis of the relationship that these variables share with other variables may be omitted. Third, for this reduced set of variables, all variables with weak correlation after examining the correlation matrix may be deleted. Fourth, if the number of variables that remain at the end of the third step is m₁, compute T_{(x1, xj, . . . , xm1)}. If a signal is detected, T_{x1, xj)}² may be examined for any pair of variables (x_i, x_j) from the sub-vector of m₁ variables that remain at the end of the third step. Pairs of variables (x_i, x_j) for which T_{(xi, xj)}² values are significant (e.g., above a threshold value) may be the causes of the anomaly. These variables may be omitted from the analysis. Fifth, if the number of variables that remain at the end of this step are m₂, compute T_{(xi, xj, . . . , xm2)}². If a signal is detected, T_{(xi, xj, xl)}² may be examined for all triplets of variables (x_i, x_j, x_k) from the sub-vector of variables that remain at the end of the fourth step. Triplets of variables (x_i, x_xj, x_k) for which T_{(xi, xj, xk)}² values are large may be amongst the causes of the anomaly. Sixth, if the number of variables that remain at the end of the fifth step are m₃, the computations may be repeated with higher order terms until all signals have been removed.

To locate the variables that are responsible for the signal, the individual terms of the MYT decomposition may be examined by comparing each individual term to a threshold value that depends on the term under consideration such as for example in:

T_xj²>UCL_(xj), and

T_{(xi, xj)}²>UCL_{(xi, xj)}.

According to one embodiment, all x_j having T_xj² greater than UCL_(xj) may be isolated and considered to be root-causes for the signal. Similarly, all pairs (x_i, x_j) having T_{(xi, xj)} values greater than the UCL_{(xi, xj)} may be excluded and may be candidates for root-cause.

UCL_(xj) may be calculated using an F-distribution:

$\left(\frac{n+1}{n}\right)F_{\left(\alpha ,1,n-1\right)},$

where α is the threshold percentile and n is the number of observations in the sample. Similarly, UCL_{xi, xj)} may be calculated using an F-distribution:

$\left(\frac{2\left(n+1\right)\left(n-1\right)}{n\left(n-2\right)}\right)F_{\left(\alpha ,2,n-2\right)}.$

In general UCL_{xi, xj, . . . , xk)} may be calculated from

$\left(\frac{k\left(n+1\right)\left(n-1\right)}{n\left(n-k\right)}\right)F_{\left(\alpha ,k,n-k\right)}.$

Operation of systems and methods described above with respect to FIG. 1 and FIG. 2 may improve application performance management techniques. According to one embodiment, the systems and methods may be implemented through software such as the statistical package R and Java. For example, a Java application may be a user interface to algorithms executing in R.

FIG. 3 is a graph illustrating an error calculation between a forecast and measured processor utilization during normal operation according to one embodiment of the disclosure. FIG. 3 illustrates a monitored processor utilization 302 as a function of time, a forecasted processor utilization 304 as a function of time, and a calculated error 306 as a function of time. FIG. 4 is a graph illustrating an error calculation between a forecast and measured memory utilization during normal operation according to one embodiment of the disclosure. FIG. 4 illustrates a monitored memory utilization 402 as a function of time, a forecasted memory utilization 404 as a function of time, and a calculated error 406 as a function of time. Small error values may be an indication of normal application behavior. The corresponding T² calculations for FIG. 3 and FIG. 4 are shown in a table 500 of FIG. 5. FIG. 5 is a table illustrating error values for processor and memory utilization during normal operation according to one embodiment of the disclosure.

FIG. 6 is a graph illustrating an error calculation between a forecast and measured processor utilization during misbehavior according to one embodiment of the disclosure. FIG. 6 illustrates a monitored processor utilization 602 as a function of time, a forecasted processor utilization 604 as a function of time, and a calculated error 606 as a function of time. FIG. 7 is a graph illustrating an error calculation between a forecast and measured memory utilization during misbehavior according to one embodiment of the disclosure. FIG. 7 illustrates a monitored memory utilization 702 as a function of time, a forecasted memory utilization 704 as a function of time, and a calculated error 706 as a function of time. Small error values may be an indication of normal application behavior. Large error values may be an indication of application misbehavior. The corresponding T² calculations for FIG. 6 and FIG. 7 are shown in a table 800 of FIG. 8. FIG. 8 is a table illustrating error values for processor and memory utilization during misbehavior according to one embodiment of the disclosure.

The corresponding T² calculations are shown in table-2. UCL values for T₁², T₂², T_1.2² and T_2.1² are calculated for α, the threshold percentile value of 0.01. UCL value of T₁² is calculated as 7.48 for a sample size of 41 and F value of 7.31, and UCL value of T₂² is calculated as 9.45 for a sample size of 15 and F value of 8.86. Similarly, UCL value of T_1.2² is calculated as 21.40 for a sample size of 10 and F value of 8.65, and UCL value of T_2.1² is calculated as 12.96 for a sample size of 20 and F value of 5.85. In the table 800 of FIG. 8, T₁² and T₂² are both greater than their respective thresholds allowing a determination that insufficient allocation of both CPU and memory are root causes of the misbehaving application.

FIG. 9 illustrates one embodiment of a system 900 for an information system. The system 900 may include a server 902, a data storage device 906, a network 908, and a user interface device 910. In a further embodiment, the system 900 may include a storage controller 904, or storage server configured to manage data communications between the data storage device 906 and the server 902 or other components in communication with the network 908. In an alternative embodiment, the storage controller 904 may be coupled to the network 908.

In one embodiment, the user interface device 910 is referred to broadly and is intended to encompass a suitable processor-based device such as a desktop computer, a laptop computer, a personal digital assistant (PDA) or table computer, a smartphone or other a mobile communication device or organizer device having access to the network 908. In a further embodiment, the user interface device 910 may access the Internet or other wide area or local area network to access a web application or web service hosted by the server 902 and provide a user interface for enabling a user to enter or receive information.

The network 908 may facilitate communications of data between the server 902 and the user interface device 910. The network 908 may include any type of communications network including, but not limited to, a direct PC-to-PC connection, a local area network (LAN), a wide area network (WAN), a modem-to-modem connection, the Internet, a combination of the above, or any other communications network now known or later developed within the networking arts which permits two or more computers to communicate, one with another.

In one embodiment, the user interface device 910 accesses the server 902 through an intermediate sever (not shown). For example, in a cloud application the user interface device 910 may access an application server. The application server fulfills requests from the user interface device 910 by accessing a database management system (DBMS). In this embodiment, the user interface device 910 may be a computer executing a Java application making requests to a JBOSS server executing on a Linux server, which fulfills the requests by accessing a relational database management system (RDMS) on a mainframe server.

In one embodiment, the server 902 is configured to store time-stamped system resource utilization information from a monitoring system 112 of FIG. 1. Scripts on the server 902 may access data stored in the data storage device 906 via a Storage Area Network (SAN) connection, a LAN, a data bus, or the like. The data storage device 906 may include a hard disk, including hard disks arranged in an Redundant Array of Independent Disks (RAID) array, a tape storage drive comprising a physical or virtual magnetic tape data storage device, an optical storage device, or the like. The data may be arranged in a database and accessible through Structured Query Language (SQL) queries, or other data base query languages or operations.

FIG. 10 illustrates one embodiment of a data management system 1000 configured to manage databases. In one embodiment, the data management system 1000 may include the server 902. The server 902 may be coupled to a data-bus 1002. In one embodiment, the data management system 1000 may also include a first data storage device 1004, a second data storage device 1006, and/or a third data storage device 1008. In further embodiments, the data management system 1000 may include additional data storage devices (not shown). In such an embodiment, each data storage device 1004, 1006, and 1008 may each host a separate database that may, in conjunction with the other databases, contain redundant data. Alternatively, a database may be spread across storage devices 1004, 1006, and 1008 using database partitioning or some other mechanism. Alternatively, the storage devices 1004, 1006, and 1008 may be arranged in a RAID configuration for storing a database or databases through may contain redundant data. Data may be stored in the storage devices 1004, 1006, 1008, and 1010 in a database management system (DBMS), a relational database management system (RDMS), an Indexed Sequential Access Method (ISAM) database, a Multi Sequential Access Method (MSAM) database, a Conference on Data Systems Languages (CODASYL) database, or other database system.

In one embodiment, the server 902 may submit a query to selected data from the storage devices 1004, 1006. The server 902 may store consolidated data sets in a consolidated data storage device 1010. In such an embodiment, the server 902 may refer back to the consolidated data storage device 1010 to obtain a set of records. Alternatively, the server 902 may query each of the data storage devices 1004, 1006, and 1008 independently or in a distributed query to obtain the set of data elements. In another alternative embodiment, multiple databases may be stored on a single consolidated data storage device 1010.

In various embodiments, the server 1002 may communicate with the data storage devices 1004, 1006, and 1008 over the data-bus 1002. The data-bus 1002 may comprise a SAN, a LAN, or the like. The communication infrastructure may include Ethernet, Fibre-Chanel Arbitrated Loop (FC-AL), Fibre-Channel over Ethernet (FCoE), Small Computer System Interface (SCSI), Internet Small Computer System Interface (iSCSI), Serial Advanced Technology Attachment (SATA), Advanced Technology Attachment (ATA), Cloud Attached Storage, and/or other similar data communication schemes associated with data storage and communication. For example, the server 902 may communicate indirectly with the data storage devices 1004, 1006, 1008, and 1010 through a storage server or the storage controller 904.

The server 902 may include modules for interfacing with the data storage devices 1004, 1006, 1008, and 1010, interfacing a network 908, interfacing with a user through the user interface device 910, and the like. In a further embodiment, the server 902 may host an engine, application plug-in, or application programming interface (API).

FIG. 11 illustrates a computer system 1100 adapted according to certain embodiments of the server 902 and/or the user interface device 910 of FIG. 4. The central processing unit (”CPU″) 1102 is coupled to the system bus 1104. The CPU 1102 may be a general purpose CPU or microprocessor, graphics processing unit (“GPU”), microcontroller, or the like. The present embodiments are not restricted by the architecture of the CPU 1102 so long as the CPU 1102, whether directly or indirectly, supports the modules and operations as described herein. The CPU 1102 may execute the various logical instructions according to the present embodiments.

The computer system 1100 also may include random access memory (RAM) 1108, which may be SRAM, DRAM, SDRAM, or the like. The computer system 1100 may utilize RAM 1108 to store the various data structures used by a software application such as databases, tables, and/or records. The computer system 1100 may also include read only memory (ROM) 1106 which may be PROM, EPROM, EEPROM, optical storage, or the like. The ROM may store configuration information for booting the computer system 1100. The RAM 1108 and the ROM 1106 hold user and system data.

The computer system 1100 may also include an input/output (I/O) adapter 1110, a communications adapter 1114, a user interface adapter 1116, and a display adapter 1122. The I/O adapter 1110 and/or the user interface adapter 1116 may, in certain embodiments, enable a user to interact with the computer system 1100. In a further embodiment, the display adapter 1122 may display a graphical user interface associated with a software or web-based application.

The I/O adapter 1110 may connect one or more storage devices 1112, such as one or more of a hard drive, a compact disk (CD) drive, a floppy disk drive, and a tape drive, to the computer system 1100. The communications adapter 1114 may be adapted to couple the computer system 1100 to a network, which may be one or more of a LAN, WAN, and/or the Internet. The communications adapter 1114 may be adapted to couple the computer system 1100 to a storage device 1112. The user interface adapter 1116 couples user input devices, such as a keyboard 1120 and a pointing device 1118, to the computer system 1100. The display adapter 1122 may be driven by the CPU 1102 to control the display on the display device 1124.

The applications of the present disclosure are not limited to the architecture of computer system 1100. Rather the computer system 1100 is provided as an example of one type of computing device that may be adapted to perform the functions of a server 902 and/or the user interface device 1110. For example, any suitable processor-based device may be utilized including, without limitation, personal data assistants (PDAs), tablet computers, smartphones, computer game consoles, and multi-processor servers. Moreover, the systems and methods of the present disclosure may be implemented on application specific integrated circuits (ASIC), very large scale integrated (VLSI) circuits, or other circuitry. In fact, persons of ordinary skill in the art may utilize any number of suitable structures capable of executing logical operations according to the described embodiments. A virtualized computing system, such as that illustrated in FIG. 1, may include one or more of the computer systems 1100 or other processor-based devices such as PDAs, table computers, smartphones, computer game consoles, and multi-processor servers.

Although the present disclosure and its advantages have been described in detail, it should be understood that various changes, substitutions and alterations can be made herein without departing from the spirit and scope of the disclosure as defined by the appended claims. Moreover, the scope of the present application is not intended to be limited to the particular embodiments of the process, machine, manufacture, composition of matter, means, methods and steps described in the specification. As one of ordinary skill in the art will readily appreciate from the present invention, disclosure, machines, manufacture, compositions of matter, means, methods, or steps, presently existing or later to be developed that perform substantially the same function or achieve substantially the same result as the corresponding embodiments described herein may be utilized according to the present disclosure. Accordingly, the appended claims are intended to include within their scope such processes, machines, manufacture, compositions of matter, means, methods, or steps.

Claims

1. A method, comprising: measuring current utilization of at least one system resource by an application;generating a forecasted utilization for the at least one system resource by the application;calculating an error between the current utilization and forecasted utilization; anddetermining when the application is misbehaving based, in part, on the error.

2. The method of claim 1, in which the step of calculating the error comprises: identifying a plurality of variables for statistical analysis;calculating a correlation matrix for the variables; anddeleting at least one variable having a weak correlation in the correlation matrix.

3. The method of claim 2, in which the step of calculating the error further comprises: computing a T2 value for plurality of variables remaining after deleting the at least one variable having a weak correlation; anddeleting at least one variable from the plurality of variables having a T2 value greater than a threshold.

4. The method of claim 3, in which the step of calculating the error further comprises: calculating a T2 value for pairs of variables of the plurality of variables remaining after deleting the at least one variable having a T2 value greater than the threshold; anddeleting at least one pair of variables from the plurality of variables having a T2 value greater than a threshold.

5. The method of claim 1, in which the at least one system resource is at least one of a processor, memory, network input/output (I/O), and disk I/O.

6. The method of claim 1, in which the current utilization is measured by executing the application on a first system of a virtualized computing system and the historical utilization is based on executing the application on a second system of the virtualized computing system different from the first system, and further comprising adjusting the forecast utilization based on differences between a first system and a second system.

7. The method of claim 1, further comprising, when the application is misbehaving, allocating different system resources to the application.

8. A computer program product, comprising: a non-transitory computer storage medium comprising: code to measure current utilization of at least one system resource by an application;code to generate a forecasted utilization for the at least one system resource by the application;code to calculate an error between the current utilization and forecasted utilization; andcode to determine when the application is misbehaving based, in part, on the error.

9. The computer program product of claim 8, in which the at least one system resource is at least one of a processor, memory, network input/output (I/O), and disk I/O.

10. The computer program product of claim 8, in which the code to generate the forecasted utilization comprises code to generate a forecasted utilization based, in part, on historical utilization.

11. The computer program product of claim 10, in which the current utilization is measured by executing the application on a first system of a virtualized computing system and the historical utilization is based on executing the application on a second system of the virtualized computing system different from the first system.

12. The computer program product of claim 11, in which the medium further comprises code to adjust the forecast utilization based on differences between the first system and the second system.

13. The computer program product of claim 11, in which the second system is a base system.

14. The computer program product of claim 11, in which the medium further comprises code to, when the application is misbehaving, allocate different system resources to the application.

15. An apparatus, comprising: a virtualized computer system;a monitoring system;a database of historical utilization data of the virtualized computer system for at least one application;a forecasting system; anda fault detection system.

16. The apparatus of claim 15, in which the virtualized computer system includes at least one computer resource coupled to the monitoring system.

17. The apparatus of claim 15, further comprising a calibration system coupled to the forecasting system.

18. The apparatus of claim 15, further comprising a provisioning system coupled to the fault detection system and the virtualized computer system.

19. The apparatus of claim 18, further comprising a policy-based management system coupled to the provisioning system and the fault detection system.

20. The apparatus of claim 15, in which the virtualized computer system is a cloud computing system.