International Business Machines Corporation

Martin John Trotter

Elliot Karl Kolodner

Susan Patricia Paice

Samuel David Borman

Ethan Lewis

Donald W Schmidt

Michael Edward Factor

Rajesh Ramkrishna Bordawekar

Robert Francis Berry

David Francis Bacon

James Edward Fox

Alain Charles Azagury

Alan Michael Webb

Paul K Bullis

Avi Teperman

Daniel P Julin

Elizabeth Anne Hutchison

Edmund James Whittaker West

Elliott Karl Kolodner

Donna Ngar Ting Dillenberger

Embodiments of the present invention address deficiencies of the art in respect to core dump generation during application fault handling and provide a method, system and computer program product for privacy preservation of core dump data during application fault handling. In an embodiment of the invention, a method for privacy preservation of core dump data during application fault handling can be provided. The method can include receiving a crash signal for an application and generating a core dump with object data for the application. The method further can include obfuscating the object data in the core dump and writing the core dump with obfuscated object data to a file. In this way, the privacy of the object data in the core dump can be preserved.

Core dump privacy during application failure

The memory used by individual users can be tracked and constrained without having to place all the work from individual users into separate JVMs. The net effect is that the 'bursty' nature of memory consumption by multiple users can be summed to result in a JVM which exhibits much less bursty memory requirements while at the same time allowing individual users to have relatively relaxed constraints.

Managing memory resources in a shared memory system

A memory leak detection scheme for use in a computer system (e.g., Java) by: finding an allocation site () which is responsible for allocating objects which accumulate in a memory heap (); and monitoring memory activity related to the found allocation site to discover a memory leak related thereto. The technique can be entirely application independent and can be made fully automatic, running as a daemon process on a machine and detecting leakage in a number of client processes simultaneously.

Memory leak detection

A method is provided for managing memory resources in a shared memory system. A point is identified () at which memory usage will be constrained. An object pertaining to an active user of the system is identified (), and further objects related to this object are also found (). A user memory footprint is then determined () from the footprints of the identified objects. Different constraint options are identified () and one of these is used to constrain () the user memory footprint. In this way the memory used by individual users may be tracked and constrained without having to place all the work from users into separate JVMs. Therefore the 'bursty' nature of memory consumption by multiple users can be summed to result in a JVM which exhibits much less bursty memory requirements and allows individual users to have relatively relaxed constraints.

Method for managing memory resources in a shared memory system

In a virtual machine environment, a method and apparatus for the use of multiple heaps to retain persistent data and transient data wherein the multiple heaps enables a single virtual machine to be easily resettable, thus avoiding the need to terminate and start a new Virtual Machine as well as enabling a single virtual machine to retain data and objects across multiple applications, thus avoiding the computing resource overhead of relinking, reloading, reverifying, and recompiling classes. The memory hierarchy includes a System Heap, a Middleware Heap and a Transient Heap. The use of three heaps enables garbage collection to be selectively targeted to one heap at a time in between applications, thus avoiding this overhead during the life of an application.

Serially, reusable virtual machine

A computer system provides an object-based virtual machine environment for running successive applications. The computer system includes storage, at least a portion of which is logically divided into two or more heaps in which objects can be stored. A first heap is reset between successive applications, and a second heap persists from one application to the next. A card table is provided which comprises multiple cards, each corresponding to a region of said storage. Each card in the card table is set to null when the first heap is reset between successive applications. A card is marked whenever an object in its corresponding storage region is created or updated. It is then possible to detect potential references from the second heap to the first heap at reset by scanning the cards in the card table corresponding to the second heap, and detecting any cards which have been marked. The system further identifies any objects on the first heap which have a finalization method. The finalization methods of any such identified objects are then run on the main thread prior to reset of the first heap.

Computer system with heap reset for performing generational garbage collection implemented by card-marking between successive applications

A method of garbage collection of shared data in a system heap within a data processing system, the method comprising the steps of: (a) determining if the contents of the system heap has reached a predetermined threshold, the system heap storing shared objects which are shared amongst a plurality of processes running in a data processing system; (b) in a table identifying each of the plurality of processes with a status field, setting the status field of a process which has carried out determining step (a) to a mark initiator value; (c) triggering remaining processes to mark all objects in the system heap that each process is currently using; (d) determining that each of the remaining processes has completed the marking, at step (c); (e) releasing any unmarked objects in the system heap to an object pool.

Method and system for the garbage collection of shared data

This invention relates to memory management in a virtual machine or operating system and in particular to object creation and garbage collection. There is described a method and system of managing memory in a multi-threaded processing environment such as a java virtual machine comprising: creating an object in a thread heap; associating a status with the object and setting the status as local; using write barriers to change the status to global if the object is assigned to a static variable or if the object is assigned to a field in a global object; changing the status of all objects referenced by that object to global; and performing garbage collection by deleting from the thread heap, when memory space in the thread heap is required, one or more local objects which can not be traced to the thread stack.

Virtual machine memory management

There is described a method of accurately scanning the C stack. One technique for solving these problems is to indirectly reference objects using handles however the some JVMs have removed handles to gain a performance improvement. The embodiment describes a solution in which 32 bit quantities are known to be object references by means of some side information. This avoids the problem of integer values masquerading as references causing objects to be needlessly retained. It also allows employment of a compacting collector which is allowed to move objects even if they are referenced from the stacks. Currently the compactor is prevented from moving such objects leading to reduced compaction efficiency.

Memory management using object pointer structure

This invention relates to memory management in a virtual machine or operating system and in particular to object creation and garbage collection. There is described a method and system of managing memory in a multi-threaded processing environment such as a java virtual machine comprising: creating an object in a thread heap; associating a status with the object and setting the status as local; using write barriers to change the status to global if the object is assigned to a static variable or if the object is assigned to a field in any other object; and performing garbage collection by deleting from the thread heap, when memory space in the thread heap is required, one or more local objects which can not be traced to the thread stack.

A computer system provides an object-based environment and includes storage. At least a portion of the storage is logically divided into two or more heaps in which objects can be stored. Each heap is subdivided into slices of memory. The system includes a two-level lookup structure for determining whether a given storage address corresponds to a particular heap. The lookup substructure involves a first level having one or more lookup substructures, each corresponding to a unit of memory representing a predetermined number of slices. The substructure indicates for each of these slices the particular heap, if any, that the slice belongs to. The two-level lookup structure further involves a second level for determining for a given memory address the first level lookup substructure that includes the slice containing that address.

Computer system with multiple heaps

A computer-implemented method for reducing a computing overhead associated with objects that are local to a particular thread and can be accessed solely by that thread. Dynamically during run-time, an object is determined to be local to a particular thread and can be accessed solely by that thread, whereby a computing overhead associated with that object may be reduced. Likewise, cache locality may be optimized in respect of objects that are determined to be global so as to avoid putting them in the same cache line, whilst thread-local objects are preferably stored in a cache line associated with that thread.

Method and system for reducing the computing overhead associated with thread local objects

A semantic network is described in which data is stored in data storage areas at nodes of the network, there being a root node from which all other nodes depend, in a branched structure, and in which data stored at each node includes relationship information about related nodes other than nodes linked by a branch from said node. The relationship information includes a token identifying the type of relationship. The other node in a relationship may be a virtual node, which does not actually exist, but whose data content is stored within the relationship information.

Growing community of inventors

Ampfield, United Kingdom

Martin John Trotter