preload-classes的前世今生(1)
preloaded-classes
在Zygote初始化的时候，会调用到ZygoteInit的main方法。在注册了ZygoteSocket的控制通道之后，就调用preload方法去加载一些预加载的数据。
public static void main(String argv[]) {
try {
// Start profiling the zygote initialization.
SamplingProfilerIntegration.start();
registerZygoteSocket();
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,
SystemClock.uptimeMillis());
preload();
...
preload方法会加载三个部分，preloadClasses，preloadResources和preloadOpenGL。
static void preload() {
preloadClasses();
preloadResources();
preloadOpenGL();
}
preloadClasses的源代码不长，我们简单看一下：
首先，打开PRELOADED_CLASSES文件，读取文件中的内容
InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream(PRELOADED_CLASSES);
如果不是以'#'开头的，则加载该类：
Class.forName(line);
这个PRELOADED_CLASSES文件位于frameworks/base/preloaded-classes。
我们看看这个文件的前几行：
# Classes which are preloaded by com.android.internal.os.ZygoteInit.
# Automatically generated by frameworks/base/tools/preload/WritePreloadedClassFile.java.
# MIN_LOAD_TIME_MICROS=1250
# MIN_PROCESSES=10
android.R$styleable
android.accounts.Account
android.accounts.Account$1
android.accounts.AccountManager
android.accounts.AccountManager$12
android.accounts.AccountManager$13
android.accounts.AccountManager$6
android.accounts.AccountManager$AmsTask
android.accounts.AccountManager$AmsTask$1
android.accounts.AccountManager$AmsTask$Response
android.accounts.AccountManagerFuture
下面是完整代码，有删节。
private static void preloadClasses() {
final VMRuntime runtime = VMRuntime.getRuntime();
InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream(PRELOADED_CLASSES);
if (is == null) {
Log.e(TAG, "Couldn't find " + PRELOADED_CLASSES + ".");
} else {
Log.i(TAG, "Preloading classes...");
long startTime = SystemClock.uptimeMillis();
// Drop root perms while running static initializers.
setEffectiveGroup(UNPRIVILEGED_GID);
setEffectiveUser(UNPRIVILEGED_UID);
// Alter the target heap utilization. With explicit GCs this
// is not likely to have any effect.
float defaultUtilization = runtime.getTargetHeapUtilization();
runtime.setTargetHeapUtilization(0.8f);
// Start with a clean slate.
System.gc();
runtime.runFinalizationSync();
Debug.startAllocCounting();
try {
BufferedReader br
= new BufferedReader(new InputStreamReader(is), 256);
int count = 0;
String line;
while ((line = br.readLine()) != null) {
// Skip comments and blank lines.
line = line.trim();
if (line.startsWith("#") || line.equals("")) {
continue;
}
try {
Class.forName(line);
if (Debug.getGlobalAllocSize() > PRELOAD_GC_THRESHOLD) {
System.gc();
runtime.runFinalizationSync();
Debug.resetGlobalAllocSize();
}
count++;
} catch (ClassNotFoundException e) {
Log.w(TAG, "Class not found for preloading: " + line);
} catch (UnsatisfiedLinkError e) {
Log.w(TAG, "Problem preloading " + line + ": " + e);
} catch (Throwable t) {
Log.e(TAG, "Error preloading " + line + ".", t);
if (t instanceof Error) {
throw (Error) t;
}
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
}
throw new RuntimeException(t);
}
}
Log.i(TAG, "...preloaded " + count + " classes in "
+ (SystemClock.uptimeMillis()-startTime) + "ms.");
} catch (IOException e) {
Log.e(TAG, "Error reading " + PRELOADED_CLASSES + ".", e);
} finally {
IoUtils.closeQuietly(is);
// Restore default.
runtime.setTargetHeapUtilization(defaultUtilization);
// Fill in dex caches with classes, fields, and methods brought in by preloading.
runtime.preloadDexCaches();
Debug.stopAllocCounting();
// Bring back root. We'll need it later.
setEffectiveUser(ROOT_UID);
setEffectiveGroup(ROOT_GID);
}
}
}
WritePreloadedClassFile.java
先看看两个重要参数：MIN_LOAD_TIME_MICROS和MIN_PROCESSES。
- MIN_LOAD_TIME_MICROS：是最小的类加载时间，如果大于这个，才值得被装载进preload-classes
- MIN_PROCESSES：是最少被多少个进程所装载，太少见的就算了
public class WritePreloadedClassFile {
/**
* Preload any class that take longer to load than MIN_LOAD_TIME_MICROS us.
*/
static final int MIN_LOAD_TIME_MICROS = 1250;
/**
* Preload any class that was loaded by at least MIN_PROCESSES processes.
*/
static final int MIN_PROCESSES = 10;
...
我们再往下看，这个工具的用法：
public static void main(String[] args) throws IOException,
ClassNotFoundException {
if (args.length != 1) {
System.err.println("Usage: WritePreloadedClassFile [compiled log]");
System.exit(-1);
}
String rootFile = args[0];
Root root = Root.fromFile(rootFile);
...
这个工具要处理的内容，是一种叫compiled log的东西。
这个compiled log，是经由frameworks/base/tools/preload/Compile.java所编译出来的。
于是我们再看Compile.java的源码，
public class Compile {
public static void main(String[] args) throws IOException {
if (args.length != 2) {
System.err.println("Usage: Compile [log file] [output file]");
System.exit(0);
}
...
这个log是谁打出来的呢？靠跟踪是查不下去了，我们需要看另一头，虚拟机是如何打印出这个log的。
虚拟机的log
Android 2.3的dalvik/vm/oo/Class.c
我们先从Android 2.3说起，在这个版本上，有一个宏LOG_CLASS_LOADING，打开这个宏，就可以让虚拟机将类的信息输出到log出。
[http://androidxref.com/2.3.7/xref/dalvik/vm/oo/Class.c#22]
虚拟机会输出一个这样格式的Log，用于记录一个类的加载时间。
LOG(LOG_INFO, "PRELOAD", "%c%d:%d:%d:%s:%d:%s:%lld\n", type, ppid, pid, tid,
get_process_name(), (int) clazz->classLoader, clazz->descriptor,time);
- 第1个参数：type：
- > 定义类开始
- < 定义类结束
- + 初始化开始
- - 初始化结束
- 第2个参数：ppid，父进程的进程号
- 第3个参数：pid，本进程的进程号
- 第4个参数：tid，本线程的线程号
- 第5个参数：process_name，进程名
- 第6个参数：类的classLoader
- 第7个参数：类的描述符
- 第8个参数：时间戳，以纳秒为单位
我们看下源码就一目了然了：
static void logClassLoadWithTime(char type, ClassObject* clazz, u8 time) {
pid_t ppid = getppid();
pid_t pid = getpid();
unsigned int tid = (unsigned int) pthread_self();
LOG(LOG_INFO, "PRELOAD", "%c%d:%d:%d:%s:%d:%s:%lld\n", type, ppid, pid, tid,
get_process_name(), (int) clazz->classLoader, clazz->descriptor,
time);
}
为了计时方便，我们将dvmGetThreadCpuTimeNsec的计时封装在函数内，定义一个包装函数，代码如下：
/*
* Logs information about a class loading.
*/
static void logClassLoad(char type, ClassObject* clazz) {
logClassLoadWithTime(type, clazz, dvmGetThreadCpuTimeNsec());
}
类的定义的点都在findClassNoInit方法中，代码见：http://androidxref.com/2.3.7/xref/dalvik/vm/oo/Class.c#1411
类的初始化的打点在dvmInitClass中，代码见：http://androidxref.com/2.3.7/xref/dalvik/vm/oo/Class.c#4228
Android 4.x的dalvik/vm/oo/Class.cpp
4.x之后，Class.c变成了Class.cpp，不过对于打印类加载信息这部分没有什么实质上的变化。
#if LOG_CLASS_LOADING
static void logClassLoadWithTime(char type, ClassObject* clazz, u8 time) {
pid_t ppid = getppid();
pid_t pid = getpid();
unsigned int tid = (unsigned int) pthread_self();
ALOG(LOG_INFO, "PRELOAD", "%c%d:%d:%d:%s:%d:%s:%lld", type, ppid, pid, tid,
get_process_name(), (int) clazz->classLoader, clazz->descriptor,
time);
}
static void logClassLoad(char type, ClassObject* clazz) {
logClassLoadWithTime(type, clazz, dvmGetThreadCpuTimeNsec());
}
#endif
定义类还是在findClassNoInit，http://androidxref.com/4.4.4_r1/xref/dalvik/vm/oo/Class.cpp#1473
初始化类还是在dvmInitClass中，http://androidxref.com/4.4.4_r1/xref/dalvik/vm/oo/Class.cpp#4241
h5. log示例
下面我们摘取一段log中抽取出来的一个完整的片段，包含了android.text.format.DateFormat类的定义和初始化一个对象的完整日志。
I/PRELOAD ( 6327): >356:6327:1074467156:unknown:0:Ljava/lang/Object;:206523751
I/PRELOAD ( 6327): <356:6327:1074467156:unknown:0:Ljava/lang/Object;:206921667
log终于大功告成了，下面我们回到frameworks/base/tools/preload/Compile.java，继续讨论如何将log转化为compiled log.
log的编译过程
frameworks/base/tools/preload/Compile.java是一个host的工具，运行在PC上。好在是java写的，还算跨平台，在Linux下编译出来的jar在Windows下也可以用。
按照新冬说的办法： mmm frameworks/base/tools/preload/
然后从out/host/linux-x86/framework中将preload.jar复制到可以用adb连接手机的PC上。
我们继续看Compile.java的源代码：
39 Root root = new Root();
40
41 List<Record> records = new ArrayList<Record>();
42
43 BufferedReader in = new BufferedReader(new InputStreamReader(
44 new FileInputStream(args[0])));
45
46 String line;
47 int lineNumber = 0;
48 while ((line = in.readLine()) != null) {
49 lineNumber++;
50 if (line.startsWith("I/PRELOAD")) {
51 try {
52 String clipped = line.substring(19);
53 records.add(new Record(clipped, lineNumber));
54 } catch (RuntimeException e) {
55 throw new RuntimeException(
56 "Exception while recording line " + lineNumber + ": " + line, e);
57 }
58 }
59 }
说实话，原生这段逻辑的处理方式实在是过于简单了，对log格式的处理实在是不足够现代化。每条期待TAG为PRELOAD，其它的log全部过滤。并且，取到type值的办法用的是最土的直接数出19个字符这样的方法。这样导致，用logcat -vtime抓出来的log是无法识别的。
下面我们来分析Record的生成过程。这里显示出现有设计的一个不足，就是采用":"来做分隔。
代码如下：
125 line = line.substring(1);
126 String[] parts = line.split(":");
这就导致了，如果包名中出现了":"的话，就会split失败。为了解决这个问题，只好打补丁。
Android采用了一个非常土的办法，将":"替换成\u003A，这个过程需要手动去做。
这一段逻辑的完整代码如下：
109 Record(String line, int lineNum) {
110 char typeChar = line.charAt(0);
111 switch (typeChar) {
112 case '>': type = Type.START_LOAD; break;
113 case '<': type = Type.END_LOAD; break;
114 case '+': type = Type.START_INIT; break;
115 case '-': type = Type.END_INIT; break;
116 default: throw new AssertionError("Bad line: " + line);
117 }
118
119 sourceLineNumber = lineNum;
120
121 for (int i = 0; i < REPLACE_CLASSES.length; i+= 2) {
122 line = line.replace(REPLACE_CLASSES[i], REPLACE_CLASSES[i+1]);
123 }
124
125 line = line.substring(1);
126 String[] parts = line.split(":");
127
128 ppid = Integer.parseInt(parts[0]);
129 pid = Integer.parseInt(parts[1]);
130 tid = Integer.parseInt(parts[2]);
131
132 processName = decode(parts[3]).intern();
133
134 classLoader = Integer.parseInt(parts[4]);
135 className = vmTypeToLanguage(decode(parts[5])).intern();
136
137 time = Long.parseLong(parts[6]);
138 }
我们看看这些patch冒号的代码，如果遇到了新的类，我们也需要去添加新的类。
22 /**
23 * The delimiter character we use, {@code :}, conflicts with some other
24 * names. In that case, manually replace the delimiter with something else.
25 */
26 private static final String[] REPLACE_CLASSES = {
27 "com.google.android.apps.maps:FriendService",
28 "com.google.android.apps.maps\\u003AFriendService",
29 "com.google.android.apps.maps:driveabout",
30 "com.google.android.apps.maps\\u003Adriveabout",
31 "com.google.android.apps.maps:GoogleLocationService",
32 "com.google.android.apps.maps\\u003AGoogleLocationService",
33 "com.google.android.apps.maps:LocationFriendService",
34 "com.google.android.apps.maps\\u003ALocationFriendService",
35 "com.google.android.apps.maps:MapsBackgroundService",
36 "com.google.android.apps.maps\\u003AMapsBackgroundService",
37 "com.google.android.apps.maps:NetworkLocationService",
38 "com.google.android.apps.maps\\u003ANetworkLocationService",
...
比如我不幸遇上了虾米音乐：fm.xiami.yunos:ui，就写这样两行将”：“替换成\u003A。
"fm.xiami.yunos:ui",
"fm.xiami.yunos\\u003Aui"
这方法土掉渣了，需要一个一个地探雷。。。
光读log还不行，还要去在线查询内存占用情况。我们来看frameworks/base/tools/preload/MemoryUsage.java中的measure方法。
221 private MemoryUsage measure() {
222 String[] commands = GET_DIRTY_PAGES;
223 if (className != null) {
224 List<String> commandList = new ArrayList<String>(
225 GET_DIRTY_PAGES.length + 1);
226 commandList.addAll(Arrays.asList(commands));
227 commandList.add(className);
228 commands = commandList.toArray(new String[commandList.size()]);
229 }
230
231 try {
232 final Process process = Runtime.getRuntime().exec(commands);
这里面要在adb shell中执行一个GET_DIRTY_PAGES的工具命令，我们看看这是何方神圣：
160 private static final String CLASS_PATH = "-Xbootclasspath"
161 + ":/system/framework/core.jar"
162 + ":/system/framework/ext.jar"
163 + ":/system/framework/framework.jar"
164 + ":/system/framework/framework-tests.jar"
165 + ":/system/framework/services.jar"
166 + ":/system/framework/loadclass.jar";
167
168 private static final String[] GET_DIRTY_PAGES = {
169 "adb", "shell", "dalvikvm", CLASS_PATH, "LoadClass" };
这个是要调用LoadClass类，位于system/framework/loadclass.jar中。那么这个loadclass.jar又是从哪里来的呢？答案是在frameworks/base/tools/preload/loadclass/目录中。
我们看loadclass目录中的Android.mk：
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES := $(call all-subdir-java-files)
LOCAL_MODULE_TAGS := tests
LOCAL_MODULE := loadclass
include $(BUILD_JAVA_LIBRARY)
于是我们make一下这个工具：mmm frameworks/base/tools/preload/loadclass/
然后我们把这个jar push到手机上的/system/framework/中去。