Guest-driven virtual machine snapshots

Systems and methods include a snapshot interface to receive, from an application executing within a virtualized execution environment, a request to generate a snapshot of the virtualized execution environment. The snapshot interface forwards the request to generate the snapshot to a virtualization manager. The snapshot interface then receives, from the virtualization manager, a result of the request to generate the snapshot, the result indicating whether the snapshot was generated. Finally, the snapshot interface forwards, to the application, the result of the request.

TECHNICAL FIELD

The present disclosure is generally related to computer systems, and more particularly, to virtual machine snapshot generation.

BACKGROUND

A virtual machine is a portion of software that, when executed on appropriate hardware, creates an environment allowing the abstraction of a physical computer system (e.g., a server, a mainframe computer, etc.). The actual physical computer system is typically referred to as a “host machine,” and the operating system (OS) of the host machine is typically referred to as the “host operating system.” Typically, software on the host machine known as a “hypervisor” (or a “virtual machine monitor”) manages the execution of one or more virtual machines or “guests,” providing a variety of functions such as virtualizing and allocating resources, context switching among virtual machines, etc. The operating system (OS) of the virtual machine is typically referred to as the “guest operating system.”

DETAILED DESCRIPTION

Described herein are methods and systems for guest-driven virtual machine snapshot generation. A snapshot of a virtual machine may include at least part of the execution state of the virtual machine. For simplicity, examples of the present disclosure refer to virtual machines. However, the disclosure is not limited to virtual machines and any virtualized execution environment may also be used in place of a virtual machine. As referred to herein, a virtualized execution environment may be a virtual machine, a virtual container, a virtual OS, etc. The snapshot may include the state of the processor, memory, disks, and/or any other component of the virtual machine at the time that the snapshot is generated. Therefore, at a later time, the virtual machine may be restored to the saved state of the virtual machine included in the snapshot. For example, the virtual machine may be restored to the snapshot state if the virtual machine crashes during execution of a task, is not functioning properly, or if other issues arise.

Generally, initiation of snapshot creation is controlled by components that are external to the virtual machine for which the snapshot is created. For example, systems that monitor the execution of virtual machines may request that the virtualization manager generate a snapshot. Client devices interacting with a virtual machine may request a snapshot, or automation scripts may request snapshots (e.g., at specific intervals). However, systems that are external to the virtual machine do not always have adequate information about the execution of the applications executing within the virtual machine. Therefore, a snapshot might not be generated at the most opportune times. For example, although an application executing within the virtual machine is about to execute a highly risky task (e.g., a task or an operation that could cause the application or virtual machine to crash), the snapshot initiating external systems may be unable to initiate a snapshot prior to execution of the task because external systems are unaware of the execution of the application.

Aspects of the present disclosure address the above noted deficiency by providing for guest-driven virtual machine snapshots. A snapshot interface may be provided to an application executing within a virtual machine, through which the application may request a snapshot of the virtual machine. The snapshot interface may be an application programming interface (API) within the virtual machine that the application can interact with directly. The snapshot interface may be included in a guest agent of the virtual machine. The guest agent may be a software component of the virtual machine that communicates with the hypervisor and virtualization manager. The guest agent may receive information about the virtual machine and its environment from the virtualization manager or forward information from within the virtual machine to the virtualization manager. For example, the guest agent may monitor components of the virtual machine. The guest agent may provide information about the virtual machine to the virtualization manager in response to a request from the virtualization manager. In another example, the guest agent may forward snapshot requests received from an application executing within the virtual machine to the virtualization manager. Alternatively, the snapshot interface may be a separate component from the guest agent but may communicate with the guest agent. For example, the application may request a snapshot through the snapshot interface. The snapshot interface may then forward the request to the guest agent. The guest agent may then forward the request to the virtualization manager to execute an instruction to generate a snapshot of the virtual machine.

