diff --git a/java/debugger/impl/src/com/intellij/debugger/engine/JavaValue.java b/java/debugger/impl/src/com/intellij/debugger/engine/JavaValue.java index 27f87c1d7b0d..0898d3a70df2 100644 --- a/java/debugger/impl/src/com/intellij/debugger/engine/JavaValue.java +++ b/java/debugger/impl/src/com/intellij/debugger/engine/JavaValue.java @@ -516,7 +516,7 @@ public class JavaValue extends XNamedValue implements NodeDescriptorProvider, XV public XValue getReferringObjectsValue() { ReferringObjectsProvider provider = ReferringObjectsProvider.BASIC_JDI; - if (MemoryAgent.capabilities(getEvaluationContext().getDebugProcess()).canGetReferringObjects()) { + if (MemoryAgent.get(getEvaluationContext().getDebugProcess()).capabilities().canGetReferringObjects()) { provider = new MemoryAgentReferringObjectsProvider(MemoryAgent.DEFAULT_GC_ROOTS_OBJECTS_LIMIT); } return new JavaReferringObjectsValue(JavaValue.this, provider, null); diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/action/CalculateRetainedSizeAction.java b/java/debugger/impl/src/com/intellij/debugger/memory/action/CalculateRetainedSizeAction.java index 79cd544b49f6..bcf26a70622f 100644 --- a/java/debugger/impl/src/com/intellij/debugger/memory/action/CalculateRetainedSizeAction.java +++ b/java/debugger/impl/src/com/intellij/debugger/memory/action/CalculateRetainedSizeAction.java @@ -2,6 +2,7 @@ package com.intellij.debugger.memory.action; import com.intellij.debugger.engine.evaluation.EvaluateException; +import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; import com.intellij.debugger.memory.agent.MemoryAgent; import com.intellij.debugger.memory.agent.MemoryAgentCapabilities; import com.intellij.openapi.application.ApplicationManager; @@ -13,10 +14,11 @@ import org.jetbrains.annotations.NotNull; public class CalculateRetainedSizeAction extends MemoryAgentActionBase { @Override - protected void perform(@NotNull MemoryAgent memoryAgent, + protected void perform(@NotNull EvaluationContextImpl evaluationContext, @NotNull ObjectReference reference, @NotNull XValueNodeImpl node) throws EvaluateException { - long size = memoryAgent.estimateObjectSize(reference); + MemoryAgent memoryAgent = MemoryAgent.get(evaluationContext.getDebugProcess()); + long size = memoryAgent.estimateObjectSize(evaluationContext, reference); ApplicationManager.getApplication().invokeLater( () -> new MessageDialog(node.getTree().getProject(), String.valueOf(size), "Size of the Object", ArrayUtil.EMPTY_STRING_ARRAY, 0, null, false) diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/action/MemoryAgentActionBase.java b/java/debugger/impl/src/com/intellij/debugger/memory/action/MemoryAgentActionBase.java index ebf7f75d1c14..446a9ef6837f 100644 --- a/java/debugger/impl/src/com/intellij/debugger/memory/action/MemoryAgentActionBase.java +++ b/java/debugger/impl/src/com/intellij/debugger/memory/action/MemoryAgentActionBase.java @@ -3,8 +3,10 @@ package com.intellij.debugger.memory.action; import com.intellij.debugger.engine.DebugProcessImpl; import com.intellij.debugger.engine.JavaDebugProcess; +import com.intellij.debugger.engine.SuspendContextImpl; import com.intellij.debugger.engine.evaluation.EvaluateException; -import com.intellij.debugger.engine.managerThread.DebuggerCommand; +import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; +import com.intellij.debugger.engine.events.SuspendContextCommandImpl; import com.intellij.debugger.memory.agent.MemoryAgent; import com.intellij.debugger.memory.agent.MemoryAgentCapabilities; import com.intellij.notification.NotificationType; @@ -25,16 +27,17 @@ public abstract class MemoryAgentActionBase extends DebuggerTreeAction { DebugProcessImpl debugProcess = JavaDebugProcess.getCurrentDebugProcess(project); ObjectReference reference = getObjectReference(node); if (debugProcess == null || reference == null) return; - debugProcess.getManagerThread().invokeCommand(new DebuggerCommand() { + SuspendContextImpl suspendContext = debugProcess.getSuspendManager().getPausedContext(); + debugProcess.getManagerThread().schedule(new SuspendContextCommandImpl(suspendContext) { @Override - public void action() { - MemoryAgent memoryAgent = MemoryAgent.using(debugProcess); - if (memoryAgent == null) { + public void contextAction(@NotNull SuspendContextImpl suspendContext) { + EvaluationContextImpl evaluationContext = suspendContext.getEvaluationContext(); + if (evaluationContext == null) { LOG.error("Evaluation impossible"); return; } try { - perform(memoryAgent, reference, node); + perform(evaluationContext, reference, node); } catch (EvaluateException ex) { XDebuggerManagerImpl.NOTIFICATION_GROUP.createNotification("Action failed", NotificationType.ERROR); @@ -52,19 +55,19 @@ public abstract class MemoryAgentActionBase extends DebuggerTreeAction { protected boolean isEnabled(@NotNull XValueNodeImpl node, @NotNull AnActionEvent e) { if (!super.isEnabled(node, e)) return false; DebugProcessImpl debugProcess = JavaDebugProcess.getCurrentDebugProcess(node.getTree().getProject()); - if (debugProcess == null || !MemoryAgent.capabilities(debugProcess).isLoaded()) { + if (debugProcess == null || debugProcess.isEvaluationPossible() || !MemoryAgent.get(debugProcess).capabilities().isLoaded()) { e.getPresentation().setVisible(false); return false; } ObjectReference reference = getObjectReference(node); - return reference != null && isEnabled(MemoryAgent.capabilities(debugProcess)); + return reference != null && isEnabled(MemoryAgent.get(debugProcess).capabilities()); } protected abstract boolean isEnabled(@NotNull MemoryAgentCapabilities agentCapabilities); - protected abstract void perform(@NotNull MemoryAgent agent, + protected abstract void perform(@NotNull EvaluationContextImpl evaluationContext, @NotNull ObjectReference reference, @NotNull XValueNodeImpl node) throws EvaluateException; } diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgent.java b/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgent.java index 36310441ff72..8cf21f86c486 100644 --- a/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgent.java +++ b/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgent.java @@ -2,12 +2,11 @@ package com.intellij.debugger.memory.agent; import com.intellij.debugger.engine.DebugProcessImpl; -import com.intellij.debugger.engine.DebuggerManagerThreadImpl; import com.intellij.debugger.engine.evaluation.EvaluateException; import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; +import com.intellij.debugger.settings.DebuggerSettings; import com.sun.jdi.ObjectReference; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import java.util.List; @@ -18,29 +17,21 @@ public interface MemoryAgent { int DEFAULT_GC_ROOTS_OBJECTS_LIMIT = 1000; @NotNull - static MemoryAgentCapabilities capabilities(@NotNull DebugProcessImpl debugProcess) { - return MemoryAgentCapabilities.get(debugProcess); - } + static MemoryAgent get(@NotNull DebugProcessImpl debugProcess) { + if (!DebuggerSettings.getInstance().ENABLE_MEMORY_AGENT) return MemoryAgentImpl.DISABLED; - @NotNull - static MemoryAgent using(@NotNull EvaluationContextImpl evaluationContext) { - DebuggerManagerThreadImpl.assertIsManagerThread(); - return new MemoryAgentImpl(evaluationContext); - } - - @Nullable - static MemoryAgent using(@NotNull DebugProcessImpl debugProcess) { - EvaluationContextImpl context = debugProcess.getDebuggerContext().createEvaluationContext(); - return context != null ? using(context) : null; + return MemoryAgentOperations.getAgent(debugProcess); } @NotNull MemoryAgentCapabilities capabilities(); - long estimateObjectSize(@NotNull ObjectReference reference) throws EvaluateException; + long estimateObjectSize(@NotNull EvaluationContextImpl evaluationContext, @NotNull ObjectReference reference) throws EvaluateException; - long[] estimateObjectsSizes(@NotNull List references) throws EvaluateException; + long[] estimateObjectsSizes(@NotNull EvaluationContextImpl evaluationContext, @NotNull List references) + throws EvaluateException; @NotNull - ReferringObjectsInfo findReferringObjects(@NotNull ObjectReference reference, int limit) throws EvaluateException; + ReferringObjectsInfo findReferringObjects(@NotNull EvaluationContextImpl evaluationContext, @NotNull ObjectReference reference, int limit) + throws EvaluateException; } diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentCapabilities.java b/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentCapabilities.java index 6469f0085a33..a02e527238cf 100644 --- a/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentCapabilities.java +++ b/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentCapabilities.java @@ -1,9 +1,6 @@ // Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. package com.intellij.debugger.memory.agent; -import com.intellij.debugger.engine.DebugProcessImpl; -import com.intellij.debugger.settings.DebuggerSettings; -import com.intellij.openapi.util.Key; import org.jetbrains.annotations.NotNull; import java.util.Collections; @@ -11,8 +8,7 @@ import java.util.EnumSet; import java.util.Set; public class MemoryAgentCapabilities { - private static final Key MEMORY_AGENT_CAPABILITIES_KEY = Key.create("MEMORY_AGENT_CAPABILITIES_KEY"); - public static final MemoryAgentCapabilities DISABLED = new MemoryAgentCapabilities(false, Collections.emptySet()); + static final MemoryAgentCapabilities DISABLED = new MemoryAgentCapabilities(false, Collections.emptySet()); private final boolean myIsLoaded; private final Set myCapabilities; @@ -23,17 +19,6 @@ public class MemoryAgentCapabilities { myCapabilities.addAll(capabilitySet); } - @NotNull - static MemoryAgentCapabilities get(@NotNull DebugProcessImpl debugProcess) { - if (!DebuggerSettings.getInstance().ENABLE_MEMORY_AGENT) return DISABLED; - MemoryAgentCapabilities capabilities = debugProcess.getUserData(MEMORY_AGENT_CAPABILITIES_KEY); - return capabilities != null ? capabilities : DISABLED; - } - - static void set(@NotNull DebugProcessImpl debugProcess, MemoryAgentCapabilities capabilities) { - debugProcess.putUserData(MEMORY_AGENT_CAPABILITIES_KEY, capabilities); - } - public boolean isLoaded() { return myIsLoaded; } diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentImpl.java b/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentImpl.java index 7d1b4a8af9d4..ddfaee7167ef 100644 --- a/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentImpl.java +++ b/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentImpl.java @@ -9,31 +9,47 @@ import org.jetbrains.annotations.NotNull; import java.util.List; class MemoryAgentImpl implements MemoryAgent { - private final EvaluationContextImpl myEvaluationContext; + static final MemoryAgent DISABLED = new MemoryAgentImpl(MemoryAgentCapabilities.DISABLED); + private final MemoryAgentCapabilities myCapabilities; - MemoryAgentImpl(@NotNull EvaluationContextImpl evaluationContext) { - myEvaluationContext = evaluationContext; + MemoryAgentImpl(@NotNull MemoryAgentCapabilities capabilities) { + myCapabilities = capabilities; } @Override - public long estimateObjectSize(@NotNull ObjectReference reference) throws EvaluateException { - return MemoryAgentOperations.estimateObjectSize(myEvaluationContext, reference); + public long estimateObjectSize(@NotNull EvaluationContextImpl evaluationContext, @NotNull ObjectReference reference) + throws EvaluateException { + if (!myCapabilities.canEstimateObjectSize()) { + throw new UnsupportedOperationException("Memory agent can't estimate object size"); + } + return MemoryAgentOperations.estimateObjectSize(evaluationContext, reference); } @Override - public long[] estimateObjectsSizes(@NotNull List references) throws EvaluateException { - return MemoryAgentOperations.estimateObjectsSizes(myEvaluationContext, references); + public long[] estimateObjectsSizes(@NotNull EvaluationContextImpl evaluationContext, @NotNull List references) + throws EvaluateException { + if (!myCapabilities.canEstimateObjectsSizes()) { + throw new UnsupportedOperationException("Memory agent can't estimate objects sizes"); + } + + return MemoryAgentOperations.estimateObjectsSizes(evaluationContext, references); } @NotNull @Override - public ReferringObjectsInfo findReferringObjects(@NotNull ObjectReference reference, int limit) throws EvaluateException { - return MemoryAgentOperations.findReferringObjects(myEvaluationContext, reference, limit); + public ReferringObjectsInfo findReferringObjects(@NotNull EvaluationContextImpl evaluationContext, + @NotNull ObjectReference reference, + int limit) throws EvaluateException { + if (!myCapabilities.canGetReferringObjects()) { + throw new UnsupportedOperationException("Memory agent can't provide referring objects"); + } + + return MemoryAgentOperations.findReferringObjects(evaluationContext, reference, limit); } @NotNull @Override public MemoryAgentCapabilities capabilities() { - return MemoryAgent.capabilities(myEvaluationContext.getDebugProcess()); + return myCapabilities; } } diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentNames.java b/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentNames.java index 0ad64cfc0605..3fdf95fa4d71 100644 --- a/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentNames.java +++ b/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentNames.java @@ -9,7 +9,7 @@ interface MemoryAgentNames { String CAN_FIND_GC_ROOTS = "canFindGcRoots"; String CAN_ESTIMATE_OBJECT_SIZE = "canEstimateObjectSize"; - String CAN_ESTIMATE_OBJECTS_SIZES = "canEstimateObjectSize"; + String CAN_ESTIMATE_OBJECTS_SIZES = "canEstimateObjectsSizes"; String ESTIMATE_OBJECT_SIZE = "size"; String ESTIMATE_OBJECTS_SIZE = "estimateRetainedSize"; diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentOperations.java b/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentOperations.java index ad351f51fa06..1fd4a8f581d1 100644 --- a/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentOperations.java +++ b/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentOperations.java @@ -13,6 +13,7 @@ import com.intellij.debugger.memory.agent.parsers.GcRootsPathsParser; import com.intellij.debugger.memory.agent.parsers.LongArrayParser; import com.intellij.debugger.memory.agent.parsers.LongValueParser; import com.intellij.openapi.diagnostic.Logger; +import com.intellij.openapi.util.Key; import com.sun.jdi.*; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -22,14 +23,11 @@ import java.util.Collections; import java.util.List; class MemoryAgentOperations { + private static final Key MEMORY_AGENT_KEY = Key.create("MEMORY_AGENT_KEY"); private static final Logger LOG = Logger.getInstance(MemoryAgentOperations.class); static long estimateObjectSize(@NotNull EvaluationContextImpl evaluationContext, @NotNull ObjectReference reference) throws EvaluateException { - if (!capabilities(evaluationContext).canEstimateObjectSize()) { - throw new UnsupportedOperationException("Memory agent can't estimate object size"); - } - Value result = callMethod(evaluationContext, MemoryAgentNames.Methods.ESTIMATE_OBJECT_SIZE, Collections.singletonList(reference)); return LongValueParser.INSTANCE.parse(result); } @@ -37,10 +35,6 @@ class MemoryAgentOperations { @NotNull static long[] estimateObjectsSizes(@NotNull EvaluationContextImpl evaluationContext, @NotNull List references) throws EvaluateException { - if (!capabilities(evaluationContext).canEstimateObjectsSizes()) { - throw new UnsupportedOperationException("Memory agent can't estimate objects sizes"); - } - ArrayReference array = wrapWithArray(evaluationContext, references); Value result = callMethod(evaluationContext, MemoryAgentNames.Methods.ESTIMATE_OBJECTS_SIZE, Collections.singletonList(array)); return LongArrayParser.INSTANCE.parse(result).stream().mapToLong(Long::longValue).toArray(); @@ -49,40 +43,42 @@ class MemoryAgentOperations { @NotNull static ReferringObjectsInfo findReferringObjects(@NotNull EvaluationContextImpl evaluationContext, @NotNull ObjectReference reference, int limit) throws EvaluateException { - if (!capabilities(evaluationContext).canGetReferringObjects()) { - throw new UnsupportedOperationException("Memory agent can't provide referring objects"); - } - IntegerValue limitValue = evaluationContext.getDebugProcess().getVirtualMachineProxy().mirrorOf(limit); Value value = callMethod(evaluationContext, MemoryAgentNames.Methods.FIND_GC_ROOTS, Arrays.asList(reference, limitValue)); return GcRootsPathsParser.INSTANCE.parse(value); } - static void initializeCapabilities(@NotNull EvaluationContextImpl context) { + @NotNull + static MemoryAgent getAgent(@NotNull DebugProcessImpl debugProcess) { + MemoryAgent agent = debugProcess.getUserData(MEMORY_AGENT_KEY); + return agent == null ? MemoryAgentImpl.DISABLED : agent; + } + + static void initializeAgent(@NotNull EvaluationContextImpl context) { DebuggerManagerThreadImpl.assertIsManagerThread(); + MemoryAgent agent = MemoryAgentImpl.DISABLED; try { - initialize(context); + agent = new MemoryAgentImpl(initializeCapabilities(context)); } catch (EvaluateException e) { LOG.error("Could not initialize memory agent. ", e); - MemoryAgentCapabilities.set(context.getDebugProcess(), MemoryAgentCapabilities.DISABLED); } + context.getDebugProcess().putUserData(MEMORY_AGENT_KEY, agent); } - private static void initialize(@NotNull EvaluationContextImpl context) throws EvaluateException { + private static MemoryAgentCapabilities initializeCapabilities(@NotNull EvaluationContextImpl context) throws EvaluateException { ClassType proxyType = getProxyType(context); boolean isAgentLoaded = checkAgentCapability(context, proxyType, MemoryAgentNames.Methods.IS_LOADED); if (!isAgentLoaded) { - MemoryAgentCapabilities.set(context.getDebugProcess(), MemoryAgentCapabilities.DISABLED); + return MemoryAgentCapabilities.DISABLED; } else { MemoryAgentCapabilities.Builder builder = new MemoryAgentCapabilities.Builder(); - MemoryAgentCapabilities capabilities = builder + return builder .setCanEstimateObjectSize(checkAgentCapability(context, proxyType, MemoryAgentNames.Methods.CAN_ESTIMATE_OBJECT_SIZE)) .setCanEstimateObjectsSizes(checkAgentCapability(context, proxyType, MemoryAgentNames.Methods.CAN_ESTIMATE_OBJECTS_SIZES)) .setCanFindGcRoots(checkAgentCapability(context, proxyType, MemoryAgentNames.Methods.CAN_FIND_GC_ROOTS)) .buildLoaded(); - MemoryAgentCapabilities.set(context.getDebugProcess(), capabilities); } } @@ -196,8 +192,4 @@ class MemoryAgentOperations { LOG.info("Wrapping values with array took " + (System.currentTimeMillis() - start) + " ms"); return instancesArray; } - - private static MemoryAgentCapabilities capabilities(@NotNull EvaluationContextImpl evaluationContext) { - return MemoryAgent.capabilities(evaluationContext.getDebugProcess()); - } } diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentReferringObjectsProvider.java b/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentReferringObjectsProvider.java index fc16e0c0ce26..485d560c6ade 100644 --- a/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentReferringObjectsProvider.java +++ b/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentReferringObjectsProvider.java @@ -35,12 +35,12 @@ public class MemoryAgentReferringObjectsProvider implements ReferringObjectsProv } } - MemoryAgent memoryAgent = MemoryAgent.using(evaluationContext); + MemoryAgent memoryAgent = MemoryAgent.get(evaluationContext.getDebugProcess()); if (memoryAgent.capabilities().canGetReferringObjects()) { throw new UnsupportedOperationException(); } - ReferringObjectsInfo roots = memoryAgent.findReferringObjects(value, myObjectsToRequestLimit); + ReferringObjectsInfo roots = memoryAgent.findReferringObjects(evaluationContext, value, myObjectsToRequestLimit); myCachedRequests.put(value, roots); return roots.getReferringObjects(value, limit); } diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentUtil.java b/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentUtil.java index fbcf6eba8383..2c39a1f40480 100644 --- a/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentUtil.java +++ b/java/debugger/impl/src/com/intellij/debugger/memory/agent/MemoryAgentUtil.java @@ -42,7 +42,6 @@ import com.intellij.util.containers.ContainerUtil; import one.util.streamex.IntStreamEx; import one.util.streamex.StreamEx; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.jetbrains.jps.model.java.JdkVersionDetector; import javax.swing.event.HyperlinkEvent; @@ -70,6 +69,11 @@ public class MemoryAgentUtil { return; } + //if(isOsSupported()) { + // LOG.info(SystemInfo.); + // + //} + if (isIbmJdk(parameters)) { LOG.info("Do not attach memory agent for IBM jdk"); return; @@ -119,14 +123,17 @@ public class MemoryAgentUtil { listenIfStartupFailed(); } - public static List tryCalculateSizes(@NotNull List objects, @Nullable MemoryAgent agent) { - if (agent == null || !agent.capabilities().canEstimateObjectsSizes()) return objects; + @NotNull + public static List tryCalculateSizes(@NotNull EvaluationContextImpl context, + @NotNull List objects) { + MemoryAgent agent = MemoryAgent.get(context.getDebugProcess()); + if (!agent.capabilities().canEstimateObjectsSizes()) return objects; if (objects.size() > ESTIMATE_OBJECTS_SIZE_LIMIT) { LOG.info("Too many objects to estimate their sizes"); return objects; } try { - long[] sizes = agent.estimateObjectsSizes(ContainerUtil.map(objects, x -> x.getObjectReference())); + long[] sizes = agent.estimateObjectsSizes(context, ContainerUtil.map(objects, x -> x.getObjectReference())); return IntStreamEx.range(0, objects.size()) .mapToObj(i -> new SizedReferenceInfo(objects.get(i).getObjectReference(), sizes[i])) .reverseSorted(Comparator.comparing(x -> x.size())) @@ -151,7 +158,7 @@ public class MemoryAgentUtil { if (context.isEvaluationPossible()) { if (isInitialized.compareAndSet(false, true)) { debugProcess.removeDebugProcessListener(this); - MemoryAgentOperations.initializeCapabilities(context); + MemoryAgentOperations.initializeAgent(context); } } } diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/ui/InstancesView.java b/java/debugger/impl/src/com/intellij/debugger/memory/ui/InstancesView.java index 655c58cb4627..0d211aabe9a4 100644 --- a/java/debugger/impl/src/com/intellij/debugger/memory/ui/InstancesView.java +++ b/java/debugger/impl/src/com/intellij/debugger/memory/ui/InstancesView.java @@ -195,7 +195,7 @@ class InstancesView extends InstancesViewBase { } if (Registry.is("debugger.memory.agent.use.in.memory.view")) { - instances = MemoryAgentUtil.tryCalculateSizes(instances, MemoryAgent.using(evaluationContext)); + instances = MemoryAgentUtil.tryCalculateSizes(evaluationContext, instances); } synchronized (myFilteringTaskLock) { diff --git a/java/debugger/impl/src/com/intellij/debugger/settings/DebuggerSettings.java b/java/debugger/impl/src/com/intellij/debugger/settings/DebuggerSettings.java index 3624b2a859b2..6317fb10f443 100644 --- a/java/debugger/impl/src/com/intellij/debugger/settings/DebuggerSettings.java +++ b/java/debugger/impl/src/com/intellij/debugger/settings/DebuggerSettings.java @@ -65,7 +65,7 @@ public class DebuggerSettings implements Cloneable, PersistentStateComponent