1 /*

     2  * Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

     5  * under the terms of "Eclipse Public License v1.0"

     6  * which accompanies this distribution, and is available

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8  *

     9  * Initial Contributors:

    10  * Nokia Corporation - initial contribution.

    11  *

    12  * Contributors:

    13  *

    14  * Description:  Definitions for the class MemoryActivityModel

    15  *

    16  */

    17 package com.nokia.s60tools.analyzetool.internal.engine;

    18 import java.util.AbstractList;

    19 import java.util.ArrayList;

    20 import java.util.Collection;

    21 

    22 import com.nokia.s60tools.analyzetool.engine.IMemoryActivityModel;

    23 import com.nokia.s60tools.analyzetool.engine.IMemoryActivityModelChangeListener;

    24 import com.nokia.s60tools.analyzetool.engine.statistic.BaseInfo;

    25 import com.nokia.s60tools.analyzetool.engine.statistic.ProcessInfo;

    26 

    27 /**

    28  * AnalyseGraphModel

    29  * this class fills a model suitable for AnalyseTool graph

    30  * the model is initialised from the constructor.  

    31  *

    32  */

    33 public class MemoryActivityModel implements IMemoryActivityModel {

    34 	private final Collection<IMemoryActivityModelChangeListener> listeners; // listeners for changes to the model

    35 

    36 	/** list of processes */

    37 	private AbstractList<ProcessInfo> processList;

    38 	

    39 	/** time of the process that started first */

    40 	private Long firstProcessTime = 0L;

    41 	

    42 	/** time of the process that ended last */

    43 	private Long lastProcessTime = 0L;

    44 	

    45 	/** first memory operation in the model */

    46 	private BaseInfo firstMemOp = null;

    47 	

    48 	/** time of the first memory operation in the model */

    49 	private Long firstMemOpTime = 0L;

    50 	

    51 	/** last memory opeartion in the  model */

    52 	private BaseInfo lastMemOp =  null;

    53 	

    54 	/** time of the last memory operation in the model */

    55 	private Long lastMemOpTime = 0L;

    56 	

    57 	/** highest cummulative memory allocation in all processes */

    58 	private int highestCumMemSize = 0;

    59 

    60 	/** the currently selected process*/

    61 	private ProcessInfo selectedProcess;

    62 	

    63 	/** computed values for currently selected process*/

    64 	private ProcessInfoComputedValues selectedProcessComputedValues;

    65 	

    66 

    67 	/**

    68 	 * Constructor. 

    69 	 * 

    70 	 */

    71 	public MemoryActivityModel() {

    72 		this.listeners= new ArrayList<IMemoryActivityModelChangeListener>();

    73 	}

    74 	

    75 	/* (non-Javadoc)

    76 	 * @see com.nokia.s60tools.analyzetool.engine.IMemoryActivityModel#addProcesses(java.util.AbstractList)

    77 	 */

    78 	public void addProcesses(AbstractList<ProcessInfo> processes){

    79 		if (processes == null) {

    80 			this.processList = new ArrayList<ProcessInfo>();

    81 		} else {

    82 			this.processList = new ArrayList<ProcessInfo>(processes);

    83 		}

    84 		selectedProcess = null;

    85 		selectedProcessComputedValues = null;

    86 		firstProcessTime = 0L;

    87 		lastProcessTime = 0L;

    88 		firstMemOp = null;

    89 		firstMemOpTime = 0L;

    90 		lastMemOp =  null;

    91 		lastMemOpTime = 0L;

    92 		highestCumMemSize = 0;

    93 		// compute all needed values.

    94 		if (!processList.isEmpty()) {

    95 			computeValues();

    96 		}	

    97 		fireDataChanged();

    98 		

    99 	}

   100 	

   101 	/**

   102 	 * Notifies listeners that data has changed

   103 	 */

   104 	private void fireDataChanged() {

   105 		for (IMemoryActivityModelChangeListener listener : listeners) {

   106 			listener.onProcessesAdded();

   107 		}

   108 		

   109 	}

   110 	/* (non-Javadoc)

   111 	 * @see com.nokia.s60tools.analyzetool.engine.IMemoryActivityModel#setSelectedProcess(com.nokia.s60tools.analyzetool.engine.statistic.ProcessInfo)

   112 	 */

   113 	public void setSelectedProcess(ProcessInfo processInfo) throws IllegalArgumentException {

   114 		if (this.processList == null || processInfo != null && !this.processList.contains(processInfo)) {

   115 			throw new IllegalArgumentException("Error selecting unknown process");

   116 		}

   117 		selectedProcess = processInfo;

   118 		selectedProcessComputedValues = null;

   119 		fireProcessSelected(processInfo);

   120 	}

   121 	

   122 	/* (non-Javadoc)

   123 	 * @see com.nokia.s60tools.analyzetool.engine.IMemoryActivityModel#getSelectedProcess()

   124 	 */

   125 	public ProcessInfo getSelectedProcess(){

   126 		return selectedProcess;

   127 	}

   128 	

   129 	/**

   130 	 * Notifies listeners that data has changed

   131 	 */

   132 	private void fireProcessSelected(ProcessInfo p) {

   133 		for (IMemoryActivityModelChangeListener listener : listeners) {

   134 			listener.onProcessSelected(p);

   135 		}

   136 		

   137 	}

   138 

   139 	/**

   140 	 * Compute the model

   141 	 */

   142 	private void computeValues() {

   143 		computeFirstProcessTime();

   144 		computeLastProcessTime();

   145 		computeFirstMemOpTime();

   146 		computeLastMemOpTime();

   147 		computeHighestCumulatedMemoryAlloc();

   148 	}

   149 

   150 	/**

   151 	 * find the start time of the process that started first

   152 	 */

   153 	private void computeFirstProcessTime() {

   154 		Long smallestTime = Long.MAX_VALUE;

   155 		firstProcessTime = 0L;//stays zero if there are no processes

   156 

   157 		for (ProcessInfo process : processList) {

   158 			if (process.getStartTime() < smallestTime) {

   159 				smallestTime = process.getStartTime();

   160 				firstProcessTime = smallestTime; 

   161 			}

   162 		}

   163 	}

   164 	

   165 	/**

   166 	 * find end time of the process that ended last

   167 	 */

   168 	private void computeLastProcessTime() {

   169 		Long biggestTime = Long.MIN_VALUE;

   170 		lastProcessTime = 0L; //stays zero if there are no processes

   171 		

   172 		for (ProcessInfo process : processList) {

   173 			Long tmpTime = process.getEndTime();

   174 			if (tmpTime > biggestTime) {

   175 				biggestTime = tmpTime;

   176 				lastProcessTime = tmpTime;

   177 			}

   178 		}

   179 	}

   180 

   181 	/**

   182 	 *  find first memory time from all processes

   183 	 */

   184 	private void computeFirstMemOpTime() {

   185 		findFirstMemOp();

   186 	}

   187 

   188 	/** find first memory operation in the model */

   189 	private void findFirstMemOp() {

   190 		Long smallestTime = Long.MAX_VALUE;

   191 		for (ProcessInfo process : processList) {

   192 			AbstractList<BaseInfo> allocsAndFrees = process.getAllocsFrees();

   193 			BaseInfo baseInfo = allocsAndFrees.get(0);

   194 			long time = baseInfo.getTime();

   195 			if (time < smallestTime ){

   196 				smallestTime = time;

   197 				firstMemOp = baseInfo;

   198 			}

   199 		}

   200 		if (firstMemOp != null) {

   201 			firstMemOpTime = smallestTime;

   202 		}

   203 	}

   204 	

   205 	/**

   206 	 * find last memory operation time from all processes

   207 	 */

   208 	void computeLastMemOpTime() {

   209 		findLastMemOp();

   210 	}

   211 

   212 	/** find last memory operation */

   213 	private void findLastMemOp() {

   214 		Long biggestTime = firstMemOpTime; //Long.MIN_VALUE;

   215 		for (ProcessInfo process : processList) {

   216 			AbstractList<BaseInfo> allocsAndFrees = process.getAllocsFrees();

   217 			BaseInfo baseInfo = allocsAndFrees.get(allocsAndFrees.size() -1);

   218 			long time = baseInfo.getTime();

   219 			if (time > biggestTime ){

   220 				biggestTime = time;

   221 				lastMemOp = baseInfo;

   222 			}

   223 		}

   224 		if (lastMemOp != null) {

   225 			lastMemOpTime = biggestTime;

   226 		}

   227 	}

   228 	

   229 	/** calculate the biggest memory size in all processes */

   230 	private void computeHighestCumulatedMemoryAlloc() {

   231 		for (ProcessInfo process : processList) {

   232 			if (process.getHighestCumulatedMemoryAlloc() > highestCumMemSize) {

   233 				highestCumMemSize = process.getHighestCumulatedMemoryAlloc();

   234 			}

   235 		}

   236 	}

   237 	

   238 	/* (non-Javadoc)

   239 	 * @see IMemoryActivityModel#getProcesses()

   240 	 */

   241 	public AbstractList<ProcessInfo> getProcesses() {

   242 		return processList;

   243 	}

   244 

   245 	/* (non-Javadoc)

   246 	 * @see com.nokia.s60tools.analyzetool.engine.IMemoryActivityModel#getFirstMemOpTime()

   247 	 */

   248 	public Long getFirstMemOpTime() {

   249 		return firstMemOpTime;

   250 	}

   251 

   252 	/* (non-Javadoc)

   253 	 * @see com.nokia.s60tools.analyzetool.engine.IMemoryActivityModel#getFirstProcessTime()

   254 	 */

   255 	public Long getFirstProcessTime() {

   256 		if (selectedProcess != null){

   257 			if (selectedProcessComputedValues == null){

   258 				selectedProcessComputedValues = new ProcessInfoComputedValues(selectedProcess);

   259 			}

   260 			return selectedProcessComputedValues.getProcessStartTime();

   261 		}

   262 		return firstProcessTime;

   263 	}

   264 

   265 

   266 	/* (non-Javadoc)

   267 	 * @see com.nokia.s60tools.analyzetool.engine.IMemoryActivityModel#getHighestCumulatedMemoryAlloc()

   268 	 */

   269 	public int getHighestCumulatedMemoryAlloc() {

   270 		if (selectedProcess != null){

   271 			if (selectedProcessComputedValues == null){

   272 				selectedProcessComputedValues = new ProcessInfoComputedValues(selectedProcess);

   273 			}

   274 			return selectedProcessComputedValues.getHighestCumulatedMemorySize();

   275 		}

   276 		return highestCumMemSize;

   277 	}

   278 

   279 

   280 	/* (non-Javadoc)

   281 	 * @see com.nokia.s60tools.analyzetool.engine.IMemoryActivityModel#getLastMemOpTime()

   282 	 */

   283 	public Long getLastMemOpTime() {

   284 		return lastMemOpTime;

   285 	}

   286 

   287 	/* (non-Javadoc)

   288 	 * @see com.nokia.s60tools.analyzetool.engine.IMemoryActivityModel#getLastProcessTime()

   289 	 */

   290 	public Long getLastProcessTime() {

   291 		if (selectedProcess != null){

   292 			if (selectedProcessComputedValues == null){

   293 				selectedProcessComputedValues = new ProcessInfoComputedValues(selectedProcess);

   294 			}

   295 			return selectedProcessComputedValues.getProcessEndTime();

   296 		}

   297 		return lastProcessTime;

   298 	}

   299 

   300 	/* (non-Javadoc)

   301 	 * @see com.nokia.s60tools.analyzetool.engine.IMemoryActivityModel#addListener(com.nokia.s60tools.analyzetool.engine.IMemoryActivityModelChangeListener)

   302 	 */

   303 	public void addListener(IMemoryActivityModelChangeListener listener) {

   304 		listeners.add(listener);

   305 	}

   306 

   307 	/* (non-Javadoc)

   308 	 * @see com.nokia.s60tools.analyzetool.engine.IMemoryActivityModel#removeListener(com.nokia.s60tools.analyzetool.engine.IMemoryActivityModelChangeListener)

   309 	 */

   310 	public void removeListener(IMemoryActivityModelChangeListener listener) {

   311 		listeners.remove(listener);

   312 	}

   313 	

   314 	/**

   315 	 * 

   316 	 * This class computes values for a given process

   317 	 *

   318 	 */

   319 	private class ProcessInfoComputedValues{

   320 		/** process life cycle start  */

   321 		private long processStartTime;

   322 		

   323 		/** process life cycle end */ 

   324 		private long processEndTime;

   325 		

   326 		/** highest value for cumulative memory allocation during the processes life time*/

   327 		private int highestCumulatedMemorySize;

   328 		

   329 		

   330 		/**

   331 		 * Constructor

   332 		 * @param p the ProcessInfo for this process

   333 		 */

   334 		public ProcessInfoComputedValues(ProcessInfo p) {

   335 			computeValues(p);

   336 		}

   337 

   338 		/**

   339 		 * Compute the values for the given process

   340 		 * @param p the ProcessInfo to use

   341 		 */

   342 		private void computeValues(ProcessInfo p){

   343 			//calculate highest cumulative memory value

   344 			highestCumulatedMemorySize = p.getHighestCumulatedMemoryAlloc();

   345 			

   346 			//work out process start time

   347 			Long startTime = p.getStartTime();

   348 			if (startTime == null && p.getAllocsFrees().size() > 0){

   349 				//take the time of the first memory activity

   350 				startTime = p.getAllocsFrees().get(0).getTime();

   351 			}

   352 			if (startTime != null){

   353 				processStartTime = startTime;

   354 			}

   355 			

   356 			//work out process end time

   357 			Long endTime = p.getEndTime();

   358 			if (endTime == null && p.getAllocsFrees().size() > 0){

   359 				//take the time of the last memory activity

   360 				endTime = p.getAllocsFrees().get(p.getAllocsFrees().size()-1).getTime();

   361 			}

   362 			if (endTime != null){

   363 				processEndTime = endTime;

   364 			}

   365 		}

   366 

   367 		/**

   368 		 * @return the process start time

   369 		 */

   370 		public long getProcessStartTime() {

   371 			return processStartTime;

   372 		}

   373 

   374 		/**

   375 		 * @return the process end time

   376 		 */

   377 		public long getProcessEndTime() {

   378 			return processEndTime;

   379 		}

   380 

   381 		/**

   382 		 * @return the highest cumulative memory size for the process

   383 		 */

   384 		public int getHighestCumulatedMemorySize() {

   385 			return highestCumulatedMemorySize;

   386 		}

   387 

   388 	}

   389 	

   390 	

   391 	// Other public methods can be added here.

   392 }