Interface ISnapshot

  • All Known Implementing Classes:
    SnapshotImpl

    public interface ISnapshot
    Interface for snapshots. It is the central API for handling HPROF snapshots.

    A snapshot basically has an SnapshotInfo object describing it and various methods operating on it. Be aware that such a snapshot potentially holds quite a lot of memory, so try to keep not too many open at the same time.

    The basic "handle" you will encounter in the API is an int. It is the id of an object and is always of the size of four bytes (no matter if 32 or 64 bit). Operations are either performed on int or int[] (addresses are stored in longs, but they should be used only for display purposes). In order to simplify working with them and for performance reasons compared to Collection<Integer> some helper classes are provided and you are strongly advised to use them: BitField (for huge fixed bit fields), ArrayIntBig and ArrayLongBig (for huge growing arrays), ArrayIntCompressed and ArrayLongCompressed (for fixed-size compressed arrays), ArrayInt and ArrayLong for large lists of ints or longs, SetInt and SetLong for large sets of ints or longs.

    No Implement:
    • Method Summary

      All Methods Instance Methods Abstract Methods 
      Modifier and Type Method Description
      void dispose()
      Dispose the whole snapshot.
      java.util.Collection<IClass> getClasses()
      Get all classes.
      java.util.Collection<IClass> getClassesByName​(java.lang.String name, boolean includeSubClasses)
      Get all classes by name.
      java.util.Collection<IClass> getClassesByName​(java.util.regex.Pattern namePattern, boolean includeSubClasses)
      Get all classes by name pattern.
      IClass getClassOf​(int objectId)
      Get object abstracting the real Java Class this object was an instance of in the heap dump identified by the given id.
      DominatorsSummary getDominatorsOf​(int[] objectIds, java.util.regex.Pattern excludePattern, IProgressListener progressListener)
      Get a summary of the dominators for all the given objects.
      GCRootInfo[] getGCRootInfo​(int objectId)
      Get the GC root info for an object.
      int[] getGCRoots()
      Get all GC roots.
      long getHeapSize​(int objectId)
      Get heap size for just the given object.
      long getHeapSize​(int[] objectIds)
      Get the total shallow heap size for a set of objects.
      Histogram getHistogram​(int[] objectIds, IProgressListener progressListener)
      Get histogram for some specific objects - usually the result of other calls to the snapshot.
      Histogram getHistogram​(IProgressListener progressListener)
      Get histogram for the whole snapshot.
      int[] getImmediateDominatedIds​(int objectId)
      Get objects the given object directly dominates, i.e.
      int getImmediateDominatorId​(int objectId)
      Get object which directly dominates the given object, i.e.
      int[] getInboundRefererIds​(int objectId)
      Get all objects referencing the given object.
      int[] getInboundRefererIds​(int[] objectIds, IProgressListener progressListener)
      Get all objects referencing the given objects.
      int[] getMinRetainedSet​(int[] objectIds, IProgressListener progressListener)
      Calculate the minimum retained set of objects for the given objects (including the given objects).
      long getMinRetainedSize​(int[] objectIds, IProgressListener listener)
      Calculate the minimum retained size for the given objects.
      IMultiplePathsFromGCRootsComputer getMultiplePathsFromGCRoots​(int[] objectIds, java.util.Map<IClass,​java.util.Set<java.lang.String>> excludeMap)
      Returns an IMultiplePathsFromGCRootsComputer object, which can be used to calculate the shortest path from the GC roots to each of objects in the specified object set.
      IObject getObject​(int objectId)
      Get object abstracting the real Java Object from the heap dump identified by the given id.
      int[] getOutboundReferentIds​(int objectId)
      Get all objects referenced by the given object.
      int[] getOutboundReferentIds​(int[] objectIds, IProgressListener progressListener)
      Get all objects referenced by the given objects.
      IPathsFromGCRootsComputer getPathsFromGCRoots​(int objectId, java.util.Map<IClass,​java.util.Set<java.lang.String>> excludeMap)
      Get interactive computer for paths from GC roots to the given object.
      long getRetainedHeapSize​(int objectId)
      Get retained heap size for the given object.
      int[] getRetainedSet​(int[] objectIds, java.lang.String[] fieldNames, IProgressListener progressMonitor)
      Get retained set of objects for the given fields at the given objects (excluding the given objects).
      int[] getRetainedSet​(int[] objectIds, ExcludedReferencesDescriptor[] excludedReferences, IProgressListener progressMonitor)
      Get retained set of objects for the given fields at the given objects (excluding the given objects).
      int[] getRetainedSet​(int[] objectIds, IProgressListener progressListener)
      Get retained set of objects for the given objects (including the given objects).
      <A> A getSnapshotAddons​(java.lang.Class<A> addon)
      Get additional JVM information, if available.
      SnapshotInfo getSnapshotInfo()
      Get info object describing the snapshot.
      IThreadStack getThreadStack​(int objectId)
      Get a the stack trace information for a given thread object, if thread stack information is available in this snapshot.
      int[] getTopAncestorsInDominatorTree​(int[] objectIds, IProgressListener listener)
      Get the top-ancestors in the dominator tree from the supplied objectIds.
      boolean isArray​(int objectId)
      Returns true if the object by this id is an array.
      boolean isClass​(int objectId)
      Returns true if the object by this id is a class.
      boolean isClassLoader​(int objectId)
      Returns true if the object by this id is a class loader.
      boolean isGCRoot​(int objectId)
      Returns true if the object by this id is a garbage collection root.
      int mapAddressToId​(long objectAddress)
      Map object address (memory address where the object was stored) to object id (snapshot internal identity assigned during parsing).
      long mapIdToAddress​(int objectId)
      Map object id (snapshot internal identity assigned during parsing) to object address (memory address where the object was stored).
    • Method Detail

      • getSnapshotInfo

        SnapshotInfo getSnapshotInfo()
        Get info object describing the snapshot.

        Performance: Fast - in memory.

        Returns:
        info object describing the snapshot
      • getGCRoots

        int[] getGCRoots()
                  throws SnapshotException
        Get all GC roots.

        A GC root is an object which doesn't need to be referenced to remain in the heap, e.g. all objects created in the thread stack frame.

        Performance: Fast - in memory.

        Returns:
        int[] containing the objectIds of all GC roots
        Throws:
        SnapshotException - should not normally occur
      • getClasses

        java.util.Collection<IClass> getClasses()
                                         throws SnapshotException
        Get all classes.

        The returned class is a snapshot representation of a Java class. It offers means to get to its name, class loader, fields, inheritance relationships and most importantly to all of its objects found in the heap.

        Performance: Fast - in memory.

        Returns:
        collection of all classes
        Throws:
        SnapshotException - should not normally occur
      • getClassesByName

        java.util.Collection<IClass> getClassesByName​(java.lang.String name,
                                                      boolean includeSubClasses)
                                               throws SnapshotException
        Get all classes by name.

        This method returns you for one full class name all classes with this name. Usually you will get only one class back, but in the case of multiple class loaders which have loaded a class with the same name twice (or even the same class) you will get multiple snapshot class representations back as only the combination of class and class loader is unique, not the name alone.

        Performance: Fast - in memory.

        Parameters:
        name - name for the class
        includeSubClasses - flag indicating whether or not to include also classes derived from matching classes (the name isn't taken into account for sub classes anymore)
        Returns:
        collection of matching classes - current implementations can return null if there is no class found
        Throws:
        SnapshotException - should not normally occur
      • getClassesByName

        java.util.Collection<IClass> getClassesByName​(java.util.regex.Pattern namePattern,
                                                      boolean includeSubClasses)
                                               throws SnapshotException
        Get all classes by name pattern.

        This method returns you all classes with a name matching the regular expression pattern.

        Performance: Fast - in memory, but needs iteration over all classes.

        Parameters:
        namePattern - name pattern for the class (regular expression)
        includeSubClasses - flag indicating whether or not to include also classes derived from matching classes (the name isn't taken into account for subclasses anymore)
        Returns:
        collection of matching classes
        Throws:
        SnapshotException - should not normally occur
      • getHistogram

        Histogram getHistogram​(IProgressListener progressListener)
                        throws SnapshotException
        Get histogram for the whole snapshot.

        This histogram lists all classes and class loaders and how many objects of the classes exist in the snapshot along with the memory consumption.

        Performance: Fast - in memory.

        Parameters:
        progressListener - progress listener informing about the current state of execution
        Returns:
        histogram
        Throws:
        SnapshotException - if there is a problem retrieving the information such as because of a damaged index.
      • getHistogram

        Histogram getHistogram​(int[] objectIds,
                               IProgressListener progressListener)
                        throws SnapshotException
        Get histogram for some specific objects - usually the result of other calls to the snapshot.

        This histogram lists all classes and class loaders and how many objects of the classes exist among the given objects along with the memory consumption.

        Performance: Fast to medium - on index (object id -> class id); depending on the number of objects.

        Parameters:
        objectIds - object ids for which the histogram should be computed
        progressListener - progress listener informing about the current state of execution
        Returns:
        histogram - current implementations can return null if the listener is cancelled
        Throws:
        SnapshotException - if there is a problem retrieving the information such as because of a damaged index.
      • getInboundRefererIds

        int[] getInboundRefererIds​(int objectId)
                            throws SnapshotException
        Get all objects referencing the given object.

        This is the inverse of getOutboundReferentIds(int).

        Performance: Relatively fast - single index operation.

        Parameters:
        objectId - object which is referenced
        Returns:
        objects referencing the given object
        Throws:
        SnapshotException - should not normally occur
      • getOutboundReferentIds

        int[] getOutboundReferentIds​(int objectId)
                              throws SnapshotException
        Get all objects referenced by the given object.

        This shows the keep-alive relationship between objects and includes:

        • a reference from an object to its type (class)
        • reference fields in objects
        • references in object arrays
        • a references from a class to its class loader
        • a reference from a class to its superclass
        • static reference fields in class objects
        • classes loaded by a class loader

        This is the inverse of getInboundRefererIds(int).

        Performance: Relatively fast - single index operation.

        Parameters:
        objectId - object which is referencing
        Returns:
        objects referenced by the given object
        Throws:
        SnapshotException - should not normally occur
      • getInboundRefererIds

        int[] getInboundRefererIds​(int[] objectIds,
                                   IProgressListener progressListener)
                            throws SnapshotException
        Get all objects referencing the given objects.

        Hint: This method is handy if you want to learn which classes reference a class. Therefore you would call this method with all objects of your class of interest and get a histogram out of the result.

        This is the inverse of getOutboundReferentIds(int[], IProgressListener).

        Performance: Fast to slow - on index; depending on the number of objects and the references.

        Parameters:
        objectIds - objects which are referenced
        progressListener - progress listener informing about the current state of execution
        Returns:
        objects referencing the given objects - current implementations can return null if the operation is cancelled
        Throws:
        SnapshotException - should not normally occur
      • getOutboundReferentIds

        int[] getOutboundReferentIds​(int[] objectIds,
                                     IProgressListener progressListener)
                              throws SnapshotException
        Get all objects referenced by the given objects.

        Hint: This method is handy if you want to learn which classes are referenced by a class. Therefore you would call this method with all objects of your class of interest and get a histogram out of the result. This is the inverse of getInboundRefererIds(int[], IProgressListener).

        Performance: Fast to slow - on index; depending on the number of objects and the references.

        Parameters:
        objectIds - objects which are referencing
        progressListener - progress listener informing about the current state of execution
        Returns:
        objects referenced by the given objects - current implementations can return null if the operation is cancelled
        Throws:
        SnapshotException - should not normally occur
      • getPathsFromGCRoots

        IPathsFromGCRootsComputer getPathsFromGCRoots​(int objectId,
                                                      java.util.Map<IClass,​java.util.Set<java.lang.String>> excludeMap)
                                               throws SnapshotException
        Get interactive computer for paths from GC roots to the given object.

        Hint: This method is handy if you want to learn which objects are responsible for the given object to remain in memory. Since the snapshot implementation artificially creates references from the object to its class and from the class to its class loader you can even see why a class or class loaders remains in memory, i.e. which other objects hold references to objects of the class or class loader of interest.

        Performance: Fast to slow - on index; depending on the number and length of GC root paths.

        Parameters:
        objectId - object for which the GC root paths should be determined
        excludeMap - a map specifying paths through which objects have to be avoided and not reported. Each entry in the map has the IClass as a key, and a Set<String> set, specifying which fields exactly from this key class have to be avoided. If for a key IClass the value (Set<String>) null is specified, then paths through any of the fields will be avoided
        Returns:
        interactive computer for paths from GC roots to the given object
        Throws:
        SnapshotException - if a problem occurs creating the paths computer
      • getMultiplePathsFromGCRoots

        IMultiplePathsFromGCRootsComputer getMultiplePathsFromGCRoots​(int[] objectIds,
                                                                      java.util.Map<IClass,​java.util.Set<java.lang.String>> excludeMap)
                                                               throws SnapshotException
        Returns an IMultiplePathsFromGCRootsComputer object, which can be used to calculate the shortest path from the GC roots to each of objects in the specified object set.
        Parameters:
        objectIds - the IDs of the objects for which a shortest path has to be calculated
        excludeMap - a map specifying paths through which objects have to be avoided and not reported. Each entry in the map has the IClass as a key, and a Set<String> set, specifying which fields exactly from this key class have to be avoided. If for a key IClass the value (Set<String>) null is specified, then paths through any of the fields will be avoided
        Returns:
        IMultiplePathsFromGCRootsComputer The object which can be used to carry out the actual computation and
        Throws:
        SnapshotException - if a problem occurs creating the paths computer
      • getRetainedSet

        int[] getRetainedSet​(int[] objectIds,
                             IProgressListener progressListener)
                      throws SnapshotException
        Get retained set of objects for the given objects (including the given objects).

        The retained set includes the given objects and all objects which are lifetime-dependent on them, i.e. which would be garbage collected if the references to the given objects would be lost and the objects garbage collected.

        Performance: Usually extremely slow - on index; depending on the number of objects and the references (deep).

        Parameters:
        objectIds - objects on which the retained set should be determined
        progressListener - progress listener informing about the current state of execution
        Returns:
        retained set of objects for the given objects
        Throws:
        SnapshotException - if a problem occurs, for example if the operation was interrupted
      • getRetainedSet

        int[] getRetainedSet​(int[] objectIds,
                             java.lang.String[] fieldNames,
                             IProgressListener progressMonitor)
                      throws SnapshotException
        Get retained set of objects for the given fields at the given objects (excluding the given objects).

        The retained set includes the objects referenced by the fields on the given objects and all objects which are lifetime-dependent on them, i.e. which would be garbage collected if the references at the given fields at the given objects would be nulled.

        Performance: Usually extremely slow - on index; depending on the number of objects and the references (deep).

        Parameters:
        objectIds - objects on which the retained set should be determined
        fieldNames - the names of the fields which could retain the objects
        progressMonitor - progress listener informing about the current state of execution
        Returns:
        retained set of objects for the given objects
        Throws:
        SnapshotException - if there was a problem, such as on cancellation
      • getRetainedSet

        int[] getRetainedSet​(int[] objectIds,
                             ExcludedReferencesDescriptor[] excludedReferences,
                             IProgressListener progressMonitor)
                      throws SnapshotException
        Get retained set of objects for the given fields at the given objects (excluding the given objects).

        The retained set includes the objects referenced by the fields on the given objects and all objects which are lifetime-dependent on them, i.e. which would be garbage collected if the references at the given fields at the given objects would be nulled.

        Performance: Usually extremely slow - on index; depending on the number of objects and the references (deep).

        Parameters:
        objectIds - objects on which the retained set should be determined
        excludedReferences - references which should not be followed
        progressMonitor - progress listener informing about the current state of execution
        Returns:
        retained set of objects for the given objects
        Throws:
        SnapshotException - if there was a problem, such as on cancellation
      • getMinRetainedSet

        int[] getMinRetainedSet​(int[] objectIds,
                                IProgressListener progressListener)
                         throws SnapshotException
        Calculate the minimum retained set of objects for the given objects (including the given objects).

        The minimum retained set includes the given objects and the union of the retained sets for each of the given objects (see getRetainedSet() for an explanation of a retained set). The union of the retained sets of the single objects is potentially smaller than the retained set of all of them, because some objects which are shared between two of the given objects may not appear in the retained set of any of the single objects, but will appear in the retained set if we take them as a whole. Because of it's faster performance the method is suitable to "mine" for a potentially big retained set (e.g. execute this method for all class loaders and see for potentially big ones). One can use the getRetainedSet() method afterwards to get the correct retained set.

        Performance: Usually fast - for smaller sets this method is much faster than getRetainedSet

        Parameters:
        objectIds - objects on which the minimum retained set should be determined
        progressListener - progress listener informing about the current state of execution
        Returns:
        the minimum retained set of objects for the given objects
        Throws:
        SnapshotException - if there was a problem, such as on cancellation
      • getMinRetainedSize

        long getMinRetainedSize​(int[] objectIds,
                                IProgressListener listener)
                         throws SnapshotException
        Calculate the minimum retained size for the given objects. Works much faster than getting the min. retained set by getMinRetainedSet() and calculating the size of the min. retained set.
        Parameters:
        objectIds - objects on which the minimum retained set should be determined
        listener - progress listener informing about the current state of execution
        Returns:
        the minimum retained set of objects for the given objects
        Throws:
        SnapshotException - if there was a problem, such as on cancellation
      • getImmediateDominatedIds

        int[] getImmediateDominatedIds​(int objectId)
                                throws SnapshotException
        Get objects the given object directly dominates, i.e. the objects which are life-time dependent on the given object (not recursively, so just the directly dependent objects), i.e. the objects which would get collected as garbage if the given object would be gone from the heap.
        Parameters:
        objectId - object for which the directly dominated objects should be returned
        Returns:
        objects the given object directly dominates
        Throws:
        SnapshotException - if the dominator tree has not been calculated
      • getImmediateDominatorId

        int getImmediateDominatorId​(int objectId)
                             throws SnapshotException
        Get object which directly dominates the given object, i.e. the object which controls the life-time of the given object (not recursively, so just the directly controlling object), i.e. the object which would cause the given object to be collected as garbage if it would be gone from the heap.
        Parameters:
        objectId - object for which the directly dominated objects should be returned
        Returns:
        Object id of the dominator. -1 if the object is dominated by the root of the dominator tree.
        Throws:
        SnapshotException - if the dominator tree has not been calculated
      • getDominatorsOf

        DominatorsSummary getDominatorsOf​(int[] objectIds,
                                          java.util.regex.Pattern excludePattern,
                                          IProgressListener progressListener)
                                   throws SnapshotException
        Get a summary of the dominators for all the given objects. The summary can be viewed on grouped by classes or class loaders

        If an exclude pattern is provided, instead of returning the immediate dominator right away, its class name will be checked against the exclude pattern. If it matches the pattern, the dominator of this dominator will be taken and checked, and so on ... until a dominator not matching the pattern is found or the dominator tree root is reached.

        Parameters:
        objectIds - the objects for which we want the dominator summary (e.g. all objects of a given class)
        excludePattern - An exclude pattern. Domminators whose class name matches the pattern will be omitted and their dominator will be taken
        progressListener - progress listener informing about the current state of execution
        Returns:
        DominatorsSummary the returned DominatorSummary contains the summary of the dominators grouped by classes or class loaders
        Throws:
        SnapshotException - if the dominator tree has not been calculated
      • getTopAncestorsInDominatorTree

        int[] getTopAncestorsInDominatorTree​(int[] objectIds,
                                             IProgressListener listener)
                                      throws SnapshotException
        Get the top-ancestors in the dominator tree from the supplied objectIds. The result will be a list of objects (int[]), such that no object from the return list is parent of another object in the returned list. I.e. from a list of objects this method will return only the ones which are independent on one another. It is then correct to sum the retained sizes of the returned objects.
        Parameters:
        objectIds - the objects for which the top-ancestors in the Dominator tree have to be found
        listener - progress listener informing about the current state of execution
        Returns:
        int[] the objects which not in a parent/child relation in the dominator tree
        Throws:
        SnapshotException - if the dominator tree has not been calculated
      • getObject

        IObject getObject​(int objectId)
                   throws SnapshotException
        Get object abstracting the real Java Object from the heap dump identified by the given id.

        Performance: Relatively fast - single index operation.

        Parameters:
        objectId - id of object you want a convenient object abstraction for
        Returns:
        object abstracting the real Java Object from the heap dump identified by the given id
        Throws:
        SnapshotException - if there is a problem, such as perhaps an invalid objectId
      • getGCRootInfo

        GCRootInfo[] getGCRootInfo​(int objectId)
                            throws SnapshotException
        Get the GC root info for an object. If the provided object is not a GC root, then null will be returned; otherwise, a GCRootInfo[]. An object can be a GC root for more than one reason and the returned array will contain one instance of GCRootInfo for each of the reasons (e.g. one GCRootInfo for every thread where an object is a java local variable)

        Performance: Fast - in memory.

        Parameters:
        objectId - id of object you want the GC root info for
        Returns:
        null if this object is no GC root or GCRootInfo[] if it is
        Throws:
        SnapshotException - on an unexpected problem
      • getClassOf

        IClass getClassOf​(int objectId)
                   throws SnapshotException
        Get object abstracting the real Java Class this object was an instance of in the heap dump identified by the given id.

        Performance: Relatively fast - single index operation.

        Parameters:
        objectId - id of object you want the convenient class abstraction for
        Returns:
        object abstracting the real Java Class this object was an instance of in the heap dump identified by the given id
        Throws:
        SnapshotException - if there is an unexpected problem
      • getHeapSize

        long getHeapSize​(int objectId)
                  throws SnapshotException
        Get heap size for just the given object. new long[Integer.MAX_VALUE] is bigger than Integer.MAX_VALUE bytes, so this method now returns a long

        Performance: Usually fast - in memory for non-array objects and single index operation for array objects.

        Parameters:
        objectId - id of object for which you want the heap size for
        Returns:
        heap size for the given object.
        Throws:
        SnapshotException - on an unexpected problem
        Since:
        1.0
      • getHeapSize

        long getHeapSize​(int[] objectIds)
                  throws SnapshotException
        Get the total shallow heap size for a set of objects.

        Performance: Relatively fast - using this method to calculate the total size of a set of objects is much faster than iterating over the ids and calling getHeapSize for each single object

        Parameters:
        objectIds - ids of the objects for which you want the heap size for
        Returns:
        total heap size for the given object set
        Throws:
        SnapshotException - on an unexpected problem
      • getRetainedHeapSize

        long getRetainedHeapSize​(int objectId)
                          throws SnapshotException
        Get retained heap size for the given object.

        The retained heap size is the memory which would be freed if all references to the given object would be released. It is extracted from the dominator tree and isn't available if the dominator tree isn't available itself.

        Performance: Relatively fast - single index operation.

        Parameters:
        objectId - id of object for which you want the retained heap size for
        Returns:
        retained heap size for the given object or 0 if no dominator tree was calculated
        Throws:
        SnapshotException - on an unexpected problem
      • isClass

        boolean isClass​(int objectId)
        Returns true if the object by this id is a class.

        Performance: Very fast.

        Parameters:
        objectId - id of object to test for being a class (and so an IClass).
        Returns:
        true if it is a class
      • isClassLoader

        boolean isClassLoader​(int objectId)
        Returns true if the object by this id is a class loader.

        Performance: Very fast.

        Parameters:
        objectId - id of object to test for being a class loader (and so an IClassLoader).
        Returns:
        true if it is a class
      • isArray

        boolean isArray​(int objectId)
        Returns true if the object by this id is an array.

        Performance: Very fast.

        Parameters:
        objectId - id of object to test for being an array (and so an IArray).
        Returns:
        true if it is an array
      • isGCRoot

        boolean isGCRoot​(int objectId)
        Returns true if the object by this id is a garbage collection root.

        Performance: Very fast.

        Parameters:
        objectId - id of object to test for being a GC root
        Returns:
        true if it is a GC root
      • mapIdToAddress

        long mapIdToAddress​(int objectId)
                     throws SnapshotException
        Map object id (snapshot internal identity assigned during parsing) to object address (memory address where the object was stored).

        Performance: Fast - in memory.

        Parameters:
        objectId - id of object you want the address for
        Returns:
        object address address of object with that id
        Throws:
        SnapshotException - shouldn't normally happen as often a RuntimeException would be thrown if the object ID is invalid.
      • mapAddressToId

        int mapAddressToId​(long objectAddress)
                    throws SnapshotException
        Map object address (memory address where the object was stored) to object id (snapshot internal identity assigned during parsing).

        Performance: Fast - binary search in memory.

        Parameters:
        objectAddress - address of object you want the id for
        Returns:
        object id
        Throws:
        SnapshotException - if the object address is not found.
      • dispose

        void dispose()
        Dispose the whole snapshot.

        Please call this method prior to dropping the last reference to the snapshot as this method ensures the proper return of all resources (e.g. main memory, file and socket handles...). After calling this method the snapshot can't be used anymore.

      • getSnapshotAddons

        <A> A getSnapshotAddons​(java.lang.Class<A> addon)
                         throws SnapshotException
        Get additional JVM information, if available.

        For example, from the supplied snapshot implementation SnapshotImpl the extra information is obtained via IObjectReader.getAddon(Class).

        Type Parameters:
        A - the type of the result
        Parameters:
        addon - the type of the additional information required
        Returns:
        SnapshotAddons - extended information, e.g. perm info, OoM stack trace info, JVM arguments, etc. returns null if the information is not present
        Throws:
        SnapshotException - if there is a problem retrieving the information
      • getThreadStack

        IThreadStack getThreadStack​(int objectId)
                             throws SnapshotException
        Get a the stack trace information for a given thread object, if thread stack information is available in this snapshot.

        Parameters:
        objectId - the object ID of the thread
        Returns:
        IThreadStack - an object representing the call stack of the thread. Returns null if no info is available for the object, or no stack info is available at all
        Throws:
        SnapshotException - if there is a problem retrieving the information
        Since:
        0.8