JetBrains.dotMemory.Model.Interface

Allocations are not collected.

Allocations are collected via ICorProfilerCallback.ObjectsAllocatedByClass()
Only objects count per class without stacktrace available.

This is fallback mode for MacOS/Linux where sampling not yet supported.

Allocations are collected via ETW GcAllocTick event.
Approx. allocated bytes per class with stacktrace captured for sampled instances available.

This is default mode for Windows.

Allocations are collected via ICorProfilerCallback.ObjectAllocated()
Exact allocated bytes per class with stacktrace captured for each instance available.

The DFS number of this node.

Compact nodes for objects dominated by all objects of this node.

Returns allocation points for each object in given object set.

Returned allocation points are ordered by GC number and might differ from original object set order.

Returns allocation points for each given object.

Returned allocation points are ordered by GC number and might differ from original objects order.

Returns allocation points for each finalized object.

Returned allocation points are ordered by GC number and might differ from original finalized objects order.

Enables batch mode.

The backtrace nod expander needs access to call trees, in the batch mode such trees are accumulated in the cache which might significantly speed up consequent calls to Expand or HasChildren. When batch mode turned off the cache will be cleared.

"Pointer" to call-tree node.

Actually pointer is an index in memory mapped array (nodes array in MergedCallTree). It implements because it is used in wpf binding and there is a memory leak if class used in binding does not implement

Contains constants for using with ConditionalAttribte

Converts "raw" snapshot came from the profiler core into the final client format. Returns human-readable snapshot name (if provided).

Dumps object graph into text file.

Zips requested snapshot sections except ones which might contain user sensitive data.

Zips requested streaming sections.

Type of objects represented by this node.

Number of objects with type ObjectsType which dominates (exclusively retains) Children.

NOTE! If compact dominator tree is built on some object subset (not all objects in snapshot) then ObjectsCount might include objects which aren't in analyzed subset but dominates someone from it.

Number of objects retained by all objects of this node, including this.ObjectsCount.

Number of bytes retained by all objects of this node including this node's objects.

Whether at least one object (associated with node) contained in analyzed object set?

The False value means 'node is just a part of domination path and no objects of appropriate type in analyzed set'.

The DFS number of this node.

Compact nodes for objects dominated by all objects of this node.

NOTE: Actually, this method filters instances of type, not just type. Probably, it will move to hypothetical IInstanceFilter

The hierarchical structure of match contexts (see ) with highlighting ranges.
The empty contexts (without children and text ranges) are omitted.

Creates new match context and adds it to current one as a child.
The returned might be used to append highlighting ranges and MUST BE properly disposed to ensure correct contexts hierarchy.

Appends new match context with a single .
Used for some special contexts like or .

Prepares MatchedRangesMap for re-using.

The MatchedRangesMap uses pooling-technique to reduce memory traffic, so calling Reuse() is preferred over creation new instance.

Starts match context walking: when actually render highlightings.

Appends matched text range.

Appends set of matched text ranges.

Forgets (removes) the last of children context-s.
Used by wildcard matchers to re-match part of current context.

Reverses order of children contexts.
Used by backward matchers to restore normal order after completion.

Commits current match context.
Used by compound matchers to commit fully matched context and revert partial matched one.

Closes current context: if autoCommit = true was specified then context automatically committed, otherwise reverted.

Approximate total count of finalized objects.

Due to optimization (see DMRY-4715) we don't store every finalized objects but only limited number of them.

Reference target object's number.

Reference index in the graph.

Calculates a set of objects retained by .

Returns a set of objects retained by sorted ascendant.

Converts tree (presented as reference-to-parent) into graph.

Converts tree (presented as reference-to-parent) into graph.

Calculates hashes for each path to root in the object tree.

Is used by presentation to show icon in case of getting icon by pid is failed

Can return multiple objects if field is a collection of ValueTypes

Return full (with array indices) fieldName for GraphReferenceId

Important! It should be GraphReferenceId from reverse graph TODO: revise this - it is strange that we should care about direct/reverse here

Returns formatted field name for given StaticReference.

Returns formatted field name by and array index. If is true then field name will include exact array indices otherwise just array marker.

