Initial commit

sources/com/squareup/haha/perflib/analysis/Dominators.java

@@ -0,0 +1,76 @@
+package com.squareup.haha.perflib.analysis;
+
+import com.squareup.haha.guava.collect.ImmutableList;
+import com.squareup.haha.guava.collect.Iterables;
+import com.squareup.haha.perflib.Heap;
+import com.squareup.haha.perflib.Instance;
+import com.squareup.haha.perflib.RootObj;
+import com.squareup.haha.perflib.Snapshot;
+import java.util.Iterator;
+
+/* loaded from: classes.dex */
+public class Dominators {
+    private final Snapshot mSnapshot;
+    private final ImmutableList<Instance> mTopSort;
+
+    public Dominators(Snapshot snapshot, ImmutableList<Instance> immutableList) {
+        this.mSnapshot = snapshot;
+        this.mTopSort = immutableList;
+        Iterator<RootObj> it = snapshot.getGCRoots().iterator();
+        while (it.hasNext()) {
+            Instance referredInstance = it.next().getReferredInstance();
+            if (referredInstance != null) {
+                referredInstance.setImmediateDominator(Snapshot.SENTINEL_ROOT);
+            }
+        }
+    }
+
+    private void computeDominators() {
+        boolean z;
+        for (boolean z2 = true; z2; z2 = z) {
+            z = false;
+            for (int i = 0; i < this.mTopSort.size(); i++) {
+                Instance instance = this.mTopSort.get(i);
+                if (instance.getImmediateDominator() != Snapshot.SENTINEL_ROOT) {
+                    Instance instance2 = null;
+                    for (int i2 = 0; i2 < instance.getHardReferences().size(); i2++) {
+                        Instance instance3 = instance.getHardReferences().get(i2);
+                        if (instance3.getImmediateDominator() != null) {
+                            if (instance2 == null) {
+                                instance2 = instance3;
+                            } else {
+                                while (instance2 != instance3) {
+                                    if (instance2.getTopologicalOrder() < instance3.getTopologicalOrder()) {
+                                        instance3 = instance3.getImmediateDominator();
+                                    } else {
+                                        instance2 = instance2.getImmediateDominator();
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    if (instance.getImmediateDominator() != instance2) {
+                        instance.setImmediateDominator(instance2);
+                        z = true;
+                    }
+                }
+            }
+        }
+    }
+
+    public void computeRetainedSizes() {
+        for (Heap heap : this.mSnapshot.getHeaps()) {
+            Iterator it = Iterables.concat(heap.getClasses(), heap.getInstances()).iterator();
+            while (it.hasNext()) {
+                ((Instance) it.next()).resetRetainedSize();
+            }
+        }
+        computeDominators();
+        for (Instance instance : this.mSnapshot.getReachableInstances()) {
+            int heapIndex = this.mSnapshot.getHeapIndex(instance.getHeap());
+            for (Instance immediateDominator = instance.getImmediateDominator(); immediateDominator != Snapshot.SENTINEL_ROOT; immediateDominator = immediateDominator.getImmediateDominator()) {
+                immediateDominator.addRetainedSize(heapIndex, instance.getSize());
+            }
+        }
+    }
+}

sources/com/squareup/haha/perflib/analysis/ShortestDistanceVisitor.java

@@ -0,0 +1,45 @@
+package com.squareup.haha.perflib.analysis;
+
+import com.ijm.dataencryption.de.DataDecryptTool;
+import com.squareup.haha.perflib.Instance;
+import com.squareup.haha.perflib.NonRecursiveVisitor;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.PriorityQueue;
+
+/* loaded from: classes.dex */
+public class ShortestDistanceVisitor extends NonRecursiveVisitor {
+    private PriorityQueue<Instance> mPriorityQueue = new PriorityQueue<>(DataDecryptTool.DECRYPT_SP_FILE, new Comparator<Instance>() { // from class: com.squareup.haha.perflib.analysis.ShortestDistanceVisitor.1
+        @Override // java.util.Comparator
+        public int compare(Instance instance, Instance instance2) {
+            return instance.getDistanceToGcRoot() - instance2.getDistanceToGcRoot();
+        }
+    });
+    private Instance mPreviousInstance = null;
+    private int mVisitDistance = 0;
+
+    @Override // com.squareup.haha.perflib.NonRecursiveVisitor
+    public void doVisit(Iterable<? extends Instance> iterable) {
+        Iterator<? extends Instance> it = iterable.iterator();
+        while (it.hasNext()) {
+            it.next().accept(this);
+        }
+        while (!this.mPriorityQueue.isEmpty()) {
+            Instance poll = this.mPriorityQueue.poll();
+            this.mVisitDistance = poll.getDistanceToGcRoot() + 1;
+            this.mPreviousInstance = poll;
+            poll.accept(this);
+        }
+    }
+
+    @Override // com.squareup.haha.perflib.NonRecursiveVisitor, com.squareup.haha.perflib.Visitor
+    public void visitLater(Instance instance, Instance instance2) {
+        if (this.mVisitDistance < instance2.getDistanceToGcRoot()) {
+            if (instance == null || instance2.getSoftReferences() == null || !instance2.getSoftReferences().contains(instance) || instance2.getIsSoftReference()) {
+                instance2.setDistanceToGcRoot(this.mVisitDistance);
+                instance2.setNextInstanceToGcRoot(this.mPreviousInstance);
+                this.mPriorityQueue.add(instance2);
+            }
+        }
+    }
+}

sources/com/squareup/haha/perflib/analysis/TopologicalSort.java

@@ -0,0 +1,73 @@
+package com.squareup.haha.perflib.analysis;
+
+import com.squareup.haha.guava.base.Joiner;
+import com.squareup.haha.guava.collect.ImmutableList;
+import com.squareup.haha.guava.collect.UnmodifiableIterator;
+import com.squareup.haha.perflib.Instance;
+import com.squareup.haha.perflib.NonRecursiveVisitor;
+import com.squareup.haha.perflib.RootObj;
+import com.squareup.haha.perflib.Snapshot;
+import gnu.trove.TLongHashSet;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public class TopologicalSort {
+
+    static class TopologicalSortVisitor extends NonRecursiveVisitor {
+        private final List<Instance> mPostorder;
+        private final TLongHashSet mVisited;
+
+        private TopologicalSortVisitor() {
+            this.mVisited = new TLongHashSet();
+            this.mPostorder = new ArrayList();
+        }
+
+        @Override // com.squareup.haha.perflib.NonRecursiveVisitor
+        public void doVisit(Iterable<? extends Instance> iterable) {
+            Iterator<? extends Instance> it = iterable.iterator();
+            while (it.hasNext()) {
+                it.next().accept(this);
+            }
+            while (!this.mStack.isEmpty()) {
+                Instance peek = this.mStack.peek();
+                if (this.mSeen.add(peek.getId())) {
+                    peek.accept(this);
+                } else {
+                    this.mStack.pop();
+                    if (this.mVisited.add(peek.getId())) {
+                        this.mPostorder.add(peek);
+                    }
+                }
+            }
+        }
+
+        ImmutableList<Instance> getOrderedInstances() {
+            return ImmutableList.copyOf((Collection) Joiner.reverse(this.mPostorder));
+        }
+
+        @Override // com.squareup.haha.perflib.NonRecursiveVisitor, com.squareup.haha.perflib.Visitor
+        public void visitLater(Instance instance, Instance instance2) {
+            if (this.mSeen.contains(instance2.getId())) {
+                return;
+            }
+            this.mStack.push(instance2);
+        }
+    }
+
+    public static ImmutableList<Instance> compute(Iterable<RootObj> iterable) {
+        TopologicalSortVisitor topologicalSortVisitor = new TopologicalSortVisitor();
+        topologicalSortVisitor.doVisit(iterable);
+        ImmutableList<Instance> orderedInstances = topologicalSortVisitor.getOrderedInstances();
+        int i = 0;
+        Snapshot.SENTINEL_ROOT.setTopologicalOrder(0);
+        UnmodifiableIterator<Instance> it = orderedInstances.iterator();
+        while (it.hasNext()) {
+            i++;
+            it.next().setTopologicalOrder(i);
+        }
+        return orderedInstances;
+    }
+}