CN101021800A - Virtual machine monitoring - Google Patents
Virtual machine monitoring Download PDFInfo
- Publication number
- CN101021800A CN101021800A CN 200610004392 CN200610004392A CN101021800A CN 101021800 A CN101021800 A CN 101021800A CN 200610004392 CN200610004392 CN 200610004392 CN 200610004392 A CN200610004392 A CN 200610004392A CN 101021800 A CN101021800 A CN 101021800A
- Authority
- CN
- China
- Prior art keywords
- status information
- memory buffer
- machine
- internal memory
- heap
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Abstract
The invention relates to a system and method for monitoring the internal operation of a virtual machine ('VM'). VM is operated to interpret and implement a procedure. The internal operation of state information is stored to the internal memory buffer during VM operating period. Subsequently, the above information is extracted from the internal VM operation at a favorable external position.
Description
Technical field
The present invention relates to relate generally to virtual machine (virtual machines), and special but do not relate to the built-in function of monitoring virtual machine uniquely.
Background technology
Enterprise software has changed the mode of various business processes and management routine work more or less.Businessman utilizes enterprise software (for example, based on network application server) to control the production schedule, buying and logistics, warehouse and inventory management, production, supplier management, customer service, finance, personnel management and other basic business activity.Continuation maturation along with enterprise software industry, multiple application software that uses for the set of this various tasks of facility and hardware resource are merged into firm (robust), highly integrated solution (for example, SAP NetWeaver, SAP xAPPs, mySAP Business Suite etc.).
For integrated various hardware and software resources, the developers of enterprise software have can minimize even cut off enterprise solution (leveraged) cross-platform engine to dependent the bar thick stick equilibrium activity of service platform.Java 2 platforms, Enterprise Edition
TM(enterprise version) (" J2EE ") (for example, J2EE standard, version 1.4) is the solution based on Java that a kind of Java of obtaining Virtual Machine (" JVM ", Java Virtual Machine) engine is supported.J2EE has simplified application and development, and by creating a standardization and the modular unit that can reuse, has reduced the needs to programming and programmer's training.Pouplarity based on the solution of Java is very obvious, just looks like that infotech (" the IT ") world is subjected to the attraction of Java language the same.
Be incorporated into along with enterprise software in the member of modern commerce, the fault of enterprise solution is a kind of tedious infringement no longer only just, but may cause the catastrophic havoc to commerce.Therefore, firm, software is critical all the time reliably.Enterprise software industry going on foot to can keep, hitless operation and do not need the final goal of the self-regeneration software of artificial interference.In order to reach this target, IT technician can have benefited from monitoring the conventional tool of health status (health) of their enterprise software.Utilize suitable monitoring tools, can in good time the take action health status of the software that guarantees them of IT technician finds that perhaps the application program of makeing mistakes repeats to make a mistake preventing.Current, JVM does not provide enough mechanism to monitor their built-in function in real time.
Summary of the invention
The system and method for the built-in function of a kind of monitoring virtual machine (" VM ") has been described.VM is operated to explain and to carry out a program.In the operating period of VM, be stored in the internal memory buffer about the status information of the built-in function of VM.Subsequently, in the operating period of VM memory buffer unit extraction internally (extract) described status information, so that monitor the operation of VM from the outside vantage point of VM.
In one embodiment, come accumulated state information by the monitor code of carrying out in the embedding program.The execution of described monitor code can interweave with the execution of the program code of described program and carry out.
During program implementation, create object and store heap (heap) into.When program during no longer with reference to these objects, an automatic garbage collection device (garbage collector) is wiped not by the object of reference.In one embodiment, status information comprises garbage collection activity information.
In one embodiment, this machine VM watch-dog (monitor) is called, internally retrieval status information in the memory buffer unit.The status information of retrieval can be transmitted to control and monitor console (monitoringconsole) subsequently, so that be presented on the control and monitor console.
In one embodiment, the VM watchdog routine is explained on VM and is carried out.The VM watchdog routine is exclusively used at least a portion status information of collection from the parts of VM, and stores described a part of status information into internal memory buffer.
In one embodiment, the fault of internal memory buffer and VM is isolated.If VM breaks down, internal memory buffer can be accessed after breaking down, so that the reason of VM fault is carried out post-survey.
Embodiments of the invention can comprise all or some above-mentioned feature.Above-mentioned feature can be implemented by the combination of computer program, method, system or device or any computer program, method or system.These of one or more embodiment of the present invention and other details will accompanying drawing and below description in set forth.
Description of drawings
Indefiniteness of the present invention will be described with reference to following accompanying drawing with embodiment non exhaustive property, wherein, unless specially explanation, drawing reference numeral identical in each accompanying drawing always refers to identical part.
Fig. 1 is the block diagram of the system of the built-in function that is used to monitor virtual machine (" VM ") according to an embodiment of the invention.
Fig. 2 is the block diagram of explanation software systems according to an embodiment of the invention, and these software systems comprise can provide the VM of internal state information to external entity, is used for VM is monitored.
Fig. 3 is the process flow diagram of the processing of the explanation built-in function that is used to monitor VM according to an embodiment of the invention.
Fig. 4 is the block diagram that explanation is used to implement the demonstration corporate environment of one embodiment of the present of invention.
Fig. 5 has illustrated the demonstration disposal system that is used to implement one embodiment of the present of invention.
Embodiment
The embodiment of the system and method for the built-in function be used to monitor virtual machine (" VM ") is described here.Fig. 1 is the block diagram of the system 100 of the built-in function of virtual machine (" VM ") 105 according to an embodiment of the invention.The embodiment of illustrated system 100 comprises VM 105, program 110 and control and monitor console 115.Operate on the VM 105 though only show three programs 110, but more or program still less 110 can move simultaneously in time-multiplexed mode.
VM 105 explains and carries out one or more programs 110 to generate output result 120.VM 105 is by explaining program that (intermediate interpreted) language (for example, bytecode) is converted to this machine machine language (native machine language) that is performed subsequently and comes interpretive routine 110 from the centre.In one embodiment, VM 105 is Java VM (" JVM "), and program 110 expressions are compiled as the java applet of Java bytecode.Though embodiments of the invention utilize OO Java programming language to describe, technology as described herein also can be applied to other interpretative code equivalently, and the VM that is used to explain and carry out these language.
In the operating period of VM 105, VM 105 can provide real-time status information 125 to be used for showing to control and monitor console 115 thereon.Status information 125 can be provided in explain and executive routine 110 during the detail operations information of internal work of VM105.Infotech (" IT ") technician is the status information 125 of browse displays on control and monitor console 115 directly, whether operates in health status with definite VM 105, whether will break down, and others.And status information 125 can be accessed after VM 105 fault/collapses, so that failure cause is carried out post-survey.
Fig. 2 is the block diagram of explanation software systems 200 according to an embodiment of the invention, and these software systems 200 comprise can provide the VM 105 of status information 125 to external entity, is used for the built-in function of VM 105 is monitored.The embodiment of illustrated software systems 200 comprises operating system 205 (for example, Windows, Linux, Unix, MS-DOS, OS/400, OS/390 etc.), this machine packet assembler (native wrapper) 210, VM 105 and this machine VM watch-dog 215.
This machine packet assembler 210 provides environment working time of VM 105.At VM 105 is to meet Java2 platform, Enterprise Edition
TM(" J2EE ") (for example, J2EE standard, version 1.4 among the embodiment of) JVM, this machine packet assembler 210 is commonly called " JLaunch ".This machine packet assembler 210 is this machine machine codes (for example, the C++ of compiling) of being carried out and managed by OS 205.When starting, this machine packet assembler 210 portion is within it set up VM 105.
During operation, the embodiment of illustrated VM 105 comprises internal memory buffer 220, internal application DLL (dynamic link library) (" API ") 225, this machine API 230, heap 235, heap manager 237, garbage collector 240, I/O (" I/O ") system 243 and safeguards and a plurality of threads 245 of the information that is associated by each tasks (for example, program 110, garbage collector 240 etc.) of VM 105 current execution.Thread 245 is not illustrated in all entities carried out of Fig. 2, and does not show crowded so that Fig. 2 is looked, invention is thickened.Internal memory buffer 220 is used for being stored in the status information 125 that 105 operating periods of VM collect from each internal part of VM 105 by VM 105.Inner API 225 provides the visit of each internal part of VM 105 to internal memory buffer 220.At VM 105 is among the embodiment of JVM, and inner API 225 is called as " Java API ".This machine API 230 provides the visit of the entity of VM 105 outsides to internal memory buffer 220, thereby the visit to status information 125 is provided, so that monitor the built-in function of VM 105 from outside vantage point.This machine API 230 enables (enable) this machine machine code entity, visits internal memory buffer 220 such as this machine VM watch-dog 215, and need be at VM 105 from being interpreted and executed on one's body.Though Fig. 2 has illustrated this machine VM watch-dog 215 in the inside of this machine packet assembler 210, in certain embodiments, this machine VM watch-dog 215 also can be in the outside of this machine packet assembler 210.
Heap 235 is set up as reserving memory pools by VM 105, so that used by these programs when being loaded in program 110 and VM watchdog routine 250 (below go through) in the future.Heap 235 is used for distributing when program 110 requests and removing allocate memory, and is used for the object 255 that storage is created by program 110 (perhaps the VM watchdog routine 250) by heap manager 237 management of VM 105.
In program 110 is that (for example, java applet among) the embodiment, they generally comprise object and class to OO program.When program 110 was loaded and carried out by VM 105, object 255 was created, and stored heap 235 then into.Class comprises executes the task and the method for return message when they finish those tasks.Object comes down to the reusable software section in the fragment (pieces) of having simulated software program aspect characteristic and the behavior.Class is used to the object that illustration has these characteristics and behavior.In other words, each object 255 is all inherited their characteristic and behavior from illustration (for example, the creating) class of special object 255.
Along with program 110 consumes heap 235 by inserting object 255 to heap 235, the storer that can accept new object in 235 at the heap shortage that can become.Therefore, garbage collector 240 is implemented the program of a kind of regular (disciplined), and the storer that is used for consuming turns back to heap 235.In one embodiment, garbage collector 240 is automatically performed by VM 105, with the storer of recovery dynamic assignment, and does not need the programmer's of program 110 clearly instruction to carry out.When to pile a object 255 in 235 no longer include with reference to the time, special object 255 is labeled and carries out refuse collection.Then, when carrying out garbage collector 240, reclaim the storer of object 255 consumption that are labeled.When the available memory in the heap 235 becomes shortage, can help to avoid resource leakage by carrying out refuse collection regularly.
Yet when the available memory in the heap 235 became shortage, because garbage collection activity, the performance of VM 105 can suffer damage.For example, surpassed 80% capacity if pile 235, the garbage collection activity of garbage collector 240 can cause the calculating that can the produce output (for example, output result 120 is referring to Fig. 1) of VM 105 to be compressed to almost and to end.Though garbage collector 240 is not done finely relatively by the object 255 of reference aspect the storer that reclaims consumption in deletion, because a variety of causes, the object 255 of not all free time all has been recovered.Therefore, outmoded more (older) VM 105 may suffer damage in very long garbage collection activity more.
In one embodiment, each entity of VM 105 by " assembling " (instrumented) monitor code so that accumulation/generation at least a portion status information 125, and described a part of status information copied to internal memory buffer 220.The execution of monitor code can interweave with the execution of the conventional program code of entity and carry out.The amount of the quantity of the object 255 that a part of status information 125 of monitored code accumulation/generation can comprise time that the processing of each entity begins and stop, carries out the processing working time of each thread 245 of entity, created by special entity, the storer that entity consumes, or the like.Each entity be assembled accumulate and/or the operation of generation and special entity with carry out relevant various status informations 125.These entities can comprise garbage collector 240, heap manager 237, I/O system 243 etc.Each the monitor code that is assemblied in these entities has following purpose: collect at least a portion of available a large amount of status informations among the VM 105, and it is reported to internal memory buffer 220.
In one embodiment, garbage collector 240 has been assembled monitor code 265, with accumulation/generation at least a portion status information 125, and described a part of status information 125 is copied to internal memory buffer 220.The execution of monitor code 265 can interweave with the execution of the conventional garbage collection activity of garbage collector 240 and carry out.In one embodiment, carry out monitor code 265 in response to the refuse collection incident.A part of status information 125 by monitor code 265 accumulation/generations comprises multiple refuse collection relevant information.This refuse collection relevant information can comprise: the counting of the timestamp of the refuse collection incident of carrying out by garbage collector 240 and working time, refuse collection incident, during each refuse collection incident from the amount of the counting of the quantity of piling 235 objects of collecting 255, the storer that during each refuse collection incident, heap 235, reclaims, heap 235 amount of available storer, the hit rate of the object 255 of requestor (for example, the programmer 110) in heap 235, the utilization factor of heap 235 etc.And monitor code 265 can be preserved the history of nearest refuse collection incident in internal memory buffer 220, and each refuse collection incident is enrolled the index of some or all above-mentioned refuse collection relevant informations.
In one embodiment, VM watchdog routine 250 can be explained on VM 105 and carry out, and its fundamental purpose is used to collect status information 125 and status information 125 is copied to internal memory buffer 220.VM watchdog routine 250 can be provided separately to carry out the monitoring responsibility.Some or all of above-mentioned status information 125 can be collected/be generated to VM watchdog routine 250, and other monitor message.Write the stand-alone program that is exclusively used in monitor task make can design program 110 and garbage collector 240 write watchdog routine long after again, and do not need refresh routine 110 and garbage collector 240.VM watchdog routine 250 makes the developer generate special-purpose watchdog routine with the problem in investigation VM 105 or the program 110 or " defective " (bug), and these problems or defective just become obvious after VM 105 and/or program 110 have been write and announced to masses.In fact, many software issues comes forth up to software architecture (software build) and just becomes obvious to bigger customer group (user base).Therefore, VM watchdog routine 250 can be designed to help Alpha (alpha) test to program 110 and/or VM 105, perhaps even be included in beta (beta) the distribution version of program 110 and/or VM 105.VM watchdog routine 250 is provided for implementing to develop after a while is used for the actual mechanism of the monitor code carried out on VM 105.
The monitor code and the VM watch-dog program 250 that comprise monitor code 265 are visited internal memory buffer 220 to duplicate the status information 125 there by inner API 225.In one embodiment, inner API 225 utilizes funcall to extract (abstract) visit to internal memory buffer 220.Each of VM105 wanted the parts of replication status information 125 to internal memory buffer 220, deliver to one or more functions of VM 105 by 225 pairs of inside of inner API and to carry out " calling " (call), and will accumulate/status information 125 that generates passes to the function of calling.Then, the function of being called copies to suitable slot (slot) or position in the internal memory buffer 220 with status information 125.
This machine VM watch-dog 215 is taken on the proxy server (for example, control and monitor console 115) of various external entities, and request is monitored the built-in function of VM 105 to the visit of internal memory buffer 220.In one embodiment, this machine VM watch-dog 215 can accepting state request 130 and status information 125 is provided or its part in response.Another kind of scheme, perhaps additional, this machine VM watch-dog 215 can be consulted a report contract with control and monitor console 115, so that status information 125 is provided regularly or periodically, and does not need state request 130.Therefore, this machine VM watch-dog 215 both can be shifted status information 125 onto control and monitor console 115, also can drag status information 125 from this machine VM watch-dog 215 by control and monitor console 115.
The visit that utilizes inner API 225 to extract internal memory buffer 220 can be isolated the content of internal memory buffer 220 and the remainder of VM 105, thus the content of protection internal memory buffer 220.Even VM 105 collapses enter endless loop, or other fault takes place, status information 220 also can be protected, and be not subjected to the infringement of fault.Because this machine API 230 uses this machine codes to carry out, this machine API 230 also can't help VM 105 and explains and carry out.Therefore, if VM 105 faults, this machine VM watch-dog 215 still can be visited internal memory buffer 220, with the latest state information that obtains just to have upgraded before VM 105 faults.Therefore, the content of internal memory buffer 220 can be retrieved, so that carry out post-survey to determine the failure cause of VM 105.
Fig. 3 is the process flow diagram of the processing 300 of the explanation built-in function that is used to monitor VM 105 according to an embodiment of the invention.At processing block 305, program 110 is explained at VM 105 and is carried out.In Java embodiment, program 110 is by real-time interpretation and the Java bytecode that is converted to this machine machine code.The machine code of being changed is performed then.
During executive routine 110, the monitor code utilization belongs to the status information 125 of other internal work of the resource consumption of specific program 110 operation, specific program 110 and VM 105 and upgrades internal memory buffer 220 (processing block 310).As mentioned above, monitor code can be carried out in an interleaved fashion with the program code of various fructifications among the VM 105.In one embodiment, monitor code calls internal memory buffer 220 by the funcall to inner API 225, and the status information 125 that will collect/generate passes to the function of calling.
Along with the execution of program 110, object 255 is created, and is stored in heap 235 (processing blocks 315).As long as heap 235 also has available storer to store new object 255, program 110 will continue to carry out, and creates required new object 255.But, if pile 235 near its capacity, and the available memory of piling the new object 255 of acceptance in 235 shortage (decision block 320) that becomes, then handle 300 and proceed to processing block 325.
At processing block 325, garbage collector 240 is carried out automatic garbage collection, so that delete not by the object 255 of reference, and is recovered in the storer that consumes in the heap 235.As mentioned above, in response to the refuse collection incident, monitor code 265 utilizes the status information 125 that contains refuse collection information to upgrade internal memory buffer 220 (processing block 330).In one embodiment, monitor code 265 visits internal memory buffer 220 by the funcall to inner API 225.
At processing block 335, this machine VM watch-dog 215 passes through this machine API 230 memory buffer unit 220 some or all status informations 125 of extraction internally.In one embodiment, this machine VM watch-dog 215 calls internal memory buffer 220 by the funcall to this machine API 230.In processing block 340, the status information of being retrieved 125 is transferred to control and monitor console 115.As mentioned above, status information 125 can be pulled to control and monitor console 115, perhaps can haul out from this machine VM watch-dog 215 by transmit status request 130.Control and monitor console 115 can with the same hardware of carrying out VM 115 on carry out, perhaps on the remote hardware that is coupled communicatedly by network or other communication medium and this machine VM watch-dog 215, carry out.
Fig. 4 is the block diagram that explanation is used to implement the demonstration corporate environment 400 of embodiments of the invention.The embodiment of illustrated corporate environment 400 comprises that coupling cluster (cluster) 405 is with the request of service from client node 410.Cluster 405 can comprise: one or more service nodes 415, and each service node 415 is all supported one or more application servers (" AS ") examples (instance) 417; Message server node 420 is supported message server 422; Database node 425, supporting database 427; And network distributor (dispatcher) 430.
AS example 417 can be a network application server, such as the network A S of SAP, and the .NET of Microsoft (Microsoft) etc.Each AS example 417 can comprise that one or more VM 105 are with executive routine 110.The program of being carried out by the VM in the AS example 417 105 110 can collective be provided for implementing the logic of each sublayer (for example, business layer, integrated layer, presentation layer etc.) of AS example 417.The multiple parts that should be appreciated that AS example 417 are excluded outside Fig. 4, and doing like this is for the sake of clarity, in order to avoid make the present invention thicken.In one embodiment, VM 105 meets the JVM of J2EE standard to carry out java applet.In one embodiment, VM 105 can meet framework from the .NET of Microsoft to carry out the .NET program.AS example 417 even can comprise the VM 105 that meets J2EE standard and .NET framework.
At VM 105 is among the embodiment of JVM, program 110 can provide the server end logic so that generate the servlet (servlet) of graphic user interface (" GUI ") on client node 410, and can comprise the java server webpage (" JSP ") that is used for providing at GUI dynamic content.Program 110 can also comprise that the commerce of the business logic that enterprise Java bean (Enterprise JavaBean) (" EJB ") is provided uses, provides the applet (applet) of client logic etc.
A client node 410 can be carried out control and monitor console 115 so that the remote monitoring to AS example 417 to be provided, particularly to the remote monitoring of each VM 105.If IT technician notices among the VM 105 and has lower heap utilization factor, too active garbage collection activity etc. that this IT technician just can take appropriate action, and comprises that the VM 105 that will go wrong resets.
Fig. 5 is the block diagram of explanation demonstration disposal system 500, described disposal system 500 is used to carry out VM105, software environment 200, handle 300 any one, perhaps be used to implement any one of client node 410, server node 415, message server node 420 or database node 425.The embodiment of illustrated disposal system 500 comprises one or more processors (perhaps CPU (central processing unit)) 505, system storage 510, non-volatile (" NV ") storer 515, DSU 520, communication link 525, chipset 530.Illustrated disposal system 500 can be represented any computing system, comprises desk-top computer, notebook, workstation, handheld computer, server, blade server (blade server) etc.
The element of disposal system 500 is following to interconnect.Processor 505 is communicatively coupled to system storage 510, NV storer 515, DSU 520 and communication link 525 by chipset 530, so that send instruction or data to them, perhaps receives instruction or data from them.In one embodiment, NV storer 515 is flash memories.In other embodiments, NV storer 515 comprises any one among ROM (read-only memory) (" ROM "), programming ROM, erasable programmable ROM, the electrically erasable ROM etc.In one embodiment, system storage 710 comprises random access memory (" RAM "), such as dynamic ram (" DRAM "), synchronous dram (" SDRAM "), Double Data Rate (double data rate) SDRAM (" DDR SDRAM "), static RAM (SRAM) (" SRAM ") etc.Any memory device that is used for software data, application and/or operating system of DSU 520 expressions, still most typical is non-volatile memory device.DSU 520 comprises one or more integrated driving electronics (" IDE ") hard disk, enhancement mode IDE (" EIDE ") hard disk, redundant array of independent disks (" RAID "), small computer system interface (" SCSI ") hard disk etc. alternatively.Though DSU 520 is shown in the inside of disposal system 500, DSU 520 also can externally be coupled to disposal system 500.Communication link 525 is coupled to network with disposal system 500, so that disposal system 500 can communicate with one or more other computing machines on network.Communication link 525 can comprise modulator-demodular unit, Ethernet card, Gigabit Ethernet Card, USB (universal serial bus) (" USB ") port, wireless network interface card, optical fiber interface etc.
Should be appreciated that for clear various other elements of disposal system 500 all are excluded outside Fig. 5 and disclosure text.For example, disposal system 500 can also comprise graphics card, additional DSU, other persistant data memory device (for example, tape drive) etc.Chipset 530 can also comprise system bus and various other data bus, be used for interconnecting with subassembly, such as memory controller hub and I/O (" I/O ") controller hub, and comprise that data bus (for example, PCI (peripheral component interconnect) bus), be used for peripherals is connected to chipset 530.Accordingly, disposal system 500 also can be operated under the situation of neither one or a plurality of illustrated element.For example, disposal system 500 does not need to comprise DSU 520.
" embodiment " of institute's reference or " embodiment " are meant that special characteristic, structure or characteristic with the corresponding description of this embodiment are included among at least one embodiment of the present invention in this piece explanation.Therefore, the statement that occurs everywhere at instructions " in one embodiment " or " in an embodiment " must not be meant same embodiment.And specific feature, structure or characteristic can be combined among one or more embodiment by rights.
The foregoing description of the embodiment that the present invention is illustrated comprises the content described in the summary, is not for exhaustive, or the present invention is defined as a kind of particular form.In more superincumbent examples, for fear of making some aspect become not obvious, known structure, material or operation are not illustrated or describe in detail.Here specific embodiment of the present invention of Miao Shuing or example are for illustration purpose, and various equivalent modifications will be appreciated that the modification that can carry out various equivalences in scope of invention.
According to top detailed description, can carry out these modifications to the present invention.Employed term should not be interpreted as limiting the present invention to disclosed specific embodiment in instructions and claims in following claims.On the contrary, protection scope of the present invention determines that by following claims are whole it should be explained according to the determined clause of claim lexical or textual analysis.
Claims (23)
1. method comprises:
A program is explained and carried out to operation virtual machine (" VM ");
In VM operating period, the status information of VM built-in function is stored into the internal memory buffer of VM; And
In VM operating period, extract described status information from described internal memory buffer, so that from the built-in function of VM outer monitoring VM.
2. method as claimed in claim 1, wherein said VM comprises Java Virtual Machine (" JVM "), and described program comprises the Java bytecode.
3. method as claimed in claim 2 wherein stores described status information into internal memory buffer and comprises, by Java application programming interface (" API ") visit internal memory buffer.
4. method as claimed in claim 2, wherein said JVM is included in the application server instance, and described program comprises that the enterprise that client requests is served uses.
5. method as claimed in claim 1 also comprises:
The object storage of creating during the executive routine is arrived heap; With
Utilize the automatic garbage collection device to no longer being carried out refuse collection by the object of described procedure reference,
Wherein store the status information of VM into internal memory buffer and comprise, with the garbage collection activity information stores to internal memory buffer.
6. at least one the quantity of the object that method as claimed in claim 5, wherein said garbage collection activity information comprise the number count of working time, the refuse collection incident of refuse collection, collect from heap and the heap in the amount of available memory.
7. method as claimed in claim 1, wherein extract status information and comprise from the internal memory buffer of VM:
The VM watch-dog of carrying out the VM outside comes retrieval status information;
By this machine application programming interface (" API ") visit VM; And
By this machine API described status information is retrieved the VM watch-dog.
8. method as claimed in claim 7 also comprises:
Call the VM watch-dog and come retrieval status information, wherein said VM watch-dog comprises can't help this machine machine code that VM explains; With
Described status information is sent to control and monitor console, is used to be presented at control and monitor console.
9. method as claimed in claim 7 also is included in the VM fault and visits described internal memory buffer so that fault is investigated afterwards.
10. method as claimed in claim 1 also is included in VM and goes up explanation and carry out the VM watchdog routine, and described VM watchdog routine is exclusively used in from the VM parts and collects at least a portion status information, and stores described a part of status information into internal memory buffer.
11. the machine accessible medium that instruction is provided if described instruction is carried out by described machine, will make machine carry out following operation:
Go up interpretive routine at virtual machine (" VM ");
Generate the status information of VM in the VM;
During interpretive routine, the status information of VM is stored into the internal memory buffer of VM; And
Be stored in status information the internal memory buffer from the VM external reference, so that the built-in function of monitoring VM.
12. as the machine accessible medium of claim 11, wherein said VM comprises Java Virtual Machine (" JVM "), and described program comprises the Java bytecode.
13. as the machine accessible medium of claim 12, wherein store status information into internal memory buffer and comprise, by Java application programming interface (" API ") visit internal memory buffer.
14. as the machine accessible medium of claim 13, wherein said Java API is isolated with infringement with internal memory buffer under the situation of VN fault.
15. machine accessible medium as claim 11, the status information that wherein generates VM comprises, execution is embedded in monitor code in the fructification of VM to obtain status information, and, wherein store status information into internal memory buffer and comprise, carry out monitor code and store described status information into internal memory buffer.
16. as the machine accessible medium of claim 15, also provide instruction, this instruction will make further operation below the execution of machine when being carried out by described machine:
Carry out the program code of monitor code and fructification, wherein said fructification comprises in heap manager and the input/output with interweaving.
17. as the machine accessible medium of claim 11, also provide instruction, this instruction will make further operation below the execution of machine when being carried out by described machine:
Will be by the object storage of program creation to heap; With
Utilize the automatic garbage collection device to no longer being carried out refuse collection by those objects of procedure reference,
Wherein store the status information of VM into internal memory buffer and comprise, with the garbage collection activity information stores to internal memory buffer.
At least one the quantity of the object that 18. as the machine accessible medium of claim 17, wherein said garbage collection activity information comprises the number count of working time, the refuse collection incident of refuse collection, collect from heap and the heap in the amount of available memory.
19., wherein comprise from VM external reference status information as the machine accessible medium of claim 11:
Execution is at the VM of VM outside watch-dog; With
Come memory buffer unit retrieval status information internally by funcall to this machine application programming interface.
20. a system comprises:
Server node is carried out application server (" AS ") example, and this AS example comprises and can be carried out to carry out the logic of following operation by the processor of server node:
Go up interpretive routine at virtual machine (" VM ");
Generate the status information of VM in the VM;
During interpretive routine, the status information of VM is stored into the internal memory buffer of VM; And
Be stored in status information in the internal memory buffer from the VM external reference, so that the built-in function of monitoring VM.
21. as the system of claim 20, wherein said VM comprises the Java Virtual Machine that meets Java 2 enterprise version standards, and described program comprises java applet.
22. system as claim 21, wherein can comprise by the logic that the processor of server node is carried out with the status information that generates VM, embed the monitor code in the automatic garbage collection device, described automatic garbage collection device is performed to reclaim by no longer by the storer of the heap that object consumed of java applet reference.
23. the system of claim 21 also comprises:
Client node is carried out control and monitor console, and this control and monitor console comprises the logic that can be carried out by the processor of client node, comprising:
The transmit status inquiry is to server node;
In response to the state inquiry from the server node receiving status information; With
Show described status information.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN 200610004392 CN101021800A (en) | 2006-02-16 | 2006-02-16 | Virtual machine monitoring |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN 200610004392 CN101021800A (en) | 2006-02-16 | 2006-02-16 | Virtual machine monitoring |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN101021800A true CN101021800A (en) | 2007-08-22 |
Family
ID=38709574
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN 200610004392 Pending CN101021800A (en) | 2006-02-16 | 2006-02-16 | Virtual machine monitoring |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN101021800A (en) |
Cited By (17)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101753380A (en) * | 2008-12-16 | 2010-06-23 | Sap股份公司 | Monitoring memory consumption |
| CN101765225B (en) * | 2008-12-24 | 2012-05-23 | 华为技术有限公司 | Virtual cluster management method and cluster node |
| CN102541634A (en) * | 2010-12-20 | 2012-07-04 | 微软公司 | Probe insertion via background virtual machine |
| CN103036711A (en) * | 2012-12-05 | 2013-04-10 | 中国电信股份有限公司云计算分公司 | State inspection method and system and management node device |
| CN104380264A (en) * | 2012-03-16 | 2015-02-25 | 国际商业机器公司 | Run-time instrumentation reporting |
| CN104503891A (en) * | 2014-12-10 | 2015-04-08 | 北京京东尚科信息技术有限公司 | Method and device for online monitoring JVM (Java Virtual Machine) thread |
| US9367316B2 (en) | 2012-03-16 | 2016-06-14 | International Business Machines Corporation | Run-time instrumentation indirect sampling by instruction operation code |
| US9367313B2 (en) | 2012-03-16 | 2016-06-14 | International Business Machines Corporation | Run-time instrumentation directed sampling |
| US9372693B2 (en) | 2012-03-16 | 2016-06-21 | International Business Machines Corporation | Run-time instrumentation sampling in transactional-execution mode |
| US9395989B2 (en) | 2012-03-16 | 2016-07-19 | International Business Machines Corporation | Run-time-instrumentation controls emit instruction |
| US9400736B2 (en) | 2012-03-16 | 2016-07-26 | International Business Machines Corporation | Transformation of a program-event-recording event into a run-time instrumentation event |
| US9405541B2 (en) | 2012-03-16 | 2016-08-02 | International Business Machines Corporation | Run-time instrumentation indirect sampling by address |
| US9454462B2 (en) | 2012-03-16 | 2016-09-27 | International Business Machines Corporation | Run-time instrumentation monitoring for processor characteristic changes |
| US9483269B2 (en) | 2012-03-16 | 2016-11-01 | International Business Machines Corporation | Hardware based run-time instrumentation facility for managed run-times |
| US9489285B2 (en) | 2012-03-16 | 2016-11-08 | International Business Machines Corporation | Modifying run-time-instrumentation controls from a lesser-privileged state |
| CN107632920A (en) * | 2017-09-16 | 2018-01-26 | 广西电网有限责任公司电力科学研究院 | A kind of power transmission and transforming equipment monitoring device deep monitored method |
| CN107729208A (en) * | 2017-09-16 | 2018-02-23 | 广西电网有限责任公司电力科学研究院 | A kind of power transmission and transforming equipment monitoring device deep monitored system |
-
2006
- 2006-02-16 CN CN 200610004392 patent/CN101021800A/en active Pending
Cited By (31)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101753380B (en) * | 2008-12-16 | 2014-03-19 | Sap股份公司 | Monitoring memory consumption |
| CN101753380A (en) * | 2008-12-16 | 2010-06-23 | Sap股份公司 | Monitoring memory consumption |
| CN101765225B (en) * | 2008-12-24 | 2012-05-23 | 华为技术有限公司 | Virtual cluster management method and cluster node |
| CN102541634B (en) * | 2010-12-20 | 2015-10-07 | 微软技术许可有限责任公司 | Inserted by the detection of background virtual machine |
| CN102541634A (en) * | 2010-12-20 | 2012-07-04 | 微软公司 | Probe insertion via background virtual machine |
| US10203974B2 (en) | 2010-12-20 | 2019-02-12 | Microsoft Technology Licensing, Llc | Probe insertion via background virtual machine |
| US9405541B2 (en) | 2012-03-16 | 2016-08-02 | International Business Machines Corporation | Run-time instrumentation indirect sampling by address |
| US9442728B2 (en) | 2012-03-16 | 2016-09-13 | International Business Machines Corporation | Run-time instrumentation indirect sampling by instruction operation code |
| CN104380264B (en) * | 2012-03-16 | 2017-06-23 | 国际商业机器公司 | Run time examining report |
| US9367316B2 (en) | 2012-03-16 | 2016-06-14 | International Business Machines Corporation | Run-time instrumentation indirect sampling by instruction operation code |
| US9367313B2 (en) | 2012-03-16 | 2016-06-14 | International Business Machines Corporation | Run-time instrumentation directed sampling |
| US9372693B2 (en) | 2012-03-16 | 2016-06-21 | International Business Machines Corporation | Run-time instrumentation sampling in transactional-execution mode |
| US9395989B2 (en) | 2012-03-16 | 2016-07-19 | International Business Machines Corporation | Run-time-instrumentation controls emit instruction |
| US9400736B2 (en) | 2012-03-16 | 2016-07-26 | International Business Machines Corporation | Transformation of a program-event-recording event into a run-time instrumentation event |
| CN104380264A (en) * | 2012-03-16 | 2015-02-25 | 国际商业机器公司 | Run-time instrumentation reporting |
| US9405543B2 (en) | 2012-03-16 | 2016-08-02 | International Business Machines Corporation | Run-time instrumentation indirect sampling by address |
| US9411591B2 (en) | 2012-03-16 | 2016-08-09 | International Business Machines Corporation | Run-time instrumentation sampling in transactional-execution mode |
| US9430238B2 (en) | 2012-03-16 | 2016-08-30 | International Business Machines Corporation | Run-time-instrumentation controls emit instruction |
| US9442824B2 (en) | 2012-03-16 | 2016-09-13 | International Business Machines Corporation | Transformation of a program-event-recording event into a run-time instrumentation event |
| US9489285B2 (en) | 2012-03-16 | 2016-11-08 | International Business Machines Corporation | Modifying run-time-instrumentation controls from a lesser-privileged state |
| US9454462B2 (en) | 2012-03-16 | 2016-09-27 | International Business Machines Corporation | Run-time instrumentation monitoring for processor characteristic changes |
| US9459873B2 (en) | 2012-03-16 | 2016-10-04 | International Business Machines Corporation | Run-time instrumentation monitoring of processor characteristics |
| US9465716B2 (en) | 2012-03-16 | 2016-10-11 | International Business Machines Corporation | Run-time instrumentation directed sampling |
| US9471315B2 (en) | 2012-03-16 | 2016-10-18 | International Business Machines Corporation | Run-time instrumentation reporting |
| US9483269B2 (en) | 2012-03-16 | 2016-11-01 | International Business Machines Corporation | Hardware based run-time instrumentation facility for managed run-times |
| US9483268B2 (en) | 2012-03-16 | 2016-11-01 | International Business Machines Corporation | Hardware based run-time instrumentation facility for managed run-times |
| CN103036711B (en) * | 2012-12-05 | 2016-03-16 | 中国电信股份有限公司 | Condition detection method and system, management node device |
| CN103036711A (en) * | 2012-12-05 | 2013-04-10 | 中国电信股份有限公司云计算分公司 | State inspection method and system and management node device |
| CN104503891A (en) * | 2014-12-10 | 2015-04-08 | 北京京东尚科信息技术有限公司 | Method and device for online monitoring JVM (Java Virtual Machine) thread |
| CN107632920A (en) * | 2017-09-16 | 2018-01-26 | 广西电网有限责任公司电力科学研究院 | A kind of power transmission and transforming equipment monitoring device deep monitored method |
| CN107729208A (en) * | 2017-09-16 | 2018-02-23 | 广西电网有限责任公司电力科学研究院 | A kind of power transmission and transforming equipment monitoring device deep monitored system |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN101021800A (en) | Virtual machine monitoring | |
| US7886294B2 (en) | Virtual machine monitoring | |
| US7552153B2 (en) | Virtual machine monitoring using shared memory | |
| EP1679602B1 (en) | Shared memory based monitoring for application servers | |
| US7689989B2 (en) | Thread monitoring using shared memory | |
| US7523196B2 (en) | Session monitoring using shared memory | |
| JP5723208B2 (en) | Fail-safe mechanism for dynamic software measurement using callbacks | |
| US7516277B2 (en) | Cache monitoring using shared memory | |
| KR101705265B1 (en) | Detection of method calls to streamline diagnosis of custom code through dynamic instrumentation | |
| JP5705084B2 (en) | 2-pass automatic application measurement | |
| Hofmeister et al. | Dynamic reconfiguration in distributed systems: Adapting software modules for replacement | |
| US8473925B2 (en) | Conditional dynamic instrumentation of software in a specified transaction context | |
| US8095823B2 (en) | Server computer component | |
| US7793304B2 (en) | System and method for monitoring memory usage | |
| US20050204341A1 (en) | Method, system and article for detecting critical memory leaks causing out-of-memory errors in Java software | |
| US20080163009A1 (en) | Method and system for providing enhanced memory error messages | |
| Huang et al. | {PYLIVE}:{On-the-Fly} Code Change for Python-based Online Services | |
| Lopes et al. | Fault tolerance in a mobile agent based computational grid | |
| Seifzadeh et al. | A Performance-based Approach to Automatic Redeployment of Enterprise Software Applications | |
| WANG et al. | Execution Repair for Spark Programs by Active Maintenance of Partition Dependency | |
| Parida | ORACLE 10g Performance Tuning |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| C06 | Publication | ||
| PB01 | Publication | ||
| C10 | Entry into substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| C53 | Correction of patent for invention or patent application | ||
| CB02 | Change of applicant information |
Address after: German Waldo Applicant after: SAP AG Address before: German Waldo Applicant before: SAP AG |
|
| COR | Change of bibliographic data |
Free format text: CORRECT: APPLICANT; FROM: SAP AG TO: SAP EUROPE AG |
|
| RJ01 | Rejection of invention patent application after publication |
Application publication date: 20070822 |