tests/TileBenchmark/src/com/test/tilebenchmark/PlaybackGraphs.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2011 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.test.tilebenchmark;

 import android.content.res.Resources;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Paint;
 import android.graphics.Rect;
 import android.graphics.drawable.ShapeDrawable;

 import com.test.tilebenchmark.RunData.TileData;

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;

 public class PlaybackGraphs {
     private static final int BAR_WIDTH = PlaybackView.TILE_SCALE * 3;
     private static final float CANVAS_SCALE = 0.2f;
     private static final double IDEAL_FRAMES = 60;
     private static final int LABELOFFSET = 100;
     private static Paint whiteLabels;

     private static double viewportCoverage(TileData view, TileData tile) {
         if (tile.left < (view.right * view.scale)
                 && tile.right >= (view.left * view.scale)
                 && tile.top < (view.bottom * view.scale)
                 && tile.bottom >= (view.top * view.scale)) {
             return 1.0f;
         }
         return 0.0f;
     }

     protected interface MetricGen {
         public double getValue(TileData[] frame);

         public double getMax();

         public int getLabelId();
     };

     protected static MetricGen[] Metrics = new MetricGen[] {
             new MetricGen() {
                 // framerate graph
                 @Override
                 public double getValue(TileData[] frame) {
                     int renderTimeUS = frame[0].level;
                     return 1.0e6f / renderTimeUS;
                 }

                 @Override
                 public double getMax() {
                     return IDEAL_FRAMES;
                 }

                 @Override
                 public int getLabelId() {
                     return R.string.frames_per_second;
                 }
             }, new MetricGen() {
                 // coverage graph
                 @Override
                 public double getValue(TileData[] frame) {
                     double total = 0, totalCount = 0;
                     for (int tileID = 1; tileID < frame.length; tileID++) {
                         TileData data = frame[tileID];
                         double coverage = viewportCoverage(frame[0], data);
                         total += coverage * (data.isReady ? 100 : 0);
                         totalCount += coverage;
                     }
                     if (totalCount == 0) {
                         return -1;
                     }
                     return total / totalCount;
                 }

                 @Override
                 public double getMax() {
                     return 100;
                 }

                 @Override
                 public int getLabelId() {
                     return R.string.viewport_coverage;
                 }
             }
     };

     protected interface StatGen {
         public double getValue(double sortedValues[]);

         public int getLabelId();
     }

     public static double getPercentile(double sortedValues[], double ratioAbove) {
         if (sortedValues.length == 0)
             return -1;

         double index = ratioAbove * (sortedValues.length - 1);
         int intIndex = (int) Math.floor(index);
         if (index == intIndex) {
             return sortedValues[intIndex];
         }
         double alpha = index - intIndex;
         return sortedValues[intIndex] * (1 - alpha)
                 + sortedValues[intIndex + 1] * (alpha);
     }

     public static double getMean(double sortedValues[]) {
         if (sortedValues.length == 0)
             return -1;

         double agg = 0;
         for (double val : sortedValues) {
             agg += val;
         }
         return agg / sortedValues.length;
     }

     public static double getStdDev(double sortedValues[]) {
         if (sortedValues.length == 0)
             return -1;

         double agg = 0;
         double sqrAgg = 0;
         for (double val : sortedValues) {
             agg += val;
             sqrAgg += val*val;
         }
         double mean = agg / sortedValues.length;
         return Math.sqrt((sqrAgg / sortedValues.length) - (mean * mean));
     }

     protected static StatGen[] Stats = new StatGen[] {
             new StatGen() {
                 @Override
                 public double getValue(double[] sortedValues) {
                     return getPercentile(sortedValues, 0.25);
                 }

                 @Override
                 public int getLabelId() {
                     return R.string.percentile_25;
                 }
             }, new StatGen() {
                 @Override
                 public double getValue(double[] sortedValues) {
                     return getPercentile(sortedValues, 0.5);
                 }

                 @Override
                 public int getLabelId() {
                     return R.string.percentile_50;
                 }
             }, new StatGen() {
                 @Override
                 public double getValue(double[] sortedValues) {
                     return getPercentile(sortedValues, 0.75);
                 }

                 @Override
                 public int getLabelId() {
                     return R.string.percentile_75;
                 }
             }, new StatGen() {
                 @Override
                 public double getValue(double[] sortedValues) {
                     return getStdDev(sortedValues);
                 }

                 @Override
                 public int getLabelId() {
                     return R.string.std_dev;
                 }
             }, new StatGen() {
                 @Override
                 public double getValue(double[] sortedValues) {
                     return getMean(sortedValues);
                 }

                 @Override
                 public int getLabelId() {
                     return R.string.mean;
                 }
             },
     };

     public PlaybackGraphs() {
         whiteLabels = new Paint();
         whiteLabels.setColor(Color.WHITE);
         whiteLabels.setTextSize(PlaybackView.TILE_SCALE / 3);
     }

     private ArrayList<ShapeDrawable> mShapes = new ArrayList<ShapeDrawable>();
     protected final double[][] mStats = new double[Metrics.length][Stats.length];
     protected HashMap<String, Double> mSingleStats;

     private void gatherFrameMetric(int metricIndex, double metricValues[], RunData data) {
         // create graph out of rectangles, one per frame
         int lastBar = 0;
         for (int frameIndex = 0; frameIndex < data.frames.length; frameIndex++) {
             TileData frame[] = data.frames[frameIndex];
             int newBar = (int)((frame[0].top + frame[0].bottom) * frame[0].scale / 2.0f);

             MetricGen s = Metrics[metricIndex];
             double absoluteValue = s.getValue(frame);
             double relativeValue = absoluteValue / s.getMax();
             relativeValue = Math.min(1,relativeValue);
             relativeValue = Math.max(0,relativeValue);
             int rightPos = (int) (-BAR_WIDTH * metricIndex);
             int leftPos = (int) (-BAR_WIDTH * (metricIndex + relativeValue));

             ShapeDrawable graphBar = new ShapeDrawable();
             graphBar.getPaint().setColor(Color.BLUE);
             graphBar.setBounds(leftPos, lastBar, rightPos, newBar);

             mShapes.add(graphBar);
             metricValues[frameIndex] = absoluteValue;
             lastBar = newBar;
         }
     }

     public void setData(RunData data) {
         mShapes.clear();
         double metricValues[] = new double[data.frames.length];

         mSingleStats = data.singleStats;

         if (data.frames.length == 0) {
             return;
         }

         for (int metricIndex = 0; metricIndex < Metrics.length; metricIndex++) {
             // calculate metric based on list of frames
             gatherFrameMetric(metricIndex, metricValues, data);

             // store aggregate statistics per metric (median, and similar)
             Arrays.sort(metricValues);
             for (int statIndex = 0; statIndex < Stats.length; statIndex++) {
                 mStats[metricIndex][statIndex] =
                         Stats[statIndex].getValue(metricValues);
             }
         }
     }

     public void drawVerticalShiftedShapes(Canvas canvas,
             ArrayList<ShapeDrawable> shapes) {
         // Shapes drawn here are drawn relative to the viewRect
         Rect viewRect = shapes.get(shapes.size() - 1).getBounds();
         canvas.translate(0, 5 * PlaybackView.TILE_SCALE - viewRect.top);

         for (ShapeDrawable shape : mShapes) {
             shape.draw(canvas);
         }
         for (ShapeDrawable shape : shapes) {
             shape.draw(canvas);
         }
     }

     public void draw(Canvas canvas, ArrayList<ShapeDrawable> shapes,
             ArrayList<String> strings, Resources resources) {
         canvas.scale(CANVAS_SCALE, CANVAS_SCALE);

         canvas.translate(BAR_WIDTH * Metrics.length, 0);

         canvas.save();
         drawVerticalShiftedShapes(canvas, shapes);
         canvas.restore();

         for (int metricIndex = 0; metricIndex < Metrics.length; metricIndex++) {
             String label = resources.getString(
                     Metrics[metricIndex].getLabelId());
             int xPos = (metricIndex + 1) * -BAR_WIDTH;
             int yPos = LABELOFFSET;
             canvas.drawText(label, xPos, yPos, whiteLabels);
             for (int statIndex = 0; statIndex < Stats.length; statIndex++) {
                 String statLabel = resources.getString(
                         Stats[statIndex].getLabelId()).substring(0,3);
                 label = statLabel + " " + resources.getString(
                         R.string.format_stat, mStats[metricIndex][statIndex]);
                 yPos = LABELOFFSET + (1 + statIndex) * PlaybackView.TILE_SCALE
                         / 2;
                 canvas.drawText(label, xPos, yPos, whiteLabels);
             }
         }
         for (int stringIndex = 0; stringIndex < strings.size(); stringIndex++) {
             int yPos = LABELOFFSET + stringIndex * PlaybackView.TILE_SCALE / 2;
             canvas.drawText(strings.get(stringIndex), 0, yPos, whiteLabels);
         }
     }
 }
	/*
	* Copyright (C) 2011 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.test.tilebenchmark;

	import android.content.res.Resources;
	import android.graphics.Canvas;
	import android.graphics.Color;
	import android.graphics.Paint;
	import android.graphics.Rect;
	import android.graphics.drawable.ShapeDrawable;

	import com.test.tilebenchmark.RunData.TileData;

	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.HashMap;

	public class PlaybackGraphs {
	private static final int BAR_WIDTH = PlaybackView.TILE_SCALE * 3;
	private static final float CANVAS_SCALE = 0.2f;
	private static final double IDEAL_FRAMES = 60;
	private static final int LABELOFFSET = 100;
	private static Paint whiteLabels;

	private static double viewportCoverage(TileData view, TileData tile) {
	if (tile.left < (view.right * view.scale)
	&& tile.right >= (view.left * view.scale)
	&& tile.top < (view.bottom * view.scale)
	&& tile.bottom >= (view.top * view.scale)) {
	return 1.0f;
	}
	return 0.0f;
	}

	protected interface MetricGen {
	public double getValue(TileData[] frame);

	public double getMax();

	public int getLabelId();
	};

	protected static MetricGen[] Metrics = new MetricGen[] {
	new MetricGen() {
	// framerate graph
	@Override
	public double getValue(TileData[] frame) {
	int renderTimeUS = frame[0].level;
	return 1.0e6f / renderTimeUS;
	}

	@Override
	public double getMax() {
	return IDEAL_FRAMES;
	}

	@Override
	public int getLabelId() {
	return R.string.frames_per_second;
	}
	}, new MetricGen() {
	// coverage graph
	@Override
	public double getValue(TileData[] frame) {
	double total = 0, totalCount = 0;
	for (int tileID = 1; tileID < frame.length; tileID++) {
	TileData data = frame[tileID];
	double coverage = viewportCoverage(frame[0], data);
	total += coverage * (data.isReady ? 100 : 0);
	totalCount += coverage;
	}
	if (totalCount == 0) {
	return -1;
	}
	return total / totalCount;
	}

	@Override
	public double getMax() {
	return 100;
	}

	@Override
	public int getLabelId() {
	return R.string.viewport_coverage;
	}
	}
	};

	protected interface StatGen {
	public double getValue(double sortedValues[]);

	public int getLabelId();
	}

	public static double getPercentile(double sortedValues[], double ratioAbove) {
	if (sortedValues.length == 0)
	return -1;

	double index = ratioAbove * (sortedValues.length - 1);
	int intIndex = (int) Math.floor(index);
	if (index == intIndex) {
	return sortedValues[intIndex];
	}
	double alpha = index - intIndex;
	return sortedValues[intIndex] * (1 - alpha)
	+ sortedValues[intIndex + 1] * (alpha);
	}

	public static double getMean(double sortedValues[]) {
	if (sortedValues.length == 0)
	return -1;

	double agg = 0;
	for (double val : sortedValues) {
	agg += val;
	}
	return agg / sortedValues.length;
	}

	public static double getStdDev(double sortedValues[]) {
	if (sortedValues.length == 0)
	return -1;

	double agg = 0;
	double sqrAgg = 0;
	for (double val : sortedValues) {
	agg += val;
	sqrAgg += val*val;
	}
	double mean = agg / sortedValues.length;
	return Math.sqrt((sqrAgg / sortedValues.length) - (mean * mean));
	}

	protected static StatGen[] Stats = new StatGen[] {
	new StatGen() {
	@Override
	public double getValue(double[] sortedValues) {
	return getPercentile(sortedValues, 0.25);
	}

	@Override
	public int getLabelId() {
	return R.string.percentile_25;
	}
	}, new StatGen() {
	@Override
	public double getValue(double[] sortedValues) {
	return getPercentile(sortedValues, 0.5);
	}

	@Override
	public int getLabelId() {
	return R.string.percentile_50;
	}
	}, new StatGen() {
	@Override
	public double getValue(double[] sortedValues) {
	return getPercentile(sortedValues, 0.75);
	}

	@Override
	public int getLabelId() {
	return R.string.percentile_75;
	}
	}, new StatGen() {
	@Override
	public double getValue(double[] sortedValues) {
	return getStdDev(sortedValues);
	}

	@Override
	public int getLabelId() {
	return R.string.std_dev;
	}
	}, new StatGen() {
	@Override
	public double getValue(double[] sortedValues) {
	return getMean(sortedValues);
	}

	@Override
	public int getLabelId() {
	return R.string.mean;
	}
	},
	};

	public PlaybackGraphs() {
	whiteLabels = new Paint();
	whiteLabels.setColor(Color.WHITE);
	whiteLabels.setTextSize(PlaybackView.TILE_SCALE / 3);
	}

	private ArrayList<ShapeDrawable> mShapes = new ArrayList<ShapeDrawable>();
	protected final double[][] mStats = new double[Metrics.length][Stats.length];
	protected HashMap<String, Double> mSingleStats;

	private void gatherFrameMetric(int metricIndex, double metricValues[], RunData data) {
	// create graph out of rectangles, one per frame
	int lastBar = 0;
	for (int frameIndex = 0; frameIndex < data.frames.length; frameIndex++) {
	TileData frame[] = data.frames[frameIndex];
	int newBar = (int)((frame[0].top + frame[0].bottom) * frame[0].scale / 2.0f);

	MetricGen s = Metrics[metricIndex];
	double absoluteValue = s.getValue(frame);
	double relativeValue = absoluteValue / s.getMax();
	relativeValue = Math.min(1,relativeValue);
	relativeValue = Math.max(0,relativeValue);
	int rightPos = (int) (-BAR_WIDTH * metricIndex);
	int leftPos = (int) (-BAR_WIDTH * (metricIndex + relativeValue));

	ShapeDrawable graphBar = new ShapeDrawable();
	graphBar.getPaint().setColor(Color.BLUE);
	graphBar.setBounds(leftPos, lastBar, rightPos, newBar);

	mShapes.add(graphBar);
	metricValues[frameIndex] = absoluteValue;
	lastBar = newBar;
	}
	}

	public void setData(RunData data) {
	mShapes.clear();
	double metricValues[] = new double[data.frames.length];

	mSingleStats = data.singleStats;

	if (data.frames.length == 0) {
	return;
	}

	for (int metricIndex = 0; metricIndex < Metrics.length; metricIndex++) {
	// calculate metric based on list of frames
	gatherFrameMetric(metricIndex, metricValues, data);

	// store aggregate statistics per metric (median, and similar)
	Arrays.sort(metricValues);
	for (int statIndex = 0; statIndex < Stats.length; statIndex++) {
	mStats[metricIndex][statIndex] =
	Stats[statIndex].getValue(metricValues);
	}
	}
	}

	public void drawVerticalShiftedShapes(Canvas canvas,
	ArrayList<ShapeDrawable> shapes) {
	// Shapes drawn here are drawn relative to the viewRect
	Rect viewRect = shapes.get(shapes.size() - 1).getBounds();
	canvas.translate(0, 5 * PlaybackView.TILE_SCALE - viewRect.top);

	for (ShapeDrawable shape : mShapes) {
	shape.draw(canvas);
	}
	for (ShapeDrawable shape : shapes) {
	shape.draw(canvas);
	}
	}

	public void draw(Canvas canvas, ArrayList<ShapeDrawable> shapes,
	ArrayList<String> strings, Resources resources) {
	canvas.scale(CANVAS_SCALE, CANVAS_SCALE);

	canvas.translate(BAR_WIDTH * Metrics.length, 0);

	canvas.save();
	drawVerticalShiftedShapes(canvas, shapes);
	canvas.restore();

	for (int metricIndex = 0; metricIndex < Metrics.length; metricIndex++) {
	String label = resources.getString(
	Metrics[metricIndex].getLabelId());
	int xPos = (metricIndex + 1) * -BAR_WIDTH;
	int yPos = LABELOFFSET;
	canvas.drawText(label, xPos, yPos, whiteLabels);
	for (int statIndex = 0; statIndex < Stats.length; statIndex++) {
	String statLabel = resources.getString(
	Stats[statIndex].getLabelId()).substring(0,3);
	label = statLabel + " " + resources.getString(
	R.string.format_stat, mStats[metricIndex][statIndex]);
	yPos = LABELOFFSET + (1 + statIndex) * PlaybackView.TILE_SCALE
	/ 2;
	canvas.drawText(label, xPos, yPos, whiteLabels);
	}
	}
	for (int stringIndex = 0; stringIndex < strings.size(); stringIndex++) {
	int yPos = LABELOFFSET + stringIndex * PlaybackView.TILE_SCALE / 2;
	canvas.drawText(strings.get(stringIndex), 0, yPos, whiteLabels);
	}
	}
	}