Represents a service of model type of the intermediate result of which differs from the type of the final result data. It may also notify a consumer about intermediate result via event. The last result is reported via and events since execution is done.

Type represents the result of service execution. Type represents the final result of service execution.

Represents a service of model which perform something useful and reports intermediate result during execution.

Type represents the result of service execution.

Thread-safe. Workspace scope.

Calculates imprints for all available workspaces.

The returned list might change in runtime as result of call to ReloadImprint.

Forces recalculation for the specific imprint.

Forces recalculation for the specific imprint using provided (already loaded) workspace scope.

This is workaround for DMRY-4568. TODO: Should be removed once we'll have concurrent readonly access to workspaces

Non-thread-safe. Global scope.

Calculates imprint for specified workspace.

Should be called on main thread only.

Calculates imprint for already loaded workspace.

Should be called on main thread only.
This is workaround for DMRY-4568.
TODO: Should be removed once we'll have concurrent readonly access to workspaces

Represents objects were finalized grouped by type. Recommendation: dispose explicitly via IDisposable.

Returns hash which depends on string value only, so it is persistent from run to run.

IMPORTANT! String.GetHashCode() for the same string returns value which might be different in different runs, so it CAN'T be stored.

For implementation details see http://www.cse.yorku.ca/~oz/hash.html

Set of internal (magic) limits and flags.

Array elements as is (without prefixed length). Supported for integral array (byte[], int[], etc) only.

UTF8 text. Supported for string only.

JSON. Supported for object and any array.

BSON (binary JSON). Supported for object and any array.

Returns export formats supported for given object.

Returns suggested object name which can be used for human object identification (e.g. as default file name).

Exports object(s) into given stream with specified format (JSON and BSON only supported).

Represents arbitrary set of objects (presented by ) belong to one memory snapshot.

If parent is null it returns roots of the tree, otherwise children of parent dotMemory.Queries.IsOfTypeGenerator should be less than dotMemory.VsNavigator despite of namespace dotMemory.Queries is greater than namespace dotMemory.

Returns the type name without namespace and with generic arguments (recursively) and arrays postfix.

Returns the type name with namespace, generic arguments (recursively) and arrays postfix.

Returns the type name with namespace, generic arguments placeholders and arrays postfix.

Returns the type name without namespace and with generic arguments (recursively) and arrays postfix.

Returns the type name intended to locate in IDE: with namespace and name but without generic arguments and arrays postfix; for unresolved type returns null.

Returns the method signature with namespace, generic arguments (recursively) and parameter types.

Returns the method signature without namespace but with generic arguments (recursively) and parameter types.

Field id in profiling session scope. Id as it should be. Apis using RawFieldId should eventually be migrated to FieldId.

The generic argument.

Method's generic arguments.

The fictive declared type for `unresolved` runtime type.

Introduced due to DMRY-7320. The IDeclaredRegularType as a base interface looks a bit confusing but this is the simplest way to resolve DMRY-7320 with current usages.

The most relevant name for this type (w/o namespace and any generic or array decorations).
For array: element name.
For declared generic: type parameter name.
For unresolved: formatted pre-defined name.

The most relevant namespace for this type.
For array: element namespace.
For declared generic: empty.
For unresolved: empty.

The most relevant generic arguments for this type.
For array: generics of element.
For runtime type: runtime generics or empty if none.
For declared type: declared generics or empty if none.
For unresolved: empty.

The aggregated collection of array ranks up to the leaf (non-array) element.

The value might be evaluated via traversing by ElementType-s, but due to performance reasons (used in comparison when sorting) it is cached and provided as separate property.

[DEPRECATED] DO NOT USE IMetadataService in the new code, USE IEntityRef<IStreamableMetadata/ISnapshotMetadata> instead.

Creates an optimized map with full knowledge about TypeId internals. The goal is to avoid assumptions about TypeId structure in the outer code.

It implements because it is used in wpf binding and there is a memory leak if class used in binding does not implement Returns an array for optimization purposes

Separate marker interface for unresolved runtime types. We might want to distinguish these types in future, e.g. by occurrence index.

Represents metadata which is continuously appended from streaming.