A filtering component, herein referred to as an “admission controller,” may be included in the snapshot interface, the guest agent, the host machine, the virtualization manager and/or the hypervisor. The admission controller may filter requests based on individual applications. For example, the admission controller may allow requests only from applications that are authorized to make snapshot requests. For example the admission controller may only authenticate applications that an administrator authorizes or that are included in a list of authorized applications. In another example, the admission controller may authenticate an application unless it is included in a list of applications that are not authorized to request snapshots (e.g., known malware or other hostile applications). In addition, the admission controller may filter requests at the virtual machine level, at the node level, or the cluster level. The admission controller may filter the requests based on the network bandwidth necessary to create the requested snapshots. For example, the network bandwidth may only support the creation of a certain volume of snapshots (i.e., number of snapshots created per unit of time) depending on a threshold amount of data included in the snapshots. If the amount of data in the generated snapshots exceeds the amount of data supported by the network bandwidth then resource starvation may result. Thus, if the amount of data associated with potential snapshots to be created by the requests exceeds the threshold amount of data then the admission controller may cancel one or more of the received requests. Accordingly, the admission controller may allow only a threshold volume of requests to be executed. The admission controller may also monitor system usage data and adjust the filtering conditions accordingly at each level (e.g., virtual machine level, node level, and cluster level).

Each request may include metadata associated with the request. The metadata associated with a request may include the snapshot name for the request, a priority associated with the request, and/or a timeout value for the request. The snapshot name may uniquely identify the resulting snapshot generated by the virtualization manager. The priority level associated with the request may be used to prioritize execution of snapshot requests. Higher priority snapshot requests may be executed before lower priority requests. As described above, the admission controller may allow only a threshold volume of requests to be executed (i.e., threshold volume of snapshots to be created) based on network bandwidth availability. If more than the threshold volume of requests is received, then the requests with higher priority may be executed at the expense of lower priority requests. For example, if only five requests may be executed within a minute and six requests are received within a minute, then the five requests with the highest priority may be executed and the lowest may be filtered out. The timeout value may be a specified period of time that the virtualization manager is to wait for the application to complete execution of a task before automatically restoring the virtual machine to the state of the snapshot.

In an illustrative example, an application may approach an operation that needs to be executed but that is deemed to be risky. The application may then request, through a snapshot interface of the virtual machine, for a snapshot to be created before it executes the risky operation. As discussed above, the snapshot interface may forward the request from the application to the virtualization manager and the virtualization manager may generate a snapshot of the virtual machine. The application may wait for a confirmation that the snapshot has been created and then proceed to execute the risky operation. If the risky operation fails or causes issues with the application or the virtual machine (e.g., crashing the application or virtual machine, causing an error state, infinite loop, freezing, etc.) then the virtualization manager may use the snapshot to restore the virtual machine to the state of virtual machine saved in the snapshot. In one example, the virtualization manager may restore the virtual machine automatically after the timeout value received in the request expires. Aspects of the present disclosure are thus capable of providing an application executing within a virtual machine the ability to initiate a snapshot of the virtual machine. More particularly, aspects of the present disclosure can provide a fallback mechanism for applications executing risky operations within a virtual machine. Thus, the snapshot interface mitigates the negative effects of negative process flows associated with executing risky operations and increases the amount of information that can be received from within an executing virtual machine.

FIG. 1depicts a high-level component diagram of an illustrative example of a computer system100, in accordance with one or more aspects of the present disclosure. One skilled in the art will appreciate that other architectures for computer system100are possible, and that the implementation of a computer system utilizing examples of the invention are not necessarily limited to the specific architecture depicted byFIG. 1.

As shown inFIG. 1, computer system100may comprise one or more client devices110and one or more host machines120and150, each connected to a network140. Client device110may be a server, a workstation, a personal computer, a mobile phone, a palm-sized computing device, a personal digital assistant, and so on. Client device110may include a client application115. Client application115may be any type of application such as a web application, a desktop application, a browser application, etc. Client application115may be used to interact with and control virtual machines executing on host machine120.

The host machine120may be a server, a mainframe, a workstation, a personal computer (PC), a mobile phone, a palm-sized computing device, etc. Host machine120may include a system comprising one or more processors, one or more memory devices, and one or more input/output interfaces. The network140may be a private network (e.g., a local area network (LAN), a wide area network (WAN), intranet, etc.) or a public network (e.g., the Internet). Host machine120may execute one or more virtual machines132by executing a software layer referred to as hypervisor130on the host machine120. The virtual machine132and hypervisor130may execute on a host operating system (OS)125. Host OS125manages the hardware resources of the computer system and provides functions such as inter-process communication, scheduling, memory management, and so forth. Virtual machine132may be software that provides a virtualized execution environment which emulates the function of a physical computer system.

It should be noted that although, for simplicity, two host machines120and150are depicted inFIG. 1, in some other embodiments computer system100may comprise any number of host machines or even a plurality of clusters of host machines.

