| ############################################################################### |
| # Copyright (c) 2009, 2020 SAP AG and IBM Corporation. |
| # All rights reserved. This program and the accompanying materials |
| # are made available under the terms of the Eclipse Public License v1.0 |
| # which accompanies this distribution, and is available at |
| # http://www.eclipse.org/legal/epl-v10.html |
| # |
| # Contributors: |
| # SAP AG - initial API and implementation |
| # IBM Corporation - additional annotations and fixes |
| ############################################################################### |
| BigDropsQuery.name = Big Drops in Dominator Tree |
| BigDropsQuery.category = Leak Identification |
| BigDropsQuery.help = Display memory accumulation points in the dominator tree.\n\n\ |
| Displayed are objects where the difference in the retained size of the parent \ |
| and the children is very big. These are places where the memory of many small \ |
| objects is accumulated under one object. The first \"interesting\" dominator \ |
| of the accumulation point is also shown. |
| BigDropsQuery.pattern.help = Specifies which dominators of the big drop object (accumulation point) should be skipped |
| |
| ClassLoaderExplorerQuery.name = Class Loader Explorer |
| ClassLoaderExplorerQuery.category = Java Basics |
| ClassLoaderExplorerQuery.help = Lists all or selected class loaders including their defined classes. \ |
| Drill-down to show the parent class loader or with -tree the child class loaders. |
| ClassLoaderExplorerQuery.objects.help = The class loaders to display. The objects are either class loaders, \ |
| or classes for which their class loaders will be used, or objects for which the class loader of their types will be used. \ |
| By default all the class loaders are chosen, or if -tree is specified then all the class loaders without parents are chosen. |
| ClassLoaderExplorerQuery.tree.help = Display the class loaders as a parent/child tree rather than expanding to show the parent. |
| |
| ClassReferrersQuery.name = Show objects by class |
| ClassReferrersQuery.menu.0.category = 2|Show objects by class |
| ClassReferrersQuery.menu.0.label = 1|by outgoing references |
| ClassReferrersQuery.menu.1.category = 2|Show objects by class |
| ClassReferrersQuery.menu.1.label = 2|by incoming references |
| ClassReferrersQuery.help = List the selected objects, grouped by class. \ |
| A class group can be expanded as a tree to show references to or from other objects, also grouped by class. \ |
| When a class group is expanded, find all the objects that any object in the group points to \ |
| and then group those objects by class. |
| ClassReferrersQuery.objects.help = The objects to display with references. |
| ClassReferrersQuery.inbound.help = When a class group is expanded find all the objects pointing to any object in the group \ |
| and then group those objects by class. |
| |
| ComparisonReport.name = Compare Snapshots Leak Report |
| ComparisonReport.category = Leak Identification |
| ComparisonReport.help = Runs a report designed to compare two snapshots. \ |
| The default report includes leak suspects based on the growth in memory usage \ |
| and a system overview comparison. |
| ComparisonReport.report.help = The report identifier. |
| ComparisonReport.baseline.help = The baseline snapshot filename. |
| |
| CustomizedRetainedSetQuery.name = Customized Retained Set |
| CustomizedRetainedSetQuery.category = Java Basics |
| CustomizedRetainedSetQuery.help = Calculate the retained set of objects excluding references via given fields.\n\n\ |
| The custom retained set comprises all objects included in the normal retained set. \ |
| Additionally, it adds objects which are (a) reachable from the root set and (b) \ |
| would be garbage collected if the references defined by the excludes would not exist.\n\n\ |
| \ |
| In terms of set operations, one could put it this way: the customized retained set contains \ |
| all objects which are unreachable if all references to the root set and all references \ |
| defined by the excludes are removed. From the resulting set, the objects of the retained set \ |
| derived only through the excludes are removed.\n\n\ |
| \ |
| For example, to calculate the retained set of all classes in a package including those \ |
| objects that would be freed only after the finalizer run (only on Sun's VM!), one could say:\n\ |
| \tcustomized_retained_set sample\\.package.* -x java.lang.ref.Finalizer:referent\n\n\ |
| \ |
| The excludes are specified as follows:\n\ |
| \texclude ::= ( <objectAddress> | <className> ) [: <field> [, <field> ]]\n\ |
| Example:\n\ |
| \tjava.lang.ref.WeakReference:referent\n\ |
| \t0x4711:attrib1,attrib2\n\n\ |
| \ |
| Use the argument 'xfile' to read excludes from the file. Each lines must have the same format. |
| CustomizedRetainedSetQuery.objects.help = Root set of objects for the retained set calculation |
| CustomizedRetainedSetQuery.excludedReferences.help = Exclude definitions |
| CustomizedRetainedSetQuery.excludedReferencesListFile.help = File containing exclude definitions |
| |
| DeltaHistogram.name = Compare Snapshots |
| DeltaHistogram.help = Compare the histograms of two snapshots by generating a difference histogram. |
| DeltaHistogram.snapshot2.help = The baseline snapshot file. |
| |
| DuplicatedClassesQuery.name = Duplicate Classes |
| DuplicatedClassesQuery.category = Java Basics |
| DuplicatedClassesQuery.help = Extract classes loaded multiple times. |
| |
| FinalizerReferenceStatQuery.name = Finalizer References Statistics |
| FinalizerReferenceStatQuery.category = Java Basics/References |
| FinalizerReferenceStatQuery.help = Statistics on Finalizers. |
| |
| FindStringsQuery.name = Find Strings |
| FindStringsQuery.category = Java Basics |
| FindStringsQuery.help = Find Strings matching the regular expression. |
| FindStringsQuery.objects.help = Optionally limit the search to Strings in this object set. |
| FindStringsQuery.pattern.help = Regular expression limiting the values of Strings considered. |
| |
| GCRootsQuery.name = GC Roots |
| GCRootsQuery.category = Java Basics |
| GCRootsQuery.help = List Garbage Collection (GC) Roots by GC Root type. |
| |
| GroupByValueQuery.name = Group By Value |
| GroupByValueQuery.category = Java Basics |
| GroupByValueQuery.help = Group objects by their string representation.\n\n\ |
| By default, the objects are grouped by the the class specific name resolver. \ |
| Alternatively, one can specify a field using the dot notation, whose name \ |
| resolver is then used.\n\n\ |
| Examples:\n\ |
| To find duplicate strings, run:\n\tgroup_by_value java.lang.String\n\ |
| To group array lists by their size, run:\n\tgroup_by_value java.util.ArrayList -field size |
| GroupByValueQuery.field.help = An optional dot notation to specify a field which is used to group the objects, \ |
| e.g. modCount to group HashMaps by their modifications. |
| GroupByValueQuery.objects.help = Objects to be grouped by value. |
| |
| HeapDumpInfoQuery.name = Heap Dump Overview |
| HeapDumpInfoQuery.help = Displays heap dump details: number of objects, etc. |
| |
| HeapDumpInfoQuery2.name = Heap Dump Overview comparison |
| HeapDumpInfoQuery2.help = Displays heap dump details: number of objects, etc. |
| HeapDumpInfoQuery2.baseline.help = The baseline snapshot file. |
| |
| HistogramQuery.name = Show As Histogram |
| HistogramQuery.category = Java Basics |
| HistogramQuery.help = Create a histogram from an arbitrary set of objects. The objects are grouped by class, superclass, classloader or package.\n\n\ |
| If you need the retained set as an histogram, use the retained_set query. |
| HistogramQuery.objects.help = Objects for which the histogram should be shown. |
| HistogramQuery.groupBy.help = Whether to group the objects in the resulting histogram by class, superclass, classloader or by package. |
| |
| ImmediateDominatorsQuery.name = Immediate Dominators |
| ImmediateDominatorsQuery.help = Find and aggregate on class level all objects dominating a given set of objects.\n\n\ |
| The immediate dominators of all char arrays (immediate_dominators char[]) \ |
| are all objects responsible for keeping the char[] alive. The result will \ |
| contain most likely java.lang.String objects. Now add the skip pattern java.*, \ |
| and you will see the non-JDK classes responsible for the char arrays. |
| ImmediateDominatorsQuery.skipPattern.help = A regular expression specifying which dominators to skip while going up the dominator tree. \ |
| If the dominator of an object matches the pattern, then the dominator of the \ |
| dominator will be taken, and so on, until an object not matching the skip pattern \ |
| is reached. |
| ImmediateDominatorsQuery.objects.help = Set of objects to include in the analysis. |
| |
| LeakHunterQuery.name = Find Leaks |
| LeakHunterQuery.category = Leak Identification |
| LeakHunterQuery.help = Report potential memory leaks.\n\n\ |
| The query analyzes the dominator tree and searches for big memory chunks \ |
| (by default more than 10% of the total heap). These could be single objects \ |
| or groups of objects from the same class. Then it tries to automatically find the exact \ |
| accumulation point - usually an array or a collection. |
| LeakHunterQuery.skipPattern.help = A regular expression specifying which dominators/referers to skip when a problematic object is described. |
| LeakHunterQuery.threshold_percent.help = Big memory chunk size in percent of the heap. (Default value is 10%.) |
| LeakHunterQuery.max_paths.help = Number of paths to garbage collection roots. (Default value is 10000.) |
| |
| LeakHunterQuery2.name = Find Leaks between Snapshots |
| LeakHunterQuery2.category = Leak Identification |
| LeakHunterQuery2.help = Report potential memory leaks.\n\n\ |
| The query compares the dominator trees from two snapshots and searches for big \ |
| increases in memory chunks \ |
| (by default more than 10% of the total baseline heap). These could be single objects \ |
| or groups of objects from the same class. Then it tries to automatically find the exact \ |
| accumulation point - usually an array or a collection. |
| LeakHunterQuery2.baseline.help = The baseline snapshot file. |
| LeakHunterQuery2.options.help = Extra options to use to compare dominator trees. |
| LeakHunterQuery2.mask.help = The 'mask' option for the compare. |
| LeakHunterQuery2.extraReferences.help = The 'x' option for the compare. |
| LeakHunterQuery2.extraReferencesListFile.help = The 'xfile' option for the compare. |
| |
| ObjectListQuery.name = List Objects |
| ObjectListQuery.menu.0.category = 1|List objects |
| ObjectListQuery.menu.0.label = 1|with outgoing references |
| ObjectListQuery.menu.1.category = 1|List objects |
| ObjectListQuery.menu.1.label = 2|with incoming references |
| ObjectListQuery.help = List the selected objects. The objects can be expanded as a tree to show references to or from other objects. \ |
| When an object is expanded show all the objects that this object points to. |
| ObjectListQuery.objects.help = The objects to display with references. |
| ObjectListQuery.inbound.help = When an object is expanded show all the objects pointing to this object, rather than \ |
| all the objects that this object points to. |
| |
| OQLQuery.name = OQL |
| OQLQuery.help = Execute an OQL Statement. |
| |
| PhantomReferenceStatQuery.name = Phantom References Statistics |
| PhantomReferenceStatQuery.category = Java Basics/References |
| PhantomReferenceStatQuery.help = Statistics for Phantom References. \ |
| This includes a histogram of referent objects referred to by the reference, the retained set only retained via the referent, \ |
| and referent objects not eligible for garbage collection as they are also strongly retained via another field of a reference. |
| |
| ReferenceLeakQuery.name = Reference Leaks |
| ReferenceLeakQuery.category = Leak Identification |
| ReferenceLeakQuery.help = If an object is the referent for a reference object, \ |
| but there is also a strong path from the reference object to the referent object then \ |
| the referent object cannot be freed by garbage collection.\n\ |
| A particular example is a WeakHashMap when there is path from the value object to the key object. \ |
| The key and so the WeakHashMap entry and value can then never be freed, even if there are no other paths to the key.\n\ |
| This query produces up to 'maxresults' trees each showing a reference and its referent object, and a \ |
| common path by class to all the suspicious referents (or a path by object if there was just one). |
| ReferenceLeakQuery.objects.help = Reference objects for which the reference leaks query should be run. |
| ReferenceLeakQuery.referent_attribute.help = The referent field name for the reference objects. |
| ReferenceLeakQuery.maxresults.help = The maximum number of objects for which a tree should be shown. |
| ReferenceLeakQuery.max_paths.help = The maximum number of reverse paths which should be tried to \ |
| from the referent object to the reference object. |
| ReferenceLeakQuery.maxobjs.help = The maximum number of objects to be examined for leaks. \ |
| A random selection of the total objects will be chosen. |
| ReferenceLeakQuery.factor.help = For common paths, how much to truncate the path as the number of objects reduces. |
| |
| ReferenceQuery.name = References Statistics... |
| ReferenceQuery.category = Java Basics/References |
| ReferenceQuery.help = Statistics for Reference-objects. \ |
| This includes a histogram of referent objects referred to by the reference, the retained set only retained via the referent, \ |
| and referent objects not eligible for garbage collection as they are also strongly retained via another field of a reference. |
| ReferenceQuery.referent_attribute.help = The referent attribute of the class. |
| ReferenceQuery.objects.help = Objects for which the reference query should be run. |
| |
| RetainedSetQuery.name = Show Retained Set |
| RetainedSetQuery.help = Calculate the retained set of an arbitrary set of objects.\n\n\ |
| Optionally one can provide a list field names. If this parameter is specified, \ |
| instead of assuming that the whole instance is not available, just the references \ |
| with the specified name are considered non-existing. |
| RetainedSetQuery.fieldNames.help = List of field names |
| RetainedSetQuery.objects.help = Set of objects to include in the analysis. |
| |
| SimpleComparison.name = Simple Comparison |
| SimpleComparison.category = Java Basics |
| SimpleComparison.help = A comparison of the results of running a query on two snapshots. |
| SimpleComparison.baseline.help = The baseline snapshot file. |
| SimpleComparison.query.help = The query to run on each snapshot. Can include options. |
| SimpleComparison.options.help = The options to pass to the comparison query. |
| SimpleComparison.defaultoptions.help = The default options passed to the comparison query. \ |
| Can be overridden but the default ignores object addresses and array sizes in the comparison. |
| SimpleComparison.retained.help = Whether to add approximate or precise retained sizes to the individual queries, \ |
| ready for the comparison. |
| |
| SoftReferenceStatQuery.name = Soft References Statistics |
| SoftReferenceStatQuery.category = Java Basics/References |
| SoftReferenceStatQuery.help = Statistics for Soft References. \ |
| This includes a histogram of referent objects referred to by the reference, the retained set only retained via the referent, \ |
| and referent objects not eligible for garbage collection as they are also strongly retained via another field of a reference. |
| |
| SystemPropertiesQuery.name = System Properties |
| SystemPropertiesQuery.category = Java Basics |
| SystemPropertiesQuery.help = Displays the Java system properties. |
| |
| TopConsumers2Query.name = Top Consumers |
| TopConsumers2Query.category = Leak Identification |
| TopConsumers2Query.help = Print biggest objects grouped by class, class loader, and package. \ |
| By default, the total heap is included in the analysis. |
| TopConsumers2Query.objects.help = Set of objects to include in the analysis. |
| TopConsumers2Query.thresholdPercent.help = Threshold (in percent of the total heap size) which objects have to exceed to be included in the analysis |
| |
| TopConsumersQuery.name = Top Consumers |
| TopConsumersQuery.help = Print biggest objects grouped by class, class loader, and package. \ |
| By default, the total heap is included in the analysis. |
| TopConsumersQuery.objects.help = Set of objects to include in the analysis. |
| TopConsumersQuery.thresholdPercent.help = Threshold (in percent of the total heap size) which objects have to exceed to be included in the analysis |
| |
| UnreachableObjectsQuery.name = Unreachable Objects Histogram |
| UnreachableObjectsQuery.category = Java Basics |
| UnreachableObjectsQuery.help = Displays histogram of unreachable objects. |
| |
| WasteInCharArraysQuery.name = Waste in Char Arrays |
| WasteInCharArraysQuery.category = Java Basics |
| WasteInCharArraysQuery.help = Find strings that retain wasteful char arrays, likely due to substring |
| WasteInCharArraysQuery.minimumWaste.help = Minimum number of characters that must be wasted in a char array to be included in the result list. |
| |
| WeakReferenceStatQuery.name = Weak References Statistics |
| WeakReferenceStatQuery.category = Java Basics/References |
| WeakReferenceStatQuery.help = Statistics for Weak References. \ |
| This includes a histogram of referent objects referred to by the reference, the retained set only retained via the referent, \ |
| and referent objects not eligible for garbage collection as they are also strongly retained via another field of a reference. |