The streamable metadata should be used via . When entity-ref is resolving the all data available in streaming at the point of request are processed and appended to streamable metadata instance. The returned instance might be alive, i.e. it might be appended (thread-safe) with next portion of metadata while you are using it.

The main idea: access is synchronized by external events.
E.g. if you received 'snapshot done' event and after has requested metadata then it is guaranteed streamable metadata contains all metadata related to given snapshot (and possibly more).
If you received N-th call tree and after has requested metadata then it is guaranteed streamable metadata contains all metadata related to N-th call tree (and possibly more).

Creates an optimized map with full knowledge about TypeId internals. The goal is to avoid assumptions about TypeId structure in the outer code.

Tries to intern given name against internal names table.

Returns field-s metadata by id.

Now fields meta are written into snapshot because used in graph only. This is ok from core point of view. But from DM point - whole meta processing tightly coupled and fields should be processed together with types. So GetField is a part of streamable metadata, but why it is internal? Because in current architecture fields meta is processed (and appended to streamable metadata instance) on ISnapshotMetadata request in snapshot scope, so sync by external events does not work for fields (i.e. we can request streamable metadata after `snapshot done` but might not see fields meta inside).

This method is used by snapshot metadata to access field meta from snapshot scope.

Gets TypeId by RawClassOffset safely: returns TypeId.Unresolved if offset doesn't exist in the map.

Actually, this says about inconsistent in data reported by profiler core and should be investigated. The method might be used as workaround only for cases such as DMRY-8723.

Raw field id obtained from the profiler snapshot. NB: unique only in snapshot scope! Should eventually be migrated to FieldId. Intorduced as a quickfix for DMRY-7202 before the 2019.2 release.

Custom map, optimized for performance with knowledge about internal TypeId structure

Structure for optimized comparison operations between IType and string

The set of extension method to obtain from metadata interfaces. This is a replacement of IEntityKindService which isn't necessary now.

The simplest implementation of IObjectSet which just wraps already calculated collection of object(s).

The simplest implementation of IObjectSetReference which just wraps already calculated collection of object(s).

This class represents common (Items, Size) pair used whenever we need it.

It implements because it is used in wpf binding and there is a memory leak if class used in binding does not implement

Describes the result of grouping objects by heap. Represents a one group.

Returns shortest set to set paths

toSet should be logically reachable from fromSet via direct references! f.ex.: fromSet can be set of root objects

The id of objects set consists of this object, use it whenever you need to use this object as object set

Returns object address in specified snapshot if any.

Sets or remove tag on specified object. The object is identified by its address in particular snapshot.

Method initiates async object tracking over gc-cycles both backward and forward. Task succeeds when both object allocation point and object death point has found.

Subscribes handler for changing of global tags list.

Fired asynchronously. The new handler invoked (synchronously) for each already existed tag.

Binds object to tag.

The changing notification might fire on any thread.

Sets or removes tag on specified object.

In the scope of current snapshot tag applied synchronously but propagation to other snapshots is asynchronous.

Returns tag binder associated with given lifetime.

The Lifetime isn't designed to contain a lot of resources, so we will not use lifetime for each bound object from set. Instead creates binder and then create tag binding for each object.

This collection contains the same snapshot descriptors which are located in .SnapshotDescriptor this collection is only a shortcut for consumers which needs only completely converted snaphsots

Func{IObjectSet, IObjectSetGenerator} is an IObjectSetGenerator provider Represents a factory of IObjectSetGenerator providers. This interface is used by implementation of or its affilates

Type of the property by which is filtering made

Marker interface

Marker interface

Marker interface

Represents a filter can be applied to an object

Returns a matcher for checking if object passed the filter or not

Execution controller Lifetime of the matcher

Checks if an object matches some criterion or not

The number of the object True if matches otherwise false

Generates a set of objects. Objects in set are ordered ascendant.

See DominatedViaPathObjectSetGenerator

See DominatedViaPathByTypeObjectSetGenerator

See AtDominationPathObjectSetGenerator

See AtDominationPathByTypeObjectSetGenerator

Raw allocation statistic stored as StreamableAdjacencyList{Header, Node} by gc number.