Host OS125may comprise a hypervisor130, which provides a virtual operating platform for virtual machine132and manages its execution. It should be noted that in some alternative implementations, hypervisor130may be external to host OS125, rather than embedded within host OS125, or may replace host OS125. Additionally, hypervisor130may be executed on a host separate from host machine120but connected to host machine120via a network connection (e.g., network140).

Virtual machine132may comprise a guest operating system (not shown) that handles the execution of applications within the virtual machine, and one or more virtual processors (not shown). It should be noted that although, for simplicity, a single virtual machine132is depicted inFIG. 1, host machine120may host a plurality of virtual machines. Virtual machine132may include a snapshot interface134and an application136. Although virtual machine132is depicted as including a single application136, it should be noted that virtual machine132may execute a plurality of applications. In some instances, snapshot interface134may be included within a guest agent of the virtual machine132. The guest agent may be a software component included in the virtual machine that allows the virtual machine132to communicate with the hypervisor130and virtualization manager155. The guest agent may receive a request for the guest operating system executing within the virtual machine132to shut down. Additionally, the guest agent may forward information about the virtual machine132to the hypervisor130and the virtualization manager155executing on host machine150.

The virtualization manager155may be one or more software modules being executed on the host machine150for centralized management of one or more host machines120executing one or more virtual machines132. Virtualization manager155may comprise various interfaces, including an administrative interface, a reporting interface, and/or an application programming interface (API) to communicate with host machine120. As described further below with respect toFIG. 2, virtualization manager155may include an admission controller to filter snapshot requests and a snapshot execution unit to generate virtual machine snapshots.

The snapshot interface134may be a standardized API that provides application136the ability to communicate with the virtualization manager155. For example, the application136may send a request for the virtualization manager155to generate a snapshot of the virtual machine132. The application136sends the request to the snapshot interface134which then forwards the request to the virtualization manager155. In one example, the snapshot interface134may be included within the guest agent, which may expose the snapshot interface134to interact with applications executing within the virtual machine. The guest agent may be a software component of the virtual machine132that communicates with the hypervisor130and virtualization manager155. The guest agent may receive a request for the guest operating system executing within the virtual machine132to shut down. In addition, the guest agent may also forward information from within the virtual machine132to the virtualization manager155. The snapshot interface134may use the guest agent of the virtual machine132to forward the request to the virtualization manager155. In another example, the snapshot interface134may be a separate component from the guest agent, or included in another component other than the guest agent that communicates with the guest agent. For example, the snapshot interface134may receive a snapshot request from an application136executing within the virtual machine132and then forward the snapshot request to the guest agent. The guest agent may then forward the snapshot request to the virtualization manager155. Upon receiving the request from the snapshot interface134, the virtualization manager155may then generate a snapshot of the virtual machine132. In some instances, the snapshot interface134may provide functionality to forward additional types of requests or information from applications to the virtualization manager that may be useful.

FIG. 2depicts a block diagram of a system200using guest-driven virtual machine snapshots, in accordance with one or more aspects of the present disclosure. As shown inFIG. 2, a virtualization manager210is communicatively coupled to a virtual machine220. Virtualization manager210may the same or similar to virtualization manager155, as described with respect toFIG. 1. Virtualization manager210includes a snapshot execution unit212and an admission controller214. Virtual machine220may include one or more applications222A-C, a guest agent224, and a snapshot interface226. Snapshot interface226may be included in guest agent224. Alternatively, snapshot interface226may be a separate component from guest agent224but may still communicate with the guest agent224. Guest agent224may be a software component of the virtual machine220used to communicate with the virtualization manager210. The snapshot interface226may provide a standardized interface for applications222A-C to request a snapshot be generated by the snapshot execution unit212of the virtualization manager210. Snapshot execution unit212may execute requests to generate a snapshot of the state of virtual machine220. Admission controller214may filter snapshot requests received from applications222A-C based on a threshold volume of allowed requests (i.e., number of requests per unit of time), the volume of snapshot requests received at the admission controller214, and a priority level of the requests received.

