diff -r 5ad7ad99af01 -r 1050670c6980 sysperfana/analyzetoolext/com.nokia.s60tools.analyzetool/src/com/nokia/s60tools/analyzetool/engine/statistic/ProcessInfo.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sysperfana/analyzetoolext/com.nokia.s60tools.analyzetool/src/com/nokia/s60tools/analyzetool/engine/statistic/ProcessInfo.java	Thu Feb 11 15:22:14 2010 +0200
@@ -0,0 +1,372 @@
+/*
+ * Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+ * All rights reserved.
+ * This component and the accompanying materials are made available
+ * under the terms of "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:  Definitions for the class ProcessInfo
+ *
+ */
+package com.nokia.s60tools.analyzetool.engine.statistic;
+
+import java.util.AbstractList;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.runtime.IStatus;
+import com.nokia.s60tools.analyzetool.Activator;
+
+/**
+ * Contains information of process
+ * 
+ * @author kihe
+ * 
+ */
+public class ProcessInfo {
+
+	/** List of allocations and frees sorted as they arrive in time */
+	AbstractList<BaseInfo> allocsFrees;
+
+	/** List of dll loads */
+	Hashtable<String, DllLoad> dllLoads;
+
+	/** Process id */
+	int processID;
+
+	/** Process Name */
+	String processName;
+
+	/** Process start time */
+	Long startTime;
+
+	/** Process start time */
+	Long endTime;
+
+	/** Trace data format version number */
+	int traceDataVersion = 1;
+
+	/** active allocations account */
+	private int allocCount = 0;
+	/** total memory consumed by this process at each event */
+	private int totalMemory = 0;
+	/** highest memory consumed by this process */
+	private int highestMemory =0;
+
+	/** Map of potential leaks; to track allocations not yet freed */
+	private Map<Long, List<AllocInfo>> potentialLeaksMap;
+
+	/**
+	 * Constructor
+	 */
+	public ProcessInfo() {
+		dllLoads = new Hashtable<String, DllLoad>();
+		allocsFrees = new ArrayList<BaseInfo>();
+		allocCount = 0;
+		potentialLeaksMap = new HashMap<Long, List<AllocInfo>>(); 
+	}
+
+	/**
+	 * Adds one memory allocation to the list.
+	 * 
+	 * @param oneInfo
+	 *            One memory allocation
+	 */
+	public void addOneAlloc(AllocInfo oneInfo) {
+		allocCount++;
+		totalMemory = totalMemory + oneInfo.getSizeInt();
+		oneInfo.setTotalMem(totalMemory);
+		if (totalMemory > highestMemory) {
+			highestMemory = totalMemory;
+		}
+		allocsFrees.add(oneInfo);
+		//add this alloc to the potential leaks map
+		Long addr = oneInfo.getMemoryAddress();
+		List<AllocInfo> allocsSameAddr = potentialLeaksMap.get(addr);
+		if (allocsSameAddr == null){
+			allocsSameAddr = new ArrayList<AllocInfo>();
+			potentialLeaksMap.put(addr, allocsSameAddr);
+		}
+		allocsSameAddr.add(oneInfo);
+	}
+
+	/**
+	 * Adds one dll load to the list.
+	 * 
+	 * @param dllLoad
+	 *            One dll load
+	 */
+	public void addOneDllLoad(DllLoad dllLoad) {
+		dllLoads.put(dllLoad.getName(), dllLoad);
+	}
+
+	/**
+	 * Updates memory leaks list by given free information
+	 * 
+	 * @param info
+	 *            Which memory allocation to be deallocated.
+	 */
+	public void free(FreeInfo info) {
+
+		int freeSize = 0;
+		
+		//remove allocs with the same address from the potential leaks map
+		Long freeAddr = info.getMemoryAddress();
+		List<AllocInfo> allocsSameAddr = potentialLeaksMap.remove(freeAddr);
+		if (allocsSameAddr != null && allocsSameAddr.size()>0){
+			for(AllocInfo allocInfo : allocsSameAddr){
+				allocInfo.setFreedBy(info);
+				info.addFreedAlloc(allocInfo);
+				allocCount--;
+				int thisFreedSize = allocInfo.getSizeInt();
+				freeSize = freeSize + thisFreedSize;
+				totalMemory = totalMemory - thisFreedSize;
+			}			
+		}
+
+		info.setSizeInt(freeSize);
+		info.setTotalMem(totalMemory);
+		
+		if (info.getTime() == null || info.getTime() == 0 ) {
+			// support old format
+			//set time as last operation time or start time.
+			Long time = getPreviousTime();
+			if (time == null || time == -1L) {
+				Activator.getDefault().log(IStatus.WARNING, String.format("AnalyzeTool encountered a process = %s, which starts with FREE.", processID), null);
+				time = startTime;
+			}
+			info.setTime(time);
+		}
+		
+		allocsFrees.add(info);
+	}
+
+	/**
+	 * Returns the timestamp of the last memory operation
+	 * @return the timestamp of the last memory operation, or -1 if there
+	 * are no memory operations
+	 */
+	private Long getPreviousTime() {
+		Long time = -1L;
+		if (!allocsFrees.isEmpty()) {
+			time = (allocsFrees.get(allocsFrees.size() -1)).getTime();
+		}
+		return time;
+	}
+
+	/**
+	 * Returns list of allocations
+	 * 
+	 * @return List of allocations
+	 */
+	public AbstractList<AllocInfo> getAllocs() {
+		AbstractList<AllocInfo> allocs = new ArrayList<AllocInfo>();
+		for (BaseInfo alloc : allocsFrees) {
+			if (alloc instanceof AllocInfo) {
+				allocs.add((AllocInfo) alloc);
+			}
+		}
+		return allocs;
+	}
+
+	/**
+	 * Returns list of dll loads
+	 * 
+	 * @return List of dll loads
+	 */
+	public Hashtable<String, DllLoad> getDllLoads() {
+		return dllLoads;
+	}
+
+	/**
+	 * Returns list of memory leak from this process.
+	 * 
+	 * @return List of memory leaks.
+	 */
+	public AbstractList<AllocInfo> getMemLeaks() {
+		AbstractList<AllocInfo> leaks = new ArrayList<AllocInfo>();
+		for (List<AllocInfo> potLeaks : potentialLeaksMap.values()) {
+			leaks.addAll(potLeaks);
+		}
+		return leaks;
+	}
+
+	/**
+	 * Returns the number of memory leaks of this process.
+	 * 
+	 * @return number of memory leaks.
+	 */
+	public int getMemLeaksNumber() {
+		int count = 0;
+		for (List<AllocInfo> potLeaks : potentialLeaksMap.values()) {
+			count += potLeaks.size();
+		}
+		return count;
+	}
+
+	/** 
+	 * get list of frees
+	 * @return List of FreeInfo
+	 */
+	public AbstractList<FreeInfo> getFrees() {
+		AbstractList<FreeInfo> frees = new ArrayList<FreeInfo>();
+		for (BaseInfo alloc : allocsFrees) {
+			if (alloc instanceof FreeInfo) {
+				frees.add((FreeInfo) alloc);
+			}
+		}
+		return frees;
+	}
+
+	/**
+	 * Returns process id
+	 * 
+	 * @return Process id
+	 */
+	public int getProcessID() {
+		return processID;
+	}
+
+	/**
+	 * Returns process start time
+	 * 
+	 * @return Process start time
+	 */
+	public Long getStartTime() {
+		return startTime;
+	}
+
+	/**
+	 * Returns trace data version number
+	 * 
+	 * @return Trace data version number
+	 */
+	public int getTraceDataVersion() {
+		return traceDataVersion;
+	}
+
+	/**
+	 * Sets process id
+	 * 
+	 * @param newProcessID
+	 *            Process id
+	 */
+	public void setProcessID(int newProcessID) {
+		this.processID = newProcessID;
+	}
+
+	/**
+	 * Sets process start time
+	 * 
+	 * @param newTime
+	 *            Process start time
+	 */
+	public void setStartTime(String newTime) {
+		Long lValue = Long.parseLong(newTime, 16);
+		this.startTime = lValue;
+	}
+
+	/**
+	 * Updates trace version number
+	 * 
+	 * @param newTraceDataVersion
+	 *            New trace data version number
+	 */
+	public void setTraceDataVersion(String newTraceDataVersion) {
+
+		try {
+			traceDataVersion = Integer.parseInt(newTraceDataVersion, 16);
+		} catch (NumberFormatException nfe) {
+			// exception while trying to set new version number
+			// use the oldest version number, this version number is safest
+			// but when use this version some information could be lost
+			traceDataVersion = 1;
+		}
+	}
+
+	/**
+	 * Unloads one dll load from the stored items
+	 * 
+	 * @param dllLoad
+	 *            Dll unload item
+	 */
+	public void unloadOneDll(DllLoad dllLoad) {
+		if (dllLoads.containsKey(dllLoad.getName())) {
+			dllLoads.remove(dllLoad.getName());
+		}
+	}
+
+	/**
+	 * set end time of the process
+	 * @param aTime
+	 */
+	public void setEndTime(String aTime) {
+		Long lValue = Long.parseLong(aTime, 16);
+		endTime = lValue;
+	}
+
+	/**
+	 * set process name
+	 * @param aProcessName
+	 */
+	public void setProcessName(String aProcessName) {
+		processName = aProcessName;
+	}
+
+	/**
+	 * @return the process name
+	 */
+	public String getProcessName() {
+		return processName;
+	}
+
+	/**
+	 * get all events
+	 * @return list of BaseInfo
+	 */
+	public AbstractList<BaseInfo> getAllocsFrees() {
+		return allocsFrees;
+	}
+
+	/**
+	 * get end time of the process
+	 * @return
+	 */
+	public Long getEndTime() {
+		return endTime;
+	}
+
+	/**
+	 * get list of allocations freed by a FreeInfo
+	 * 
+	 * @param free
+	 * @return AbstractList<AllocInfo> list of allocations freed by the provided
+	 *         FreeInfo
+	 */
+	public AbstractList<AllocInfo> getAllocsFreedBy(FreeInfo free) {
+		AbstractList<AllocInfo> allocs = new ArrayList<AllocInfo>();
+		for (BaseInfo alloc : allocsFrees) {
+			if (alloc instanceof AllocInfo && ((AllocInfo) alloc).getFreedBy() == free) {
+				allocs.add((AllocInfo) alloc);
+			}
+		}
+		return allocs;
+	}
+	/**
+	 * Getter for highest memory allocation for the current process
+	 * @return int containing highest memory usage
+	 */
+	public int getHighestCumulatedMemoryAlloc() {
+		return highestMemory;
+	}
+
+}