Workspaces starting from 2021.3 do not contain irregular nodes, so IsRegular() check is unnecessary. But there are some tests based on pre-saved workspaces to support them we still need this method. >

Returns set of frozen tree refs. 'Frozen' means 'do not include live updates'.

Fetches the whole tree from storage into memory.

IMPORTANT! Use to check node ptr validity, this method take in account possible incomplete insertions due to live updates.

Streaming mode - eighter `Realtime` or `Persisted`.

The streaming mode might change in runtime from `Realtime` to `Persisted` but not vise versa.

Streaming start date-time.

Subscribes for streaming index update.

On subscribe listener will be initially called for all entries already written to streaming.
Be aware, listener might be called in different threads.

Called for each index entry appeared in the streaming index.

Called when no entry appeared in some interval of time.

Called when streaming has finished.

It is guaranteed that OnFinish is called when all index entries already passed to OnNextIndexEntry callback.

Applicable only for , ignored in case of

Injector modifier which provide access to specified object from each snapshot scope. Should be used instead of direct creation via ISnapshotScope.

MUST BE used from main (UI) thread only.

Calculates estimated snapshot summary quickly. Used in WorkspaceImprintProvider which operates on main thread due to architecture limitations.

Due to DMRY-8591 it doesn't use cached values even they are existed, but always return just estimation.

JetImmutableArray<GraphRoot> - unique asc-ordered GraphRoot-s
DiskArray<GraphRoot> - the same on-disk
JetImmutableArray<ObjectNumber> - unique asc-ordered by number root objects
DiskArray<ObjectNumber> - the same on-disk
JetAdjacencyList<GraphRoot> - GraphRoot-s per each object in snapshot
DiskAdjacencyList<GraphRoot> - the same on-disk

The index in array corresponded to after-gc statistics.

GC start time (just an alias of Timestamp).

GC finish time (Timestamp + DurationMs).

The consumer-side of timeline (realtime) inspections.

Subscribes for handling each detected issue.

On subscribe handler will be initially called for all already detected issues and then for each issue detected in realtime.
Be aware, handler might be called in different threads, but handlers aren't concurrent (executed just one in a moment).

Timeline updates provider.

Updates are sent as envelopes. The next envelope is sent only when previous one is opened. This technique prevent pipeline invalidation by next update while previous one isn't really processed.

The updates might be fired on arbitrary thread.

Update envelope - special update wrapper which prevent pipeline invalidation by next update while previous one isn't really processed.

Whether final update or not?

Final means (1) profiling session is finished and (2) all streaming data have been read.

Opens update envelope and returns timeline state at current point of time.

IMPORTANT. Timeline might stays freezed till returned state is disposed, so caller should dispose it as fast as possible. The Dispose() MUST BE called on the same thread as Open() was called.

The consequent Open() on the same envelope instance should return the same state.

The realtime memory statistics.

BE AWARE: due to memory-consumption optimizations the values might be approximated. See / methods.

Packs long-value to approximate uint-value.
If greater than 2GB it stored as rounded number of mega bytes.

Unpacks uint-value to approximate original long-value.

IMPORTANT! The -s must be appended in ascending order of its DfsNumber.Enter.

IMPORTANT! The must be asc-ordered by 'MethodId, DfsNumber.Enter'.

IMPORTANT! The must be asc-ordered by 'Enter' and must not include nested dfs-numbers.

IMPORTANT! The must be asc-ordered by 'DfsNumber'.

Either , or , or .

IMPORTANT! The must be asc-ordered by 'TypeId, MethodId, DfsNumber.Enter'.

Generally unavailable for whole workspace (e.g. imported dump).

No data available (i.e. no allocations on given interval).

Only statistical data available: objects count per class provided by ICorProfilerCallback.ObjectsAllocatedByClass() without stacktrace.

This is default fallback mode for MacOS/Linux where sampling not yet supported.

The sampled data available: approx. allocated bytes per class with stacktrace captured for sampled instances.

This is default mode for Windows.

The mix of None + Traced (backward compatibility).

The traced data available: exact allocated bytes per class with stacktrace captured for each instance.

Calculates allocations data availability on the given gc range.