For example, applications222A-C executing within virtual machine220may approach execution of an operation that needs to be executed but that could cause problems with execution of the application222A-C or even the virtual machine220(e.g., cause the virtual machine to crash). In response, the application222A-C may send a snapshot request to the snapshot interface226with which the applications222A-C can interact directly. A component of the admission controller214(not depicted) located in the virtual machine220with the snapshot interface226may determine whether the application222A-C is authorized to request a snapshot. For example, the admissions controller214may authorize the request if the application is not on an application “blacklist” that includes applications that are not allowed to request snapshots. In another example the admissions controller214may authorize the request only if the application is included in a list of applications that are explicitly allowed to request snapshots. If the application222A-C is authorized to submit snapshot requests, then the snapshot interface226may provide the request to the guest agent224. The guest agent224may then forward the request to the virtualization manager210. Once the snapshot request is received by the virtualization manager210, the admission controller214may determine, based on a threshold volume of allowed snapshot requests and a priority of the request, whether to allow the snapshot request to be forwarded to the execution unit212to generate a snapshot of the virtual machine220. The admission controller214may filter received requests to allow only the threshold volume of requests received from the virtual machine220to go through to the snapshot execution unit212. If the threshold volume of requests haven't been received from the virtual machine220then the request is forwarded to the snapshot execution unit212to be executed. Otherwise, if the threshold volume of requests have been received at the admission controller214then the request may be rejected. In another example, as described further with respect toFIG. 5, the admission controller214may filter the requests according to priorities associated with the requests, and ratings of the virtual machines from which they are received. In addition, the admission controller214may filter the requests at the virtual machine level, the node level, or the cluster level. For example, a policy rule enforced by the admission controller may allow only a first threshold number of requests from a virtual machine. Another policy rule may allow only a second threshold number of requests from a single host machine. Yet another policy rule may allow only a third threshold number of requests from a cluster of host machines.

The snapshot execution unit212of the virtualization manager210may create a snapshot by saving the current state of the virtual machine220. For example, virtual disks of the virtual machine220may consist of a chain of one or more volumes that include the virtual machine's220operating system, applications220A-C and data that make up the state of the virtual machine220. At the time the snapshot is created, the volumes that the virtual disks of the virtual machine220consists of at that moment may become read-only volumes and a new volume to store changes to the virtual machine220may be created. Thus, the snapshot maintains the state of the original volumes and then any changes to the virtual machine220are copied to the new volume that is not part of the snapshot. When the virtualization manager210restores the virtual machine220to the snapshot state, the virtual machine220may simply disregard the changes stored in the new volumes. Therefore, a snapshot may be viewed as a storage function allowing creation of a restore point of a virtual machine's220operating system, memory state, applications, and data at a certain point in time.

FIG. 3depicts a flow diagram of an example method300for generating a guest-driven virtual machine snapshot. The method may be performed by processing logic that may comprise hardware (circuitry, dedicated logic, etc.), software (such as is run on a general purpose computer system or a dedicated machine), or a combination of both. In one illustrative example, method300may be performed by snapshot interface226inFIG. 2. Alternatively, some or all of method300might be performed by another module or machine. It should be noted that blocks depicted inFIG. 3could be performed simultaneously or in a different order than that depicted.

At block302, the snapshot interface receives, from an application executing within a virtualized execution environment, a request to generate a snapshot of the virtualized execution environment, wherein the snapshot comprises a state of the virtualized execution environment. The snapshot interface may be a standardized interface that may be used by any application executing within a virtualized execution environment in which the snapshot interface is installed. Therefore, the snapshot interface may allow applications from across different virtualization platforms to use the standardized interface to request a snapshot of the virtualized execution environment in which the application is executing. The request may include a name of the request and/or a name of the snapshot to be generated by the request and a priority of the request. The priority of the request may indicate the relative importance of the request as compared to other requests. Thus, the priority may dictate an order of execution of received snapshot requests. The request may additionally include a timeout value. The timeout value may be a length of time that the virtualization manager is to wait after receiving the request before automatically restoring the virtualized execution environment to the state of the snapshot. However, if the application completes execution of the task associated with the timeout value then the application, through the snapshot interface, may instruct the virtualization manager to cancel the automatic restoration of the virtualized execution environment. The application may request the snapshot as it approaches execution of a risky task or operation that may cause the virtualized execution environment to crash or become corrupted.

At block304, the snapshot interface forwards, to the virtualization manager, the request to generate the snapshot. The snapshot interface may be included in a guest agent of the virtual machine. The guest agent may be software that communicates with the virtualization manager. The guest agent may expose the snapshot interface to the application and forward the request to the virtualization manager. The snapshot interface may also be a separate component from the guest agent. The hypervisor may expose the snapshot interface to the application if the snapshot interface is a separate component from the guest agent. The snapshot interface may forward the request received from the application to the guest agent which then forwards the request to the virtualization manager.

