services/core/java/com/android/server/pm/CompilerStats.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2016 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.pm;

 import android.util.ArrayMap;
 import android.util.AtomicFile;
 import android.util.Log;

 import com.android.internal.util.FastPrintWriter;
 import com.android.internal.util.IndentingPrintWriter;

 import libcore.io.IoUtils;

 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
 import java.io.Reader;
 import java.io.Writer;
 import java.util.HashMap;
 import java.util.Map;

 /**
  * A class that collects, serializes and deserializes compiler-related statistics on a
  * per-package per-code-path basis.
  *
  * Currently used to track compile times.
  */
 class CompilerStats extends AbstractStatsBase<Void> {

     private final static String COMPILER_STATS_VERSION_HEADER = "PACKAGE_MANAGER__COMPILER_STATS__";
     private final static int COMPILER_STATS_VERSION = 1;

     /**
      * Class to collect all stats pertaining to one package.
      */
     static class PackageStats {

         private final String packageName;

         /**
          * This map stores compile-times for all code paths in the package. The value
          * is in milliseconds.
          */
         private final Map<String, Long> compileTimePerCodePath;

         /**
          * @param packageName
          */
         public PackageStats(String packageName) {
             this.packageName = packageName;
             // We expect at least one element in here, but let's make it minimal.
             compileTimePerCodePath = new ArrayMap<>(2);
         }

         public String getPackageName() {
             return packageName;
         }

         /**
          * Return the recorded compile time for a given code path. Returns
          * 0 if there is no recorded time.
          */
         public long getCompileTime(String codePath) {
             String storagePath = getStoredPathFromCodePath(codePath);
             synchronized (compileTimePerCodePath) {
                 Long l = compileTimePerCodePath.get(storagePath);
                 if (l == null) {
                     return 0;
                 }
                 return l;
             }
         }

         public void setCompileTime(String codePath, long compileTimeInMs) {
             String storagePath = getStoredPathFromCodePath(codePath);
             synchronized (compileTimePerCodePath) {
                 if (compileTimeInMs <= 0) {
                     compileTimePerCodePath.remove(storagePath);
                 } else {
                     compileTimePerCodePath.put(storagePath, compileTimeInMs);
                 }
             }
         }

         private static String getStoredPathFromCodePath(String codePath) {
             int lastSlash = codePath.lastIndexOf(File.separatorChar);
             return codePath.substring(lastSlash + 1);
         }

         public void dump(IndentingPrintWriter ipw) {
             synchronized (compileTimePerCodePath) {
                 if (compileTimePerCodePath.size() == 0) {
                     ipw.println("(No recorded stats)");
                 } else {
                     for (Map.Entry<String, Long> e : compileTimePerCodePath.entrySet()) {
                         ipw.println(" " + e.getKey() + " - " + e.getValue());
                     }
                 }
             }
         }
     }

     private final Map<String, PackageStats> packageStats;

     public CompilerStats() {
         super("package-cstats.list", "CompilerStats_DiskWriter", /* lock */ false);
         packageStats = new HashMap<>();
     }

     public PackageStats getPackageStats(String packageName) {
         synchronized (packageStats) {
             return packageStats.get(packageName);
         }
     }

     public void setPackageStats(String packageName, PackageStats stats) {
         synchronized (packageStats) {
             packageStats.put(packageName, stats);
         }
     }

     public PackageStats createPackageStats(String packageName) {
         synchronized (packageStats) {
             PackageStats newStats = new PackageStats(packageName);
             packageStats.put(packageName, newStats);
             return newStats;
         }
     }

     public PackageStats getOrCreatePackageStats(String packageName) {
         synchronized (packageStats) {
             PackageStats existingStats = packageStats.get(packageName);
             if (existingStats != null) {
                 return existingStats;
             }

             return createPackageStats(packageName);
         }
     }

     public void deletePackageStats(String packageName) {
         synchronized (packageStats) {
             packageStats.remove(packageName);
         }
     }

     // I/O

     // The encoding is simple:
     //
     // 1) The first line is a line consisting of the version header and the version number.
     //
     // 2) The rest of the file is package data.
     // 2.1) A package is started by any line not starting with "-";
     // 2.2) Any line starting with "-" is code path data. The format is:
     //      '-'{code-path}':'{compile-time}

     public void write(Writer out) {
         @SuppressWarnings("resource")
         FastPrintWriter fpw = new FastPrintWriter(out);

         fpw.print(COMPILER_STATS_VERSION_HEADER);
         fpw.println(COMPILER_STATS_VERSION);

         synchronized (packageStats) {
             for (PackageStats pkg : packageStats.values()) {
                 synchronized (pkg.compileTimePerCodePath) {
                     if (!pkg.compileTimePerCodePath.isEmpty()) {
                         fpw.println(pkg.getPackageName());

                         for (Map.Entry<String, Long> e : pkg.compileTimePerCodePath.entrySet()) {
                             fpw.println("-" + e.getKey() + ":" + e.getValue());
                         }
                     }
                 }
             }
         }

         fpw.flush();
     }

     public boolean read(Reader r) {
         synchronized (packageStats) {
             // TODO: Could make this a final switch, then we wouldn't have to synchronize over
             //       the whole reading.
             packageStats.clear();

             try {
                 BufferedReader in = new BufferedReader(r);

                 // Read header, do version check.
                 String versionLine = in.readLine();
                 if (versionLine == null) {
                     throw new IllegalArgumentException("No version line found.");
                 } else {
                     if (!versionLine.startsWith(COMPILER_STATS_VERSION_HEADER)) {
                         throw new IllegalArgumentException("Invalid version line: " + versionLine);
                     }
                     int version = Integer.parseInt(
                             versionLine.substring(COMPILER_STATS_VERSION_HEADER.length()));
                     if (version != COMPILER_STATS_VERSION) {
                         // TODO: Upgrade older formats? For now, just reject and regenerate.
                         throw new IllegalArgumentException("Unexpected version: " + version);
                     }
                 }

                 // For simpler code, we ignore any data lines before the first package. We
                 // collect it in a fake package.
                 PackageStats currentPackage = new PackageStats("fake package");

                 String s = null;
                 while ((s = in.readLine()) != null) {
                     if (s.startsWith("-")) {
                         int colonIndex = s.indexOf(':');
                         if (colonIndex == -1 || colonIndex == 1) {
                             throw new IllegalArgumentException("Could not parse data " + s);
                         }
                         String codePath = s.substring(1, colonIndex);
                         long time = Long.parseLong(s.substring(colonIndex + 1));
                         currentPackage.setCompileTime(codePath, time);
                     } else {
                         currentPackage = getOrCreatePackageStats(s);
                     }
                 }
             } catch (Exception e) {
                 Log.e(PackageManagerService.TAG, "Error parsing compiler stats", e);
                 return false;
             }

             return true;
         }
     }

     void writeNow() {
         writeNow(null);
     }

     boolean maybeWriteAsync() {
         return maybeWriteAsync(null);
     }

     @Override
     protected void writeInternal(Void data) {
         AtomicFile file = getFile();
         FileOutputStream f = null;

         try {
             f = file.startWrite();
             OutputStreamWriter osw = new OutputStreamWriter(f);
             write(osw);
             osw.flush();
             file.finishWrite(f);
         } catch (IOException e) {
             if (f != null) {
                 file.failWrite(f);
             }
             Log.e(PackageManagerService.TAG, "Failed to write compiler stats", e);
         }
     }

     void read() {
         read((Void)null);
     }

     @Override
     protected void readInternal(Void data) {
         AtomicFile file = getFile();
         BufferedReader in = null;
         try {
             in = new BufferedReader(new InputStreamReader(file.openRead()));
             read(in);
         } catch (FileNotFoundException expected) {
         } finally {
             IoUtils.closeQuietly(in);
         }
     }
 }
	/*
	* Copyright (C) 2016 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.pm;

	import android.util.ArrayMap;
	import android.util.AtomicFile;
	import android.util.Log;

	import com.android.internal.util.FastPrintWriter;
	import com.android.internal.util.IndentingPrintWriter;

	import libcore.io.IoUtils;

	import java.io.BufferedReader;
	import java.io.File;
	import java.io.FileNotFoundException;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.InputStreamReader;
	import java.io.OutputStreamWriter;
	import java.io.Reader;
	import java.io.Writer;
	import java.util.HashMap;
	import java.util.Map;

	/**
	* A class that collects, serializes and deserializes compiler-related statistics on a
	* per-package per-code-path basis.
	*
	* Currently used to track compile times.
	*/
	class CompilerStats extends AbstractStatsBase<Void> {

	private final static String COMPILER_STATS_VERSION_HEADER = "PACKAGE_MANAGER__COMPILER_STATS__";
	private final static int COMPILER_STATS_VERSION = 1;

	/**
	* Class to collect all stats pertaining to one package.
	*/
	static class PackageStats {

	private final String packageName;

	/**
	* This map stores compile-times for all code paths in the package. The value
	* is in milliseconds.
	*/
	private final Map<String, Long> compileTimePerCodePath;

	/**
	* @param packageName
	*/
	public PackageStats(String packageName) {
	this.packageName = packageName;
	// We expect at least one element in here, but let's make it minimal.
	compileTimePerCodePath = new ArrayMap<>(2);
	}

	public String getPackageName() {
	return packageName;
	}

	/**
	* Return the recorded compile time for a given code path. Returns
	* 0 if there is no recorded time.
	*/
	public long getCompileTime(String codePath) {
	String storagePath = getStoredPathFromCodePath(codePath);
	synchronized (compileTimePerCodePath) {
	Long l = compileTimePerCodePath.get(storagePath);
	if (l == null) {
	return 0;
	}
	return l;
	}
	}

	public void setCompileTime(String codePath, long compileTimeInMs) {
	String storagePath = getStoredPathFromCodePath(codePath);
	synchronized (compileTimePerCodePath) {
	if (compileTimeInMs <= 0) {
	compileTimePerCodePath.remove(storagePath);
	} else {
	compileTimePerCodePath.put(storagePath, compileTimeInMs);
	}
	}
	}

	private static String getStoredPathFromCodePath(String codePath) {
	int lastSlash = codePath.lastIndexOf(File.separatorChar);
	return codePath.substring(lastSlash + 1);
	}

	public void dump(IndentingPrintWriter ipw) {
	synchronized (compileTimePerCodePath) {
	if (compileTimePerCodePath.size() == 0) {
	ipw.println("(No recorded stats)");
	} else {
	for (Map.Entry<String, Long> e : compileTimePerCodePath.entrySet()) {
	ipw.println(" " + e.getKey() + " - " + e.getValue());
	}
	}
	}
	}
	}

	private final Map<String, PackageStats> packageStats;

	public CompilerStats() {
	super("package-cstats.list", "CompilerStats_DiskWriter", /* lock */ false);
	packageStats = new HashMap<>();
	}

	public PackageStats getPackageStats(String packageName) {
	synchronized (packageStats) {
	return packageStats.get(packageName);
	}
	}

	public void setPackageStats(String packageName, PackageStats stats) {
	synchronized (packageStats) {
	packageStats.put(packageName, stats);
	}
	}

	public PackageStats createPackageStats(String packageName) {
	synchronized (packageStats) {
	PackageStats newStats = new PackageStats(packageName);
	packageStats.put(packageName, newStats);
	return newStats;
	}
	}

	public PackageStats getOrCreatePackageStats(String packageName) {
	synchronized (packageStats) {
	PackageStats existingStats = packageStats.get(packageName);
	if (existingStats != null) {
	return existingStats;
	}

	return createPackageStats(packageName);
	}
	}

	public void deletePackageStats(String packageName) {
	synchronized (packageStats) {
	packageStats.remove(packageName);
	}
	}

	// I/O

	// The encoding is simple:
	//
	// 1) The first line is a line consisting of the version header and the version number.
	//
	// 2) The rest of the file is package data.
	// 2.1) A package is started by any line not starting with "-";
	// 2.2) Any line starting with "-" is code path data. The format is:
	// '-'{code-path}':'{compile-time}

	public void write(Writer out) {
	@SuppressWarnings("resource")
	FastPrintWriter fpw = new FastPrintWriter(out);

	fpw.print(COMPILER_STATS_VERSION_HEADER);
	fpw.println(COMPILER_STATS_VERSION);

	synchronized (packageStats) {
	for (PackageStats pkg : packageStats.values()) {
	synchronized (pkg.compileTimePerCodePath) {
	if (!pkg.compileTimePerCodePath.isEmpty()) {
	fpw.println(pkg.getPackageName());

	for (Map.Entry<String, Long> e : pkg.compileTimePerCodePath.entrySet()) {
	fpw.println("-" + e.getKey() + ":" + e.getValue());
	}
	}
	}
	}
	}

	fpw.flush();
	}

	public boolean read(Reader r) {
	synchronized (packageStats) {
	// TODO: Could make this a final switch, then we wouldn't have to synchronize over
	// the whole reading.
	packageStats.clear();

	try {
	BufferedReader in = new BufferedReader(r);

	// Read header, do version check.
	String versionLine = in.readLine();
	if (versionLine == null) {
	throw new IllegalArgumentException("No version line found.");
	} else {
	if (!versionLine.startsWith(COMPILER_STATS_VERSION_HEADER)) {
	throw new IllegalArgumentException("Invalid version line: " + versionLine);
	}
	int version = Integer.parseInt(
	versionLine.substring(COMPILER_STATS_VERSION_HEADER.length()));
	if (version != COMPILER_STATS_VERSION) {
	// TODO: Upgrade older formats? For now, just reject and regenerate.
	throw new IllegalArgumentException("Unexpected version: " + version);
	}
	}

	// For simpler code, we ignore any data lines before the first package. We
	// collect it in a fake package.
	PackageStats currentPackage = new PackageStats("fake package");

	String s = null;
	while ((s = in.readLine()) != null) {
	if (s.startsWith("-")) {
	int colonIndex = s.indexOf(':');
	if (colonIndex == -1 \|\| colonIndex == 1) {
	throw new IllegalArgumentException("Could not parse data " + s);
	}
	String codePath = s.substring(1, colonIndex);
	long time = Long.parseLong(s.substring(colonIndex + 1));
	currentPackage.setCompileTime(codePath, time);
	} else {
	currentPackage = getOrCreatePackageStats(s);
	}
	}
	} catch (Exception e) {
	Log.e(PackageManagerService.TAG, "Error parsing compiler stats", e);
	return false;
	}

	return true;
	}
	}

	void writeNow() {
	writeNow(null);
	}

	boolean maybeWriteAsync() {
	return maybeWriteAsync(null);
	}

	@Override
	protected void writeInternal(Void data) {
	AtomicFile file = getFile();
	FileOutputStream f = null;

	try {
	f = file.startWrite();
	OutputStreamWriter osw = new OutputStreamWriter(f);
	write(osw);
	osw.flush();
	file.finishWrite(f);
	} catch (IOException e) {
	if (f != null) {
	file.failWrite(f);
	}
	Log.e(PackageManagerService.TAG, "Failed to write compiler stats", e);
	}
	}

	void read() {
	read((Void)null);
	}

	@Override
	protected void readInternal(Void data) {
	AtomicFile file = getFile();
	BufferedReader in = null;
	try {
	in = new BufferedReader(new InputStreamReader(file.openRead()));
	read(in);
	} catch (FileNotFoundException expected) {
	} finally {
	IoUtils.closeQuietly(in);
	}
	}
	}