If range contains mixed data + then availability returned;
if + then returned;
if + then returned (it possible for workspaces created before 2021.3).
The + mix not supported the exception thrown.

The merged raw allocation statistic.

Aggregates allocation statistics per-call and per-type for given gc-range.

Related stuff:
* AllocationStatisticPreMerger
* MergedAllocationsTupleResolver

IMPORTANT! The must be asc-ordered by 'DfsNumber.Enter'.

The merged call tree with raw-to-merged node ptr-s mapping.

The merged tree exists in two hypostasis: live () and fixed for given gc-range ().

The live hypostasis represents frozen tree state at the moment of request via . It CAN NOT be appended while unreleased instances are exist - new requests will be blocked. So client-code should release live MergedCallTree instance as soon as possible to prevent long-term locking. When live call tree appended the all previous call-pointers are guaranteed to stay valid but NextSibling, FirstChild and DfsNumber of previous nodes might change.

The fixed hypostasis represents immutable state copied from live tree at the moment of request. Such tree stays immutable for given gc-range. Normally the fixed tree should be used in consumer code.

Related stuff:
* AllocationStatisticPreMerger
* MergedAllocationsTupleResolver

Pre-merged blocks of allocation statistic.

Due to performance reason allocation statistics on session-level aggregated (per-call and per-type) in blocks containing 256 GC cycles. The statistics for any given gc-range utilizes such blocks to speed-up calculations.

Related stuff:
* AllocationStatisticPreMerger
* MergedAllocationsTupleResolver

Represents the result of grouping objects by class.

The wrapper for bound to Ui-state folder (see ).

Returns the list of files with information about lost profiling session which could be recovered.

If true, the returned collection contains only one file, corresponding to the "current" workspace. Returns empty collection if there are no corresponding recoverables found.

Whether workspace will be saved or not.
Normally, the empty (containing no one profiling session) or postponed but non-confirmed workspaces should not be saved.

Sets output directory. Unique file name will be auto-generated. Throws if output file/directory already set.

The output file/directory must be set before first profiling session added.

Sets output file. Throws if output file/directory already set.

The output file/directory must be set before first profiling session added.

Sets the mode of the saving a workspace, see for details

Creates directory structure for new profiling session inside current workspace. Supports concurrent call.

profiling session identifier

Creates directory structure for new profiling session inside current workspace. Supports concurrent call.

Updates profiling session information. Supports concurrent call.

Creates directory structure for new snapshot inside given profiling session. Supports concurrent call.

snapshot index file path

Sets snapshot name.

Confirms snapshot completely ready and can be included into workspace.

Saves workspace index file and returns path to workspace packed file.

There are several calls to Build is possible on the same instance. Subsequent call overwrites result of previous one. The previously built workspace might be lost if last Build fail. path to workspace file

Gets workspace root folder where located added workspace files.

Save a workspace after profiling session is finished

Save a workspace after profiling session is finished if it contains at least one snapshot

Save a workspace if user sent a special message during the profiling session

Creates directory for a new workspace

Creates temporary directory in the same place where workspaces are stored

Validates workspaces directory availability, returns true if workspaces directory is write-accessible and false otherwise.

If workspaces directory doesn't exist it will be created (if possible).

Detects workspace format, reads and places it it to the directory where all dotMemory workspaces are placed.

If format is not recognized then UnsupportedFormatException is thrown.

If workspace has incompatible version then VersionMismatchException is thrown.

Returns the full path to the imported workspace index file.

Validates workspaces directory availability, returns true if workspaces directory is write-accessible and false otherwise.

If workspaces directory doesn't exist it will be created.

Trims workspace name if it too long and normalizes it to prevent some undesirable behavior on possible following export (see DMRY-8165).

Writes data from sourceFolder to workspace archive.

Source folder must contain data organized according to WorkspaceStructure. archive file path null if format is not supported

Reads data and puts it to given folder according to .

Summary info about workspace with additional index of profilling sessions and snapshots.

Profiling sessions contained in workspace.

Deserializes header part of workspace index.

Deserializes full workspace index.

Summary info about workspace.

Workspace version. See

Name of product which created workspace.

Version of product which created workspace.