At block306, the snapshot interface receives, from the virtualization manager, a result of the request to generate the snapshot, the result indicating whether the snapshot was generated. The result received from the virtualization manager may indicate whether the virtualization manager generated the snapshot. In one example, the result may be a confirmation that the virtualization manager generated the snapshot, or a failure notification that the snapshot was not generated.

At block308, the snapshot interface provides, to the application, the result of the request. If the result indicates that the snapshot was created, the application may proceed to execute. As discussed in block302, the request sent to the virtualization manager may include a timeout value. When the application continues to execute, if the virtualization manager does not receive a notification that the risky task or operation was executed successfully, the virtual machine may automatically be restored to the state of the snapshot after the timeout expires. Otherwise, if execution of the code is successful then the virtualization manager may cancel the automatic restoration after receiving an indication from the application, through the snapshot interface that there was no issue with execution.

FIG. 4depicts a flow diagram of an example method400for generating a guest-driven virtual machine snapshot. The method may be performed by processing logic that may comprise hardware (circuitry, dedicated logic, etc.), software (such as is run on a general purpose computer system or a dedicated machine), or a combination of both. In one illustrative example, method400may be performed by an admission controller214of virtualization manager210inFIG. 2. Alternatively, some or all of method400might be performed by another module or machine. It should be noted that blocks depicted inFIG. 4could be performed simultaneously or in a different order than that depicted.

At block402, the admission controller receives, from an application executing within a virtual machine, a request to generate a snapshot of the virtual machine, wherein the snapshot comprises a state of the virtual machine. The admission controller may be a component of a virtualization manager to receive and filter snapshot requests from applications. The admission controller may authorize, filter, and forward requests received from virtual machines to a snapshot execution component of the virtualization manager.

At block,404, the admission controller authenticates the request to generate the snapshot, wherein authenticating the snapshot comprises determining that the application that initiated the request is authorized to request the snapshot. The admission controller may authenticate the request by determining that a threshold volume of requests have not been received within a certain period of time. The threshold volume of requests may be determined by the network bandwidth necessary to create the threshold volume of snapshots. If the threshold volume of requests have not been received within the period of time then no requests are filtered out. The admission controller may also authenticate the application by determining that the application is not included in an applications blacklist consisting of applications that are not authorized to request snapshots (e.g., malicious applications). Similarly, the admission controller may authenticate the application by determine that the application is included in a list of applications authorized to request a snapshot. The admission controller may additionally filter requests based on a priority level associated with a request. The admission controller may forward requests with a higher priority level to the snapshot execution unit to be executed first. The admission controller may filter out requests with a lower priority level first if more than the threshold volume of requests are received.

At block406, the admission controller forwards, to a snapshot execution unit, an instruction to generate a snapshot of the virtual machine, wherein generating the snapshot comprises saving the state of the virtual machine at the time the instruction is executed, as described above with respect toFIGS. 2 and 3. The saved state of the virtual machine may be used at a later time to restore the virtual machine to the saved state if the virtual machine, or an application executing within the virtual machine, encounters an error state. For example, the application may provide a timeout value with the request to generate a snapshot. Once the timeout lapses the virtualization manager may restore the virtual machine to the state of the snapshot. However, if the virtualization manager receives an indication to cancel the restoration (e.g., because the application successfully executed a risky task) then the virtualization manager may not restore the virtual machine when the timeout lapses.

