Virtual machine monitoring using shared memory

• US 7,552,153 B2
• Filed: 12/28/2004
• Issued: 06/23/2009
• Est. Priority Date: 12/28/2004
• Status: Active Grant

• Current Assignee: SAP SE
• Original Assignee: SAP AG (SAP SE)
• Inventors: Werner, Randolf, Dostert, Jan, Kilian, Frank, Fleischer, Christian
• Primary Examiner(s): To; Baoquoc N
• Application Number:
  US11/024,393
• Publication Number:
  US 20060143595A1
• Time in Patent Office: 1,638 Days
• Field of Search: None
• US Class Current: 1/1
• CPC Class Codes: G06F 11/0712 in a virtual computing platform, e.g. logically partitioned systems
• CPC Class Codes: G06F 11/0718 in an object-oriented system
• CPC Class Codes: G06F 11/0778 Dumping, i.e. gathering error/state information after a fault for later diagnosis
• CPC Class Codes: G06F 11/3409 for performance assessment
• CPC Class Codes: G06F 11/3433 for load management allocation of a server based on load conditions G06F9/505; load rebalancing G06F9/5083; redistributing the load in a network by a load balancer H04L67/1029
• CPC Class Codes: G06F 2201/815 Virtual middleware or OS functionality using virtual machines to implement generic software techniques for error detection or fault masking G06F11/1484
• CPC Class Codes: G06F 2201/86 Event-based monitoring
• CPC Class Codes: G06F 2201/865 Monitoring of software
• CPC Class Codes: G06F 9/45504 Abstract machines for programme code execution, e.g. Java virtual machine [JVM], interpreters, emulators
• CPC Class Codes: Y10S 707/99953 Recoverability
• CPC Class Codes: Y10S 707/99957 Garbage collection

Abstract

A system and method to monitor a virtual machine VM. The VM executes one or more applications. During executing of the one or more applications, local objects are created and stored within an internal heap maintained by the VM. Status data of the internal heap is published to monitoring memory external to the VM.

Claims

1. A computer-implemented method, comprising:

implementing at a server node in a network of nodes an application server instance having a virtual machine control unit;

launching with the virtual machine control unit at least two worker nodes within the application server instance, each of the at least two worker nodes providing a respective run-time environment;

in each of the respective run-time environments of the at least two worker nodes,

executing a respective virtual machine (“

VM”

) and a respective virtual machine monitor for the respective VM, and

running by the respective VM a respective application , including storing a local object within a respective heap internal to and maintained by the VM;

one of the virtual machines (“

VMs”

) instantiating a data object in a shared heap of the application server instance external to the at least two worker nodes and accessible by the VMs of the at least two worker nodes; and

publishing status data to a monitoring memory of the application server instance external to and shared by the at least two worker nodes and the shared heap, wherein the monitoring memory is accessible to a monitoring console configured to display the published status data, the published status data including

data specifying a utilization of the shared heap, and

for each of the plurality of worker nodes,

data specifying a utilization of the internal heap of the respective VM, and

data specifying a history of garbage collecting events of the internal heap of the respective VM.

2. The method of claim 1, wherein the respective VMs of the at least two worker nodes comprise a Java VM (“

JVM”

) and wherein the application run by the JVM includes a Java application.

3. The method of claim 1, wherein publishing the status data comprises:

accessing an internal heap through a native application programming interface (“

API”

);

retrieving the status data of the accessed internal heap by a VM monitor executed within the respective worker node of the accessed internal heap; and

copying the status data retrieved by the VM monitor to the monitoring memory.

4. The method of claim 3, wherein one of the VM monitors of the at least two worker nodes comprises native machine code.

5. The method of claim 2, further comprising:

garbage collecting at least one of the local objects maintained within the internal heap of the JVM when available memory of the internal heap is scarce; and

registering the garbage collecting with the monitoring memory.

6. The method of claim 1, wherein the shared status data includes at least one of shared object utilization data, shared class utilization data, and shared heap garbage collecting activity.

7. The method of claim 1, further comprising:

