Merge "Merge "Framework: Remove SamplingProfiler" into oc-dev-plus-aosp am:... (a985db2f) · Commits · e / os / android_frameworks_base

core/java/android/app/ActivityThread.java

+0 −31

Original line number	Original line	Diff line number	Diff line
	@@ -122,7 +122,6 @@ import com.android.internal.app.IVoiceInteractor;
	import com.android.internal.content.ReferrerIntent;		import com.android.internal.content.ReferrerIntent;
	import com.android.internal.os.BinderInternal;		import com.android.internal.os.BinderInternal;
	import com.android.internal.os.RuntimeInit;		import com.android.internal.os.RuntimeInit;
	import com.android.internal.os.SamplingProfilerIntegration;
	import com.android.internal.os.SomeArgs;		import com.android.internal.os.SomeArgs;
	import com.android.internal.util.ArrayUtils;		import com.android.internal.util.ArrayUtils;
	import com.android.internal.util.FastPrintWriter;		import com.android.internal.util.FastPrintWriter;
	@@ -1608,7 +1607,6 @@ public final class ActivityThread {
	handlePauseActivity((IBinder) args.arg1, false,		handlePauseActivity((IBinder) args.arg1, false,
	(args.argi1 & USER_LEAVING) != 0, args.argi2,		(args.argi1 & USER_LEAVING) != 0, args.argi2,
	(args.argi1 & DONT_REPORT) != 0, args.argi3);		(args.argi1 & DONT_REPORT) != 0, args.argi3);
	maybeSnapshot();
	Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);		Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
	} break;		} break;
	case PAUSE_ACTIVITY_FINISHING: {		case PAUSE_ACTIVITY_FINISHING: {
	@@ -1678,7 +1676,6 @@ public final class ActivityThread {
	case RECEIVER:		case RECEIVER:
	Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "broadcastReceiveComp");		Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "broadcastReceiveComp");
	handleReceiver((ReceiverData)msg.obj);		handleReceiver((ReceiverData)msg.obj);
	maybeSnapshot();
	Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);		Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
	break;		break;
	case CREATE_SERVICE:		case CREATE_SERVICE:
	@@ -1704,7 +1701,6 @@ public final class ActivityThread {
	case STOP_SERVICE:		case STOP_SERVICE:
	Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceStop");		Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceStop");
	handleStopService((IBinder)msg.obj);		handleStopService((IBinder)msg.obj);
	maybeSnapshot();
	Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);		Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
	break;		break;
	case CONFIGURATION_CHANGED:		case CONFIGURATION_CHANGED:
	@@ -1866,32 +1862,6 @@ public final class ActivityThread {
	}		}
	if (DEBUG_MESSAGES) Slog.v(TAG, "<<< done: " + codeToString(msg.what));		if (DEBUG_MESSAGES) Slog.v(TAG, "<<< done: " + codeToString(msg.what));
	}		}

	private void maybeSnapshot() {
	if (mBoundApplication != null && SamplingProfilerIntegration.isEnabled()) {
	// convert the private ActivityThread.PackageInfo to public known
	// android.content.pm.PackageInfo
	String packageName = mBoundApplication.info.mPackageName;
	android.content.pm.PackageInfo packageInfo = null;
	try {
	Context context = getSystemContext();
	if(context == null) {
	Log.e(TAG, "cannot get a valid context");
	return;
	}
	PackageManager pm = context.getPackageManager();
	if(pm == null) {
	Log.e(TAG, "cannot get a valid PackageManager");
	return;
	}
	packageInfo = pm.getPackageInfo(
	packageName, PackageManager.GET_ACTIVITIES);
	} catch (NameNotFoundException e) {
	Log.e(TAG, "cannot get package info for " + packageName, e);
	}
	SamplingProfilerIntegration.writeSnapshot(mBoundApplication.processName, packageInfo);
	}
	}
	}		}

	private class Idler implements MessageQueue.IdleHandler {		private class Idler implements MessageQueue.IdleHandler {
	@@ -6501,7 +6471,6 @@ public final class ActivityThread {

	public static void main(String[] args) {		public static void main(String[] args) {
	Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");		Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
	SamplingProfilerIntegration.start();

	// CloseGuard defaults to true and can be quite spammy. We		// CloseGuard defaults to true and can be quite spammy. We
	// disable it here, but selectively enable it later (via		// disable it here, but selectively enable it later (via

core/java/com/android/internal/os/SamplingProfilerIntegration.java

deleted100644 → 0

+0 −226

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright (C) 2009 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.
	*/

	package com.android.internal.os;

	import android.content.pm.PackageInfo;
	import android.os.Build;
	import android.os.SystemProperties;
	import android.util.Log;
	import dalvik.system.profiler.BinaryHprofWriter;
	import dalvik.system.profiler.SamplingProfiler;
	import java.io.BufferedOutputStream;
	import java.io.File;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.OutputStream;
	import java.io.PrintStream;
	import java.util.Date;
	import java.util.concurrent.Executor;
	import java.util.concurrent.Executors;
	import java.util.concurrent.ThreadFactory;
	import java.util.concurrent.atomic.AtomicBoolean;
	import libcore.io.IoUtils;

	/**
	* Integrates the framework with Dalvik's sampling profiler.
	*/
	public class SamplingProfilerIntegration {

	private static final String TAG = "SamplingProfilerIntegration";

	public static final String SNAPSHOT_DIR = "/data/snapshots";

	private static final boolean enabled;
	private static final Executor snapshotWriter;
	private static final int samplingProfilerMilliseconds;
	private static final int samplingProfilerDepth;

	/** Whether or not a snapshot is being persisted. */
	private static final AtomicBoolean pending = new AtomicBoolean(false);

	static {
	samplingProfilerMilliseconds = SystemProperties.getInt("persist.sys.profiler_ms", 0);
	samplingProfilerDepth = SystemProperties.getInt("persist.sys.profiler_depth", 4);
	if (samplingProfilerMilliseconds > 0) {
	File dir = new File(SNAPSHOT_DIR);
	dir.mkdirs();
	// the directory needs to be writable to anybody to allow file writing
	dir.setWritable(true, false);
	// the directory needs to be executable to anybody to allow file creation
	dir.setExecutable(true, false);
	if (dir.isDirectory()) {
	snapshotWriter = Executors.newSingleThreadExecutor(new ThreadFactory() {
	public Thread newThread(Runnable r) {
	return new Thread(r, TAG);
	}
	});
	enabled = true;
	Log.i(TAG, "Profiling enabled. Sampling interval ms: "
	+ samplingProfilerMilliseconds);
	} else {
	snapshotWriter = null;
	enabled = true;
	Log.w(TAG, "Profiling setup failed. Could not create " + SNAPSHOT_DIR);
	}
	} else {
	snapshotWriter = null;
	enabled = false;
	Log.i(TAG, "Profiling disabled.");
	}
	}

	private static SamplingProfiler samplingProfiler;
	private static long startMillis;

	/**
	* Is profiling enabled?
	*/
	public static boolean isEnabled() {
	return enabled;
	}

	/**
	* Starts the profiler if profiling is enabled.
	*/
	public static void start() {
	if (!enabled) {
	return;
	}
	if (samplingProfiler != null) {
	Log.e(TAG, "SamplingProfilerIntegration already started at " + new Date(startMillis));
	return;
	}

	ThreadGroup group = Thread.currentThread().getThreadGroup();
	SamplingProfiler.ThreadSet threadSet = SamplingProfiler.newThreadGroupThreadSet(group);
	samplingProfiler = new SamplingProfiler(samplingProfilerDepth, threadSet);
	samplingProfiler.start(samplingProfilerMilliseconds);
	startMillis = System.currentTimeMillis();
	}

	/**
	* Writes a snapshot if profiling is enabled.
	*/
	public static void writeSnapshot(final String processName, final PackageInfo packageInfo) {
	if (!enabled) {
	return;
	}
	if (samplingProfiler == null) {
	Log.e(TAG, "SamplingProfilerIntegration is not started");
	return;
	}

	/*
	* If we're already writing a snapshot, don't bother enqueueing another
	* request right now. This will reduce the number of individual
	* snapshots and in turn the total amount of memory consumed (one big
	* snapshot is smaller than N subset snapshots).
	*/
	if (pending.compareAndSet(false, true)) {
	snapshotWriter.execute(new Runnable() {
	public void run() {
	try {
	writeSnapshotFile(processName, packageInfo);
	} finally {
	pending.set(false);
	}
	}
	});
	}
	}

	/**
	* Writes the zygote's snapshot to internal storage if profiling is enabled.
	*/
	public static void writeZygoteSnapshot() {
	if (!enabled) {
	return;
	}
	writeSnapshotFile("zygote", null);
	samplingProfiler.shutdown();
	samplingProfiler = null;
	startMillis = 0;
	}

	/**
	* pass in PackageInfo to retrieve various values for snapshot header
	*/
	private static void writeSnapshotFile(String processName, PackageInfo packageInfo) {
	if (!enabled) {
	return;
	}
	samplingProfiler.stop();

	/*
	* We use the global start time combined with the process name
	* as a unique ID. We can't use a counter because processes
	* restart. This could result in some overlap if we capture
	* two snapshots in rapid succession.
	*/
	String name = processName.replaceAll(":", ".");
	String path = SNAPSHOT_DIR + "/" + name + "-" + startMillis + ".snapshot";
	long start = System.currentTimeMillis();
	OutputStream outputStream = null;
	try {
	outputStream = new BufferedOutputStream(new FileOutputStream(path));
	PrintStream out = new PrintStream(outputStream);
	generateSnapshotHeader(name, packageInfo, out);
	if (out.checkError()) {
	throw new IOException();
	}
	BinaryHprofWriter.write(samplingProfiler.getHprofData(), outputStream);
	} catch (IOException e) {
	Log.e(TAG, "Error writing snapshot to " + path, e);
	return;
	} finally {
	IoUtils.closeQuietly(outputStream);
	}
	// set file readable to the world so that SamplingProfilerService
	// can put it to dropbox
	new File(path).setReadable(true, false);

	long elapsed = System.currentTimeMillis() - start;
	Log.i(TAG, "Wrote snapshot " + path + " in " + elapsed + "ms.");
	samplingProfiler.start(samplingProfilerMilliseconds);
	}

	/**
	* generate header for snapshots, with the following format
	* (like an HTTP header but without the \r):
	*
	* Version: <version number of profiler>\n
	* Process: <process name>\n
	* Package: <package name, if exists>\n
	* Package-Version: <version number of the package, if exists>\n
	* Build: <fingerprint>\n
	* \n
	* <the actual snapshot content begins here...>
	*/
	private static void generateSnapshotHeader(String processName, PackageInfo packageInfo,
	PrintStream out) {
	// profiler version
	out.println("Version: 3");
	out.println("Process: " + processName);
	if (packageInfo != null) {
	out.println("Package: " + packageInfo.packageName);
	out.println("Package-Version: " + packageInfo.versionCode);
	}
	out.println("Build: " + Build.FINGERPRINT);
	// single blank line means the end of snapshot header.
	out.println();
	}
	}

core/java/com/android/internal/os/ZygoteInit.java

+0 −5

Original line number	Original line	Diff line number	Diff line
	@@ -694,8 +694,6 @@ public class ZygoteInit {
	Trace.TRACE_TAG_DALVIK);		Trace.TRACE_TAG_DALVIK);
	bootTimingsTraceLog.traceBegin("ZygoteInit");		bootTimingsTraceLog.traceBegin("ZygoteInit");
	RuntimeInit.enableDdms();		RuntimeInit.enableDdms();
	// Start profiling the zygote initialization.
	SamplingProfilerIntegration.start();

	boolean startSystemServer = false;		boolean startSystemServer = false;
	String socketName = "zygote";		String socketName = "zygote";
	@@ -734,9 +732,6 @@ public class ZygoteInit {
	Zygote.resetNicePriority();		Zygote.resetNicePriority();
	}		}

	// Finish profiling the zygote initialization.
	SamplingProfilerIntegration.writeZygoteSnapshot();

	// Do an initial gc to clean up after startup		// Do an initial gc to clean up after startup
	bootTimingsTraceLog.traceBegin("PostZygoteInitGC");		bootTimingsTraceLog.traceBegin("PostZygoteInitGC");
	gcAndFinalize();		gcAndFinalize();

services/core/java/com/android/server/SamplingProfilerService.java

deleted100644 → 0

+0 −122

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright (C) 2010 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.
	*/

	package com.android.server;

	import android.content.ContentResolver;
	import android.os.DropBoxManager;
	import android.os.FileObserver;
	import android.os.Binder;

	import android.util.Slog;
	import android.content.Context;
	import android.database.ContentObserver;
	import android.os.SystemProperties;
	import android.provider.Settings;
	import com.android.internal.os.SamplingProfilerIntegration;
	import com.android.internal.util.DumpUtils;

	import java.io.File;
	import java.io.FileDescriptor;
	import java.io.IOException;
	import java.io.PrintWriter;

	public class SamplingProfilerService extends Binder {

	private static final String TAG = "SamplingProfilerService";
	private static final boolean LOCAL_LOGV = false;
	public static final String SNAPSHOT_DIR = SamplingProfilerIntegration.SNAPSHOT_DIR;

	private final Context mContext;
	private FileObserver snapshotObserver;

	public SamplingProfilerService(Context context) {
	mContext = context;
	registerSettingObserver(context);
	startWorking(context);
	}

	private void startWorking(Context context) {
	if (LOCAL_LOGV) Slog.v(TAG, "starting SamplingProfilerService!");

	final DropBoxManager dropbox =
	(DropBoxManager) context.getSystemService(Context.DROPBOX_SERVICE);

	// before FileObserver is ready, there could have already been some snapshots
	// in the directory, we don't want to miss them
	File[] snapshotFiles = new File(SNAPSHOT_DIR).listFiles();
	for (int i = 0; snapshotFiles != null && i < snapshotFiles.length; i++) {
	handleSnapshotFile(snapshotFiles[i], dropbox);
	}

	// detect new snapshot and put it in dropbox
	// delete it afterwards no matter what happened before
	// Note: needs listening at event ATTRIB rather than CLOSE_WRITE, because we set the
	// readability of snapshot files after writing them!
	snapshotObserver = new FileObserver(SNAPSHOT_DIR, FileObserver.ATTRIB) {
	@Override
	public void onEvent(int event, String path) {
	handleSnapshotFile(new File(SNAPSHOT_DIR, path), dropbox);
	}
	};
	snapshotObserver.startWatching();

	if (LOCAL_LOGV) Slog.v(TAG, "SamplingProfilerService activated");
	}

	private void handleSnapshotFile(File file, DropBoxManager dropbox) {
	try {
	dropbox.addFile(TAG, file, 0);
	if (LOCAL_LOGV) Slog.v(TAG, file.getPath() + " added to dropbox");
	} catch (IOException e) {
	Slog.e(TAG, "Can't add " + file.getPath() + " to dropbox", e);
	} finally {
	file.delete();
	}
	}

	private void registerSettingObserver(Context context) {
	ContentResolver contentResolver = context.getContentResolver();
	contentResolver.registerContentObserver(
	Settings.Global.getUriFor(Settings.Global.SAMPLING_PROFILER_MS),
	false, new SamplingProfilerSettingsObserver(contentResolver));
	}

	@Override
	protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
	if (!DumpUtils.checkDumpPermission(mContext, TAG, pw)) return;

	pw.println("SamplingProfilerService:");
	pw.println("Watching directory: " + SNAPSHOT_DIR);
	}

	private class SamplingProfilerSettingsObserver extends ContentObserver {
	private ContentResolver mContentResolver;
	public SamplingProfilerSettingsObserver(ContentResolver contentResolver) {
	super(null);
	mContentResolver = contentResolver;
	onChange(false);
	}
	@Override
	public void onChange(boolean selfChange) {
	Integer samplingProfilerMs = Settings.Global.getInt(
	mContentResolver, Settings.Global.SAMPLING_PROFILER_MS, 0);
	// setting this secure property will start or stop sampling profiler,
	// as well as adjust the the time between taking snapshots.
	SystemProperties.set("persist.sys.profiler_ms", samplingProfilerMs.toString());
	}
	}
	}

services/java/com/android/server/SystemServer.java

+0 −30

Original line number	Original line	Diff line number	Diff line
	@@ -55,7 +55,6 @@ import com.android.internal.app.NightDisplayController;
	import com.android.internal.logging.MetricsLogger;		import com.android.internal.logging.MetricsLogger;
	import com.android.internal.notification.SystemNotificationChannels;		import com.android.internal.notification.SystemNotificationChannels;
	import com.android.internal.os.BinderInternal;		import com.android.internal.os.BinderInternal;
	import com.android.internal.os.SamplingProfilerIntegration;
	import com.android.internal.util.EmergencyAffordanceManager;		import com.android.internal.util.EmergencyAffordanceManager;
	import com.android.internal.util.ConcurrentUtils;		import com.android.internal.util.ConcurrentUtils;
	import com.android.internal.widget.ILockSettings;		import com.android.internal.widget.ILockSettings;
	@@ -330,18 +329,6 @@ public final class SystemServer {
	// the property. http://b/11463182		// the property. http://b/11463182
	SystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());		SystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());

	// Enable the sampling profiler.
	if (SamplingProfilerIntegration.isEnabled()) {
	SamplingProfilerIntegration.start();
	mProfilerSnapshotTimer = new Timer();
	mProfilerSnapshotTimer.schedule(new TimerTask() {
	@Override
	public void run() {
	SamplingProfilerIntegration.writeSnapshot("system_server", null);
	}
	}, SNAPSHOT_INTERVAL, SNAPSHOT_INTERVAL);
	}

	// Mmmmmm... more memory!		// Mmmmmm... more memory!
	VMRuntime.getRuntime().clearGrowthLimit();		VMRuntime.getRuntime().clearGrowthLimit();

	@@ -710,8 +697,6 @@ public final class SystemServer {
	false);		false);
	boolean disableTextServices = SystemProperties.getBoolean("config.disable_textservices",		boolean disableTextServices = SystemProperties.getBoolean("config.disable_textservices",
	false);		false);
	boolean disableSamplingProfiler = SystemProperties.getBoolean("config.disable_samplingprof",
	false);
	boolean disableConsumerIr = SystemProperties.getBoolean("config.disable_consumerir", false);		boolean disableConsumerIr = SystemProperties.getBoolean("config.disable_consumerir", false);
	boolean disableVrManager = SystemProperties.getBoolean("config.disable_vrmanager", false);		boolean disableVrManager = SystemProperties.getBoolean("config.disable_vrmanager", false);
	boolean disableCameraService = SystemProperties.getBoolean("config.disable_cameraservice",		boolean disableCameraService = SystemProperties.getBoolean("config.disable_cameraservice",
	@@ -1353,21 +1338,6 @@ public final class SystemServer {
	}		}
	traceEnd();		traceEnd();

	if (!disableSamplingProfiler) {
	traceBeginAndSlog("StartSamplingProfilerService");
	try {
	// need to add this service even if SamplingProfilerIntegration.isEnabled()
	// is false, because it is this service that detects system property change and
	// turns on SamplingProfilerIntegration. Plus, when sampling profiler doesn't work,
	// there is little overhead for running this service.
	ServiceManager.addService("samplingprofiler",
	new SamplingProfilerService(context));
	} catch (Throwable e) {
	reportWtf("starting SamplingProfiler Service", e);
	}
	traceEnd();
	}

	if (!disableNetwork && !disableNetworkTime) {		if (!disableNetwork && !disableNetworkTime) {
	traceBeginAndSlog("StartNetworkTimeUpdateService");		traceBeginAndSlog("StartNetworkTimeUpdateService");
	try {		try {