1/*
2 * Copyright (C) 2008 Google Inc.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.hit;
18
19import java.util.ArrayList;
20import java.util.HashMap;
21
22/*
23 * State is a snapshot of all of the heaps, and related meta-data, for
24 * the runtime at a given instant.
25 *
26 * During parsing of the HPROF file HEAP_DUMP_INFO chunks change which heap
27 * is being referenced.
28 */
29public class State {
30    HashMap<Integer, Heap> mHeaps;
31    Heap mCurrentHeap;
32
33    public State() {
34        mHeaps = new HashMap<Integer, Heap>();
35        setToDefaultHeap();
36    }
37
38    public Heap setToDefaultHeap() {
39        return setHeapTo(0, "default");
40    }
41
42    public Heap setHeapTo(int id, String name) {
43        Heap heap = mHeaps.get(id);
44
45        if (heap == null) {
46            heap = new Heap(name);
47            heap.mState = this;
48            mHeaps.put(id, heap);
49        }
50
51        mCurrentHeap = heap;
52
53        return mCurrentHeap;
54    }
55
56    public Heap getHeap(int id) {
57        return mHeaps.get(id);
58    }
59
60    public Heap getHeap(String name) {
61        for (Heap heap: mHeaps.values()) {
62            if (heap.mName.equals(name)) {
63                return heap;
64            }
65        }
66
67        return null;
68    }
69
70    public final void addStackFrame(StackFrame theFrame) {
71        mCurrentHeap.addStackFrame(theFrame);
72    }
73
74    public final StackFrame getStackFrame(long id) {
75        return mCurrentHeap.getStackFrame(id);
76    }
77
78    public final void addStackTrace(StackTrace theTrace) {
79        mCurrentHeap.addStackTrace(theTrace);
80    }
81
82    public final StackTrace getStackTrace(int traceSerialNumber) {
83        return mCurrentHeap.getStackTrace(traceSerialNumber);
84    }
85
86    public final StackTrace getStackTraceAtDepth(int traceSerialNumber,
87            int depth) {
88        return mCurrentHeap.getStackTraceAtDepth(traceSerialNumber, depth);
89    }
90
91    public final void addRoot(RootObj root) {
92        mCurrentHeap.addRoot(root);
93    }
94
95    public final void addThread(ThreadObj thread, int serialNumber) {
96        mCurrentHeap.addThread(thread, serialNumber);
97    }
98
99    public final ThreadObj getThread(int serialNumber) {
100        return mCurrentHeap.getThread(serialNumber);
101    }
102
103    public final void addInstance(long id, Instance instance) {
104        mCurrentHeap.addInstance(id, instance);
105    }
106
107    public final void addClass(long id, ClassObj theClass) {
108        mCurrentHeap.addClass(id, theClass);
109    }
110
111    public final Instance findReference(long id) {
112        for (Heap heap: mHeaps.values()) {
113            Instance instance = heap.getInstance(id);
114
115            if (instance != null) {
116                return instance;
117            }
118        }
119
120        //  Couldn't find an instance of a class, look for a class object
121        return findClass(id);
122    }
123
124    public final ClassObj findClass(long id) {
125        for (Heap heap: mHeaps.values()) {
126            ClassObj theClass = heap.getClass(id);
127
128            if (theClass != null) {
129                return theClass;
130            }
131        }
132
133        return null;
134    }
135
136    public final ClassObj findClass(String name) {
137        for (Heap heap: mHeaps.values()) {
138            ClassObj theClass = heap.getClass(name);
139
140            if (theClass != null) {
141                return theClass;
142            }
143        }
144
145        return null;
146    }
147
148    public final void dumpInstanceCounts() {
149        for (Heap heap: mHeaps.values()) {
150            System.out.println(
151                "+------------------ instance counts for heap: " + heap.mName);
152            heap.dumpInstanceCounts();
153        }
154    }
155
156    public final void dumpSizes() {
157        for (Heap heap: mHeaps.values()) {
158            System.out.println(
159                "+------------------ sizes for heap: " + heap.mName);
160            heap.dumpSizes();
161        }
162    }
163
164    public final void dumpSubclasses() {
165        for (Heap heap: mHeaps.values()) {
166            System.out.println(
167                "+------------------ subclasses for heap: " + heap.mName);
168            heap.dumpSubclasses();
169        }
170    }
171
172    public final void resolveReferences() {
173        for (Heap heap: mHeaps.values()) {
174            heap.resolveInstanceRefs(this);
175            heap.resolveClassStatics(this);
176            heap.resolveRoots(this);
177        }
178    }
179}
180