retrieving the status data from the monitoring memory; and

transmitting the status data to the monitoring console to display the status data.

8. The method of claim 1, wherein the monitoring memory is isolated from the respective VMs of the at least two worker nodes to provide acccss to the status data published to the monitoring memory in the event one of the VMs fails.

9. A computer-readable storage medium having stored thereon instructions that, if executed by a machine, will cause the machine to perform operations comprising:

implementing at a server node in a network of nodes an application server instance having a virtual machine control unit;

launching with the virtual machine control unit at least two worker nodes within the application server instance, each of the at least two worker nodes providing a respective run-time environment;

in each of the respective run-time environments of the at least two worker nodes,

executing a respective java virtual machine (“

JVM”

) and a respective virtual machine monitor for the respective JVM, and

running by the respective JVM a respective application , including storing local objects within a corresponding internal heap internal to and maintained by the corresponding JVM;

one of the java virtual machines (“

JVMs”

) instantiating a data object in a shared heap of the application server instance external to the at least two worker nodes and accessible by the JVMs of the at least two worker nodes; and

publishing status data to a monitoring memory of the application server instance external to and shared by the at least two worker nodes and the shared heap, wherein the monitoring memory is accessible to a monitoring console configured to display the published status data, the published status data including

data specifying a utilization of the shared heap, and

for each of the plurality of worker nodes,

data specifying a utilization of the internal heap of the respective JVM, and

data specifying a history of garbage collecting events of the internal heap of the respective JVM.

10. The computer-readable storage medium of claim 9, wherein publishing the status data comprises:

accessing an internal heap through a native application programming interface (“

API”

);

retrieving status data of the accessed internal heap by a VM monitor executed within the respective worker node of the accessed internal heap; and

copying the status data retrieved by the VM monitor to the shared monitoring memory.

11. The computer-readable storage medium of claim 9, further providing instructions that, if executed by the machine, will cause the machine to perform further operations, comprising:

garbage collecting at least one of the local objects maintained within the internal heap of one of the plurality of JVMs when available memory of the internal heap is scarce; and

in response to the garbage collecting, publishing garbage collecting monitoring data to the shared monitoring memory.

12. The computer-readable storage medium of claim 9, wherein the status data comprises at least one of shared object utilization data, shared class utilization data, and shared heap garbage collecting data.

13. A system, comprising:

a server node to execute an application server (“

AS”

) instance, the AS instance including logic executable by a processor of the server node to;

launch with a virtual machine control unit at least two worker nodes within the AS instance, each of the at least two worker nodes providing a run-time environment;

in each of the respective run-time enviromnents of the at least two worker nodes,

execute a respective java virtual machine (“

JVM”

) and a respective virtual machine monitor for the respective JVM, and

run by the respective JVM a respective application, including storing local objects within a corresponding internal heap internal to and maintained by the corresponding JVM;

instantiate with one of the java virtual machines (“

JVMs”

) a data object in a shared heap of the AS instance external to the at least two worker nodes and accessible by the JVMs of the at least two worker nodes; and

publish status data to a monitoring memory of the application server instance external to and shared by the at least two worker nodes and the shared heap, wherein the monitoring memory is accessible to a monitoring console configured to display the published status data, the published status data including

data specifying a utilization of the shared heap, and

for each of the plurality of worker nodes,

data specifying a utilization of the internal heap of the respective JVM, and

data specifying a history of garbage collecting events of the internal heap of the respective JVM.

14. The system of claim 13, wherein the logic is further to:

garbage collect at least one of the local objects maintained within the internal heap of one of the plurality of JVMs when available memory of the internal heap is scarce; and

wherein the publishing the status data to the shared monitoring memory is in response to the garbage collecting event.

15. The system of claim 14, further comprising:

a client node to execute the monitoring console, the client node communicatively coupled to the server node, the monitoring console including logic executable by a processor of the client node to;

receive the status data from the server node; and

display the status data to a screen of the client node.

16. The system of claim 15, wherein the monitoring console further includes logic executable by the processor of the client node to monitor a cluster of AS instances.