Workspace name.

Workspace creation time.

Workspace's content signature.

Content signature is an arbitrary string value uniquely identifies content of the workspace.
For different content signature MUST BE different, for the same content signature SHOULD BE equal.

Workspace source: .

Unique profiling session identifier.

Name of profiled process.

Command line of profiled process.

Id of profiled process.

Relative (against this profiling session's folder) path to the streaming storage file.

Snapshots contained in the profiling session.

Unique snapshot identifier.

Zero-base snapshot index inside profiling session.

Optional, user assigned snapshot name.

Gets or sets the value indicating this Item has been converted and exported into new Home/AppBrowser

Folder containing essential data gathered during profiling.

Used during backward compatibility conversion only.

Folder where "core" stores its raw, temp, and diagnostics data during profiling session.

Folder containing snapshot related files.

Folder containing realtime chart data in old (pre-streaming) format.

Workspace level cache folder. E.g. <workspace-root>/State/Cache.v191

Profiling session level cache folder. E.g. <workspace-root>/State/Cache.v191/session#<id>

Snapshot level cache folder. E.g. <workspace-root>/State/Cache.v191/session#<id>/snapshot#<id>

Snapshot level cache folder. E.g. <workspace-root>/State/Cache.v191/session#<id>/#<snapshot-id-a>+#<snapshot-id-b>

Object set level cache folder. E.g. <workspace-root>/State/Cache.v191/session#<id>/snapshot#<id>/set#<id>

This folder will be deleted automatically when all tabs which shares specified object set are closed.

Gc-range level cache folder. E.g. <workspace-root>/State/Cache.v191/session#<id>/<gc-range>

Workspace root folder.

Folder containing data evaluated during analysis - caches, UI settings, etc.

This folder might be safely deleted by user - dotMemory just reset to initial analysis state.

Workspace level per probing (analysis tab) ui-state folder. E.g. <workspace-root>/State/Ui.v193/A#<probing-id>
Introduced since v193.

Profiling session level ui-state folder. E.g. <workspace-root>/State/Ui.v193/A#<probing-id>/<session-id>

Snapshot level ui-state folder. E.g. <workspace-root>/State/Ui.v193/A#<probing-id>/<session-id>/<snapshot-id>

Snapshot level ui-state folder. E.g. <workspace-root>/State/Ui.v193/A#<probing-id>/<session-id>/<snapshot-id>

Object set level ui-state folder. E.g. <workspace-root>/State/Ui.v193/A#<probing-id>/<session-id>/<snapshot-id>/<set-id>

This folder will be deleted automatically when all tabs which shares specified object set are closed.

Gc-range level ui-state folder. E.g. <workspace-root>/State/Ui.v193/A#<probing-id>/<session-id>/<gc-range>

Describes origin of workspace.

Workspace source is unknown.

Workspace created from dotMemory profiler itself.

Workspace created from CLR dump.

Workspace created from Java (.hprof) dump.

When dotMemory encounters a workspace with an incompatible **older** version it tries to get additional instructions from our website. available by the following URL: https://www.jetbrains.com/config/dotmemory.json This file contains a so-called "compatibility map" - set of version ranges and links to the latest dotMemory portables capable of opening this workspace version. If there is a matching entry, dotMemory will download the corresponding portable and ask it to open the incompatible workspace. The actual version of the map is placed at "Config\dotMemory.json" relative path. To promote dotMemory workspace version produced by the current dotMemory version perform this steps. 1. Set to current dotMemory version e.g. 251 or 268. 2. If backward compatibility is also broken by these changes, set to the same value. 3. Add corresponding record to the table in "Config\readme.md" with the detailed explanation which change leaded to breaking of compatibility 4. Add corresponding record to the "Config\dotMemory.json" file. Use URLs from these pages https://www.jetbrains.com/dotmemory/download/#section=portable https://www.jetbrains.com/dotmemory/download/other.html 5. Create a ticket in the YouTrack. Look at this ticked as an real life example https://youtrack.jetbrains.com/issue/JS-19947 6. After the new compatibility map is placed, retest behaviour. !!! DON'T forget to update "Config\readme.md" file on any changes of this class. !!!