| /* |
| * Copyright (C) 2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.ahat; |
| |
| import com.android.tools.perflib.heap.ClassObj; |
| import com.android.tools.perflib.heap.Heap; |
| import com.android.tools.perflib.heap.Instance; |
| import com.android.tools.perflib.heap.RootObj; |
| import com.android.tools.perflib.heap.RootType; |
| import com.android.tools.perflib.heap.Snapshot; |
| import com.android.tools.perflib.heap.StackFrame; |
| import com.android.tools.perflib.heap.StackTrace; |
| import com.android.tools.perflib.captures.MemoryMappedFileBuffer; |
| import com.google.common.collect.Lists; |
| import gnu.trove.TObjectProcedure; |
| import java.io.File; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| |
| /** |
| * A wrapper over the perflib snapshot that provides the behavior we use in |
| * ahat. |
| */ |
| class AhatSnapshot { |
| private final Snapshot mSnapshot; |
| private final List<Heap> mHeaps; |
| |
| // Map from Instance to the list of Instances it immediately dominates. |
| private final Map<Instance, List<Instance>> mDominated |
| = new HashMap<Instance, List<Instance>>(); |
| |
| // Collection of objects whose immediate dominator is the SENTINEL_ROOT. |
| private final List<Instance> mRooted = new ArrayList<Instance>(); |
| |
| // Map from roots to their types. |
| // Instances are only included if they are roots, and the collection of root |
| // types is guaranteed to be non-empty. |
| private final Map<Instance, Collection<RootType>> mRoots |
| = new HashMap<Instance, Collection<RootType>>(); |
| |
| private final Site mRootSite = new Site("ROOT"); |
| private final Map<Heap, Long> mHeapSizes = new HashMap<Heap, Long>(); |
| |
| private final List<InstanceUtils.NativeAllocation> mNativeAllocations |
| = new ArrayList<InstanceUtils.NativeAllocation>(); |
| |
| /** |
| * Create an AhatSnapshot from an hprof file. |
| */ |
| public static AhatSnapshot fromHprof(File hprof) throws IOException { |
| Snapshot snapshot = Snapshot.createSnapshot(new MemoryMappedFileBuffer(hprof)); |
| snapshot.computeDominators(); |
| return new AhatSnapshot(snapshot); |
| } |
| |
| /** |
| * Construct an AhatSnapshot for the given perflib snapshot. |
| * Ther user is responsible for calling snapshot.computeDominators before |
| * calling this AhatSnapshot constructor. |
| */ |
| private AhatSnapshot(Snapshot snapshot) { |
| mSnapshot = snapshot; |
| mHeaps = new ArrayList<Heap>(mSnapshot.getHeaps()); |
| |
| ClassObj javaLangClass = mSnapshot.findClass("java.lang.Class"); |
| for (Heap heap : mHeaps) { |
| // Use a single element array for the total to act as a reference to a |
| // long. |
| final long[] total = new long[]{0}; |
| TObjectProcedure<Instance> processInstance = new TObjectProcedure<Instance>() { |
| @Override |
| public boolean execute(Instance inst) { |
| Instance dominator = inst.getImmediateDominator(); |
| if (dominator != null) { |
| total[0] += inst.getSize(); |
| |
| if (dominator == Snapshot.SENTINEL_ROOT) { |
| mRooted.add(inst); |
| } |
| |
| // Properly label the class of a class object. |
| if (inst instanceof ClassObj && javaLangClass != null && inst.getClassObj() == null) { |
| inst.setClassId(javaLangClass.getId()); |
| } |
| |
| // Update dominated instances. |
| List<Instance> instances = mDominated.get(dominator); |
| if (instances == null) { |
| instances = new ArrayList<Instance>(); |
| mDominated.put(dominator, instances); |
| } |
| instances.add(inst); |
| |
| // Update sites. |
| List<StackFrame> path = Collections.emptyList(); |
| StackTrace stack = getStack(inst); |
| int stackId = getStackTraceSerialNumber(stack); |
| if (stack != null) { |
| StackFrame[] frames = getStackFrames(stack); |
| if (frames != null && frames.length > 0) { |
| path = Lists.reverse(Arrays.asList(frames)); |
| } |
| } |
| mRootSite.add(stackId, 0, path.iterator(), inst); |
| |
| // Update native allocations. |
| InstanceUtils.NativeAllocation alloc = InstanceUtils.getNativeAllocation(inst); |
| if (alloc != null) { |
| mNativeAllocations.add(alloc); |
| } |
| } |
| return true; |
| } |
| }; |
| for (Instance instance : heap.getClasses()) { |
| processInstance.execute(instance); |
| } |
| heap.forEachInstance(processInstance); |
| mHeapSizes.put(heap, total[0]); |
| } |
| |
| // Record the roots and their types. |
| for (RootObj root : snapshot.getGCRoots()) { |
| Instance inst = root.getReferredInstance(); |
| Collection<RootType> types = mRoots.get(inst); |
| if (types == null) { |
| types = new HashSet<RootType>(); |
| mRoots.put(inst, types); |
| } |
| types.add(root.getRootType()); |
| } |
| } |
| |
| // Note: This method is exposed for testing purposes. |
| public ClassObj findClass(String name) { |
| return mSnapshot.findClass(name); |
| } |
| |
| public Instance findInstance(long id) { |
| return mSnapshot.findInstance(id); |
| } |
| |
| public int getHeapIndex(Heap heap) { |
| return mSnapshot.getHeapIndex(heap); |
| } |
| |
| public Heap getHeap(String name) { |
| return mSnapshot.getHeap(name); |
| } |
| |
| /** |
| * Returns a collection of instances whose immediate dominator is the |
| * SENTINEL_ROOT. |
| */ |
| public List<Instance> getRooted() { |
| return mRooted; |
| } |
| |
| /** |
| * Returns true if the given instance is a root. |
| */ |
| public boolean isRoot(Instance inst) { |
| return mRoots.containsKey(inst); |
| } |
| |
| /** |
| * Returns the list of root types for the given instance, or null if the |
| * instance is not a root. |
| */ |
| public Collection<RootType> getRootTypes(Instance inst) { |
| return mRoots.get(inst); |
| } |
| |
| public List<Heap> getHeaps() { |
| return mHeaps; |
| } |
| |
| public Site getRootSite() { |
| return mRootSite; |
| } |
| |
| /** |
| * Look up the site at which the given object was allocated. |
| */ |
| public Site getSiteForInstance(Instance inst) { |
| Site site = mRootSite; |
| StackTrace stack = getStack(inst); |
| if (stack != null) { |
| StackFrame[] frames = getStackFrames(stack); |
| if (frames != null) { |
| List<StackFrame> path = Lists.reverse(Arrays.asList(frames)); |
| site = mRootSite.getChild(path.iterator()); |
| } |
| } |
| return site; |
| } |
| |
| /** |
| * Return a list of those objects immediately dominated by the given |
| * instance. |
| */ |
| public List<Instance> getDominated(Instance inst) { |
| return mDominated.get(inst); |
| } |
| |
| /** |
| * Return the total size of reachable objects allocated on the given heap. |
| */ |
| public long getHeapSize(Heap heap) { |
| return mHeapSizes.get(heap); |
| } |
| |
| /** |
| * Return the class name for the given class object. |
| * classObj may be null, in which case "(class unknown)" is returned. |
| */ |
| public static String getClassName(ClassObj classObj) { |
| if (classObj == null) { |
| return "(class unknown)"; |
| } |
| return classObj.getClassName(); |
| } |
| |
| // Return the stack where the given instance was allocated. |
| private static StackTrace getStack(Instance inst) { |
| return inst.getStack(); |
| } |
| |
| // Return the list of stack frames for a stack trace. |
| private static StackFrame[] getStackFrames(StackTrace stack) { |
| return stack.getFrames(); |
| } |
| |
| // Return the serial number of the given stack trace. |
| private static int getStackTraceSerialNumber(StackTrace stack) { |
| return stack.getSerialNumber(); |
| } |
| |
| // Get the site associated with the given stack id and depth. |
| // Returns the root site if no such site found. |
| // depth of -1 means the full stack. |
| public Site getSite(int stackId, int depth) { |
| Site site = mRootSite; |
| StackTrace stack = mSnapshot.getStackTrace(stackId); |
| if (stack != null) { |
| StackFrame[] frames = getStackFrames(stack); |
| if (frames != null) { |
| List<StackFrame> path = Lists.reverse(Arrays.asList(frames)); |
| if (depth >= 0) { |
| path = path.subList(0, depth); |
| } |
| site = mRootSite.getChild(path.iterator()); |
| } |
| } |
| return site; |
| } |
| |
| // Return a list of known native allocations in the snapshot. |
| public List<InstanceUtils.NativeAllocation> getNativeAllocations() { |
| return mNativeAllocations; |
| } |
| } |