sysperfana/perfinvestigator/com.nokia.carbide.cpp.pi.power/src/com/nokia/carbide/cpp/pi/power/PwrTrace.java
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/sysperfana/perfinvestigator/com.nokia.carbide.cpp.pi.power/src/com/nokia/carbide/cpp/pi/power/PwrTrace.java Thu Feb 11 15:32:31 2010 +0200
@@ -0,0 +1,322 @@
+/*
+ * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * All rights reserved.
+ * This component and the accompanying materials are made available
+ * under the terms of the License "Eclipse Public License v1.0"
+ * which accompanies this distribution, and is available
+ * at the URL "http://www.eclipse.org/legal/epl-v10.html".
+ *
+ * Initial Contributors:
+ * Nokia Corporation - initial contribution.
+ *
+ * Contributors:
+ *
+ * Description:
+ *
+ */
+
+package com.nokia.carbide.cpp.pi.power;
+
+import java.util.ArrayList;
+
+import com.nokia.carbide.cpp.internal.pi.analyser.NpiInstanceRepository;
+import com.nokia.carbide.cpp.internal.pi.model.GenericSampledTrace;
+import com.nokia.carbide.cpp.internal.pi.visual.GenericTraceGraph;
+import com.nokia.carbide.cpp.pi.editors.PIPageEditor;
+
+
+public class PwrTrace extends GenericSampledTrace
+{
+ private static final long serialVersionUID = -2398791759386296139L;
+
+ transient private PowerTraceGraph[] graphs = null;
+ transient private boolean complete = false;
+ transient private ArrayList<PwrSample> powerChangePoints; // times when power samples change
+ transient private long maxEndTime;
+
+ private float voltage = 3.7f;
+
+ // used when manually positioning the trace
+ public int offset = 0;
+
+ public float batterySize = 1500f;
+
+ private double scale = 0.0;
+ private double min = 0.0;
+ private double max = 0.0;
+ private double synchValue = 0.0;
+
+ transient private int[] sampleTimes;
+ transient private int[] ampValues;
+ transient private int[] voltValues;
+ transient private int[] capaValues;
+ transient private double maxAmps = Double.MIN_VALUE;
+ transient private double minAmps = Double.MAX_VALUE;
+ transient private double maxPower = 0.0;
+
+ public GenericTraceGraph getTraceGraph(int graphIndex, int uid)
+ {
+ return getPowerGraph(graphIndex, uid);
+ }
+
+ public PowerTraceGraph getPowerGraph(int graphIndex, int uid)
+ {
+ if (graphs == null) {
+ graphs = new PowerTraceGraph[3];
+ maxEndTime = (long) ((PIPageEditor.currentPageEditor().getMaxEndTime() + .0005) * 1000);
+ }
+
+ // note that graphIndex needs not match the index sent to GppTraceGraph
+ if ( (graphIndex == PIPageEditor.THREADS_PAGE)
+ || (graphIndex == PIPageEditor.BINARIES_PAGE)
+ || (graphIndex == PIPageEditor.FUNCTIONS_PAGE)) {
+ if (graphs[graphIndex] == null)
+ graphs[graphIndex] = new PowerTraceGraph(graphIndex, uid, this);
+ return graphs[graphIndex];
+ }
+
+ return null;
+ }
+
+ public float getBatterySize()
+ {
+ return batterySize;
+ }
+
+ public void setBatterySize(float newVal)
+ {
+ batterySize = newVal;
+ }
+
+ public int getOffset()
+ {
+ return offset;
+ }
+
+ public float getVoltage()
+ {
+ return voltage;
+ }
+
+ public int[] getSampleTimes()
+ {
+ return sampleTimes;
+ }
+
+ public int[] getAmpValues()
+ {
+ return ampValues;
+ }
+
+ public int[] getVoltValues()
+ {
+ return voltValues;
+ }
+
+ public int[] getCapaValues()
+ {
+ return capaValues;
+ }
+
+ public double getMaxAmps()
+ {
+ return maxAmps;
+ }
+
+ public double getMinAmps()
+ {
+ return minAmps;
+ }
+
+ public double getMaxPower()
+ {
+ return maxPower;
+ }
+
+ public void setVoltage(float voltage)
+ {
+ this.voltage = voltage;
+ }
+
+ public void setOffset( int newOffset )
+ {
+ int mySize = getSampleAmount();
+
+ if( newOffset > mySize )
+ offset = mySize;
+ else if( (newOffset * -1) > mySize )
+ offset = (-1)*mySize;
+ else
+ offset = newOffset;
+ }
+
+ public double getScale()
+ {
+ return scale;
+ }
+
+ public double getMin()
+ {
+ return min;
+ }
+
+ public double getMax()
+ {
+ return max;
+ }
+
+ public long getMaxEndTime()
+ {
+ return maxEndTime;
+ }
+
+ public double getSynchValue()
+ {
+ return synchValue;
+ }
+
+ public void setSynchValue(double aSynchValue)
+ {
+ synchValue = aSynchValue;
+ }
+
+ public void addSample(PwrSample sample)
+ {
+ this.samples.add(sample);
+ }
+
+ public PwrSample getPwrSample(int number)
+ {
+ return (PwrSample)this.samples.elementAt(number);
+ }
+
+ // compensate for different sampling speeds.
+ // the software traces are done at 1KHz and the
+ // power traces are typically done at 250Khz.
+ //
+ public void initData()
+ {
+ ArrayList<PwrSample> powerChangePoints = new ArrayList<PwrSample>();
+ PwrSample sample = (PwrSample) this.samples.get(0);
+
+ long currentTime = sample.sampleSynchTime;
+ double currentCurrent = sample.current;
+ double currentVoltage = sample.voltage;
+ double currentCapacity = sample.capacity;
+
+ for (int i = 1; i < this.samples.size(); i++) {
+ sample = (PwrSample) this.samples.get(i);
+ if ( sample.current != currentCurrent
+ || sample.voltage != currentVoltage
+ || sample.capacity != currentCapacity) {
+ PwrSample addSample = new PwrSample(currentTime, currentCurrent, currentVoltage, currentCapacity);
+ powerChangePoints.add(addSample);
+ currentTime = sample.sampleSynchTime;
+ currentCurrent = sample.current;
+ currentVoltage = sample.voltage;
+ currentCapacity = sample.capacity;
+ }
+ }
+
+ sample = powerChangePoints.get(powerChangePoints.size() - 1);
+ if ( sample.current != currentCurrent
+ || sample.voltage != currentVoltage
+ || sample.capacity != currentCapacity) {
+ powerChangePoints.add(new PwrSample(currentTime, currentCurrent, currentVoltage, currentCapacity));
+ }
+
+ this.powerChangePoints = powerChangePoints;
+
+ sampleTimes = new int[this.powerChangePoints.size()];
+ ampValues = new int[this.powerChangePoints.size()];
+ voltValues = new int[this.powerChangePoints.size()];
+ capaValues = new int[this.powerChangePoints.size()];
+
+ int localMaxAmps = Integer.MIN_VALUE;
+ int localMinAmps = Integer.MAX_VALUE;
+
+ for (int i = 0; i < this.powerChangePoints.size(); i++)
+ {
+ PwrSample tmp = this.powerChangePoints.get(i);
+ sampleTimes[i] = (int)Math.abs(tmp.sampleSynchTime);
+ ampValues[i] = (int)Math.abs(tmp.current); // in milliamps
+ voltValues[i] = (int)Math.abs(tmp.voltage); // in millivolts
+ capaValues[i] = (int)Math.abs(tmp.capacity);
+
+ if (ampValues[i] > localMaxAmps)
+ {
+ localMaxAmps = ampValues[i];
+ }
+ else if (ampValues[i] < minAmps )
+ {
+ localMinAmps = ampValues[i];
+ }
+ }
+
+ maxAmps = localMaxAmps;
+ minAmps = localMinAmps;
+
+ scaleMaxPower();
+ }
+
+ public ArrayList<PwrSample> getPowerChangePoints()
+ {
+ return this.powerChangePoints;
+ }
+
+ public void scaleMaxPower()
+ {
+ maxPower = maxAmps * this.voltage;
+
+ if (maxPower < 10)
+ maxPower = 10;
+ else if (maxPower < 20)
+ maxPower = 20;
+ else if (maxPower < 50)
+ maxPower = 50;
+ else if (maxPower < 100)
+ maxPower = 100;
+ else if (maxPower < 200)
+ maxPower = 200;
+ else if (maxPower < 500)
+ maxPower = 500;
+ else if (maxPower < 1000)
+ maxPower = 1000;
+ else if (maxPower < 2000)
+ maxPower = 2000;
+ else if (maxPower < 5000)
+ maxPower = 5000;
+ else if (maxPower < 10000)
+ maxPower = 10000;
+ else if (maxPower < 20000)
+ maxPower = 20000;
+ else if (maxPower < 50000)
+ maxPower = 50000;
+ else if (maxPower < 100000)
+ maxPower = 100000;
+ }
+
+ /*
+ * Check if the power trace is complete (first sample is at time 1, sample N is at time N)
+ */
+ public void setComplete()
+ {
+ int samplingInterval = (Integer) NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.samplingInterval"); //$NON-NLS-1$
+ int size;
+
+ this.complete = true;
+
+ size = this.samples.size();
+ for (int i = 0; i < size; i++) {
+ PwrSample element = (PwrSample)this.samples.get(i);
+ if (element.sampleSynchTime != i*samplingInterval) {
+ this.complete = false;
+ break;
+ }
+ }
+ }
+
+ public boolean isComplete() {
+ return this.complete;
+ }
+}