Initial Contribution

1 files changed, 163 insertions, 0 deletions

diff --git a/tools/preload/Root.java b/tools/preload/Root.java
new file mode 100644
index 0000000..949f9b7
--- /dev/null
+++ b/tools/preload/Root.java
@@ -0,0 +1,163 @@
+/*
+ * Copyright (C) 2008 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.
+ */
+
+import java.io.Serializable;
+import java.io.IOException;
+import java.io.Writer;
+import java.io.BufferedWriter;
+import java.io.OutputStreamWriter;
+import java.io.FileOutputStream;
+import java.io.FileInputStream;
+import java.io.ObjectInputStream;
+import java.io.BufferedInputStream;
+import java.io.ObjectOutputStream;
+import java.io.BufferedOutputStream;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.Arrays;
+import java.nio.charset.Charset;
+
+/**
+ * Root of our data model.
+ */
+public class Root implements Serializable {
+
+    private static final long serialVersionUID = 0;
+
+    /** pid -> Proc */
+    final Map<Integer, Proc> processes = new HashMap<Integer, Proc>();
+
+    /** Class name -> LoadedClass */
+    final Map<String, LoadedClass> loadedClasses
+            = new HashMap<String, LoadedClass>();
+
+    final MemoryUsage baseline = MemoryUsage.baseline();
+
+    /**
+     * Records class loads and initializations.
+     */
+    void indexClassOperation(Record record) {
+        Proc process = processes.get(record.pid);
+
+        // Ignore dexopt output. It loads applications classes through the
+        // system class loader and messes us up.
+        if (record.processName.equals("dexopt")) {
+            return;
+        }
+
+        String name = record.className;
+        LoadedClass loadedClass = loadedClasses.get(name);
+        Operation o = null;
+
+        switch (record.type) {
+            case START_LOAD:
+            case START_INIT:
+                if (loadedClass == null) {
+                    loadedClass = new LoadedClass(
+                            name, record.classLoader == 0);
+                    if (loadedClass.systemClass) {
+                        // Only measure memory for classes in the boot
+                        // classpath.
+                        loadedClass.measureMemoryUsage();
+                    }
+                    loadedClasses.put(name, loadedClass);
+                }
+                break;
+
+            case END_LOAD:
+            case END_INIT:
+                o = process.endOperation(record.tid, record.className,
+                        loadedClass, record.time);
+                if (o == null) {
+                    return;
+                }
+        }
+
+        switch (record.type) {
+            case START_LOAD:
+                process.startOperation(record.tid, loadedClass, record.time,
+                        Operation.Type.LOAD);
+                break;
+
+            case START_INIT:
+                process.startOperation(record.tid, loadedClass, record.time,
+                        Operation.Type.INIT);
+                break;
+
+            case END_LOAD:
+                loadedClass.loads.add(o);
+                break;
+
+            case END_INIT:
+                loadedClass.initializations.add(o);
+                break;
+        }
+    }
+
+    /**
+     * Indexes information about the process from the given record.
+     */
+    void indexProcess(Record record) {
+        Proc proc = processes.get(record.pid);
+
+        if (proc == null) {
+            // Create a new process object.
+            Proc parent = processes.get(record.ppid);
+            proc = new Proc(parent, record.pid);
+            processes.put(proc.id, proc);
+            if (parent != null) {
+                parent.children.add(proc);
+            }
+        }
+
+        proc.setName(record.processName);
+    }
+
+    /**
+     * Writes this graph to a file.
+     */
+    void toFile(String fileName) throws IOException {
+        FileOutputStream out = new FileOutputStream(fileName);
+        ObjectOutputStream oout = new ObjectOutputStream(
+                new BufferedOutputStream(out));
+
+        System.err.println("Writing object model...");
+
+        oout.writeObject(this);
+
+        oout.close();
+
+        System.err.println("Done!");
+    }
+
+    /**
+     * Reads Root from a file.
+     */
+    static Root fromFile(String fileName)
+            throws IOException, ClassNotFoundException {
+        FileInputStream fin = new FileInputStream(fileName);
+        ObjectInputStream oin = new ObjectInputStream(
+                new BufferedInputStream(fin));
+
+        Root root = (Root) oin.readObject();
+
+        oin.close();
+
+        return root;
+    }
+}