At block408, the admission controller provides, to the application, a result of the request, the result of the request indicating that the snapshot was generated. The application may then continue to execute in response to receiving the result. If the application then fails, the snapshot may be used to restore the virtual machine to the state saved in the snapshot (i.e., prior to the application's failure). In one example, the application is blocked from executing (e.g., by the snapshot interface) after initially sending the request until the virtualization manager provides the result of the request to the application. Once the virtualization manager provides the result of the request to the application, the application may then continue to execute. In another example, the application continues to execute while waiting for the virtualization manager to provide the result of the request unless the risky task is reached before the result is provided.

FIG. 5depicts a component diagram illustrating a system500for guest-driven snapshot generation using an admission controller524A-C to monitor and filter snapshot requests. The system500may include a cluster505of host machines510A-B and a host machine520that may be separate from cluster505or included within the cluster505. The host machines510A-B of the cluster505and the host machine520may be connected to a network540. The host machines510A-B of the cluster505may include one or more virtual machines512A-D executing on a respective host operating system of the host machines510A-B. Virtual machines512A-D may each include a guest agent514A-D and a snapshot interface516A-D, respectively. Although not depicted, each virtual machine may also execute one or more applications.

The cluster505may be a collection of host machines that are all interconnected to form a larger network of host machines. The virtual machines512A-D may be virtualized execution environments that contain one or more processes and/or applications. Guest agent514A-D may be a guest-level software component that receives information from the virtualization manager522and forwards snapshot requests from applications to the virtualization manager522, as described above.

Snapshot interfaces516A-D may be a standardized interface (e.g., an API) that allows applications executing within the virtual machines512A-D to request a snapshot of the corresponding virtual machine on which it executes. The snapshot interfaces516A-D may be an API that receives the snapshot requests from applications and forwards them to the virtualization manager522through the guest agent514A-D. In some instances, the snapshot interface516A-D, exposed to the application by a hypervisor, can forward the request directly to the virtualization manager522. In yet another instance, the applications executing within the virtual machines512A-D may transmit the request directly to the virtualization manager522without a snapshot interface.

Host machine520may include a virtualization manager522. Virtualization manager522may in turn include an admission controller524A and snapshot execution unit526. Admission controller524A may be a part of a larger distributed admission controller comprised of admission controller524A of the virtualization manager522, admission controller524B of the host machine510A, and admission controller524C of host machine510B.

Admission controller524A-C may filter incoming snapshot requests at the cluster-level, node-level, virtual machine level, or application level. At each level, a maximum volume of snapshot requests may be defined so that the virtualization manager522is not overloaded with requests resulting in resource starvation. For example, for a ten second period, admission controller524A may only allow two requests from each application, ten requests from each virtual machine, twenty five requests from each host machine, or node, and fifty requests in total from a cluster. Additionally, the admission controller524A may disable requests granularly at each level for some period of time (e.g., can identify applications, virtual machines, nodes, or clusters from which requests are not allowed for the period of time).

Admission controllers524B-C may be used to enforce a node-level filtering policy as well as virtual machine and application level filtering policies. The node level filtering policy may filter snapshot requests sent from applications and virtual machines that run on the node, or host machine. Admission controllers524B-C may be installed directly on the host machines510A-B as depicted, or may run within the virtual machines512A-D executing on the host machines510A-B. The number of requests that the admission controllers524A-C admit may be predefined static thresholds. Alternatively, the admission controllers may monitor usage of resources of the host machines510A-B to dynamically select a threshold number of requests to be allowed. For example, the system may calculate the consumption of the network bandwidth for host machines510A-B and accordingly select the threshold volume of snapshots that can be created by the virtualization manager522for each host machine510A-B.

Another aspect of admission controller filtering may include the use of priority levels associated with the requests to filter out less important requests. For example, snapshots that are generated as a regular part of system management may take priority over snapshot requests from applications. Thus, if more than the selected threshold number of requests are received, then the lower priority application requests may be filtered out first. Additionally, virtual machines may each have an associated priority level (e.g., platinum, gold, silver, etc.). Snapshot requests may then be filtered according to the priority level of the virtual machines from which the requests were received. For example, requests received from platinum virtual machines may take priority over requests received from gold and silver virtual machines. The priority levels may also be used to determine priority order of execution. Thus, higher priority requests may be executed before lower priority requests.

The example computer system600includes a processing device602, a main memory604(e.g., read-only memory (ROM), flash memory, dynamic random access memory (DRAM) such as synchronous DRAM (SDRAM) or DRAM (RDRAM), etc.), a static memory606(e.g., flash memory, static random access memory (SRAM), etc.), and a data storage device618, which communicate with each other via a bus630. The processing device602may be operatively coupled with the main memory604, static memory606, and/or the data storage device618.

The computer system600may further include a network interface device608. The computer system600also may include a video display unit610(e.g., a liquid crystal display (LCD) or a cathode ray tube (CRT)), an alphanumeric input device612(e.g., a keyboard), a cursor control device614(e.g., a mouse), and a signal generation device616(e.g., a speaker).

The data storage device618may include a machine-readable storage medium628(also known as a computer-readable medium) on which is stored one or more sets of instructions or software622embodying any one or more of the methodologies or functions described herein. The instructions622may also reside, completely or at least partially, within the main memory604and/or within the processing device602during execution thereof by the computer system600, the main memory604and the processing device602also constituting machine-readable storage media.