tools/preload/Proc.java

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   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
  17 import java.util.List;
  18 import java.util.ArrayList;
  19 import java.util.LinkedList;
  20 import java.util.Map;
  21 import java.util.HashMap;
  22 import java.io.Serializable;
  23
  24 /**
  25  * A Dalvik process.
  26  */
  27 class Proc implements Serializable {
  28
  29     private static final long serialVersionUID = 0;
  30
  31     /** Parent process. */
  32     final Proc parent;
  33
  34     /** Process ID. */
  35     final int id;
  36
  37     /**
  38      * Name of this process. We may not have the correct name at first, i.e.
  39      * some classes could have been loaded before the process name was set.
  40      */
  41     String name;
  42
  43     /** Child processes. */
  44     final List<Proc> children = new ArrayList<Proc>();
  45
  46     /** Maps thread ID to operation stack. */
  47     transient final Map<Integer, LinkedList<Operation>> stacks
  48             = new HashMap<Integer, LinkedList<Operation>>();
  49
  50     /** Number of operations. */
  51     int operationCount;
  52
  53     /** Sequential list of operations that happened in this process. */
  54     final List<Operation> operations = new ArrayList<Operation>();
  55
  56     /** List of past process names. */
  57     final List<String> nameHistory = new ArrayList<String>();
  58
  59     /** Constructs a new process. */
  60     Proc(Proc parent, int id) {
  61         this.parent = parent;
  62         this.id = id;
  63     }
  64
  65     /** Sets name of this process. */
  66     void setName(String name) {
  67         if (!name.equals(this.name)) {
  68             if (this.name != null) {
  69                 nameHistory.add(this.name);
  70             }
  71             this.name = name;
  72         }
  73     }
  74
  75     /**
  76      * Returns true if this process comes from the zygote.
  77      */
  78     public boolean fromZygote() {
  79         return parent != null && parent.name.equals("zygote")
  80                 && !name.equals("com.android.development");
  81     }
  82
  83     /**
  84      * Starts an operation.
  85      *
  86      * @param threadId thread the operation started in
  87      * @param loadedClass class operation happened to
  88      * @param time the operation started
  89      */
  90     void startOperation(int threadId, LoadedClass loadedClass, long time,
  91             Operation.Type type) {
  92         Operation o = new Operation(
  93                 this, loadedClass, time, operationCount++, type);
  94         operations.add(o);
  95
  96         LinkedList<Operation> stack = stacks.get(threadId);
  97         if (stack == null) {
  98             stack = new LinkedList<Operation>();
  99             stacks.put(threadId, stack);
 100         }
 101
 102         if (!stack.isEmpty()) {
 103             stack.getLast().subops.add(o);
 104         }
 105
 106         stack.add(o);
 107     }
 108
 109     /**
 110      * Ends an operation.
 111      *
 112      * @param threadId thread the operation ended in
 113      * @param loadedClass class operation happened to
 114      * @param time the operation ended
 115      */
 116     Operation endOperation(int threadId, String className,
 117             LoadedClass loadedClass, long time) {
 118         LinkedList<Operation> stack = stacks.get(threadId);
 119
 120         if (stack == null || stack.isEmpty()) {
 121             didNotStart(className);
 122             return null;
 123         }
 124
 125         Operation o = stack.getLast();
 126         if (loadedClass != o.loadedClass) {
 127             didNotStart(className);
 128             return null;
 129         }
 130
 131         stack.removeLast();
 132
 133         o.endTimeNanos = time;
 134         return o;
 135     }
 136
 137     /**
 138      * Prints an error indicating that we saw the end of an operation but not
 139      * the start. A bug in the logging framework which results in dropped logs
 140      * causes this.
 141      */
 142     private static void didNotStart(String name) {
 143         System.err.println("Warning: An operation ended on " + name
 144             + " but it never started!");
 145     }
 146
 147     /**
 148      * Prints this process tree to stdout.
 149      */
 150     void print() {
 151         print("");
 152     }
 153
 154     /**
 155      * Prints a child proc to standard out.
 156      */
 157     private void print(String prefix) {
 158         System.out.println(prefix + "id=" + id + ", name=" + name);
 159         for (Proc child : children) {
 160             child.print(prefix + "    ");
 161         }
 162     }
 163
 164     @Override
 165     public String toString() {
 166         return this.name;
 167     }
 168 }